diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13196efa9ade729ceb9055f51616010d5a29a04c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/appellseqs.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/appellseqs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0c038da0e70d2239f5fb8ddfbc3718f68a31875
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/appellseqs.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/compatibility.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/compatibility.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed1f98ba099ab30c7efe9480ba273ed3fbfee0b9
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/compatibility.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/constructor.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/constructor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b18e98a393c489cf477919a70b4a08663cbed2c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/constructor.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densearith.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densearith.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36a1964a66db6ed8a26bb05d1f51f670d3584146
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densearith.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densetools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densetools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60b136986e3e8bd416b5648a650ad586b2b99b61
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/densetools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/distributedmodules.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/distributedmodules.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5509c00d454327b3634f4dc207ff6b3e6490340e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/distributedmodules.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/domainmatrix.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/domainmatrix.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec2c3362e23638dbc184ef2dead1f8eeabe7509e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/domainmatrix.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/factortools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/factortools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9744197dba7fe9eaf75e4e176efe3872bd2df02
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/factortools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/fields.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/fields.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bbb321cf1a46d6df55a8a64f87c85f7c335cb4ea
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/fields.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/galoistools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/galoistools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d97bb21070fbf5e8380925528b2a74cb24df17b
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/galoistools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/groebnertools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/groebnertools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d474aa14673034240640d94f6adaad3e2b11f104
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/groebnertools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/modulargcd.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/modulargcd.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0967528c4043c20c34e1fa0ce4ec39e0b4b7504
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/modulargcd.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/monomials.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/monomials.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77b2167479646bd3224327e212ac5818b84944de
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/monomials.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/multivariate_resultants.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/multivariate_resultants.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b13810d9b303db9cb78f43542af0080a716f021
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/multivariate_resultants.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orderings.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orderings.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45256adb963f2cc27c50089ac2cfdc622464d5a6
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orderings.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orthopolys.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orthopolys.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2cd2ddb9c2400e5a5acc349f9bd3b9c1f4ff8bc
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/orthopolys.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/partfrac.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/partfrac.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccd1c6a10da711add78a66dcd1d46de588d38b27
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/partfrac.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyclasses.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyclasses.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10cf7edfe4e8cd9a7e41f182ca3f32918d5ee8aa
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyclasses.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyconfig.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyconfig.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e82bb39cb203261c8793b3840b53513e2330fffd
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyconfig.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyerrors.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyerrors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fdc814089a3532c367ea50fcd1da173d1438d790
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyerrors.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyfuncs.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyfuncs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..913b445bf427e485f68ebbe70b79ba8cd75a5bc3
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyfuncs.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polymatrix.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polymatrix.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..644185874d3db198289c79bfa113980c4fb6638f
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polymatrix.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyoptions.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyoptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d8f5e3800ce45763764de38ae10288d516fa1af
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyoptions.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3673c0bbf01b7db3b2e43fcb5a2bac3122b0f6fe
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyroots.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyroots.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..101175bd400ed544dc2666c2d357fd59a92c4c36
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyroots.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polytools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polytools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb0a443c1678d30658ce6977083d6d673b0b833c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polytools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyutils.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyutils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb37700f12ce0e5c1689ac4d79bdc21b04472a13
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/polyutils.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rationaltools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rationaltools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a175a41d0be30c9b8d54319eacd062455247083
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rationaltools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/ring_series.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/ring_series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d29ab945e3a70fed871d8f33332fddcb754000f9
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/ring_series.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rings.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rings.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15b9c79418e4bcf17ca799fbb633973e99555c66
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rings.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootisolation.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootisolation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..35f3bb9ee674469978c8c229bbddef950de7995e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootisolation.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootoftools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootoftools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..84cab15ad61c0d30d25ec69c53bd049577c93e49
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/rootoftools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/specialpolys.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/specialpolys.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c62409e3c8f798fab1b0b67c55cdd267b4b4af69
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/specialpolys.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/sqfreetools.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/sqfreetools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7862595a5f978b57f6267dcb8313db63140c58e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/sqfreetools.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/subresultants_qq_zz.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/subresultants_qq_zz.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ad8f735ecfe2232f88e461118fa0748b1dd1f13
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/__pycache__/subresultants_qq_zz.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e2a50358d8dcf4cf427ae6e992a4486e1489fdb
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_extensions.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_extensions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbb68b1bd502433166fb1bd828c7ed6536fabfb4
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_extensions.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_ideals.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_ideals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..daae4f2519a665bd239726d86031e7ecf9002271
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_ideals.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_modules.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_modules.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c08298d71bd25ff54da61b527a521dbff5f873ff
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/__pycache__/test_modules.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_extensions.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_extensions.py
new file mode 100644
index 0000000000000000000000000000000000000000..4becf4fd800a7a34c16989adaaf97e312c18f01c
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_extensions.py
@@ -0,0 +1,196 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys import QQ, ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyerrors import NotInvertible
+from sympy.polys.agca.extensions import FiniteExtension
+from sympy.polys.domainmatrix import DomainMatrix
+
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, t
+
+
+def test_FiniteExtension():
+    # Gaussian integers
+    A = FiniteExtension(Poly(x**2 + 1, x))
+    assert A.rank == 2
+    assert str(A) == 'ZZ[x]/(x**2 + 1)'
+    i = A.generator
+    assert i.parent() is A
+
+    assert i*i == A(-1)
+    raises(TypeError, lambda: i*())
+
+    assert A.basis == (A.one, i)
+    assert A(1) == A.one
+    assert i**2 == A(-1)
+    assert i**2 != -1  # no coercion
+    assert (2 + i)*(1 - i) == 3 - i
+    assert (1 + i)**8 == A(16)
+    assert A(1).inverse() == A(1)
+    raises(NotImplementedError, lambda: A(2).inverse())
+
+    # Finite field of order 27
+    F = FiniteExtension(Poly(x**3 - x + 1, x, modulus=3))
+    assert F.rank == 3
+    a = F.generator  # also generates the cyclic group F - {0}
+    assert F.basis == (F(1), a, a**2)
+    assert a**27 == a
+    assert a**26 == F(1)
+    assert a**13 == F(-1)
+    assert a**9 == a + 1
+    assert a**3 == a - 1
+    assert a**6 == a**2 + a + 1
+    assert F(x**2 + x).inverse() == 1 - a
+    assert F(x + 2)**(-1) == F(x + 2).inverse()
+    assert a**19 * a**(-19) == F(1)
+    assert (a - 1) / (2*a**2 - 1) == a**2 + 1
+    assert (a - 1) // (2*a**2 - 1) == a**2 + 1
+    assert 2/(a**2 + 1) == a**2 - a + 1
+    assert (a**2 + 1)/2 == -a**2 - 1
+    raises(NotInvertible, lambda: F(0).inverse())
+
+    # Function field of an elliptic curve
+    K = FiniteExtension(Poly(t**2 - x**3 - x + 1, t, field=True))
+    assert K.rank == 2
+    assert str(K) == 'ZZ(x)[t]/(t**2 - x**3 - x + 1)'
+    y = K.generator
+    c = 1/(x**3 - x**2 + x - 1)
+    assert ((y + x)*(y - x)).inverse() == K(c)
+    assert (y + x)*(y - x)*c == K(1)  # explicit inverse of y + x
+
+
+def test_FiniteExtension_eq_hash():
+    # Test eq and hash
+    p1 = Poly(x**2 - 2, x, domain=ZZ)
+    p2 = Poly(x**2 - 2, x, domain=QQ)
+    K1 = FiniteExtension(p1)
+    K2 = FiniteExtension(p2)
+    assert K1 == FiniteExtension(Poly(x**2 - 2))
+    assert K2 != FiniteExtension(Poly(x**2 - 2))
+    assert len({K1, K2, FiniteExtension(p1)}) == 2
+
+
+def test_FiniteExtension_mod():
+    # Test mod
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=QQ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    assert 1 % (xf**2 - 1) == K.zero
+    assert (xf**2 - 1) / (xf - 1) == xf + 1
+    assert (xf**2 - 1) // (xf - 1) == xf + 1
+    assert (xf**2 - 1) % (xf - 1) == K.zero
+    raises(ZeroDivisionError, lambda: (xf**2 - 1) % 0)
+    raises(TypeError, lambda: xf % [])
+    raises(TypeError, lambda: [] % xf)
+
+    # Test mod over ring
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    raises(NotImplementedError, lambda: (xf**2 - 1) % (xf - 1))
+
+
+def test_FiniteExtension_from_sympy():
+    # Test to_sympy/from_sympy
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert K.from_sympy(x) == xf
+    assert K.to_sympy(xf) == x
+
+
+def test_FiniteExtension_set_domain():
+    KZ = FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))
+    KQ = FiniteExtension(Poly(x**2 + 1, x, domain='QQ'))
+    assert KZ.set_domain(QQ) == KQ
+
+
+def test_FiniteExtension_exquo():
+    # Test exquo
+    K = FiniteExtension(Poly(x**4 + 1))
+    xf = K(x)
+    assert K.exquo(xf**2 - 1, xf - 1) == xf + 1
+
+
+def test_FiniteExtension_convert():
+    # Test from_MonogenicFiniteExtension
+    K1 = FiniteExtension(Poly(x**2 + 1))
+    K2 = QQ[x]
+    x1, x2 = K1(x), K2(x)
+    assert K1.convert(x2) == x1
+    assert K2.convert(x1) == x2
+
+    K = FiniteExtension(Poly(x**2 - 1, domain=QQ))
+    assert K.convert_from(QQ(1, 2), QQ) == K.one/2
+
+
+def test_FiniteExtension_division_ring():
+    # Test division in FiniteExtension over a ring
+    KQ = FiniteExtension(Poly(x**2 - 1, x, domain=QQ))
+    KZ = FiniteExtension(Poly(x**2 - 1, x, domain=ZZ))
+    KQt = FiniteExtension(Poly(x**2 - 1, x, domain=QQ[t]))
+    KQtf = FiniteExtension(Poly(x**2 - 1, x, domain=QQ.frac_field(t)))
+    assert KQ.is_Field is True
+    assert KZ.is_Field is False
+    assert KQt.is_Field is False
+    assert KQtf.is_Field is True
+    for K in KQ, KZ, KQt, KQtf:
+        xK = K.convert(x)
+        assert xK / K.one == xK
+        assert xK // K.one == xK
+        assert xK % K.one == K.zero
+        raises(ZeroDivisionError, lambda: xK / K.zero)
+        raises(ZeroDivisionError, lambda: xK // K.zero)
+        raises(ZeroDivisionError, lambda: xK % K.zero)
+        if K.is_Field:
+            assert xK / xK == K.one
+            assert xK // xK == K.one
+            assert xK % xK == K.zero
+        else:
+            raises(NotImplementedError, lambda: xK / xK)
+            raises(NotImplementedError, lambda: xK // xK)
+            raises(NotImplementedError, lambda: xK % xK)
+
+
+def test_FiniteExtension_Poly():
+    K = FiniteExtension(Poly(x**2 - 2))
+    p = Poly(x, y, domain=K)
+    assert p.domain == K
+    assert p.as_expr() == x
+    assert (p**2).as_expr() == 2
+
+    K = FiniteExtension(Poly(x**2 - 2, x, domain=QQ))
+    K2 = FiniteExtension(Poly(t**2 - 2, t, domain=K))
+    assert str(K2) == 'QQ[x]/(x**2 - 2)[t]/(t**2 - 2)'
+
+    eK = K2.convert(x + t)
+    assert K2.to_sympy(eK) == x + t
+    assert K2.to_sympy(eK ** 2) == 4 + 2*x*t
+    p = Poly(x + t, y, domain=K2)
+    assert p**2 == Poly(4 + 2*x*t, y, domain=K2)
+
+
+def test_FiniteExtension_sincos_jacobian():
+    # Use FiniteExtensino to compute the Jacobian of a matrix involving sin
+    # and cos of different symbols.
+    r, p, t = symbols('rho, phi, theta')
+    elements = [
+        [sin(p)*cos(t), r*cos(p)*cos(t), -r*sin(p)*sin(t)],
+        [sin(p)*sin(t), r*cos(p)*sin(t),  r*sin(p)*cos(t)],
+        [       cos(p),       -r*sin(p),                0],
+    ]
+
+    def make_extension(K):
+        K = FiniteExtension(Poly(sin(p)**2+cos(p)**2-1, sin(p), domain=K[cos(p)]))
+        K = FiniteExtension(Poly(sin(t)**2+cos(t)**2-1, sin(t), domain=K[cos(t)]))
+        return K
+
+    Ksc1 = make_extension(ZZ[r])
+    Ksc2 = make_extension(ZZ)[r]
+
+    for K in [Ksc1, Ksc2]:
+        elements_K = [[K.convert(e) for e in row] for row in elements]
+        J = DomainMatrix(elements_K, (3, 3), K)
+        det = J.charpoly()[-1] * (-K.one)**3
+        assert det == K.convert(r**2*sin(p))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_homomorphisms.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_homomorphisms.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e63838e09ed9b9436a58a7d8041175e731bc4ef
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_homomorphisms.py
@@ -0,0 +1,113 @@
+"""Tests for homomorphisms."""
+
+from sympy.core.singleton import S
+from sympy.polys.domains.rationalfield import QQ
+from sympy.abc import x, y
+from sympy.polys.agca import homomorphism
+from sympy.testing.pytest import raises
+
+
+def test_printing():
+    R = QQ.old_poly_ring(x)
+
+    assert str(homomorphism(R.free_module(1), R.free_module(1), [0])) == \
+        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1'
+    assert str(homomorphism(R.free_module(2), R.free_module(2), [0, 0])) == \
+        'Matrix([                       \n[0, 0], : QQ[x]**2 -> QQ[x]**2\n[0, 0]])                       '
+    assert str(homomorphism(R.free_module(1), R.free_module(1) / [[x]], [0])) == \
+        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1/<[x]>'
+    assert str(R.free_module(0).identity_hom()) == 'Matrix(0, 0, []) : QQ[x]**0 -> QQ[x]**0'
+
+def test_operations():
+    F = QQ.old_poly_ring(x).free_module(2)
+    G = QQ.old_poly_ring(x).free_module(3)
+    f = F.identity_hom()
+    g = homomorphism(F, F, [0, [1, x]])
+    h = homomorphism(F, F, [[1, 0], 0])
+    i = homomorphism(F, G, [[1, 0, 0], [0, 1, 0]])
+
+    assert f == f
+    assert f != g
+    assert f != i
+    assert (f != F.identity_hom()) is False
+    assert 2*f == f*2 == homomorphism(F, F, [[2, 0], [0, 2]])
+    assert f/2 == homomorphism(F, F, [[S.Half, 0], [0, S.Half]])
+    assert f + g == homomorphism(F, F, [[1, 0], [1, x + 1]])
+    assert f - g == homomorphism(F, F, [[1, 0], [-1, 1 - x]])
+    assert f*g == g == g*f
+    assert h*g == homomorphism(F, F, [0, [1, 0]])
+    assert g*h == homomorphism(F, F, [0, 0])
+    assert i*f == i
+    assert f([1, 2]) == [1, 2]
+    assert g([1, 2]) == [2, 2*x]
+
+    assert i.restrict_domain(F.submodule([x, x]))([x, x]) == i([x, x])
+    h1 = h.quotient_domain(F.submodule([0, 1]))
+    assert h1([1, 0]) == h([1, 0])
+    assert h1.restrict_domain(h1.domain.submodule([x, 0]))([x, 0]) == h([x, 0])
+
+    raises(TypeError, lambda: f/g)
+    raises(TypeError, lambda: f + 1)
+    raises(TypeError, lambda: f + i)
+    raises(TypeError, lambda: f - 1)
+    raises(TypeError, lambda: f*i)
+
+
+def test_creation():
+    F = QQ.old_poly_ring(x).free_module(3)
+    G = QQ.old_poly_ring(x).free_module(2)
+    SM = F.submodule([1, 1, 1])
+    Q = F / SM
+    SQ = Q.submodule([1, 0, 0])
+
+    matrix = [[1, 0], [0, 1], [-1, -1]]
+    h = homomorphism(F, G, matrix)
+    h2 = homomorphism(Q, G, matrix)
+    assert h.quotient_domain(SM) == h2
+    raises(ValueError, lambda: h.quotient_domain(F.submodule([1, 0, 0])))
+    assert h2.restrict_domain(SQ) == homomorphism(SQ, G, matrix)
+    raises(ValueError, lambda: h.restrict_domain(G))
+    raises(ValueError, lambda: h.restrict_codomain(G.submodule([1, 0])))
+    raises(ValueError, lambda: h.quotient_codomain(F))
+
+    im = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    for M in [F, SM, Q, SQ]:
+        assert M.identity_hom() == homomorphism(M, M, im)
+    assert SM.inclusion_hom() == homomorphism(SM, F, im)
+    assert SQ.inclusion_hom() == homomorphism(SQ, Q, im)
+    assert Q.quotient_hom() == homomorphism(F, Q, im)
+    assert SQ.quotient_hom() == homomorphism(SQ.base, SQ, im)
+
+    class conv:
+        def convert(x, y=None):
+            return x
+
+    class dummy:
+        container = conv()
+
+        def submodule(*args):
+            return None
+    raises(TypeError, lambda: homomorphism(dummy(), G, matrix))
+    raises(TypeError, lambda: homomorphism(F, dummy(), matrix))
+    raises(
+        ValueError, lambda: homomorphism(QQ.old_poly_ring(x, y).free_module(3), G, matrix))
+    raises(ValueError, lambda: homomorphism(F, G, [0, 0]))
+
+
+def test_properties():
+    R = QQ.old_poly_ring(x, y)
+    F = R.free_module(2)
+    h = homomorphism(F, F, [[x, 0], [y, 0]])
+    assert h.kernel() == F.submodule([-y, x])
+    assert h.image() == F.submodule([x, 0], [y, 0])
+    assert not h.is_injective()
+    assert not h.is_surjective()
+    assert h.restrict_codomain(h.image()).is_surjective()
+    assert h.restrict_domain(F.submodule([1, 0])).is_injective()
+    assert h.quotient_domain(
+        h.kernel()).restrict_codomain(h.image()).is_isomorphism()
+
+    R2 = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
+    F = R2.free_module(2)
+    h = homomorphism(F, F, [[x, 0], [y, y + 1]])
+    assert h.is_isomorphism()
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_ideals.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_ideals.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7fff0674b54a22e2a5acba5110d62d96a877074
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_ideals.py
@@ -0,0 +1,131 @@
+"""Test ideals.py code."""
+
+from sympy.polys import QQ, ilex
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+
+
+def test_ideal_operations():
+    R = QQ.old_poly_ring(x, y)
+    I = R.ideal(x)
+    J = R.ideal(y)
+    S = R.ideal(x*y)
+    T = R.ideal(x, y)
+
+    assert not (I == J)
+    assert I == I
+
+    assert I.union(J) == T
+    assert I + J == T
+    assert I + T == T
+
+    assert not I.subset(T)
+    assert T.subset(I)
+
+    assert I.product(J) == S
+    assert I*J == S
+    assert x*J == S
+    assert I*y == S
+    assert R.convert(x)*J == S
+    assert I*R.convert(y) == S
+
+    assert not I.is_zero()
+    assert not J.is_whole_ring()
+
+    assert R.ideal(x**2 + 1, x).is_whole_ring()
+    assert R.ideal() == R.ideal(0)
+    assert R.ideal().is_zero()
+
+    assert T.contains(x*y)
+    assert T.subset([x, y])
+
+    assert T.in_terms_of_generators(x) == [R(1), R(0)]
+
+    assert T**0 == R.ideal(1)
+    assert T**1 == T
+    assert T**2 == R.ideal(x**2, y**2, x*y)
+    assert I**5 == R.ideal(x**5)
+
+
+def test_exceptions():
+    I = QQ.old_poly_ring(x).ideal(x)
+    J = QQ.old_poly_ring(y).ideal(1)
+    raises(ValueError, lambda: I.union(x))
+    raises(ValueError, lambda: I + J)
+    raises(ValueError, lambda: I * J)
+    raises(ValueError, lambda: I.union(J))
+    assert (I == J) is False
+    assert I != J
+
+
+def test_nontriv_global():
+    R = QQ.old_poly_ring(x, y, z)
+
+    def contains(I, f):
+        return R.ideal(*I).contains(f)
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
+    assert contains([x, 1 + x + y, 5 - 7*y], 1)
+    assert contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**3)
+    assert not contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**2 + y**2)
+
+    # compare local order
+    assert not contains([x*(1 + x + y), y*(1 + z)], x)
+    assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_nontriv_local():
+    R = QQ.old_poly_ring(x, y, z, order=ilex)
+
+    def contains(I, f):
+        return R.ideal(*I).contains(f)
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x*(1 + x + y), y*(1 + z)], x)
+    assert contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_intersection():
+    R = QQ.old_poly_ring(x, y, z)
+    # SCA, example 1.8.11
+    assert R.ideal(x, y).intersect(R.ideal(y**2, z)) == R.ideal(y**2, y*z, x*z)
+
+    assert R.ideal(x, y).intersect(R.ideal()).is_zero()
+
+    R = QQ.old_poly_ring(x, y, z, order="ilex")
+    assert R.ideal(x, y).intersect(R.ideal(y**2 + y**2*z, z + z*x**3*y)) == \
+        R.ideal(y**2, y*z, x*z)
+
+
+def test_quotient():
+    # SCA, example 1.8.13
+    R = QQ.old_poly_ring(x, y, z)
+    assert R.ideal(x, y).quotient(R.ideal(y**2, z)) == R.ideal(x, y)
+
+
+def test_reduction():
+    from sympy.polys.distributedmodules import sdm_nf_buchberger_reduced
+    R = QQ.old_poly_ring(x, y)
+    I = R.ideal(x**5, y)
+    e = R.convert(x**3 + y**2)
+    assert I.reduce_element(e) == e
+    assert I.reduce_element(e, NF=sdm_nf_buchberger_reduced) == R.convert(x**3)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_modules.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..29c2d4ce45f452f6f61420654be64a67d13b396b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/agca/tests/test_modules.py
@@ -0,0 +1,408 @@
+"""Test modules.py code."""
+
+from sympy.polys.agca.modules import FreeModule, ModuleOrder, FreeModulePolyRing
+from sympy.polys import CoercionFailed, QQ, lex, grlex, ilex, ZZ
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+from sympy.core.numbers import Rational
+
+
+def test_FreeModuleElement():
+    M = QQ.old_poly_ring(x).free_module(3)
+    e = M.convert([1, x, x**2])
+    f = [QQ.old_poly_ring(x).convert(1), QQ.old_poly_ring(x).convert(x), QQ.old_poly_ring(x).convert(x**2)]
+    assert list(e) == f
+    assert f[0] == e[0]
+    assert f[1] == e[1]
+    assert f[2] == e[2]
+    raises(IndexError, lambda: e[3])
+
+    g = M.convert([x, 0, 0])
+    assert e + g == M.convert([x + 1, x, x**2])
+    assert f + g == M.convert([x + 1, x, x**2])
+    assert -e == M.convert([-1, -x, -x**2])
+    assert e - g == M.convert([1 - x, x, x**2])
+    assert e != g
+
+    assert M.convert([x, x, x]) / QQ.old_poly_ring(x).convert(x) == [1, 1, 1]
+    R = QQ.old_poly_ring(x, order="ilex")
+    assert R.free_module(1).convert([x]) / R.convert(x) == [1]
+
+
+def test_FreeModule():
+    M1 = FreeModule(QQ.old_poly_ring(x), 2)
+    assert M1 == FreeModule(QQ.old_poly_ring(x), 2)
+    assert M1 != FreeModule(QQ.old_poly_ring(y), 2)
+    assert M1 != FreeModule(QQ.old_poly_ring(x), 3)
+    M2 = FreeModule(QQ.old_poly_ring(x, order="ilex"), 2)
+
+    assert [x, 1] in M1
+    assert [x] not in M1
+    assert [2, y] not in M1
+    assert [1/(x + 1), 2] not in M1
+
+    e = M1.convert([x, x**2 + 1])
+    X = QQ.old_poly_ring(x).convert(x)
+    assert e == [X, X**2 + 1]
+    assert e == [x, x**2 + 1]
+    assert 2*e == [2*x, 2*x**2 + 2]
+    assert e*2 == [2*x, 2*x**2 + 2]
+    assert e/2 == [x/2, (x**2 + 1)/2]
+    assert x*e == [x**2, x**3 + x]
+    assert e*x == [x**2, x**3 + x]
+    assert X*e == [x**2, x**3 + x]
+    assert e*X == [x**2, x**3 + x]
+
+    assert [x, 1] in M2
+    assert [x] not in M2
+    assert [2, y] not in M2
+    assert [1/(x + 1), 2] in M2
+
+    e = M2.convert([x, x**2 + 1])
+    X = QQ.old_poly_ring(x, order="ilex").convert(x)
+    assert e == [X, X**2 + 1]
+    assert e == [x, x**2 + 1]
+    assert 2*e == [2*x, 2*x**2 + 2]
+    assert e*2 == [2*x, 2*x**2 + 2]
+    assert e/2 == [x/2, (x**2 + 1)/2]
+    assert x*e == [x**2, x**3 + x]
+    assert e*x == [x**2, x**3 + x]
+    assert e/(1 + x) == [x/(1 + x), (x**2 + 1)/(1 + x)]
+    assert X*e == [x**2, x**3 + x]
+    assert e*X == [x**2, x**3 + x]
+
+    M3 = FreeModule(QQ.old_poly_ring(x, y), 2)
+    assert M3.convert(e) == M3.convert([x, x**2 + 1])
+
+    assert not M3.is_submodule(0)
+    assert not M3.is_zero()
+
+    raises(NotImplementedError, lambda: ZZ.old_poly_ring(x).free_module(2))
+    raises(NotImplementedError, lambda: FreeModulePolyRing(ZZ, 2))
+    raises(CoercionFailed, lambda: M1.convert(QQ.old_poly_ring(x).free_module(3)
+           .convert([1, 2, 3])))
+    raises(CoercionFailed, lambda: M3.convert(1))
+
+
+def test_ModuleOrder():
+    o1 = ModuleOrder(lex, grlex, False)
+    o2 = ModuleOrder(ilex, lex, False)
+
+    assert o1 == ModuleOrder(lex, grlex, False)
+    assert (o1 != ModuleOrder(lex, grlex, False)) is False
+    assert o1 != o2
+
+    assert o1((1, 2, 3)) == (1, (5, (2, 3)))
+    assert o2((1, 2, 3)) == (-1, (2, 3))
+
+
+def test_SubModulePolyRing_global():
+    R = QQ.old_poly_ring(x, y)
+    F = R.free_module(3)
+    Fd = F.submodule([1, 0, 0], [1, 2, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, 1 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert not F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
+    assert not M.is_submodule(0)
+
+    m = F.convert([x**2 + y**2, 1, 0])
+    n = M.convert(m)
+    assert m.module is F
+    assert n.module is M
+
+    raises(ValueError, lambda: M.submodule([1, 0, 0]))
+    raises(TypeError, lambda: M.union(1))
+    raises(ValueError, lambda: M.union(R.free_module(1).submodule([x])))
+
+    assert F.submodule([x, x, x]) != F.submodule([x, x, x], order="ilex")
+
+
+def test_SubModulePolyRing_local():
+    R = QQ.old_poly_ring(x, y, order=ilex)
+    F = R.free_module(3)
+    Fd = F.submodule([1 + x, 0, 0], [1 + y, 2 + 2*y, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, 1 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule(
+        [1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1 + x*y])) == F
+
+    raises(ValueError, lambda: M.submodule([1, 0, 0]))
+
+
+def test_SubModulePolyRing_nontriv_global():
+    R = QQ.old_poly_ring(x, y, z)
+    F = R.free_module(1)
+
+    def contains(I, f):
+        return F.submodule(*[[g] for g in I]).contains([f])
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
+    assert contains([x, 1 + x + y, 5 - 7*y], 1)
+    assert contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**3)
+    assert not contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**2 + y**2)
+
+    # compare local order
+    assert not contains([x*(1 + x + y), y*(1 + z)], x)
+    assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_SubModulePolyRing_nontriv_local():
+    R = QQ.old_poly_ring(x, y, z, order=ilex)
+    F = R.free_module(1)
+
+    def contains(I, f):
+        return F.submodule(*[[g] for g in I]).contains([f])
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x*(1 + x + y), y*(1 + z)], x)
+    assert contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_syzygy():
+    R = QQ.old_poly_ring(x, y, z)
+    M = R.free_module(1).submodule([x*y], [y*z], [x*z])
+    S = R.free_module(3).submodule([0, x, -y], [z, -x, 0])
+    assert M.syzygy_module() == S
+
+    M2 = M / ([x*y*z],)
+    S2 = R.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
+    assert M2.syzygy_module() == S2
+
+    F = R.free_module(3)
+    assert F.submodule(*F.basis()).syzygy_module() == F.submodule()
+
+    R2 = QQ.old_poly_ring(x, y, z) / [x*y*z]
+    M3 = R2.free_module(1).submodule([x*y], [y*z], [x*z])
+    S3 = R2.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
+    assert M3.syzygy_module() == S3
+
+
+def test_in_terms_of_generators():
+    R = QQ.old_poly_ring(x, order="ilex")
+    M = R.free_module(2).submodule([2*x, 0], [1, 2])
+    assert M.in_terms_of_generators(
+        [x, x]) == [R.convert(Rational(1, 4)), R.convert(x/2)]
+    raises(ValueError, lambda: M.in_terms_of_generators([1, 0]))
+
+    M = R.free_module(2) / ([x, 0], [1, 1])
+    SM = M.submodule([1, x])
+    assert SM.in_terms_of_generators([2, 0]) == [R.convert(-2/(x - 1))]
+
+    R = QQ.old_poly_ring(x, y) / [x**2 - y**2]
+    M = R.free_module(2)
+    SM = M.submodule([x, 0], [0, y])
+    assert SM.in_terms_of_generators(
+        [x**2, x**2]) == [R.convert(x), R.convert(y)]
+
+
+def test_QuotientModuleElement():
+    R = QQ.old_poly_ring(x)
+    F = R.free_module(3)
+    N = F.submodule([1, x, x**2])
+    M = F/N
+    e = M.convert([x**2, 2, 0])
+
+    assert M.convert([x + 1, x**2 + x, x**3 + x**2]) == 0
+    assert e == [x**2, 2, 0] + N == F.convert([x**2, 2, 0]) + N == \
+        M.convert(F.convert([x**2, 2, 0]))
+
+    assert M.convert([x**2 + 1, 2*x + 2, x**2]) == e + [0, x, 0] == \
+        e + M.convert([0, x, 0]) == e + F.convert([0, x, 0])
+    assert M.convert([x**2 + 1, 2, x**2]) == e - [0, x, 0] == \
+        e - M.convert([0, x, 0]) == e - F.convert([0, x, 0])
+    assert M.convert([0, 2, 0]) == M.convert([x**2, 4, 0]) - e == \
+        [x**2, 4, 0] - e == F.convert([x**2, 4, 0]) - e
+    assert M.convert([x**3 + x**2, 2*x + 2, 0]) == (1 + x)*e == \
+        R.convert(1 + x)*e == e*(1 + x) == e*R.convert(1 + x)
+    assert -e == [-x**2, -2, 0]
+
+    f = [x, x, 0] + N
+    assert M.convert([1, 1, 0]) == f / x == f / R.convert(x)
+
+    M2 = F/[(2, 2*x, 2*x**2), (0, 0, 1)]
+    G = R.free_module(2)
+    M3 = G/[[1, x]]
+    M4 = F.submodule([1, x, x**2], [1, 0, 0]) / N
+    raises(CoercionFailed, lambda: M.convert(G.convert([1, x])))
+    raises(CoercionFailed, lambda: M.convert(M3.convert([1, x])))
+    raises(CoercionFailed, lambda: M.convert(M2.convert([1, x, x])))
+    assert M2.convert(M.convert([2, x, x**2])) == [2, x, 0]
+    assert M.convert(M4.convert([2, 0, 0])) == [2, 0, 0]
+
+
+def test_QuotientModule():
+    R = QQ.old_poly_ring(x)
+    F = R.free_module(3)
+    N = F.submodule([1, x, x**2])
+    M = F/N
+
+    assert M != F
+    assert M != N
+    assert M == F / [(1, x, x**2)]
+    assert not M.is_zero()
+    assert (F / F.basis()).is_zero()
+
+    SQ = F.submodule([1, x, x**2], [2, 0, 0]) / N
+    assert SQ == M.submodule([2, x, x**2])
+    assert SQ != M.submodule([2, 1, 0])
+    assert SQ != M
+    assert M.is_submodule(SQ)
+    assert not SQ.is_full_module()
+
+    raises(ValueError, lambda: N/F)
+    raises(ValueError, lambda: F.submodule([2, 0, 0]) / N)
+    raises(ValueError, lambda: R.free_module(2)/F)
+    raises(CoercionFailed, lambda: F.convert(M.convert([1, x, x**2])))
+
+    M1 = F / [[1, 1, 1]]
+    M2 = M1.submodule([1, 0, 0], [0, 1, 0])
+    assert M1 == M2
+
+
+def test_ModulesQuotientRing():
+    R = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
+    M1 = R.free_module(2)
+    assert M1 == R.free_module(2)
+    assert M1 != QQ.old_poly_ring(x).free_module(2)
+    assert M1 != R.free_module(3)
+
+    assert [x, 1] in M1
+    assert [x] not in M1
+    assert [1/(R.convert(x) + 1), 2] in M1
+    assert [1, 2/(1 + y)] in M1
+    assert [1, 2/y] not in M1
+
+    assert M1.convert([x**2, y]) == [-1, y]
+
+    F = R.free_module(3)
+    Fd = F.submodule([x**2, 0, 0], [1, 2, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, -x**2 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert F.submodule([x, 0, 0]) == F.submodule([1, 0, 0])
+    assert not F.submodule([y, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
+    assert not M.is_submodule(0)
+
+
+def test_module_mul():
+    R = QQ.old_poly_ring(x)
+    M = R.free_module(2)
+    S1 = M.submodule([x, 0], [0, x])
+    S2 = M.submodule([x**2, 0], [0, x**2])
+    I = R.ideal(x)
+
+    assert I*M == M*I == S1 == x*M == M*x
+    assert I*S1 == S2 == x*S1
+
+
+def test_intersection():
+    # SCA, example 2.8.5
+    F = QQ.old_poly_ring(x, y).free_module(2)
+    M1 = F.submodule([x, y], [y, 1])
+    M2 = F.submodule([0, y - 1], [x, 1], [y, x])
+    I = F.submodule([x, y], [y**2 - y, y - 1], [x*y + y, x + 1])
+    I1, rel1, rel2 = M1.intersect(M2, relations=True)
+    assert I1 == M2.intersect(M1) == I
+    for i, g in enumerate(I1.gens):
+        assert g == sum(c*x for c, x in zip(rel1[i], M1.gens)) \
+                 == sum(d*y for d, y in zip(rel2[i], M2.gens))
+
+    assert F.submodule([x, y]).intersect(F.submodule([y, x])).is_zero()
+
+
+def test_quotient():
+    # SCA, example 2.8.6
+    R = QQ.old_poly_ring(x, y, z)
+    F = R.free_module(2)
+    assert F.submodule([x*y, x*z], [y*z, x*y]).module_quotient(
+        F.submodule([y, z], [z, y])) == QQ.old_poly_ring(x, y, z).ideal(x**2*y**2 - x*y*z**2)
+    assert F.submodule([x, y]).module_quotient(F.submodule()).is_whole_ring()
+
+    M = F.submodule([x**2, x**2], [y**2, y**2])
+    N = F.submodule([x + y, x + y])
+    q, rel = M.module_quotient(N, relations=True)
+    assert q == R.ideal(y**2, x - y)
+    for i, g in enumerate(q.gens):
+        assert g*N.gens[0] == sum(c*x for c, x in zip(rel[i], M.gens))
+
+
+def test_groebner_extendend():
+    M = QQ.old_poly_ring(x, y, z).free_module(3).submodule([x + 1, y, 1], [x*y, z, z**2])
+    G, R = M._groebner_vec(extended=True)
+    for i, g in enumerate(G):
+        assert g == sum(c*gen for c, gen in zip(R[i], M.gens))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..38403fdf80be22d47589a346d1b1878b982c3c93
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__init__.py
@@ -0,0 +1,27 @@
+"""Computational algebraic field theory. """
+
+__all__ = [
+    'minpoly', 'minimal_polynomial',
+
+    'field_isomorphism', 'primitive_element', 'to_number_field',
+
+    'isolate',
+
+    'round_two',
+
+    'prime_decomp', 'prime_valuation',
+
+    'galois_group',
+]
+
+from .minpoly import minpoly, minimal_polynomial
+
+from .subfield import field_isomorphism, primitive_element, to_number_field
+
+from .utilities import isolate
+
+from .basis import round_two
+
+from .primes import prime_decomp, prime_valuation
+
+from .galoisgroups import galois_group
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4358b3b693d179a5a3054aa6e13c618c1eec5249
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/basis.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/basis.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..143820651ffb501151b80de84cfc0f8314138591
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/basis.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/exceptions.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5873185a7f23c14287d13cbc10fe48b0b9fc806
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galois_resolvents.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galois_resolvents.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..048ebad1cc1f9c8606b192e8aecb3876a150a992
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galois_resolvents.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galoisgroups.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galoisgroups.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8068e487b6fac391c803407c5bbba10ee234269
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/galoisgroups.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/minpoly.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/minpoly.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b108bb308727d4b1363af807e925de1f2ac3a95
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/minpoly.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/modules.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/modules.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e558423c282d6426c5ceb15c9ad38d21920215c9
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/modules.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/primes.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/primes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eea481de6831cce43dec8977fb9d2dfb81cc128a
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/primes.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c8e90ca8e279c542edd9350a7e079e942a67276
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/subfield.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/subfield.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b6e858560cf2a0c9fe39514eb92153b7995421c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/subfield.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/utilities.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/utilities.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b09227f855488cd24c0f57bb227f9b03f9bd96dc
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/__pycache__/utilities.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/basis.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/basis.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c9cb41925973b3a10a80cc6ba1442cf44330971
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/basis.py
@@ -0,0 +1,246 @@
+"""Computing integral bases for number fields. """
+
+from sympy.polys.polytools import Poly
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.utilities.decorator import public
+from .modules import ModuleEndomorphism, ModuleHomomorphism, PowerBasis
+from .utilities import extract_fundamental_discriminant
+
+
+def _apply_Dedekind_criterion(T, p):
+    r"""
+    Apply the "Dedekind criterion" to test whether the order needs to be
+    enlarged relative to a given prime *p*.
+    """
+    x = T.gen
+    T_bar = Poly(T, modulus=p)
+    lc, fl = T_bar.factor_list()
+    assert lc == 1
+    g_bar = Poly(1, x, modulus=p)
+    for ti_bar, _ in fl:
+        g_bar *= ti_bar
+    h_bar = T_bar // g_bar
+    g = Poly(g_bar, domain=ZZ)
+    h = Poly(h_bar, domain=ZZ)
+    f = (g * h - T) // p
+    f_bar = Poly(f, modulus=p)
+    Z_bar = f_bar
+    for b in [g_bar, h_bar]:
+        Z_bar = Z_bar.gcd(b)
+    U_bar = T_bar // Z_bar
+    m = Z_bar.degree()
+    return U_bar, m
+
+
+def nilradical_mod_p(H, p, q=None):
+    r"""
+    Compute the nilradical mod *p* for a given order *H*, and prime *p*.
+
+    Explanation
+    ===========
+
+    This is the ideal $I$ in $H/pH$ consisting of all elements some positive
+    power of which is zero in this quotient ring, i.e. is a multiple of *p*.
+
+    Parameters
+    ==========
+
+    H : :py:class:`~.Submodule`
+        The given order.
+    p : int
+        The rational prime.
+    q : int, optional
+        If known, the smallest power of *p* that is $>=$ the dimension of *H*.
+        If not provided, we compute it here.
+
+    Returns
+    =======
+
+    :py:class:`~.Module` representing the nilradical mod *p* in *H*.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+    (See Lemma 6.1.6.)
+
+    """
+    n = H.n
+    if q is None:
+        q = p
+        while q < n:
+            q *= p
+    phi = ModuleEndomorphism(H, lambda x: x**q)
+    return phi.kernel(modulus=p)
+
+
+def _second_enlargement(H, p, q):
+    r"""
+    Perform the second enlargement in the Round Two algorithm.
+    """
+    Ip = nilradical_mod_p(H, p, q=q)
+    B = H.parent.submodule_from_matrix(H.matrix * Ip.matrix, denom=H.denom)
+    C = B + p*H
+    E = C.endomorphism_ring()
+    phi = ModuleHomomorphism(H, E, lambda x: E.inner_endomorphism(x))
+    gamma = phi.kernel(modulus=p)
+    G = H.parent.submodule_from_matrix(H.matrix * gamma.matrix, denom=H.denom * p)
+    H1 = G + H
+    return H1, Ip
+
+
+@public
+def round_two(T, radicals=None):
+    r"""
+    Zassenhaus's "Round 2" algorithm.
+
+    Explanation
+    ===========
+
+    Carry out Zassenhaus's "Round 2" algorithm on an irreducible polynomial
+    *T* over :ref:`ZZ` or :ref:`QQ`. This computes an integral basis and the
+    discriminant for the field $K = \mathbb{Q}[x]/(T(x))$.
+
+    Alternatively, you may pass an :py:class:`~.AlgebraicField` instance, in
+    place of the polynomial *T*, in which case the algorithm is applied to the
+    minimal polynomial for the field's primitive element.
+
+    Ordinarily this function need not be called directly, as one can instead
+    access the :py:meth:`~.AlgebraicField.maximal_order`,
+    :py:meth:`~.AlgebraicField.integral_basis`, and
+    :py:meth:`~.AlgebraicField.discriminant` methods of an
+    :py:class:`~.AlgebraicField`.
+
+    Examples
+    ========
+
+    Working through an AlgebraicField:
+
+    >>> from sympy import Poly, QQ
+    >>> from sympy.abc import x
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> K = QQ.alg_field_from_poly(T, "theta")
+    >>> print(K.maximal_order())
+    Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2
+    >>> print(K.discriminant())
+    -503
+    >>> print(K.integral_basis(fmt='sympy'))
+    [1, theta, theta/2 + theta**2/2]
+
+    Calling directly:
+
+    >>> from sympy import Poly
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.basis import round_two
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> print(round_two(T))
+    (Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2, -503)
+
+    The nilradicals mod $p$ that are sometimes computed during the Round Two
+    algorithm may be useful in further calculations. Pass a dictionary under
+    `radicals` to receive these:
+
+    >>> T = Poly(x**3 + 3*x**2 + 5)
+    >>> rad = {}
+    >>> ZK, dK = round_two(T, radicals=rad)
+    >>> print(rad)
+    {3: Submodule[[-1, 1, 0], [-1, 0, 1]]}
+
+    Parameters
+    ==========
+
+    T : :py:class:`~.Poly`, :py:class:`~.AlgebraicField`
+        Either (1) the irreducible polynomial over :ref:`ZZ` or :ref:`QQ`
+        defining the number field, or (2) an :py:class:`~.AlgebraicField`
+        representing the number field itself.
+
+    radicals : dict, optional
+        This is a way for any $p$-radicals (if computed) to be returned by
+        reference. If desired, pass an empty dictionary. If the algorithm
+        reaches the point where it computes the nilradical mod $p$ of the ring
+        of integers $Z_K$, then an $\mathbb{F}_p$-basis for this ideal will be
+        stored in this dictionary under the key ``p``. This can be useful for
+        other algorithms, such as prime decomposition.
+
+    Returns
+    =======
+
+    Pair ``(ZK, dK)``, where:
+
+        ``ZK`` is a :py:class:`~sympy.polys.numberfields.modules.Submodule`
+        representing the maximal order.
+
+        ``dK`` is the discriminant of the field $K = \mathbb{Q}[x]/(T(x))$.
+
+    See Also
+    ========
+
+    .AlgebraicField.maximal_order
+    .AlgebraicField.integral_basis
+    .AlgebraicField.discriminant
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+
+    """
+    K = None
+    if isinstance(T, AlgebraicField):
+        K, T = T, T.ext.minpoly_of_element()
+    if (   not T.is_univariate
+        or not T.is_irreducible
+        or T.domain not in [ZZ, QQ]):
+        raise ValueError('Round 2 requires an irreducible univariate polynomial over ZZ or QQ.')
+    T, _ = T.make_monic_over_integers_by_scaling_roots()
+    n = T.degree()
+    D = T.discriminant()
+    D_modulus = ZZ.from_sympy(abs(D))
+    # D must be 0 or 1 mod 4 (see Cohen Sec 4.4), which ensures we can write
+    # it in the form D = D_0 * F**2, where D_0 is 1 or a fundamental discriminant.
+    _, F = extract_fundamental_discriminant(D)
+    Ztheta = PowerBasis(K or T)
+    H = Ztheta.whole_submodule()
+    nilrad = None
+    while F:
+        # Next prime:
+        p, e = F.popitem()
+        U_bar, m = _apply_Dedekind_criterion(T, p)
+        if m == 0:
+            continue
+        # For a given prime p, the first enlargement of the order spanned by
+        # the current basis can be done in a simple way:
+        U = Ztheta.element_from_poly(Poly(U_bar, domain=ZZ))
+        # TODO:
+        #  Theory says only first m columns of the U//p*H term below are needed.
+        #  Could be slightly more efficient to use only those. Maybe `Submodule`
+        #  class should support a slice operator?
+        H = H.add(U // p * H, hnf_modulus=D_modulus)
+        if e <= m:
+            continue
+        # A second, and possibly more, enlargements for p will be needed.
+        # These enlargements require a more involved procedure.
+        q = p
+        while q < n:
+            q *= p
+        H1, nilrad = _second_enlargement(H, p, q)
+        while H1 != H:
+            H = H1
+            H1, nilrad = _second_enlargement(H, p, q)
+    # Note: We do not store all nilradicals mod p, only the very last. This is
+    # because, unless computed against the entire integral basis, it might not
+    # be accurate. (In other words, if H was not already equal to ZK when we
+    # passed it to `_second_enlargement`, then we can't trust the nilradical
+    # so computed.) Example: if T(x) = x ** 3 + 15 * x ** 2 - 9 * x + 13, then
+    # F is divisible by 2, 3, and 7, and the nilradical mod 2 as computed above
+    # will not be accurate for the full, maximal order ZK.
+    if nilrad is not None and isinstance(radicals, dict):
+        radicals[p] = nilrad
+    ZK = H
+    # Pre-set expensive boolean properties which we already know to be true:
+    ZK._starts_with_unity = True
+    ZK._is_sq_maxrank_HNF = True
+    dK = (D * ZK.matrix.det() ** 2) // ZK.denom ** (2 * n)
+    return ZK, dK
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/exceptions.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfe59562e7c83c790888e9c2d405c4580322ce36
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/exceptions.py
@@ -0,0 +1,53 @@
+"""Special exception classes for numberfields. """
+
+
+class ClosureFailure(Exception):
+    r"""
+    Signals that a :py:class:`ModuleElement` which we tried to represent in a
+    certain :py:class:`Module` cannot in fact be represented there.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.numberfields.modules import PowerBasis, to_col, ClosureFailure
+    >>> from sympy.testing.pytest import raises
+    >>> T = Poly(cyclotomic_poly(5))
+    >>> A = PowerBasis(T)
+    >>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+
+    Because we are in a cyclotomic field, the power basis ``A`` is an integral
+    basis, and the submodule ``B`` is just the ideal $(2)$. Therefore ``B`` can
+    represent an element having all even coefficients over the power basis:
+
+    >>> a1 = A(to_col([2, 4, 6, 8]))
+    >>> print(B.represent(a1))
+    DomainMatrix([[1], [2], [3], [4]], (4, 1), ZZ)
+
+    but ``B`` cannot represent an element with an odd coefficient:
+
+    >>> a2 = A(to_col([1, 2, 2, 2]))
+    >>> print(raises(ClosureFailure, lambda: B.represent(a2)))
+    <ExceptionInfo ClosureFailure('Element in QQ-span but not ZZ-span of this basis.')>
+
+    """
+    pass
+
+
+class StructureError(Exception):
+    r"""
+    Represents cases in which an algebraic structure was expected to have a
+    certain property, or be of a certain type, but was not.
+    """
+    pass
+
+
+class MissingUnityError(StructureError):
+    r"""Structure should contain a unity element but does not."""
+    pass
+
+
+__all__ = [
+    'ClosureFailure', 'StructureError', 'MissingUnityError',
+]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galois_resolvents.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galois_resolvents.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b62e6e63c462671a25dc5bf7167f5d1c6f96c51
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galois_resolvents.py
@@ -0,0 +1,673 @@
+r"""
+Galois resolvents
+
+Each of the functions in ``sympy.polys.numberfields.galoisgroups`` that
+computes Galois groups for a particular degree $n$ uses resolvents. Given the
+polynomial $T$ whose Galois group is to be computed, a resolvent is a
+polynomial $R$ whose roots are defined as functions of the roots of $T$.
+
+One way to compute the coefficients of $R$ is by approximating the roots of $T$
+to sufficient precision. This module defines a :py:class:`~.Resolvent` class
+that handles this job, determining the necessary precision, and computing $R$.
+
+In some cases, the coefficients of $R$ are symmetric in the roots of $T$,
+meaning they are equal to fixed functions of the coefficients of $T$. Therefore
+another approach is to compute these functions once and for all, and record
+them in a lookup table. This module defines code that can compute such tables.
+The tables for polynomials $T$ of degrees 4 through 6, produced by this code,
+are recorded in the resolvent_lookup.py module.
+
+"""
+
+from sympy.core.evalf import (
+    evalf, fastlog, _evalf_with_bounded_error, quad_to_mpmath,
+)
+from sympy.core.symbol import symbols, Dummy
+from sympy.polys.densetools import dup_eval
+from sympy.polys.domains import ZZ
+from sympy.polys.numberfields.resolvent_lookup import resolvent_coeff_lambdas
+from sympy.polys.orderings import lex
+from sympy.polys.polyroots import preprocess_roots
+from sympy.polys.polytools import Poly
+from sympy.polys.rings import xring
+from sympy.polys.specialpolys import symmetric_poly
+from sympy.utilities.lambdify import lambdify
+
+from mpmath import MPContext
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class GaloisGroupException(Exception):
+    ...
+
+
+class ResolventException(GaloisGroupException):
+    ...
+
+
+class Resolvent:
+    r"""
+    If $G$ is a subgroup of the symmetric group $S_n$,
+    $F$ a multivariate polynomial in $\mathbb{Z}[X_1, \ldots, X_n]$,
+    $H$ the stabilizer of $F$ in $G$ (i.e. the permutations $\sigma$ such that
+    $F(X_{\sigma(1)}, \ldots, X_{\sigma(n)}) = F(X_1, \ldots, X_n)$), and $s$
+    a set of left coset representatives of $H$ in $G$, then the resolvent
+    polynomial $R(Y)$ is the product over $\sigma \in s$ of
+    $Y - F(X_{\sigma(1)}, \ldots, X_{\sigma(n)})$.
+
+    For example, consider the resolvent for the form
+    $$F = X_0 X_2 + X_1 X_3$$
+    and the group $G = S_4$. In this case, the stabilizer $H$ is the dihedral
+    group $D4 = < (0123), (02) >$, and a set of representatives of $G/H$ is
+    $\{I, (01), (03)\}$. The resolvent can be constructed as follows:
+
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.core.symbol import symbols
+    >>> from sympy.polys.numberfields.galoisgroups import Resolvent
+    >>> X = symbols('X0 X1 X2 X3')
+    >>> F = X[0]*X[2] + X[1]*X[3]
+    >>> s = [Permutation([0, 1, 2, 3]), Permutation([1, 0, 2, 3]),
+    ... Permutation([3, 1, 2, 0])]
+    >>> R = Resolvent(F, X, s)
+
+    This resolvent has three roots, which are the conjugates of ``F`` under the
+    three permutations in ``s``:
+
+    >>> R.root_lambdas[0](*X)
+    X0*X2 + X1*X3
+    >>> R.root_lambdas[1](*X)
+    X0*X3 + X1*X2
+    >>> R.root_lambdas[2](*X)
+    X0*X1 + X2*X3
+
+    Resolvents are useful for computing Galois groups. Given a polynomial $T$
+    of degree $n$, we will use a resolvent $R$ where $Gal(T) \leq G \leq S_n$.
+    We will then want to substitute the roots of $T$ for the variables $X_i$
+    in $R$, and study things like the discriminant of $R$, and the way $R$
+    factors over $\mathbb{Q}$.
+
+    From the symmetry in $R$'s construction, and since $Gal(T) \leq G$, we know
+    from Galois theory that the coefficients of $R$ must lie in $\mathbb{Z}$.
+    This allows us to compute the coefficients of $R$ by approximating the
+    roots of $T$ to sufficient precision, plugging these values in for the
+    variables $X_i$ in the coefficient expressions of $R$, and then simply
+    rounding to the nearest integer.
+
+    In order to determine a sufficient precision for the roots of $T$, this
+    ``Resolvent`` class imposes certain requirements on the form ``F``. It
+    could be possible to design a different ``Resolvent`` class, that made
+    different precision estimates, and different assumptions about ``F``.
+
+    ``F`` must be homogeneous, and all terms must have unit coefficient.
+    Furthermore, if $r$ is the number of terms in ``F``, and $t$ the total
+    degree, and if $m$ is the number of conjugates of ``F``, i.e. the number
+    of permutations in ``s``, then we require that $m < r 2^t$. Again, it is
+    not impossible to work with forms ``F`` that violate these assumptions, but
+    this ``Resolvent`` class requires them.
+
+    Since determining the integer coefficients of the resolvent for a given
+    polynomial $T$ is one of the main problems this class solves, we take some
+    time to explain the precision bounds it uses.
+
+    The general problem is:
+    Given a multivariate polynomial $P \in \mathbb{Z}[X_1, \ldots, X_n]$, and a
+    bound $M \in \mathbb{R}_+$, compute an $\varepsilon > 0$ such that for any
+    complex numbers $a_1, \ldots, a_n$ with $|a_i| < M$, if the $a_i$ are
+    approximated to within an accuracy of $\varepsilon$ by $b_i$, that is,
+    $|a_i - b_i| < \varepsilon$ for $i = 1, \ldots, n$, then
+    $|P(a_1, \ldots, a_n) - P(b_1, \ldots, b_n)| < 1/2$. In other words, if it
+    is known that $P(a_1, \ldots, a_n) = c$ for some $c \in \mathbb{Z}$, then
+    $P(b_1, \ldots, b_n)$ can be rounded to the nearest integer in order to
+    determine $c$.
+
+    To derive our error bound, consider the monomial $xyz$. Defining
+    $d_i = b_i - a_i$, our error is
+    $|(a_1 + d_1)(a_2 + d_2)(a_3 + d_3) - a_1 a_2 a_3|$, which is bounded
+    above by $|(M + \varepsilon)^3 - M^3|$. Passing to a general monomial of
+    total degree $t$, this expression is bounded by
+    $M^{t-1}\varepsilon(t + 2^t\varepsilon/M)$ provided $\varepsilon < M$,
+    and by $(t+1)M^{t-1}\varepsilon$ provided $\varepsilon < M/2^t$.
+    But since our goal is to make the error less than $1/2$, we will choose
+    $\varepsilon < 1/(2(t+1)M^{t-1})$, which implies the condition that
+    $\varepsilon < M/2^t$, as long as $M \geq 2$.
+
+    Passing from the general monomial to the general polynomial is easy, by
+    scaling and summing error bounds.
+
+    In our specific case, we are given a homogeneous polynomial $F$ of
+    $r$ terms and total degree $t$, all of whose coefficients are $\pm 1$. We
+    are given the $m$ permutations that make the conjugates of $F$, and
+    we want to bound the error in the coefficients of the monic polynomial
+    $R(Y)$ having $F$ and its conjugates as roots (i.e. the resolvent).
+
+    For $j$ from $1$ to $m$, the coefficient of $Y^{m-j}$ in $R(Y)$ is the
+    $j$th elementary symmetric polynomial in the conjugates of $F$. This sums
+    the products of these conjugates, taken $j$ at a time, in all possible
+    combinations. There are $\binom{m}{j}$ such combinations, and each product
+    of $j$ conjugates of $F$ expands to a sum of $r^j$ terms, each of unit
+    coefficient, and total degree $jt$. An error bound for the $j$th coeff of
+    $R$ is therefore
+    $$\binom{m}{j} r^j (jt + 1) M^{jt - 1} \varepsilon$$
+    When our goal is to evaluate all the coefficients of $R$, we will want to
+    use the maximum of these error bounds. It is clear that this bound is
+    strictly increasing for $j$ up to the ceiling of $m/2$. After that point,
+    the first factor $\binom{m}{j}$ begins to decrease, while the others
+    continue to increase. However, the binomial coefficient never falls by more
+    than a factor of $1/m$ at a time, so our assumptions that $M \geq 2$ and
+    $m < r 2^t$ are enough to tell us that the constant coefficient of $R$,
+    i.e. that where $j = m$, has the largest error bound. Therefore we can use
+    $$r^m (mt + 1) M^{mt - 1} \varepsilon$$
+    as our error bound for all the coefficients.
+
+    Note that this bound is also (more than) adequate to determine whether any
+    of the roots of $R$ is an integer. Each of these roots is a single
+    conjugate of $F$, which contains less error than the trace, i.e. the
+    coefficient of $Y^{m - 1}$. By rounding the roots of $R$ to the nearest
+    integers, we therefore get all the candidates for integer roots of $R$. By
+    plugging these candidates into $R$, we can check whether any of them
+    actually is a root.
+
+    Note: We take the definition of resolvent from Cohen, but the error bound
+    is ours.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+       (Def 6.3.2)
+
+    """
+
+    def __init__(self, F, X, s):
+        r"""
+        Parameters
+        ==========
+
+        F : :py:class:`~.Expr`
+            polynomial in the symbols in *X*
+        X : list of :py:class:`~.Symbol`
+        s : list of :py:class:`~.Permutation`
+            representing the cosets of the stabilizer of *F* in
+            some subgroup $G$ of $S_n$, where $n$ is the length of *X*.
+        """
+        self.F = F
+        self.X = X
+        self.s = s
+
+        # Number of conjugates:
+        self.m = len(s)
+        # Total degree of F (computed below):
+        self.t = None
+        # Number of terms in F (computed below):
+        self.r = 0
+
+        for monom, coeff in Poly(F).terms():
+            if abs(coeff) != 1:
+                raise ResolventException('Resolvent class expects forms with unit coeffs')
+            t = sum(monom)
+            if t != self.t and self.t is not None:
+                raise ResolventException('Resolvent class expects homogeneous forms')
+            self.t = t
+            self.r += 1
+
+        m, t, r = self.m, self.t, self.r
+        if not m < r * 2**t:
+            raise ResolventException('Resolvent class expects m < r*2^t')
+        M = symbols('M')
+        # Precision sufficient for computing the coeffs of the resolvent:
+        self.coeff_prec_func = Poly(r**m*(m*t + 1)*M**(m*t - 1))
+        # Precision sufficient for checking whether any of the roots of the
+        # resolvent are integers:
+        self.root_prec_func = Poly(r*(t + 1)*M**(t - 1))
+
+        # The conjugates of F are the roots of the resolvent.
+        # For evaluating these to required numerical precisions, we need
+        # lambdified versions.
+        # Note: for a given permutation sigma, the conjugate (sigma F) is
+        # equivalent to lambda [sigma^(-1) X]: F.
+        self.root_lambdas = [
+            lambdify((~s[j])(X), F)
+            for j in range(self.m)
+        ]
+
+        # For evaluating the coeffs, we'll also need lambdified versions of
+        # the elementary symmetric functions for degree m.
+        Y = symbols('Y')
+        R = symbols(' '.join(f'R{i}' for i in range(m)))
+        f = 1
+        for r in R:
+            f *= (Y - r)
+        C = Poly(f, Y).coeffs()
+        self.esf_lambdas = [lambdify(R, c) for c in C]
+
+    def get_prec(self, M, target='coeffs'):
+        r"""
+        For a given upper bound *M* on the magnitude of the complex numbers to
+        be plugged in for this resolvent's symbols, compute a sufficient
+        precision for evaluating those complex numbers, such that the
+        coefficients, or the integer roots, of the resolvent can be determined.
+
+        Parameters
+        ==========
+
+        M : real number
+            Upper bound on magnitude of the complex numbers to be plugged in.
+
+        target : str, 'coeffs' or 'roots', default='coeffs'
+            Name the task for which a sufficient precision is desired.
+            This is either determining the coefficients of the resolvent
+            ('coeffs') or determining its possible integer roots ('roots').
+            The latter may require significantly lower precision.
+
+        Returns
+        =======
+
+        int $m$
+            such that $2^{-m}$ is a sufficient upper bound on the
+            error in approximating the complex numbers to be plugged in.
+
+        """
+        # As explained in the docstring for this class, our precision estimates
+        # require that M be at least 2.
+        M = max(M, 2)
+        f = self.coeff_prec_func if target == 'coeffs' else self.root_prec_func
+        r, _, _, _ = evalf(2*f(M), 1, {})
+        return fastlog(r) + 1
+
+    def approximate_roots_of_poly(self, T, target='coeffs'):
+        """
+        Approximate the roots of a given polynomial *T* to sufficient precision
+        in order to evaluate this resolvent's coefficients, or determine
+        whether the resolvent has an integer root.
+
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`
+
+        target : str, 'coeffs' or 'roots', default='coeffs'
+            Set the approximation precision to be sufficient for the desired
+            task, which is either determining the coefficients of the resolvent
+            ('coeffs') or determining its possible integer roots ('roots').
+            The latter may require significantly lower precision.
+
+        Returns
+        =======
+
+        list of elements of :ref:`CC`
+
+        """
+        ctx = MPContext()
+        # Because sympy.polys.polyroots._integer_basis() is called when a CRootOf
+        # is formed, we proactively extract the integer basis now. This means that
+        # when we call T.all_roots(), every root will be a CRootOf, not a Mul
+        # of Integer*CRootOf.
+        coeff, T = preprocess_roots(T)
+        coeff = ctx.mpf(str(coeff))
+
+        scaled_roots = T.all_roots(radicals=False)
+
+        # Since we're going to be approximating the roots of T anyway, we can
+        # get a good upper bound on the magnitude of the roots by starting with
+        # a very low precision approx.
+        approx0 = [coeff * quad_to_mpmath(_evalf_with_bounded_error(r, m=0)) for r in scaled_roots]
+        # Here we add 1 to account for the possible error in our initial approximation.
+        M = max(abs(b) for b in approx0) + 1
+        m = self.get_prec(M, target=target)
+        n = fastlog(M._mpf_) + 1
+        p = m + n + 1
+        ctx.prec = p
+        d = prec_to_dps(p)
+
+        approx1 = [r.eval_approx(d, return_mpmath=True) for r in scaled_roots]
+        approx1 = [coeff*ctx.mpc(r) for r in approx1]
+
+        return approx1
+
+    @staticmethod
+    def round_mpf(a):
+        if isinstance(a, int):
+            return a
+        # If we use python's built-in `round()`, we lose precision.
+        # If we use `ZZ` directly, we may add or subtract 1.
+        return ZZ(a.context.nint(a))
+
+    def round_roots_to_integers_for_poly(self, T):
+        """
+        For a given polynomial *T*, round the roots of this resolvent to the
+        nearest integers.
+
+        Explanation
+        ===========
+
+        None of the integers returned by this method is guaranteed to be a
+        root of the resolvent; however, if the resolvent has any integer roots
+        (for the given polynomial *T*), then they must be among these.
+
+        If the coefficients of the resolvent are also desired, then this method
+        should not be used. Instead, use the ``eval_for_poly`` method. This
+        method may be significantly faster than ``eval_for_poly``.
+
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`
+
+        Returns
+        =======
+
+        dict
+            Keys are the indices of those permutations in ``self.s`` such that
+            the corresponding root did round to a rational integer.
+
+            Values are :ref:`ZZ`.
+
+
+        """
+        approx_roots_of_T = self.approximate_roots_of_poly(T, target='roots')
+        approx_roots_of_self = [r(*approx_roots_of_T) for r in self.root_lambdas]
+        return {
+            i: self.round_mpf(r.real)
+            for i, r in enumerate(approx_roots_of_self)
+            if self.round_mpf(r.imag) == 0
+        }
+
+    def eval_for_poly(self, T, find_integer_root=False):
+        r"""
+        Compute the integer values of the coefficients of this resolvent, when
+        plugging in the roots of a given polynomial.
+
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`
+
+        find_integer_root : ``bool``, default ``False``
+            If ``True``, then also determine whether the resolvent has an
+            integer root, and return the first one found, along with its
+            index, i.e. the index of the permutation ``self.s[i]`` it
+            corresponds to.
+
+        Returns
+        =======
+
+        Tuple ``(R, a, i)``
+
+            ``R`` is this resolvent as a dense univariate polynomial over
+            :ref:`ZZ`, i.e. a list of :ref:`ZZ`.
+
+            If *find_integer_root* was ``True``, then ``a`` and ``i`` are the
+            first integer root found, and its index, if one exists.
+            Otherwise ``a`` and ``i`` are both ``None``.
+
+        """
+        approx_roots_of_T = self.approximate_roots_of_poly(T, target='coeffs')
+        approx_roots_of_self = [r(*approx_roots_of_T) for r in self.root_lambdas]
+        approx_coeffs_of_self = [c(*approx_roots_of_self) for c in self.esf_lambdas]
+
+        R = []
+        for c in approx_coeffs_of_self:
+            if self.round_mpf(c.imag) != 0:
+                # If precision was enough, this should never happen.
+                raise ResolventException(f"Got non-integer coeff for resolvent: {c}")
+            R.append(self.round_mpf(c.real))
+
+        a0, i0 = None, None
+
+        if find_integer_root:
+            for i, r in enumerate(approx_roots_of_self):
+                if self.round_mpf(r.imag) != 0:
+                    continue
+                if not dup_eval(R, (a := self.round_mpf(r.real)), ZZ):
+                    a0, i0 = a, i
+                    break
+
+        return R, a0, i0
+
+
+def wrap(text, width=80):
+    """Line wrap a polynomial expression. """
+    out = ''
+    col = 0
+    for c in text:
+        if c == ' ' and col > width:
+            c, col = '\n', 0
+        else:
+            col += 1
+        out += c
+    return out
+
+
+def s_vars(n):
+    """Form the symbols s1, s2, ..., sn to stand for elem. symm. polys. """
+    return symbols([f's{i + 1}' for i in range(n)])
+
+
+def sparse_symmetrize_resolvent_coeffs(F, X, s, verbose=False):
+    """
+    Compute the coefficients of a resolvent as functions of the coefficients of
+    the associated polynomial.
+
+    F must be a sparse polynomial.
+    """
+    import time, sys
+    # Roots of resolvent as multivariate forms over vars X:
+    root_forms = [
+        F.compose(list(zip(X, sigma(X))))
+        for sigma in s
+    ]
+
+    # Coeffs of resolvent (besides lead coeff of 1) as symmetric forms over vars X:
+    Y = [Dummy(f'Y{i}') for i in range(len(s))]
+    coeff_forms = []
+    for i in range(1, len(s) + 1):
+        if verbose:
+            print('----')
+            print(f'Computing symmetric poly of degree {i}...')
+            sys.stdout.flush()
+        t0 = time.time()
+        G = symmetric_poly(i, *Y)
+        t1 = time.time()
+        if verbose:
+            print(f'took {t1 - t0} seconds')
+            print('lambdifying...')
+            sys.stdout.flush()
+        t0 = time.time()
+        C = lambdify(Y, (-1)**i*G)
+        t1 = time.time()
+        if verbose:
+            print(f'took {t1 - t0} seconds')
+            sys.stdout.flush()
+        coeff_forms.append(C)
+
+    coeffs = []
+    for i, f in enumerate(coeff_forms):
+        if verbose:
+            print('----')
+            print(f'Plugging root forms into elem symm poly {i+1}...')
+            sys.stdout.flush()
+        t0 = time.time()
+        g = f(*root_forms)
+        t1 = time.time()
+        coeffs.append(g)
+        if verbose:
+            print(f'took {t1 - t0} seconds')
+            sys.stdout.flush()
+
+    # Now symmetrize these coeffs. This means recasting them as polynomials in
+    # the elementary symmetric polys over X.
+    symmetrized = []
+    symmetrization_times = []
+    ss = s_vars(len(X))
+    for i, A in list(enumerate(coeffs)):
+        if verbose:
+            print('-----')
+            print(f'Coeff {i+1}...')
+            sys.stdout.flush()
+        t0 = time.time()
+        B, rem, _ = A.symmetrize()
+        t1 = time.time()
+        if rem != 0:
+            msg = f"Got nonzero remainder {rem} for resolvent (F, X, s) = ({F}, {X}, {s})"
+            raise ResolventException(msg)
+        B_str = str(B.as_expr(*ss))
+        symmetrized.append(B_str)
+        symmetrization_times.append(t1 - t0)
+        if verbose:
+            print(wrap(B_str))
+            print(f'took {t1 - t0} seconds')
+            sys.stdout.flush()
+
+    return symmetrized, symmetrization_times
+
+
+def define_resolvents():
+    """Define all the resolvents for polys T of degree 4 through 6. """
+    from sympy.combinatorics.galois import PGL2F5
+    from sympy.combinatorics.permutations import Permutation
+
+    R4, X4 = xring("X0,X1,X2,X3", ZZ, lex)
+    X = X4
+
+    # The one resolvent used in `_galois_group_degree_4_lookup()`:
+    F40 = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[0]**2
+    s40 = [
+        Permutation(3),
+        Permutation(3)(0, 1),
+        Permutation(3)(0, 2),
+        Permutation(3)(0, 3),
+        Permutation(3)(1, 2),
+        Permutation(3)(2, 3),
+    ]
+
+    # First resolvent used in `_galois_group_degree_4_root_approx()`:
+    F41 = X[0]*X[2] + X[1]*X[3]
+    s41 = [
+        Permutation(3),
+        Permutation(3)(0, 1),
+        Permutation(3)(0, 3)
+    ]
+
+    R5, X5 = xring("X0,X1,X2,X3,X4", ZZ, lex)
+    X = X5
+
+    # First resolvent used in `_galois_group_degree_5_hybrid()`,
+    # and only one used in `_galois_group_degree_5_lookup_ext_factor()`:
+    F51 = (  X[0]**2*(X[1]*X[4] + X[2]*X[3])
+           + X[1]**2*(X[2]*X[0] + X[3]*X[4])
+           + X[2]**2*(X[3]*X[1] + X[4]*X[0])
+           + X[3]**2*(X[4]*X[2] + X[0]*X[1])
+           + X[4]**2*(X[0]*X[3] + X[1]*X[2]))
+    s51 = [
+        Permutation(4),
+        Permutation(4)(0, 1),
+        Permutation(4)(0, 2),
+        Permutation(4)(0, 3),
+        Permutation(4)(0, 4),
+        Permutation(4)(1, 4)
+    ]
+
+    R6, X6 = xring("X0,X1,X2,X3,X4,X5", ZZ, lex)
+    X = X6
+
+    # First resolvent used in `_galois_group_degree_6_lookup()`:
+    H = PGL2F5()
+    term0 = X[0]**2*X[5]**2*(X[1]*X[4] + X[2]*X[3])
+    terms = {term0.compose(list(zip(X, s(X)))) for s in H.elements}
+    F61 = sum(terms)
+    s61 = [Permutation(5)] + [Permutation(5)(0, n) for n in range(1, 6)]
+
+    # Second resolvent used in `_galois_group_degree_6_lookup()`:
+    F62 = X[0]*X[1]*X[2] + X[3]*X[4]*X[5]
+    s62 = [Permutation(5)] + [
+        Permutation(5)(i, j + 3) for i in range(3) for j in range(3)
+    ]
+
+    return {
+        (4, 0): (F40, X4, s40),
+        (4, 1): (F41, X4, s41),
+        (5, 1): (F51, X5, s51),
+        (6, 1): (F61, X6, s61),
+        (6, 2): (F62, X6, s62),
+    }
+
+
+def generate_lambda_lookup(verbose=False, trial_run=False):
+    """
+    Generate the whole lookup table of coeff lambdas, for all resolvents.
+    """
+    jobs = define_resolvents()
+    lambda_lists = {}
+    total_time = 0
+    time_for_61 = 0
+    time_for_61_last = 0
+    for k, (F, X, s) in jobs.items():
+        symmetrized, times = sparse_symmetrize_resolvent_coeffs(F, X, s, verbose=verbose)
+
+        total_time += sum(times)
+        if k == (6, 1):
+            time_for_61 = sum(times)
+            time_for_61_last = times[-1]
+
+        sv = s_vars(len(X))
+        head = f'lambda {", ".join(str(v) for v in sv)}:'
+        lambda_lists[k] = ',\n        '.join([
+            f'{head} ({wrap(f)})'
+            for f in symmetrized
+        ])
+
+        if trial_run:
+            break
+
+    table = (
+         "# This table was generated by a call to\n"
+         "# `sympy.polys.numberfields.galois_resolvents.generate_lambda_lookup()`.\n"
+        f"# The entire job took {total_time:.2f}s.\n"
+        f"# Of this, Case (6, 1) took {time_for_61:.2f}s.\n"
+        f"# The final polynomial of Case (6, 1) alone took {time_for_61_last:.2f}s.\n"
+         "resolvent_coeff_lambdas = {\n")
+
+    for k, L in lambda_lists.items():
+        table += f"    {k}: [\n"
+        table +=  "        " + L + '\n'
+        table +=  "    ],\n"
+    table += "}\n"
+    return table
+
+
+def get_resolvent_by_lookup(T, number):
+    """
+    Use the lookup table, to return a resolvent (as dup) for a given
+    polynomial *T*.
+
+    Parameters
+    ==========
+
+    T : Poly
+        The polynomial whose resolvent is needed
+
+    number : int
+        For some degrees, there are multiple resolvents.
+        Use this to indicate which one you want.
+
+    Returns
+    =======
+
+    dup
+
+    """
+    degree = T.degree()
+    L = resolvent_coeff_lambdas[(degree, number)]
+    T_coeffs = T.rep.rep[1:]
+    return [ZZ(1)] + [c(*T_coeffs) for c in L]
+
+
+# Use
+#   (.venv) $ python -m sympy.polys.numberfields.galois_resolvents
+# to reproduce the table found in resolvent_lookup.py
+if __name__ == "__main__":
+    import sys
+    verbose = '-v' in sys.argv[1:]
+    trial_run = '-t' in sys.argv[1:]
+    table = generate_lambda_lookup(verbose=verbose, trial_run=trial_run)
+    print(table)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galoisgroups.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galoisgroups.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb2d778b77a5466d8198a98a2cc832fb204fbe5e
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/galoisgroups.py
@@ -0,0 +1,623 @@
+"""
+Compute Galois groups of polynomials.
+
+We use algorithms from [1], with some modifications to use lookup tables for
+resolvents.
+
+References
+==========
+
+.. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+
+"""
+
+from collections import defaultdict
+import random
+
+from sympy.core.symbol import Dummy, symbols
+from sympy.ntheory.primetest import is_square
+from sympy.polys.domains import ZZ
+from sympy.polys.densebasic import dup_random
+from sympy.polys.densetools import dup_eval
+from sympy.polys.euclidtools import dup_discriminant
+from sympy.polys.factortools import dup_factor_list, dup_irreducible_p
+from sympy.polys.numberfields.galois_resolvents import (
+    GaloisGroupException, get_resolvent_by_lookup, define_resolvents,
+    Resolvent,
+)
+from sympy.polys.numberfields.utilities import coeff_search
+from sympy.polys.polytools import (Poly, poly_from_expr,
+                                   PolificationFailed, ComputationFailed)
+from sympy.polys.sqfreetools import dup_sqf_p
+from sympy.utilities import public
+
+
+class MaxTriesException(GaloisGroupException):
+    ...
+
+
+def tschirnhausen_transformation(T, max_coeff=10, max_tries=30, history=None,
+                                 fixed_order=True):
+    r"""
+    Given a univariate, monic, irreducible polynomial over the integers, find
+    another such polynomial defining the same number field.
+
+    Explanation
+    ===========
+
+    See Alg 6.3.4 of [1].
+
+    Parameters
+    ==========
+
+    T : Poly
+        The given polynomial
+    max_coeff : int
+        When choosing a transformation as part of the process,
+        keep the coeffs between plus and minus this.
+    max_tries : int
+        Consider at most this many transformations.
+    history : set, None, optional (default=None)
+        Pass a set of ``Poly.rep``'s in order to prevent any of these
+        polynomials from being returned as the polynomial ``U`` i.e. the
+        transformation of the given polynomial *T*. The given poly *T* will
+        automatically be added to this set, before we try to find a new one.
+    fixed_order : bool, default True
+        If ``True``, work through candidate transformations A(x) in a fixed
+        order, from small coeffs to large, resulting in deterministic behavior.
+        If ``False``, the A(x) are chosen randomly, while still working our way
+        up from small coefficients to larger ones.
+
+    Returns
+    =======
+
+    Pair ``(A, U)``
+
+        ``A`` and ``U`` are ``Poly``, ``A`` is the
+        transformation, and ``U`` is the transformed polynomial that defines
+        the same number field as *T*. The polynomial ``A`` maps the roots of
+        *T* to the roots of ``U``.
+
+    Raises
+    ======
+
+    MaxTriesException
+        if could not find a polynomial before exceeding *max_tries*.
+
+    """
+    X = Dummy('X')
+    n = T.degree()
+    if history is None:
+        history = set()
+    history.add(T.rep)
+
+    if fixed_order:
+        coeff_generators = {}
+        deg_coeff_sum = 3
+        current_degree = 2
+
+    def get_coeff_generator(degree):
+        gen = coeff_generators.get(degree, coeff_search(degree, 1))
+        coeff_generators[degree] = gen
+        return gen
+
+    for i in range(max_tries):
+
+        # We never use linear A(x), since applying a fixed linear transformation
+        # to all roots will only multiply the discriminant of T by a square
+        # integer. This will change nothing important. In particular, if disc(T)
+        # was zero before, it will still be zero now, and typically we apply
+        # the transformation in hopes of replacing T by a squarefree poly.
+
+        if fixed_order:
+            # If d is degree and c max coeff, we move through the dc-space
+            # along lines of constant sum. First d + c = 3 with (d, c) = (2, 1).
+            # Then d + c = 4 with (d, c) = (3, 1), (2, 2). Then d + c = 5 with
+            # (d, c) = (4, 1), (3, 2), (2, 3), and so forth. For a given (d, c)
+            # we go though all sets of coeffs where max = c, before moving on.
+            gen = get_coeff_generator(current_degree)
+            coeffs = next(gen)
+            m = max(abs(c) for c in coeffs)
+            if current_degree + m > deg_coeff_sum:
+                if current_degree == 2:
+                    deg_coeff_sum += 1
+                    current_degree = deg_coeff_sum - 1
+                else:
+                    current_degree -= 1
+                gen = get_coeff_generator(current_degree)
+                coeffs = next(gen)
+            a = [ZZ(1)] + [ZZ(c) for c in coeffs]
+
+        else:
+            # We use a progressive coeff bound, up to the max specified, since it
+            # is preferable to succeed with smaller coeffs.
+            # Give each coeff bound five tries, before incrementing.
+            C = min(i//5 + 1, max_coeff)
+            d = random.randint(2, n - 1)
+            a = dup_random(d, -C, C, ZZ)
+
+        A = Poly(a, T.gen)
+        U = Poly(T.resultant(X - A), X)
+        if U.rep not in history and dup_sqf_p(U.rep.rep, ZZ):
+            return A, U
+    raise MaxTriesException
+
+
+def has_square_disc(T):
+    """Convenience to check if a Poly or dup has square discriminant. """
+    d = T.discriminant() if isinstance(T, Poly) else dup_discriminant(T, ZZ)
+    return is_square(d)
+
+
+def _galois_group_degree_3(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 3.
+
+    Explanation
+    ===========
+
+    Uses Prop 6.3.5 of [1].
+
+    """
+    from sympy.combinatorics.galois import S3TransitiveSubgroups
+    return ((S3TransitiveSubgroups.A3, True) if has_square_disc(T)
+            else (S3TransitiveSubgroups.S3, False))
+
+
+def _galois_group_degree_4_root_approx(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 4.
+
+    Explanation
+    ===========
+
+    Follows Alg 6.3.7 of [1], using a pure root approximation approach.
+
+    """
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.galois import S4TransitiveSubgroups
+
+    X = symbols('X0 X1 X2 X3')
+    # We start by considering the resolvent for the form
+    #   F = X0*X2 + X1*X3
+    # and the group G = S4. In this case, the stabilizer H is D4 = < (0123), (02) >,
+    # and a set of representatives of G/H is {I, (01), (03)}
+    F1 = X[0]*X[2] + X[1]*X[3]
+    s1 = [
+        Permutation(3),
+        Permutation(3)(0, 1),
+        Permutation(3)(0, 3)
+    ]
+    R1 = Resolvent(F1, X, s1)
+
+    # In the second half of the algorithm (if we reach it), we use another
+    # form and set of coset representatives. However, we may need to permute
+    # them first, so cannot form their resolvent now.
+    F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[0]**2
+    s2_pre = [
+        Permutation(3),
+        Permutation(3)(0, 2)
+    ]
+
+    history = set()
+    for i in range(max_tries):
+        if i > 0:
+            # If we're retrying, need a new polynomial T.
+            _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                                history=history,
+                                                fixed_order=not randomize)
+
+        R_dup, _, i0 = R1.eval_for_poly(T, find_integer_root=True)
+        # If R is not squarefree, must retry.
+        if not dup_sqf_p(R_dup, ZZ):
+            continue
+
+        # By Prop 6.3.1 of [1], Gal(T) is contained in A4 iff disc(T) is square.
+        sq_disc = has_square_disc(T)
+
+        if i0 is None:
+            # By Thm 6.3.3 of [1], Gal(T) is not conjugate to any subgroup of the
+            # stabilizer H = D4 that we chose. This means Gal(T) is either A4 or S4.
+            return ((S4TransitiveSubgroups.A4, True) if sq_disc
+                    else (S4TransitiveSubgroups.S4, False))
+
+        # Gal(T) is conjugate to a subgroup of H = D4, so it is either V, C4
+        # or D4 itself.
+
+        if sq_disc:
+            # Neither C4 nor D4 is contained in A4, so Gal(T) must be V.
+            return (S4TransitiveSubgroups.V, True)
+
+        # Gal(T) can only be D4 or C4.
+        # We will now use our second resolvent, with G being that conjugate of D4 that
+        # Gal(T) is contained in. To determine the right conjugate, we will need
+        # the permutation corresponding to the integer root we found.
+        sigma = s1[i0]
+        # Applying sigma means permuting the args of F, and
+        # conjugating the set of coset representatives.
+        F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
+        s2 = [sigma*tau*sigma for tau in s2_pre]
+        R2 = Resolvent(F2, X, s2)
+        R_dup, _, _ = R2.eval_for_poly(T)
+        d = dup_discriminant(R_dup, ZZ)
+        # If d is zero (R has a repeated root), must retry.
+        if d == 0:
+            continue
+        if is_square(d):
+            return (S4TransitiveSubgroups.C4, False)
+        else:
+            return (S4TransitiveSubgroups.D4, False)
+
+    raise MaxTriesException
+
+
+def _galois_group_degree_4_lookup(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 4.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.6 of [1], but uses resolvent coeff lookup.
+
+    """
+    from sympy.combinatorics.galois import S4TransitiveSubgroups
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 0)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    # Compute list L of degrees of irreducible factors of R, in increasing order:
+    fl = dup_factor_list(R_dup, ZZ)
+    L = sorted(sum([
+        [len(r) - 1] * e for r, e in fl[1]
+    ], []))
+
+    if L == [6]:
+        return ((S4TransitiveSubgroups.A4, True) if has_square_disc(T)
+            else (S4TransitiveSubgroups.S4, False))
+
+    if L == [1, 1, 4]:
+        return (S4TransitiveSubgroups.C4, False)
+
+    if L == [2, 2, 2]:
+        return (S4TransitiveSubgroups.V, True)
+
+    assert L == [2, 4]
+    return (S4TransitiveSubgroups.D4, False)
+
+
+def _galois_group_degree_5_hybrid(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 5.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.9 of [1], but uses a hybrid approach, combining resolvent
+    coeff lookup, with root approximation.
+
+    """
+    from sympy.combinatorics.galois import S5TransitiveSubgroups
+    from sympy.combinatorics.permutations import Permutation
+
+    X5 = symbols("X0,X1,X2,X3,X4")
+    res = define_resolvents()
+    F51, _, s51 = res[(5, 1)]
+    F51 = F51.as_expr(*X5)
+    R51 = Resolvent(F51, X5, s51)
+
+    history = set()
+    reached_second_stage = False
+    for i in range(max_tries):
+        if i > 0:
+            _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                                history=history,
+                                                fixed_order=not randomize)
+        R51_dup = get_resolvent_by_lookup(T, 1)
+        if not dup_sqf_p(R51_dup, ZZ):
+            continue
+
+        # First stage
+        # If we have not yet reached the second stage, then the group still
+        # might be S5, A5, or M20, so must test for that.
+        if not reached_second_stage:
+            sq_disc = has_square_disc(T)
+
+            if dup_irreducible_p(R51_dup, ZZ):
+                return ((S5TransitiveSubgroups.A5, True) if sq_disc
+                        else (S5TransitiveSubgroups.S5, False))
+
+            if not sq_disc:
+                return (S5TransitiveSubgroups.M20, False)
+
+        # Second stage
+        reached_second_stage = True
+        # R51 must have an integer root for T.
+        # To choose our second resolvent, we need to know which conjugate of
+        # F51 is a root.
+        rounded_roots = R51.round_roots_to_integers_for_poly(T)
+        # These are integers, and candidates to be roots of R51.
+        # We find the first one that actually is a root.
+        for permutation_index, candidate_root in rounded_roots.items():
+            if not dup_eval(R51_dup, candidate_root, ZZ):
+                break
+
+        X = X5
+        F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[4]**2 + X[4]*X[0]**2
+        s2_pre = [
+            Permutation(4),
+            Permutation(4)(0, 1)(2, 4)
+        ]
+
+        i0 = permutation_index
+        sigma = s51[i0]
+        F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
+        s2 = [sigma*tau*sigma for tau in s2_pre]
+        R2 = Resolvent(F2, X, s2)
+        R_dup, _, _ = R2.eval_for_poly(T)
+        d = dup_discriminant(R_dup, ZZ)
+
+        if d == 0:
+            continue
+        if is_square(d):
+            return (S5TransitiveSubgroups.C5, True)
+        else:
+            return (S5TransitiveSubgroups.D5, True)
+
+    raise MaxTriesException
+
+
+def _galois_group_degree_5_lookup_ext_factor(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 5.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.9 of [1], but uses resolvent coeff lookup, plus
+    factorization over an algebraic extension.
+
+    """
+    from sympy.combinatorics.galois import S5TransitiveSubgroups
+
+    _T = T
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 1)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    sq_disc = has_square_disc(T)
+
+    if dup_irreducible_p(R_dup, ZZ):
+        return ((S5TransitiveSubgroups.A5, True) if sq_disc
+                else (S5TransitiveSubgroups.S5, False))
+
+    if not sq_disc:
+        return (S5TransitiveSubgroups.M20, False)
+
+    # If we get this far, Gal(T) can only be D5 or C5.
+    # But for Gal(T) to have order 5, T must already split completely in
+    # the extension field obtained by adjoining a single one of its roots.
+    fl = Poly(_T, domain=ZZ.alg_field_from_poly(_T)).factor_list()[1]
+    if len(fl) == 5:
+        return (S5TransitiveSubgroups.C5, True)
+    else:
+        return (S5TransitiveSubgroups.D5, True)
+
+
+def _galois_group_degree_6_lookup(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 6.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.10 of [1], but uses resolvent coeff lookup.
+
+    """
+    from sympy.combinatorics.galois import S6TransitiveSubgroups
+
+    # First resolvent:
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 1)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    fl = dup_factor_list(R_dup, ZZ)
+
+    # Group the factors by degree.
+    factors_by_deg = defaultdict(list)
+    for r, _ in fl[1]:
+        factors_by_deg[len(r) - 1].append(r)
+
+    L = sorted(sum([
+        [d] * len(ff) for d, ff in factors_by_deg.items()
+    ], []))
+
+    T_has_sq_disc = has_square_disc(T)
+
+    if L == [1, 2, 3]:
+        f1 = factors_by_deg[3][0]
+        return ((S6TransitiveSubgroups.C6, False) if has_square_disc(f1)
+                else (S6TransitiveSubgroups.D6, False))
+
+    elif L == [3, 3]:
+        f1, f2 = factors_by_deg[3]
+        any_square = has_square_disc(f1) or has_square_disc(f2)
+        return ((S6TransitiveSubgroups.G18, False) if any_square
+                else (S6TransitiveSubgroups.G36m, False))
+
+    elif L == [2, 4]:
+        if T_has_sq_disc:
+            return (S6TransitiveSubgroups.S4p, True)
+        else:
+            f1 = factors_by_deg[4][0]
+            return ((S6TransitiveSubgroups.A4xC2, False) if has_square_disc(f1)
+                    else (S6TransitiveSubgroups.S4xC2, False))
+
+    elif L == [1, 1, 4]:
+        return ((S6TransitiveSubgroups.A4, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.S4m, False))
+
+    elif L == [1, 5]:
+        return ((S6TransitiveSubgroups.PSL2F5, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.PGL2F5, False))
+
+    elif L == [1, 1, 1, 3]:
+        return (S6TransitiveSubgroups.S3, False)
+
+    assert L == [6]
+
+    # Second resolvent:
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 2)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    T_has_sq_disc = has_square_disc(T)
+
+    if dup_irreducible_p(R_dup, ZZ):
+        return ((S6TransitiveSubgroups.A6, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.S6, False))
+    else:
+        return ((S6TransitiveSubgroups.G36p, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.G72, False))
+
+
+@public
+def galois_group(f, *gens, by_name=False, max_tries=30, randomize=False, **args):
+    r"""
+    Compute the Galois group for polynomials *f* up to degree 6.
+
+    Examples
+    ========
+
+    >>> from sympy import galois_group
+    >>> from sympy.abc import x
+    >>> f = x**4 + 1
+    >>> G, alt = galois_group(f)
+    >>> print(G)
+    PermutationGroup([
+    (0 1)(2 3),
+    (0 2)(1 3)])
+
+    The group is returned along with a boolean, indicating whether it is
+    contained in the alternating group $A_n$, where $n$ is the degree of *T*.
+    Along with other group properties, this can help determine which group it
+    is:
+
+    >>> alt
+    True
+    >>> G.order()
+    4
+
+    Alternatively, the group can be returned by name:
+
+    >>> G_name, _ = galois_group(f, by_name=True)
+    >>> print(G_name)
+    S4TransitiveSubgroups.V
+
+    The group itself can then be obtained by calling the name's
+    ``get_perm_group()`` method:
+
+    >>> G_name.get_perm_group()
+    PermutationGroup([
+    (0 1)(2 3),
+    (0 2)(1 3)])
+
+    Group names are values of the enum classes
+    :py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`,
+    :py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`,
+    etc.
+
+    Parameters
+    ==========
+
+    f : Expr
+        Irreducible polynomial over :ref:`ZZ` or :ref:`QQ`, whose Galois group
+        is to be determined.
+    gens : optional list of symbols
+        For converting *f* to Poly, and will be passed on to the
+        :py:func:`~.poly_from_expr` function.
+    by_name : bool, default False
+        If ``True``, the Galois group will be returned by name.
+        Otherwise it will be returned as a :py:class:`~.PermutationGroup`.
+    max_tries : int, default 30
+        Make at most this many attempts in those steps that involve
+        generating Tschirnhausen transformations.
+    randomize : bool, default False
+        If ``True``, then use random coefficients when generating Tschirnhausen
+        transformations. Otherwise try transformations in a fixed order. Both
+        approaches start with small coefficients and degrees and work upward.
+    args : optional
+        For converting *f* to Poly, and will be passed on to the
+        :py:func:`~.poly_from_expr` function.
+
+    Returns
+    =======
+
+    Pair ``(G, alt)``
+        The first element ``G`` indicates the Galois group. It is an instance
+        of one of the :py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`
+        :py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`, etc. enum
+        classes if *by_name* was ``True``, and a :py:class:`~.PermutationGroup`
+        if ``False``.
+
+        The second element is a boolean, saying whether the group is contained
+        in the alternating group $A_n$ ($n$ the degree of *T*).
+
+    Raises
+    ======
+
+    ValueError
+        if *f* is of an unsupported degree.
+
+    MaxTriesException
+        if could not complete before exceeding *max_tries* in those steps
+        that involve generating Tschirnhausen transformations.
+
+    See Also
+    ========
+
+    .Poly.galois_group
+
+    """
+    gens = gens or []
+    args = args or {}
+
+    try:
+        F, opt = poly_from_expr(f, *gens, **args)
+    except PolificationFailed as exc:
+        raise ComputationFailed('galois_group', 1, exc)
+
+    return F.galois_group(by_name=by_name, max_tries=max_tries,
+                          randomize=randomize)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/minpoly.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/minpoly.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3543339bfbaeb0ec5b3bea1ea66c4f354a0c8af
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/minpoly.py
@@ -0,0 +1,883 @@
+"""Minimal polynomials for algebraic numbers."""
+
+from functools import reduce
+
+from sympy.core.add import Add
+from sympy.core.exprtools import Factors
+from sympy.core.function import expand_mul, expand_multinomial, _mexpand
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi, _illegal)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.core.traversal import preorder_traversal
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt, cbrt
+from sympy.functions.elementary.trigonometric import cos, sin, tan
+from sympy.ntheory.factor_ import divisors
+from sympy.utilities.iterables import subsets
+
+from sympy.polys.domains import ZZ, QQ, FractionField
+from sympy.polys.orthopolys import dup_chebyshevt
+from sympy.polys.polyerrors import (
+    NotAlgebraic,
+    GeneratorsError,
+)
+from sympy.polys.polytools import (
+    Poly, PurePoly, invert, factor_list, groebner, resultant,
+    degree, poly_from_expr, parallel_poly_from_expr, lcm
+)
+from sympy.polys.polyutils import dict_from_expr, expr_from_dict
+from sympy.polys.ring_series import rs_compose_add
+from sympy.polys.rings import ring
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.utilities import (
+    numbered_symbols, public, sift
+)
+
+
+def _choose_factor(factors, x, v, dom=QQ, prec=200, bound=5):
+    """
+    Return a factor having root ``v``
+    It is assumed that one of the factors has root ``v``.
+    """
+
+    if isinstance(factors[0], tuple):
+        factors = [f[0] for f in factors]
+    if len(factors) == 1:
+        return factors[0]
+
+    prec1 = 10
+    points = {}
+    symbols = dom.symbols if hasattr(dom, 'symbols') else []
+    while prec1 <= prec:
+        # when dealing with non-Rational numbers we usually evaluate
+        # with `subs` argument but we only need a ballpark evaluation
+        fe = [f.as_expr().xreplace({x:v}) for f in factors]
+        if v.is_number:
+            fe = [f.n(prec) for f in fe]
+
+        # assign integers [0, n) to symbols (if any)
+        for n in subsets(range(bound), k=len(symbols), repetition=True):
+            for s, i in zip(symbols, n):
+                points[s] = i
+
+            # evaluate the expression at these points
+            candidates = [(abs(f.subs(points).n(prec1)), i)
+                for i,f in enumerate(fe)]
+
+            # if we get invalid numbers (e.g. from division by zero)
+            # we try again
+            if any(i in _illegal for i, _ in candidates):
+                continue
+
+            # find the smallest two -- if they differ significantly
+            # then we assume we have found the factor that becomes
+            # 0 when v is substituted into it
+            can = sorted(candidates)
+            (a, ix), (b, _) = can[:2]
+            if b > a * 10**6:  # XXX what to use?
+                return factors[ix]
+
+        prec1 *= 2
+
+    raise NotImplementedError("multiple candidates for the minimal polynomial of %s" % v)
+
+
+def _is_sum_surds(p):
+    args = p.args if p.is_Add else [p]
+    for y in args:
+        if not ((y**2).is_Rational and y.is_extended_real):
+            return False
+    return True
+
+
+def _separate_sq(p):
+    """
+    helper function for ``_minimal_polynomial_sq``
+
+    It selects a rational ``g`` such that the polynomial ``p``
+    consists of a sum of terms whose surds squared have gcd equal to ``g``
+    and a sum of terms with surds squared prime with ``g``;
+    then it takes the field norm to eliminate ``sqrt(g)``
+
+    See simplify.simplify.split_surds and polytools.sqf_norm.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.minpoly import _separate_sq
+    >>> p= -x + sqrt(2) + sqrt(3) + sqrt(7)
+    >>> p = _separate_sq(p); p
+    -x**2 + 2*sqrt(3)*x + 2*sqrt(7)*x - 2*sqrt(21) - 8
+    >>> p = _separate_sq(p); p
+    -x**4 + 4*sqrt(7)*x**3 - 32*x**2 + 8*sqrt(7)*x + 20
+    >>> p = _separate_sq(p); p
+    -x**8 + 48*x**6 - 536*x**4 + 1728*x**2 - 400
+
+    """
+    def is_sqrt(expr):
+        return expr.is_Pow and expr.exp is S.Half
+    # p = c1*sqrt(q1) + ... + cn*sqrt(qn) -> a = [(c1, q1), .., (cn, qn)]
+    a = []
+    for y in p.args:
+        if not y.is_Mul:
+            if is_sqrt(y):
+                a.append((S.One, y**2))
+            elif y.is_Atom:
+                a.append((y, S.One))
+            elif y.is_Pow and y.exp.is_integer:
+                a.append((y, S.One))
+            else:
+                raise NotImplementedError
+        else:
+            T, F = sift(y.args, is_sqrt, binary=True)
+            a.append((Mul(*F), Mul(*T)**2))
+    a.sort(key=lambda z: z[1])
+    if a[-1][1] is S.One:
+        # there are no surds
+        return p
+    surds = [z for y, z in a]
+    for i in range(len(surds)):
+        if surds[i] != 1:
+            break
+    from sympy.simplify.radsimp import _split_gcd
+    g, b1, b2 = _split_gcd(*surds[i:])
+    a1 = []
+    a2 = []
+    for y, z in a:
+        if z in b1:
+            a1.append(y*z**S.Half)
+        else:
+            a2.append(y*z**S.Half)
+    p1 = Add(*a1)
+    p2 = Add(*a2)
+    p = _mexpand(p1**2) - _mexpand(p2**2)
+    return p
+
+def _minimal_polynomial_sq(p, n, x):
+    """
+    Returns the minimal polynomial for the ``nth-root`` of a sum of surds
+    or ``None`` if it fails.
+
+    Parameters
+    ==========
+
+    p : sum of surds
+    n : positive integer
+    x : variable of the returned polynomial
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.minpoly import _minimal_polynomial_sq
+    >>> from sympy import sqrt
+    >>> from sympy.abc import x
+    >>> q = 1 + sqrt(2) + sqrt(3)
+    >>> _minimal_polynomial_sq(q, 3, x)
+    x**12 - 4*x**9 - 4*x**6 + 16*x**3 - 8
+
+    """
+    p = sympify(p)
+    n = sympify(n)
+    if not n.is_Integer or not n > 0 or not _is_sum_surds(p):
+        return None
+    pn = p**Rational(1, n)
+    # eliminate the square roots
+    p -= x
+    while 1:
+        p1 = _separate_sq(p)
+        if p1 is p:
+            p = p1.subs({x:x**n})
+            break
+        else:
+            p = p1
+
+    # _separate_sq eliminates field extensions in a minimal way, so that
+    # if n = 1 then `p = constant*(minimal_polynomial(p))`
+    # if n > 1 it contains the minimal polynomial as a factor.
+    if n == 1:
+        p1 = Poly(p)
+        if p.coeff(x**p1.degree(x)) < 0:
+            p = -p
+        p = p.primitive()[1]
+        return p
+    # by construction `p` has root `pn`
+    # the minimal polynomial is the factor vanishing in x = pn
+    factors = factor_list(p)[1]
+
+    result = _choose_factor(factors, x, pn)
+    return result
+
+def _minpoly_op_algebraic_element(op, ex1, ex2, x, dom, mp1=None, mp2=None):
+    """
+    return the minimal polynomial for ``op(ex1, ex2)``
+
+    Parameters
+    ==========
+
+    op : operation ``Add`` or ``Mul``
+    ex1, ex2 : expressions for the algebraic elements
+    x : indeterminate of the polynomials
+    dom: ground domain
+    mp1, mp2 : minimal polynomials for ``ex1`` and ``ex2`` or None
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, Add, Mul, QQ
+    >>> from sympy.polys.numberfields.minpoly import _minpoly_op_algebraic_element
+    >>> from sympy.abc import x, y
+    >>> p1 = sqrt(sqrt(2) + 1)
+    >>> p2 = sqrt(sqrt(2) - 1)
+    >>> _minpoly_op_algebraic_element(Mul, p1, p2, x, QQ)
+    x - 1
+    >>> q1 = sqrt(y)
+    >>> q2 = 1 / y
+    >>> _minpoly_op_algebraic_element(Add, q1, q2, x, QQ.frac_field(y))
+    x**2*y**2 - 2*x*y - y**3 + 1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Resultant
+    .. [2] I.M. Isaacs, Proc. Amer. Math. Soc. 25 (1970), 638
+           "Degrees of sums in a separable field extension".
+
+    """
+    y = Dummy(str(x))
+    if mp1 is None:
+        mp1 = _minpoly_compose(ex1, x, dom)
+    if mp2 is None:
+        mp2 = _minpoly_compose(ex2, y, dom)
+    else:
+        mp2 = mp2.subs({x: y})
+
+    if op is Add:
+        # mp1a = mp1.subs({x: x - y})
+        if dom == QQ:
+            R, X = ring('X', QQ)
+            p1 = R(dict_from_expr(mp1)[0])
+            p2 = R(dict_from_expr(mp2)[0])
+        else:
+            (p1, p2), _ = parallel_poly_from_expr((mp1, x - y), x, y)
+            r = p1.compose(p2)
+            mp1a = r.as_expr()
+
+    elif op is Mul:
+        mp1a = _muly(mp1, x, y)
+    else:
+        raise NotImplementedError('option not available')
+
+    if op is Mul or dom != QQ:
+        r = resultant(mp1a, mp2, gens=[y, x])
+    else:
+        r = rs_compose_add(p1, p2)
+        r = expr_from_dict(r.as_expr_dict(), x)
+
+    deg1 = degree(mp1, x)
+    deg2 = degree(mp2, y)
+    if op is Mul and deg1 == 1 or deg2 == 1:
+        # if deg1 = 1, then mp1 = x - a; mp1a = x - y - a;
+        # r = mp2(x - a), so that `r` is irreducible
+        return r
+
+    r = Poly(r, x, domain=dom)
+    _, factors = r.factor_list()
+    res = _choose_factor(factors, x, op(ex1, ex2), dom)
+    return res.as_expr()
+
+
+def _invertx(p, x):
+    """
+    Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
+    """
+    p1 = poly_from_expr(p, x)[0]
+
+    n = degree(p1)
+    a = [c * x**(n - i) for (i,), c in p1.terms()]
+    return Add(*a)
+
+
+def _muly(p, x, y):
+    """
+    Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
+    """
+    p1 = poly_from_expr(p, x)[0]
+
+    n = degree(p1)
+    a = [c * x**i * y**(n - i) for (i,), c in p1.terms()]
+    return Add(*a)
+
+
+def _minpoly_pow(ex, pw, x, dom, mp=None):
+    """
+    Returns ``minpoly(ex**pw, x)``
+
+    Parameters
+    ==========
+
+    ex : algebraic element
+    pw : rational number
+    x : indeterminate of the polynomial
+    dom: ground domain
+    mp : minimal polynomial of ``p``
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, QQ, Rational
+    >>> from sympy.polys.numberfields.minpoly import _minpoly_pow, minpoly
+    >>> from sympy.abc import x, y
+    >>> p = sqrt(1 + sqrt(2))
+    >>> _minpoly_pow(p, 2, x, QQ)
+    x**2 - 2*x - 1
+    >>> minpoly(p**2, x)
+    x**2 - 2*x - 1
+    >>> _minpoly_pow(y, Rational(1, 3), x, QQ.frac_field(y))
+    x**3 - y
+    >>> minpoly(y**Rational(1, 3), x)
+    x**3 - y
+
+    """
+    pw = sympify(pw)
+    if not mp:
+        mp = _minpoly_compose(ex, x, dom)
+    if not pw.is_rational:
+        raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    if pw < 0:
+        if mp == x:
+            raise ZeroDivisionError('%s is zero' % ex)
+        mp = _invertx(mp, x)
+        if pw == -1:
+            return mp
+        pw = -pw
+        ex = 1/ex
+
+    y = Dummy(str(x))
+    mp = mp.subs({x: y})
+    n, d = pw.as_numer_denom()
+    res = Poly(resultant(mp, x**d - y**n, gens=[y]), x, domain=dom)
+    _, factors = res.factor_list()
+    res = _choose_factor(factors, x, ex**pw, dom)
+    return res.as_expr()
+
+
+def _minpoly_add(x, dom, *a):
+    """
+    returns ``minpoly(Add(*a), dom, x)``
+    """
+    mp = _minpoly_op_algebraic_element(Add, a[0], a[1], x, dom)
+    p = a[0] + a[1]
+    for px in a[2:]:
+        mp = _minpoly_op_algebraic_element(Add, p, px, x, dom, mp1=mp)
+        p = p + px
+    return mp
+
+
+def _minpoly_mul(x, dom, *a):
+    """
+    returns ``minpoly(Mul(*a), dom, x)``
+    """
+    mp = _minpoly_op_algebraic_element(Mul, a[0], a[1], x, dom)
+    p = a[0] * a[1]
+    for px in a[2:]:
+        mp = _minpoly_op_algebraic_element(Mul, p, px, x, dom, mp1=mp)
+        p = p * px
+    return mp
+
+
+def _minpoly_sin(ex, x):
+    """
+    Returns the minimal polynomial of ``sin(ex)``
+    see https://mathworld.wolfram.com/TrigonometryAngles.html
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            n = c.q
+            q = sympify(n)
+            if q.is_prime:
+                # for a = pi*p/q with q odd prime, using chebyshevt
+                # write sin(q*a) = mp(sin(a))*sin(a);
+                # the roots of mp(x) are sin(pi*p/q) for p = 1,..., q - 1
+                a = dup_chebyshevt(n, ZZ)
+                return Add(*[x**(n - i - 1)*a[i] for i in range(n)])
+            if c.p == 1:
+                if q == 9:
+                    return 64*x**6 - 96*x**4 + 36*x**2 - 3
+
+            if n % 2 == 1:
+                # for a = pi*p/q with q odd, use
+                # sin(q*a) = 0 to see that the minimal polynomial must be
+                # a factor of dup_chebyshevt(n, ZZ)
+                a = dup_chebyshevt(n, ZZ)
+                a = [x**(n - i)*a[i] for i in range(n + 1)]
+                r = Add(*a)
+                _, factors = factor_list(r)
+                res = _choose_factor(factors, x, ex)
+                return res
+
+            expr = ((1 - cos(2*c*pi))/2)**S.Half
+            res = _minpoly_compose(expr, x, QQ)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_cos(ex, x):
+    """
+    Returns the minimal polynomial of ``cos(ex)``
+    see https://mathworld.wolfram.com/TrigonometryAngles.html
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            if c.p == 1:
+                if c.q == 7:
+                    return 8*x**3 - 4*x**2 - 4*x + 1
+                if c.q == 9:
+                    return 8*x**3 - 6*x - 1
+            elif c.p == 2:
+                q = sympify(c.q)
+                if q.is_prime:
+                    s = _minpoly_sin(ex, x)
+                    return _mexpand(s.subs({x:sqrt((1 - x)/2)}))
+
+            # for a = pi*p/q, cos(q*a) =T_q(cos(a)) = (-1)**p
+            n = int(c.q)
+            a = dup_chebyshevt(n, ZZ)
+            a = [x**(n - i)*a[i] for i in range(n + 1)]
+            r = Add(*a) - (-1)**c.p
+            _, factors = factor_list(r)
+            res = _choose_factor(factors, x, ex)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_tan(ex, x):
+    """
+    Returns the minimal polynomial of ``tan(ex)``
+    see https://github.com/sympy/sympy/issues/21430
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            c = c * 2
+            n = int(c.q)
+            a = n if c.p % 2 == 0 else 1
+            terms = []
+            for k in range((c.p+1)%2, n+1, 2):
+                terms.append(a*x**k)
+                a = -(a*(n-k-1)*(n-k)) // ((k+1)*(k+2))
+
+            r = Add(*terms)
+            _, factors = factor_list(r)
+            res = _choose_factor(factors, x, ex)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_exp(ex, x):
+    """
+    Returns the minimal polynomial of ``exp(ex)``
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a == I*pi:
+        if c.is_rational:
+            q = sympify(c.q)
+            if c.p == 1 or c.p == -1:
+                if q == 3:
+                    return x**2 - x + 1
+                if q == 4:
+                    return x**4 + 1
+                if q == 6:
+                    return x**4 - x**2 + 1
+                if q == 8:
+                    return x**8 + 1
+                if q == 9:
+                    return x**6 - x**3 + 1
+                if q == 10:
+                    return x**8 - x**6 + x**4 - x**2 + 1
+                if q.is_prime:
+                    s = 0
+                    for i in range(q):
+                        s += (-x)**i
+                    return s
+
+            # x**(2*q) = product(factors)
+            factors = [cyclotomic_poly(i, x) for i in divisors(2*q)]
+            mp = _choose_factor(factors, x, ex)
+            return mp
+        else:
+            raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_rootof(ex, x):
+    """
+    Returns the minimal polynomial of a ``CRootOf`` object.
+    """
+    p = ex.expr
+    p = p.subs({ex.poly.gens[0]:x})
+    _, factors = factor_list(p, x)
+    result = _choose_factor(factors, x, ex)
+    return result
+
+
+def _minpoly_compose(ex, x, dom):
+    """
+    Computes the minimal polynomial of an algebraic element
+    using operations on minimal polynomials
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, Rational
+    >>> from sympy.abc import x, y
+    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=True)
+    x**2 - 2*x - 1
+    >>> minimal_polynomial(sqrt(y) + 1/y, x, compose=True)
+    x**2*y**2 - 2*x*y - y**3 + 1
+
+    """
+    if ex.is_Rational:
+        return ex.q*x - ex.p
+    if ex is I:
+        _, factors = factor_list(x**2 + 1, x, domain=dom)
+        return x**2 + 1 if len(factors) == 1 else x - I
+
+    if ex is S.GoldenRatio:
+        _, factors = factor_list(x**2 - x - 1, x, domain=dom)
+        if len(factors) == 1:
+            return x**2 - x - 1
+        else:
+            return _choose_factor(factors, x, (1 + sqrt(5))/2, dom=dom)
+
+    if ex is S.TribonacciConstant:
+        _, factors = factor_list(x**3 - x**2 - x - 1, x, domain=dom)
+        if len(factors) == 1:
+            return x**3 - x**2 - x - 1
+        else:
+            fac = (1 + cbrt(19 - 3*sqrt(33)) + cbrt(19 + 3*sqrt(33))) / 3
+            return _choose_factor(factors, x, fac, dom=dom)
+
+    if hasattr(dom, 'symbols') and ex in dom.symbols:
+        return x - ex
+
+    if dom.is_QQ and _is_sum_surds(ex):
+        # eliminate the square roots
+        ex -= x
+        while 1:
+            ex1 = _separate_sq(ex)
+            if ex1 is ex:
+                return ex
+            else:
+                ex = ex1
+
+    if ex.is_Add:
+        res = _minpoly_add(x, dom, *ex.args)
+    elif ex.is_Mul:
+        f = Factors(ex).factors
+        r = sift(f.items(), lambda itx: itx[0].is_Rational and itx[1].is_Rational)
+        if r[True] and dom == QQ:
+            ex1 = Mul(*[bx**ex for bx, ex in r[False] + r[None]])
+            r1 = dict(r[True])
+            dens = [y.q for y in r1.values()]
+            lcmdens = reduce(lcm, dens, 1)
+            neg1 = S.NegativeOne
+            expn1 = r1.pop(neg1, S.Zero)
+            nums = [base**(y.p*lcmdens // y.q) for base, y in r1.items()]
+            ex2 = Mul(*nums)
+            mp1 = minimal_polynomial(ex1, x)
+            # use the fact that in SymPy canonicalization products of integers
+            # raised to rational powers are organized in relatively prime
+            # bases, and that in ``base**(n/d)`` a perfect power is
+            # simplified with the root
+            # Powers of -1 have to be treated separately to preserve sign.
+            mp2 = ex2.q*x**lcmdens - ex2.p*neg1**(expn1*lcmdens)
+            ex2 = neg1**expn1 * ex2**Rational(1, lcmdens)
+            res = _minpoly_op_algebraic_element(Mul, ex1, ex2, x, dom, mp1=mp1, mp2=mp2)
+        else:
+            res = _minpoly_mul(x, dom, *ex.args)
+    elif ex.is_Pow:
+        res = _minpoly_pow(ex.base, ex.exp, x, dom)
+    elif ex.__class__ is sin:
+        res = _minpoly_sin(ex, x)
+    elif ex.__class__ is cos:
+        res = _minpoly_cos(ex, x)
+    elif ex.__class__ is tan:
+        res = _minpoly_tan(ex, x)
+    elif ex.__class__ is exp:
+        res = _minpoly_exp(ex, x)
+    elif ex.__class__ is CRootOf:
+        res = _minpoly_rootof(ex, x)
+    else:
+        raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    return res
+
+
+@public
+def minimal_polynomial(ex, x=None, compose=True, polys=False, domain=None):
+    """
+    Computes the minimal polynomial of an algebraic element.
+
+    Parameters
+    ==========
+
+    ex : Expr
+        Element or expression whose minimal polynomial is to be calculated.
+
+    x : Symbol, optional
+        Independent variable of the minimal polynomial
+
+    compose : boolean, optional (default=True)
+        Method to use for computing minimal polynomial. If ``compose=True``
+        (default) then ``_minpoly_compose`` is used, if ``compose=False`` then
+        groebner bases are used.
+
+    polys : boolean, optional (default=False)
+        If ``True`` returns a ``Poly`` object else an ``Expr`` object.
+
+    domain : Domain, optional
+        Ground domain
+
+    Notes
+    =====
+
+    By default ``compose=True``, the minimal polynomial of the subexpressions of ``ex``
+    are computed, then the arithmetic operations on them are performed using the resultant
+    and factorization.
+    If ``compose=False``, a bottom-up algorithm is used with ``groebner``.
+    The default algorithm stalls less frequently.
+
+    If no ground domain is given, it will be generated automatically from the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, solve, QQ
+    >>> from sympy.abc import x, y
+
+    >>> minimal_polynomial(sqrt(2), x)
+    x**2 - 2
+    >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2)))
+    x - sqrt(2)
+    >>> minimal_polynomial(sqrt(2) + sqrt(3), x)
+    x**4 - 10*x**2 + 1
+    >>> minimal_polynomial(solve(x**3 + x + 3)[0], x)
+    x**3 + x + 3
+    >>> minimal_polynomial(sqrt(y), x)
+    x**2 - y
+
+    """
+
+    ex = sympify(ex)
+    if ex.is_number:
+        # not sure if it's always needed but try it for numbers (issue 8354)
+        ex = _mexpand(ex, recursive=True)
+    for expr in preorder_traversal(ex):
+        if expr.is_AlgebraicNumber:
+            compose = False
+            break
+
+    if x is not None:
+        x, cls = sympify(x), Poly
+    else:
+        x, cls = Dummy('x'), PurePoly
+
+    if not domain:
+        if ex.free_symbols:
+            domain = FractionField(QQ, list(ex.free_symbols))
+        else:
+            domain = QQ
+    if hasattr(domain, 'symbols') and x in domain.symbols:
+        raise GeneratorsError("the variable %s is an element of the ground "
+                              "domain %s" % (x, domain))
+
+    if compose:
+        result = _minpoly_compose(ex, x, domain)
+        result = result.primitive()[1]
+        c = result.coeff(x**degree(result, x))
+        if c.is_negative:
+            result = expand_mul(-result)
+        return cls(result, x, field=True) if polys else result.collect(x)
+
+    if not domain.is_QQ:
+        raise NotImplementedError("groebner method only works for QQ")
+
+    result = _minpoly_groebner(ex, x, cls)
+    return cls(result, x, field=True) if polys else result.collect(x)
+
+
+def _minpoly_groebner(ex, x, cls):
+    """
+    Computes the minimal polynomial of an algebraic number
+    using Groebner bases
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, Rational
+    >>> from sympy.abc import x
+    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=False)
+    x**2 - 2*x - 1
+
+    """
+
+    generator = numbered_symbols('a', cls=Dummy)
+    mapping, symbols = {}, {}
+
+    def update_mapping(ex, exp, base=None):
+        a = next(generator)
+        symbols[ex] = a
+
+        if base is not None:
+            mapping[ex] = a**exp + base
+        else:
+            mapping[ex] = exp.as_expr(a)
+
+        return a
+
+    def bottom_up_scan(ex):
+        """
+        Transform a given algebraic expression *ex* into a multivariate
+        polynomial, by introducing fresh variables with defining equations.
+
+        Explanation
+        ===========
+
+        The critical elements of the algebraic expression *ex* are root
+        extractions, instances of :py:class:`~.AlgebraicNumber`, and negative
+        powers.
+
+        When we encounter a root extraction or an :py:class:`~.AlgebraicNumber`
+        we replace this expression with a fresh variable ``a_i``, and record
+        the defining polynomial for ``a_i``. For example, if ``a_0**(1/3)``
+        occurs, we will replace it with ``a_1``, and record the new defining
+        polynomial ``a_1**3 - a_0``.
+
+        When we encounter a negative power we transform it into a positive
+        power by algebraically inverting the base. This means computing the
+        minimal polynomial in ``x`` for the base, inverting ``x`` modulo this
+        poly (which generates a new polynomial) and then substituting the
+        original base expression for ``x`` in this last polynomial.
+
+        We return the transformed expression, and we record the defining
+        equations for new symbols using the ``update_mapping()`` function.
+
+        """
+        if ex.is_Atom:
+            if ex is S.ImaginaryUnit:
+                if ex not in mapping:
+                    return update_mapping(ex, 2, 1)
+                else:
+                    return symbols[ex]
+            elif ex.is_Rational:
+                return ex
+        elif ex.is_Add:
+            return Add(*[ bottom_up_scan(g) for g in ex.args ])
+        elif ex.is_Mul:
+            return Mul(*[ bottom_up_scan(g) for g in ex.args ])
+        elif ex.is_Pow:
+            if ex.exp.is_Rational:
+                if ex.exp < 0:
+                    minpoly_base = _minpoly_groebner(ex.base, x, cls)
+                    inverse = invert(x, minpoly_base).as_expr()
+                    base_inv = inverse.subs(x, ex.base).expand()
+
+                    if ex.exp == -1:
+                        return bottom_up_scan(base_inv)
+                    else:
+                        ex = base_inv**(-ex.exp)
+                if not ex.exp.is_Integer:
+                    base, exp = (
+                        ex.base**ex.exp.p).expand(), Rational(1, ex.exp.q)
+                else:
+                    base, exp = ex.base, ex.exp
+                base = bottom_up_scan(base)
+                expr = base**exp
+
+                if expr not in mapping:
+                    if exp.is_Integer:
+                        return expr.expand()
+                    else:
+                        return update_mapping(expr, 1 / exp, -base)
+                else:
+                    return symbols[expr]
+        elif ex.is_AlgebraicNumber:
+            if ex not in mapping:
+                return update_mapping(ex, ex.minpoly_of_element())
+            else:
+                return symbols[ex]
+
+        raise NotAlgebraic("%s does not seem to be an algebraic number" % ex)
+
+    def simpler_inverse(ex):
+        """
+        Returns True if it is more likely that the minimal polynomial
+        algorithm works better with the inverse
+        """
+        if ex.is_Pow:
+            if (1/ex.exp).is_integer and ex.exp < 0:
+                if ex.base.is_Add:
+                    return True
+        if ex.is_Mul:
+            hit = True
+            for p in ex.args:
+                if p.is_Add:
+                    return False
+                if p.is_Pow:
+                    if p.base.is_Add and p.exp > 0:
+                        return False
+
+            if hit:
+                return True
+        return False
+
+    inverted = False
+    ex = expand_multinomial(ex)
+    if ex.is_AlgebraicNumber:
+        return ex.minpoly_of_element().as_expr(x)
+    elif ex.is_Rational:
+        result = ex.q*x - ex.p
+    else:
+        inverted = simpler_inverse(ex)
+        if inverted:
+            ex = ex**-1
+        res = None
+        if ex.is_Pow and (1/ex.exp).is_Integer:
+            n = 1/ex.exp
+            res = _minimal_polynomial_sq(ex.base, n, x)
+
+        elif _is_sum_surds(ex):
+            res = _minimal_polynomial_sq(ex, S.One, x)
+
+        if res is not None:
+            result = res
+
+        if res is None:
+            bus = bottom_up_scan(ex)
+            F = [x - bus] + list(mapping.values())
+            G = groebner(F, list(symbols.values()) + [x], order='lex')
+
+            _, factors = factor_list(G[-1])
+            # by construction G[-1] has root `ex`
+            result = _choose_factor(factors, x, ex)
+    if inverted:
+        result = _invertx(result, x)
+        if result.coeff(x**degree(result, x)) < 0:
+            result = expand_mul(-result)
+
+    return result
+
+
+@public
+def minpoly(ex, x=None, compose=True, polys=False, domain=None):
+    """This is a synonym for :py:func:`~.minimal_polynomial`."""
+    return minimal_polynomial(ex, x=x, compose=compose, polys=polys, domain=domain)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/modules.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..db0e619a2c860a3c4d54e3b41e308346f5b68dad
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/modules.py
@@ -0,0 +1,2111 @@
+r"""Modules in number fields.
+
+The classes defined here allow us to work with finitely generated, free
+modules, whose generators are algebraic numbers.
+
+There is an abstract base class called :py:class:`~.Module`, which has two
+concrete subclasses, :py:class:`~.PowerBasis` and :py:class:`~.Submodule`.
+
+Every module is defined by its basis, or set of generators:
+
+* For a :py:class:`~.PowerBasis`, the generators are the first $n$ powers
+  (starting with the zeroth) of an algebraic integer $\theta$ of degree $n$.
+  The :py:class:`~.PowerBasis` is constructed by passing either the minimal
+  polynomial of $\theta$, or an :py:class:`~.AlgebraicField` having $\theta$
+  as its primitive element.
+
+* For a :py:class:`~.Submodule`, the generators are a set of
+  $\mathbb{Q}$-linear combinations of the generators of another module. That
+  other module is then the "parent" of the :py:class:`~.Submodule`. The
+  coefficients of the $\mathbb{Q}$-linear combinations may be given by an
+  integer matrix, and a positive integer denominator. Each column of the matrix
+  defines a generator.
+
+>>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+>>> from sympy.abc import x
+>>> from sympy.polys.matrices import DomainMatrix, DM
+>>> from sympy.polys.numberfields.modules import PowerBasis
+>>> T = Poly(cyclotomic_poly(5, x))
+>>> A = PowerBasis(T)
+>>> print(A)
+PowerBasis(x**4 + x**3 + x**2 + x + 1)
+>>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ), denom=3)
+>>> print(B)
+Submodule[[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]/3
+>>> print(B.parent)
+PowerBasis(x**4 + x**3 + x**2 + x + 1)
+
+Thus, every module is either a :py:class:`~.PowerBasis`,
+or a :py:class:`~.Submodule`, some ancestor of which is a
+:py:class:`~.PowerBasis`. (If ``S`` is a :py:class:`~.Submodule`, then its
+ancestors are ``S.parent``, ``S.parent.parent``, and so on).
+
+The :py:class:`~.ModuleElement` class represents a linear combination of the
+generators of any module. Critically, the coefficients of this linear
+combination are not restricted to be integers, but may be any rational
+numbers. This is necessary so that any and all algebraic integers be
+representable, starting from the power basis in a primitive element $\theta$
+for the number field in question. For example, in a quadratic field
+$\mathbb{Q}(\sqrt{d})$ where $d \equiv 1 \mod{4}$, a denominator of $2$ is
+needed.
+
+A :py:class:`~.ModuleElement` can be constructed from an integer column vector
+and a denominator:
+
+>>> U = Poly(x**2 - 5)
+>>> M = PowerBasis(U)
+>>> e = M(DM([[1], [1]], ZZ), denom=2)
+>>> print(e)
+[1, 1]/2
+>>> print(e.module)
+PowerBasis(x**2 - 5)
+
+The :py:class:`~.PowerBasisElement` class is a subclass of
+:py:class:`~.ModuleElement` that represents elements of a
+:py:class:`~.PowerBasis`, and adds functionality pertinent to elements
+represented directly over powers of the primitive element $\theta$.
+
+
+Arithmetic with module elements
+===============================
+
+While a :py:class:`~.ModuleElement` represents a linear combination over the
+generators of a particular module, recall that every module is either a
+:py:class:`~.PowerBasis` or a descendant (along a chain of
+:py:class:`~.Submodule` objects) thereof, so that in fact every
+:py:class:`~.ModuleElement` represents an algebraic number in some field
+$\mathbb{Q}(\theta)$, where $\theta$ is the defining element of some
+:py:class:`~.PowerBasis`. It thus makes sense to talk about the number field
+to which a given :py:class:`~.ModuleElement` belongs.
+
+This means that any two :py:class:`~.ModuleElement` instances can be added,
+subtracted, multiplied, or divided, provided they belong to the same number
+field. Similarly, since $\mathbb{Q}$ is a subfield of every number field,
+any :py:class:`~.ModuleElement` may be added, multiplied, etc. by any
+rational number.
+
+>>> from sympy import QQ
+>>> from sympy.polys.numberfields.modules import to_col
+>>> T = Poly(cyclotomic_poly(5))
+>>> A = PowerBasis(T)
+>>> C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+>>> e = A(to_col([0, 2, 0, 0]), denom=3)
+>>> f = A(to_col([0, 0, 0, 7]), denom=5)
+>>> g = C(to_col([1, 1, 1, 1]))
+>>> e + f
+[0, 10, 0, 21]/15
+>>> e - f
+[0, 10, 0, -21]/15
+>>> e - g
+[-9, -7, -9, -9]/3
+>>> e + QQ(7, 10)
+[21, 20, 0, 0]/30
+>>> e * f
+[-14, -14, -14, -14]/15
+>>> e ** 2
+[0, 0, 4, 0]/9
+>>> f // g
+[7, 7, 7, 7]/15
+>>> f * QQ(2, 3)
+[0, 0, 0, 14]/15
+
+However, care must be taken with arithmetic operations on
+:py:class:`~.ModuleElement`, because the module $C$ to which the result will
+belong will be the nearest common ancestor (NCA) of the modules $A$, $B$ to
+which the two operands belong, and $C$ may be different from either or both
+of $A$ and $B$.
+
+>>> A = PowerBasis(T)
+>>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+>>> C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+>>> print((B(0) * C(0)).module == A)
+True
+
+Before the arithmetic operation is performed, copies of the two operands are
+automatically converted into elements of the NCA (the operands themselves are
+not modified). This upward conversion along an ancestor chain is easy: it just
+requires the successive multiplication by the defining matrix of each
+:py:class:`~.Submodule`.
+
+Conversely, downward conversion, i.e. representing a given
+:py:class:`~.ModuleElement` in a submodule, is also supported -- namely by
+the :py:meth:`~sympy.polys.numberfields.modules.Submodule.represent` method
+-- but is not guaranteed to succeed in general, since the given element may
+not belong to the submodule. The main circumstance in which this issue tends
+to arise is with multiplication, since modules, while closed under addition,
+need not be closed under multiplication.
+
+
+Multiplication
+--------------
+
+Generally speaking, a module need not be closed under multiplication, i.e. need
+not form a ring. However, many of the modules we work with in the context of
+number fields are in fact rings, and our classes do support multiplication.
+
+Specifically, any :py:class:`~.Module` can attempt to compute its own
+multiplication table, but this does not happen unless an attempt is made to
+multiply two :py:class:`~.ModuleElement` instances belonging to it.
+
+>>> A = PowerBasis(T)
+>>> print(A._mult_tab is None)
+True
+>>> a = A(0)*A(1)
+>>> print(A._mult_tab is None)
+False
+
+Every :py:class:`~.PowerBasis` is, by its nature, closed under multiplication,
+so instances of :py:class:`~.PowerBasis` can always successfully compute their
+multiplication table.
+
+When a :py:class:`~.Submodule` attempts to compute its multiplication table,
+it converts each of its own generators into elements of its parent module,
+multiplies them there, in every possible pairing, and then tries to
+represent the results in itself, i.e. as $\mathbb{Z}$-linear combinations
+over its own generators. This will succeed if and only if the submodule is
+in fact closed under multiplication.
+
+
+Module Homomorphisms
+====================
+
+Many important number theoretic algorithms require the calculation of the
+kernel of one or more module homomorphisms. Accordingly we have several
+lightweight classes, :py:class:`~.ModuleHomomorphism`,
+:py:class:`~.ModuleEndomorphism`, :py:class:`~.InnerEndomorphism`, and
+:py:class:`~.EndomorphismRing`, which provide the minimal necessary machinery
+to support this.
+
+"""
+
+from sympy.core.numbers import igcd, ilcm
+from sympy.core.symbol import Dummy
+from sympy.polys.polyclasses import ANP
+from sympy.polys.polytools import Poly
+from sympy.polys.densetools import dup_clear_denoms
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.finitefield import FF
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.matrices.exceptions import DMBadInputError
+from sympy.polys.matrices.normalforms import hermite_normal_form
+from sympy.polys.polyerrors import CoercionFailed, UnificationFailed
+from sympy.polys.polyutils import IntegerPowerable
+from .exceptions import ClosureFailure, MissingUnityError, StructureError
+from .utilities import AlgIntPowers, is_rat, get_num_denom
+
+
+def to_col(coeffs):
+    r"""Transform a list of integer coefficients into a column vector."""
+    return DomainMatrix([[ZZ(c) for c in coeffs]], (1, len(coeffs)), ZZ).transpose()
+
+
+class Module:
+    """
+    Generic finitely-generated module.
+
+    This is an abstract base class, and should not be instantiated directly.
+    The two concrete subclasses are :py:class:`~.PowerBasis` and
+    :py:class:`~.Submodule`.
+
+    Every :py:class:`~.Submodule` is derived from another module, referenced
+    by its ``parent`` attribute. If ``S`` is a submodule, then we refer to
+    ``S.parent``, ``S.parent.parent``, and so on, as the "ancestors" of
+    ``S``. Thus, every :py:class:`~.Module` is either a
+    :py:class:`~.PowerBasis` or a :py:class:`~.Submodule`, some ancestor of
+    which is a :py:class:`~.PowerBasis`.
+    """
+
+    @property
+    def n(self):
+        """The number of generators of this module."""
+        raise NotImplementedError
+
+    def mult_tab(self):
+        """
+        Get the multiplication table for this module (if closed under mult).
+
+        Explanation
+        ===========
+
+        Computes a dictionary ``M`` of dictionaries of lists, representing the
+        upper triangular half of the multiplication table.
+
+        In other words, if ``0 <= i <= j < self.n``, then ``M[i][j]`` is the
+        list ``c`` of coefficients such that
+        ``g[i] * g[j] == sum(c[k]*g[k], k in range(self.n))``,
+        where ``g`` is the list of generators of this module.
+
+        If ``j < i`` then ``M[i][j]`` is undefined.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> print(A.mult_tab())  # doctest: +SKIP
+        {0: {0: [1, 0, 0, 0], 1: [0, 1, 0, 0], 2: [0, 0, 1, 0],     3: [0, 0, 0, 1]},
+                          1: {1: [0, 0, 1, 0], 2: [0, 0, 0, 1],     3: [-1, -1, -1, -1]},
+                                           2: {2: [-1, -1, -1, -1], 3: [1, 0, 0, 0]},
+                                                                3: {3: [0, 1, 0, 0]}}
+
+        Returns
+        =======
+
+        dict of dict of lists
+
+        Raises
+        ======
+
+        ClosureFailure
+            If the module is not closed under multiplication.
+
+        """
+        raise NotImplementedError
+
+    @property
+    def parent(self):
+        """
+        The parent module, if any, for this module.
+
+        Explanation
+        ===========
+
+        For a :py:class:`~.Submodule` this is its ``parent`` attribute; for a
+        :py:class:`~.PowerBasis` this is ``None``.
+
+        Returns
+        =======
+
+        :py:class:`~.Module`, ``None``
+
+        See Also
+        ========
+
+        Module
+
+        """
+        return None
+
+    def represent(self, elt):
+        r"""
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        Explanation
+        ===========
+
+        In our system, to "represent" always means to write a
+        :py:class:`~.ModuleElement` as a :ref:`ZZ`-linear combination over the
+        generators of the present :py:class:`~.Module`. Furthermore, the
+        incoming :py:class:`~.ModuleElement` must belong to an ancestor of
+        the present :py:class:`~.Module` (or to the present
+        :py:class:`~.Module` itself).
+
+        The most common application is to represent a
+        :py:class:`~.ModuleElement` in a :py:class:`~.Submodule`. For example,
+        this is involved in computing multiplication tables.
+
+        On the other hand, representing in a :py:class:`~.PowerBasis` is an
+        odd case, and one which tends not to arise in practice, except for
+        example when using a :py:class:`~.ModuleEndomorphism` on a
+        :py:class:`~.PowerBasis`.
+
+        In such a case, (1) the incoming :py:class:`~.ModuleElement` must
+        belong to the :py:class:`~.PowerBasis` itself (since the latter has no
+        proper ancestors) and (2) it is "representable" iff it belongs to
+        $\mathbb{Z}[\theta]$ (although generally a
+        :py:class:`~.PowerBasisElement` may represent any element of
+        $\mathbb{Q}(\theta)$, i.e. any algebraic number).
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, to_col
+        >>> from sympy.abc import zeta
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> a = A(to_col([2, 4, 6, 8]))
+
+        The :py:class:`~.ModuleElement` ``a`` has all even coefficients.
+        If we represent ``a`` in the submodule ``B = 2*A``, the coefficients in
+        the column vector will be halved:
+
+        >>> B = A.submodule_from_gens([2*A(i) for i in range(4)])
+        >>> b = B.represent(a)
+        >>> print(b.transpose())  # doctest: +SKIP
+        DomainMatrix([[1, 2, 3, 4]], (1, 4), ZZ)
+
+        However, the element of ``B`` so defined still represents the same
+        algebraic number:
+
+        >>> print(a.poly(zeta).as_expr())
+        8*zeta**3 + 6*zeta**2 + 4*zeta + 2
+        >>> print(B(b).over_power_basis().poly(zeta).as_expr())
+        8*zeta**3 + 6*zeta**2 + 4*zeta + 2
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ModuleElement`
+            The module element to be represented. Must belong to some ancestor
+            module of this module (including this module itself).
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            This will be a column vector, representing the coefficients of a
+            linear combination of this module's generators, which equals the
+            given element.
+
+        Raises
+        ======
+
+        ClosureFailure
+            If the given element cannot be represented as a :ref:`ZZ`-linear
+            combination over this module.
+
+        See Also
+        ========
+
+        .Submodule.represent
+        .PowerBasis.represent
+
+        """
+        raise NotImplementedError
+
+    def ancestors(self, include_self=False):
+        """
+        Return the list of ancestor modules of this module, from the
+        foundational :py:class:`~.PowerBasis` downward, optionally including
+        ``self``.
+
+        See Also
+        ========
+
+        Module
+
+        """
+        c = self.parent
+        a = [] if c is None else c.ancestors(include_self=True)
+        if include_self:
+            a.append(self)
+        return a
+
+    def power_basis_ancestor(self):
+        """
+        Return the :py:class:`~.PowerBasis` that is an ancestor of this module.
+
+        See Also
+        ========
+
+        Module
+
+        """
+        if isinstance(self, PowerBasis):
+            return self
+        c = self.parent
+        if c is not None:
+            return c.power_basis_ancestor()
+        return None
+
+    def nearest_common_ancestor(self, other):
+        """
+        Locate the nearest common ancestor of this module and another.
+
+        Returns
+        =======
+
+        :py:class:`~.Module`, ``None``
+
+        See Also
+        ========
+
+        Module
+
+        """
+        sA = self.ancestors(include_self=True)
+        oA = other.ancestors(include_self=True)
+        nca = None
+        for sa, oa in zip(sA, oA):
+            if sa == oa:
+                nca = sa
+            else:
+                break
+        return nca
+
+    @property
+    def number_field(self):
+        r"""
+        Return the associated :py:class:`~.AlgebraicField`, if any.
+
+        Explanation
+        ===========
+
+        A :py:class:`~.PowerBasis` can be constructed on a :py:class:`~.Poly`
+        $f$ or on an :py:class:`~.AlgebraicField` $K$. In the latter case, the
+        :py:class:`~.PowerBasis` and all its descendant modules will return $K$
+        as their ``.number_field`` property, while in the former case they will
+        all return ``None``.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicField`, ``None``
+
+        """
+        return self.power_basis_ancestor().number_field
+
+    def is_compat_col(self, col):
+        """Say whether *col* is a suitable column vector for this module."""
+        return isinstance(col, DomainMatrix) and col.shape == (self.n, 1) and col.domain.is_ZZ
+
+    def __call__(self, spec, denom=1):
+        r"""
+        Generate a :py:class:`~.ModuleElement` belonging to this module.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, to_col
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> e = A(to_col([1, 2, 3, 4]), denom=3)
+        >>> print(e)  # doctest: +SKIP
+        [1, 2, 3, 4]/3
+        >>> f = A(2)
+        >>> print(f)  # doctest: +SKIP
+        [0, 0, 1, 0]
+
+        Parameters
+        ==========
+
+        spec : :py:class:`~.DomainMatrix`, int
+            Specifies the numerators of the coefficients of the
+            :py:class:`~.ModuleElement`. Can be either a column vector over
+            :ref:`ZZ`, whose length must equal the number $n$ of generators of
+            this module, or else an integer ``j``, $0 \leq j < n$, which is a
+            shorthand for column $j$ of $I_n$, the $n \times n$ identity
+            matrix.
+        denom : int, optional (default=1)
+            Denominator for the coefficients of the
+            :py:class:`~.ModuleElement`.
+
+        Returns
+        =======
+
+        :py:class:`~.ModuleElement`
+            The coefficients are the entries of the *spec* vector, divided by
+            *denom*.
+
+        """
+        if isinstance(spec, int) and 0 <= spec < self.n:
+            spec = DomainMatrix.eye(self.n, ZZ)[:, spec].to_dense()
+        if not self.is_compat_col(spec):
+            raise ValueError('Compatible column vector required.')
+        return make_mod_elt(self, spec, denom=denom)
+
+    def starts_with_unity(self):
+        """Say whether the module's first generator equals unity."""
+        raise NotImplementedError
+
+    def basis_elements(self):
+        """
+        Get list of :py:class:`~.ModuleElement` being the generators of this
+        module.
+        """
+        return [self(j) for j in range(self.n)]
+
+    def zero(self):
+        """Return a :py:class:`~.ModuleElement` representing zero."""
+        return self(0) * 0
+
+    def one(self):
+        """
+        Return a :py:class:`~.ModuleElement` representing unity,
+        and belonging to the first ancestor of this module (including
+        itself) that starts with unity.
+        """
+        return self.element_from_rational(1)
+
+    def element_from_rational(self, a):
+        """
+        Return a :py:class:`~.ModuleElement` representing a rational number.
+
+        Explanation
+        ===========
+
+        The returned :py:class:`~.ModuleElement` will belong to the first
+        module on this module's ancestor chain (including this module
+        itself) that starts with unity.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, QQ
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> a = A.element_from_rational(QQ(2, 3))
+        >>> print(a)  # doctest: +SKIP
+        [2, 0, 0, 0]/3
+
+        Parameters
+        ==========
+
+        a : int, :ref:`ZZ`, :ref:`QQ`
+
+        Returns
+        =======
+
+        :py:class:`~.ModuleElement`
+
+        """
+        raise NotImplementedError
+
+    def submodule_from_gens(self, gens, hnf=True, hnf_modulus=None):
+        """
+        Form the submodule generated by a list of :py:class:`~.ModuleElement`
+        belonging to this module.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> gens = [A(0), 2*A(1), 3*A(2), 4*A(3)//5]
+        >>> B = A.submodule_from_gens(gens)
+        >>> print(B)  # doctest: +SKIP
+        Submodule[[5, 0, 0, 0], [0, 10, 0, 0], [0, 0, 15, 0], [0, 0, 0, 4]]/5
+
+        Parameters
+        ==========
+
+        gens : list of :py:class:`~.ModuleElement` belonging to this module.
+        hnf : boolean, optional (default=True)
+            If True, we will reduce the matrix into Hermite Normal Form before
+            forming the :py:class:`~.Submodule`.
+        hnf_modulus : int, None, optional (default=None)
+            Modulus for use in the HNF reduction algorithm. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        See Also
+        ========
+
+        submodule_from_matrix
+
+        """
+        if not all(g.module == self for g in gens):
+            raise ValueError('Generators must belong to this module.')
+        n = len(gens)
+        if n == 0:
+            raise ValueError('Need at least one generator.')
+        m = gens[0].n
+        d = gens[0].denom if n == 1 else ilcm(*[g.denom for g in gens])
+        B = DomainMatrix.zeros((m, 0), ZZ).hstack(*[(d // g.denom) * g.col for g in gens])
+        if hnf:
+            B = hermite_normal_form(B, D=hnf_modulus)
+        return self.submodule_from_matrix(B, denom=d)
+
+    def submodule_from_matrix(self, B, denom=1):
+        """
+        Form the submodule generated by the elements of this module indicated
+        by the columns of a matrix, with an optional denominator.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_matrix(DM([
+        ...     [0, 10, 0, 0],
+        ...     [0,  0, 7, 0],
+        ... ], ZZ).transpose(), denom=15)
+        >>> print(B)  # doctest: +SKIP
+        Submodule[[0, 10, 0, 0], [0, 0, 7, 0]]/15
+
+        Parameters
+        ==========
+
+        B : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            Each column gives the numerators of the coefficients of one
+            generator of the submodule. Thus, the number of rows of *B* must
+            equal the number of generators of the present module.
+        denom : int, optional (default=1)
+            Common denominator for all generators of the submodule.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        Raises
+        ======
+
+        ValueError
+            If the given matrix *B* is not over :ref:`ZZ` or its number of rows
+            does not equal the number of generators of the present module.
+
+        See Also
+        ========
+
+        submodule_from_gens
+
+        """
+        m, n = B.shape
+        if not B.domain.is_ZZ:
+            raise ValueError('Matrix must be over ZZ.')
+        if not m == self.n:
+            raise ValueError('Matrix row count must match base module.')
+        return Submodule(self, B, denom=denom)
+
+    def whole_submodule(self):
+        """
+        Return a submodule equal to this entire module.
+
+        Explanation
+        ===========
+
+        This is useful when you have a :py:class:`~.PowerBasis` and want to
+        turn it into a :py:class:`~.Submodule` (in order to use methods
+        belonging to the latter).
+
+        """
+        B = DomainMatrix.eye(self.n, ZZ)
+        return self.submodule_from_matrix(B)
+
+    def endomorphism_ring(self):
+        """Form the :py:class:`~.EndomorphismRing` for this module."""
+        return EndomorphismRing(self)
+
+
+class PowerBasis(Module):
+    """The module generated by the powers of an algebraic integer."""
+
+    def __init__(self, T):
+        """
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`, :py:class:`~.AlgebraicField`
+            Either (1) the monic, irreducible, univariate polynomial over
+            :ref:`ZZ`, a root of which is the generator of the power basis,
+            or (2) an :py:class:`~.AlgebraicField` whose primitive element
+            is the generator of the power basis.
+
+        """
+        K = None
+        if isinstance(T, AlgebraicField):
+            K, T = T, T.ext.minpoly_of_element()
+        # Sometimes incoming Polys are formally over QQ, although all their
+        # coeffs are integral. We want them to be formally over ZZ.
+        T = T.set_domain(ZZ)
+        self.K = K
+        self.T = T
+        self._n = T.degree()
+        self._mult_tab = None
+
+    @property
+    def number_field(self):
+        return self.K
+
+    def __repr__(self):
+        return f'PowerBasis({self.T.as_expr()})'
+
+    def __eq__(self, other):
+        if isinstance(other, PowerBasis):
+            return self.T == other.T
+        return NotImplemented
+
+    @property
+    def n(self):
+        return self._n
+
+    def mult_tab(self):
+        if self._mult_tab is None:
+            self.compute_mult_tab()
+        return self._mult_tab
+
+    def compute_mult_tab(self):
+        theta_pow = AlgIntPowers(self.T)
+        M = {}
+        n = self.n
+        for u in range(n):
+            M[u] = {}
+            for v in range(u, n):
+                M[u][v] = theta_pow[u + v]
+        self._mult_tab = M
+
+    def represent(self, elt):
+        r"""
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        See Also
+        ========
+
+        .Module.represent
+        .Submodule.represent
+
+        """
+        if elt.module == self and elt.denom == 1:
+            return elt.column()
+        else:
+            raise ClosureFailure('Element not representable in ZZ[theta].')
+
+    def starts_with_unity(self):
+        return True
+
+    def element_from_rational(self, a):
+        return self(0) * a
+
+    def element_from_poly(self, f):
+        """
+        Produce an element of this module, representing *f* after reduction mod
+        our defining minimal polynomial.
+
+        Parameters
+        ==========
+
+        f : :py:class:`~.Poly` over :ref:`ZZ` in same var as our defining poly.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+
+        """
+        n, k = self.n, f.degree()
+        if k >= n:
+            f = f % self.T
+        if f == 0:
+            return self.zero()
+        d, c = dup_clear_denoms(f.rep.rep, QQ, convert=True)
+        c = list(reversed(c))
+        ell = len(c)
+        z = [ZZ(0)] * (n - ell)
+        col = to_col(c + z)
+        return self(col, denom=d)
+
+    def _element_from_rep_and_mod(self, rep, mod):
+        """
+        Produce a PowerBasisElement representing a given algebraic number.
+
+        Parameters
+        ==========
+
+        rep : list of coeffs
+            Represents the number as polynomial in the primitive element of the
+            field.
+
+        mod : list of coeffs
+            Represents the minimal polynomial of the primitive element of the
+            field.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+
+        """
+        if mod != self.T.rep.rep:
+            raise UnificationFailed('Element does not appear to be in the same field.')
+        return self.element_from_poly(Poly(rep, self.T.gen))
+
+    def element_from_ANP(self, a):
+        """Convert an ANP into a PowerBasisElement. """
+        return self._element_from_rep_and_mod(a.rep, a.mod)
+
+    def element_from_alg_num(self, a):
+        """Convert an AlgebraicNumber into a PowerBasisElement. """
+        return self._element_from_rep_and_mod(a.rep.rep, a.minpoly.rep.rep)
+
+
+class Submodule(Module, IntegerPowerable):
+    """A submodule of another module."""
+
+    def __init__(self, parent, matrix, denom=1, mult_tab=None):
+        """
+        Parameters
+        ==========
+
+        parent : :py:class:`~.Module`
+            The module from which this one is derived.
+        matrix : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            The matrix whose columns define this submodule's generators as
+            linear combinations over the parent's generators.
+        denom : int, optional (default=1)
+            Denominator for the coefficients given by the matrix.
+        mult_tab : dict, ``None``, optional
+            If already known, the multiplication table for this module may be
+            supplied.
+
+        """
+        self._parent = parent
+        self._matrix = matrix
+        self._denom = denom
+        self._mult_tab = mult_tab
+        self._n = matrix.shape[1]
+        self._QQ_matrix = None
+        self._starts_with_unity = None
+        self._is_sq_maxrank_HNF = None
+
+    def __repr__(self):
+        r = 'Submodule' + repr(self.matrix.transpose().to_Matrix().tolist())
+        if self.denom > 1:
+            r += f'/{self.denom}'
+        return r
+
+    def reduced(self):
+        """
+        Produce a reduced version of this submodule.
+
+        Explanation
+        ===========
+
+        In the reduced version, it is guaranteed that 1 is the only positive
+        integer dividing both the submodule's denominator, and every entry in
+        the submodule's matrix.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        if self.denom == 1:
+            return self
+        g = igcd(self.denom, *self.coeffs)
+        if g == 1:
+            return self
+        return type(self)(self.parent, (self.matrix / g).convert_to(ZZ), denom=self.denom // g, mult_tab=self._mult_tab)
+
+    def discard_before(self, r):
+        """
+        Produce a new module by discarding all generators before a given
+        index *r*.
+        """
+        W = self.matrix[:, r:]
+        s = self.n - r
+        M = None
+        mt = self._mult_tab
+        if mt is not None:
+            M = {}
+            for u in range(s):
+                M[u] = {}
+                for v in range(u, s):
+                    M[u][v] = mt[r + u][r + v][r:]
+        return Submodule(self.parent, W, denom=self.denom, mult_tab=M)
+
+    @property
+    def n(self):
+        return self._n
+
+    def mult_tab(self):
+        if self._mult_tab is None:
+            self.compute_mult_tab()
+        return self._mult_tab
+
+    def compute_mult_tab(self):
+        gens = self.basis_element_pullbacks()
+        M = {}
+        n = self.n
+        for u in range(n):
+            M[u] = {}
+            for v in range(u, n):
+                M[u][v] = self.represent(gens[u] * gens[v]).flat()
+        self._mult_tab = M
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def matrix(self):
+        return self._matrix
+
+    @property
+    def coeffs(self):
+        return self.matrix.flat()
+
+    @property
+    def denom(self):
+        return self._denom
+
+    @property
+    def QQ_matrix(self):
+        """
+        :py:class:`~.DomainMatrix` over :ref:`QQ`, equal to
+        ``self.matrix / self.denom``, and guaranteed to be dense.
+
+        Explanation
+        ===========
+
+        Depending on how it is formed, a :py:class:`~.DomainMatrix` may have
+        an internal representation that is sparse or dense. We guarantee a
+        dense representation here, so that tests for equivalence of submodules
+        always come out as expected.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5, x))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_matrix(3*DomainMatrix.eye(4, ZZ), denom=6)
+        >>> C = A.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=2)
+        >>> print(B.QQ_matrix == C.QQ_matrix)
+        True
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix` over :ref:`QQ`
+
+        """
+        if self._QQ_matrix is None:
+            self._QQ_matrix = (self.matrix / self.denom).to_dense()
+        return self._QQ_matrix
+
+    def starts_with_unity(self):
+        if self._starts_with_unity is None:
+            self._starts_with_unity = self(0).equiv(1)
+        return self._starts_with_unity
+
+    def is_sq_maxrank_HNF(self):
+        if self._is_sq_maxrank_HNF is None:
+            self._is_sq_maxrank_HNF = is_sq_maxrank_HNF(self._matrix)
+        return self._is_sq_maxrank_HNF
+
+    def is_power_basis_submodule(self):
+        return isinstance(self.parent, PowerBasis)
+
+    def element_from_rational(self, a):
+        if self.starts_with_unity():
+            return self(0) * a
+        else:
+            return self.parent.element_from_rational(a)
+
+    def basis_element_pullbacks(self):
+        """
+        Return list of this submodule's basis elements as elements of the
+        submodule's parent module.
+        """
+        return [e.to_parent() for e in self.basis_elements()]
+
+    def represent(self, elt):
+        """
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        See Also
+        ========
+
+        .Module.represent
+        .PowerBasis.represent
+
+        """
+        if elt.module == self:
+            return elt.column()
+        elif elt.module == self.parent:
+            try:
+                # The given element should be a ZZ-linear combination over our
+                # basis vectors; however, due to the presence of denominators,
+                # we need to solve over QQ.
+                A = self.QQ_matrix
+                b = elt.QQ_col
+                x = A._solve(b)[0].transpose()
+                x = x.convert_to(ZZ)
+            except DMBadInputError:
+                raise ClosureFailure('Element outside QQ-span of this basis.')
+            except CoercionFailed:
+                raise ClosureFailure('Element in QQ-span but not ZZ-span of this basis.')
+            return x
+        elif isinstance(self.parent, Submodule):
+            coeffs_in_parent = self.parent.represent(elt)
+            parent_element = self.parent(coeffs_in_parent)
+            return self.represent(parent_element)
+        else:
+            raise ClosureFailure('Element outside ancestor chain of this module.')
+
+    def is_compat_submodule(self, other):
+        return isinstance(other, Submodule) and other.parent == self.parent
+
+    def __eq__(self, other):
+        if self.is_compat_submodule(other):
+            return other.QQ_matrix == self.QQ_matrix
+        return NotImplemented
+
+    def add(self, other, hnf=True, hnf_modulus=None):
+        """
+        Add this :py:class:`~.Submodule` to another.
+
+        Explanation
+        ===========
+
+        This represents the module generated by the union of the two modules'
+        sets of generators.
+
+        Parameters
+        ==========
+
+        other : :py:class:`~.Submodule`
+        hnf : boolean, optional (default=True)
+            If ``True``, reduce the matrix of the combined module to its
+            Hermite Normal Form.
+        hnf_modulus : :ref:`ZZ`, None, optional
+            If a positive integer is provided, use this as modulus in the
+            HNF reduction. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        d, e = self.denom, other.denom
+        m = ilcm(d, e)
+        a, b = m // d, m // e
+        B = (a * self.matrix).hstack(b * other.matrix)
+        if hnf:
+            B = hermite_normal_form(B, D=hnf_modulus)
+        return self.parent.submodule_from_matrix(B, denom=m)
+
+    def __add__(self, other):
+        if self.is_compat_submodule(other):
+            return self.add(other)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def mul(self, other, hnf=True, hnf_modulus=None):
+        """
+        Multiply this :py:class:`~.Submodule` by a rational number, a
+        :py:class:`~.ModuleElement`, or another :py:class:`~.Submodule`.
+
+        Explanation
+        ===========
+
+        To multiply by a rational number or :py:class:`~.ModuleElement` means
+        to form the submodule whose generators are the products of this
+        quantity with all the generators of the present submodule.
+
+        To multiply by another :py:class:`~.Submodule` means to form the
+        submodule whose generators are all the products of one generator from
+        the one submodule, and one generator from the other.
+
+        Parameters
+        ==========
+
+        other : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.ModuleElement`, :py:class:`~.Submodule`
+        hnf : boolean, optional (default=True)
+            If ``True``, reduce the matrix of the product module to its
+            Hermite Normal Form.
+        hnf_modulus : :ref:`ZZ`, None, optional
+            If a positive integer is provided, use this as modulus in the
+            HNF reduction. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        if is_rat(other):
+            a, b = get_num_denom(other)
+            if a == b == 1:
+                return self
+            else:
+                return Submodule(self.parent,
+                             self.matrix * a, denom=self.denom * b,
+                             mult_tab=None).reduced()
+        elif isinstance(other, ModuleElement) and other.module == self.parent:
+            # The submodule is multiplied by an element of the parent module.
+            # We presume this means we want a new submodule of the parent module.
+            gens = [other * e for e in self.basis_element_pullbacks()]
+            return self.parent.submodule_from_gens(gens, hnf=hnf, hnf_modulus=hnf_modulus)
+        elif self.is_compat_submodule(other):
+            # This case usually means you're multiplying ideals, and want another
+            # ideal, i.e. another submodule of the same parent module.
+            alphas, betas = self.basis_element_pullbacks(), other.basis_element_pullbacks()
+            gens = [a * b for a in alphas for b in betas]
+            return self.parent.submodule_from_gens(gens, hnf=hnf, hnf_modulus=hnf_modulus)
+        return NotImplemented
+
+    def __mul__(self, other):
+        return self.mul(other)
+
+    __rmul__ = __mul__
+
+    def _first_power(self):
+        return self
+
+    def reduce_element(self, elt):
+        r"""
+        If this submodule $B$ has defining matrix $W$ in square, maximal-rank
+        Hermite normal form, then, given an element $x$ of the parent module
+        $A$, we produce an element $y \in A$ such that $x - y \in B$, and the
+        $i$th coordinate of $y$ satisfies $0 \leq y_i < w_{i,i}$. This
+        representative $y$ is unique, in the sense that every element of
+        the coset $x + B$ reduces to it under this procedure.
+
+        Explanation
+        ===========
+
+        In the special case where $A$ is a power basis for a number field $K$,
+        and $B$ is a submodule representing an ideal $I$, this operation
+        represents one of a few important ways of reducing an element of $K$
+        modulo $I$ to obtain a "small" representative. See [Cohen00]_ Section
+        1.4.3.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Poly, symbols
+        >>> t = symbols('t')
+        >>> k = QQ.alg_field_from_poly(Poly(t**3 + t**2 - 2*t + 8))
+        >>> Zk = k.maximal_order()
+        >>> A = Zk.parent
+        >>> B = (A(2) - 3*A(0))*Zk
+        >>> B.reduce_element(A(2))
+        [3, 0, 0]
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ModuleElement`
+            An element of this submodule's parent module.
+
+        Returns
+        =======
+
+        elt : :py:class:`~.ModuleElement`
+            An element of this submodule's parent module.
+
+        Raises
+        ======
+
+        NotImplementedError
+            If the given :py:class:`~.ModuleElement` does not belong to this
+            submodule's parent module.
+        StructureError
+            If this submodule's defining matrix is not in square, maximal-rank
+            Hermite normal form.
+
+        References
+        ==========
+
+        .. [Cohen00] Cohen, H. *Advanced Topics in Computational Number
+           Theory.*
+
+        """
+        if not elt.module == self.parent:
+            raise NotImplementedError
+        if not self.is_sq_maxrank_HNF():
+            msg = "Reduction not implemented unless matrix square max-rank HNF"
+            raise StructureError(msg)
+        B = self.basis_element_pullbacks()
+        a = elt
+        for i in range(self.n - 1, -1, -1):
+            b = B[i]
+            q = a.coeffs[i]*b.denom // (b.coeffs[i]*a.denom)
+            a -= q*b
+        return a
+
+
+def is_sq_maxrank_HNF(dm):
+    r"""
+    Say whether a :py:class:`~.DomainMatrix` is in that special case of Hermite
+    Normal Form, in which the matrix is also square and of maximal rank.
+
+    Explanation
+    ===========
+
+    We commonly work with :py:class:`~.Submodule` instances whose matrix is in
+    this form, and it can be useful to be able to check that this condition is
+    satisfied.
+
+    For example this is the case with the :py:class:`~.Submodule` ``ZK``
+    returned by :py:func:`~sympy.polys.numberfields.basis.round_two`, which
+    represents the maximal order in a number field, and with ideals formed
+    therefrom, such as ``2 * ZK``.
+
+    """
+    if dm.domain.is_ZZ and dm.is_square and dm.is_upper:
+        n = dm.shape[0]
+        for i in range(n):
+            d = dm[i, i].element
+            if d <= 0:
+                return False
+            for j in range(i + 1, n):
+                if not (0 <= dm[i, j].element < d):
+                    return False
+        return True
+    return False
+
+
+def make_mod_elt(module, col, denom=1):
+    r"""
+    Factory function which builds a :py:class:`~.ModuleElement`, but ensures
+    that it is a :py:class:`~.PowerBasisElement` if the module is a
+    :py:class:`~.PowerBasis`.
+    """
+    if isinstance(module, PowerBasis):
+        return PowerBasisElement(module, col, denom=denom)
+    else:
+        return ModuleElement(module, col, denom=denom)
+
+
+class ModuleElement(IntegerPowerable):
+    r"""
+    Represents an element of a :py:class:`~.Module`.
+
+    NOTE: Should not be constructed directly. Use the
+    :py:meth:`~.Module.__call__` method or the :py:func:`make_mod_elt()`
+    factory function instead.
+    """
+
+    def __init__(self, module, col, denom=1):
+        """
+        Parameters
+        ==========
+
+        module : :py:class:`~.Module`
+            The module to which this element belongs.
+        col : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            Column vector giving the numerators of the coefficients of this
+            element.
+        denom : int, optional (default=1)
+            Denominator for the coefficients of this element.
+
+        """
+        self.module = module
+        self.col = col
+        self.denom = denom
+        self._QQ_col = None
+
+    def __repr__(self):
+        r = str([int(c) for c in self.col.flat()])
+        if self.denom > 1:
+            r += f'/{self.denom}'
+        return r
+
+    def reduced(self):
+        """
+        Produce a reduced version of this ModuleElement, i.e. one in which the
+        gcd of the denominator together with all numerator coefficients is 1.
+        """
+        if self.denom == 1:
+            return self
+        g = igcd(self.denom, *self.coeffs)
+        if g == 1:
+            return self
+        return type(self)(self.module,
+                            (self.col / g).convert_to(ZZ),
+                            denom=self.denom // g)
+
+    def reduced_mod_p(self, p):
+        """
+        Produce a version of this :py:class:`~.ModuleElement` in which all
+        numerator coefficients have been reduced mod *p*.
+        """
+        return make_mod_elt(self.module,
+                            self.col.convert_to(FF(p)).convert_to(ZZ),
+                            denom=self.denom)
+
+    @classmethod
+    def from_int_list(cls, module, coeffs, denom=1):
+        """
+        Make a :py:class:`~.ModuleElement` from a list of ints (instead of a
+        column vector).
+        """
+        col = to_col(coeffs)
+        return cls(module, col, denom=denom)
+
+    @property
+    def n(self):
+        """The length of this element's column."""
+        return self.module.n
+
+    def __len__(self):
+        return self.n
+
+    def column(self, domain=None):
+        """
+        Get a copy of this element's column, optionally converting to a domain.
+        """
+        return self.col.convert_to(domain)
+
+    @property
+    def coeffs(self):
+        return self.col.flat()
+
+    @property
+    def QQ_col(self):
+        """
+        :py:class:`~.DomainMatrix` over :ref:`QQ`, equal to
+        ``self.col / self.denom``, and guaranteed to be dense.
+
+        See Also
+        ========
+
+        .Submodule.QQ_matrix
+
+        """
+        if self._QQ_col is None:
+            self._QQ_col = (self.col / self.denom).to_dense()
+        return self._QQ_col
+
+    def to_parent(self):
+        """
+        Transform into a :py:class:`~.ModuleElement` belonging to the parent of
+        this element's module.
+        """
+        if not isinstance(self.module, Submodule):
+            raise ValueError('Not an element of a Submodule.')
+        return make_mod_elt(
+            self.module.parent, self.module.matrix * self.col,
+            denom=self.module.denom * self.denom)
+
+    def to_ancestor(self, anc):
+        """
+        Transform into a :py:class:`~.ModuleElement` belonging to a given
+        ancestor of this element's module.
+
+        Parameters
+        ==========
+
+        anc : :py:class:`~.Module`
+
+        """
+        if anc == self.module:
+            return self
+        else:
+            return self.to_parent().to_ancestor(anc)
+
+    def over_power_basis(self):
+        """
+        Transform into a :py:class:`~.PowerBasisElement` over our
+        :py:class:`~.PowerBasis` ancestor.
+        """
+        e = self
+        while not isinstance(e.module, PowerBasis):
+            e = e.to_parent()
+        return e
+
+    def is_compat(self, other):
+        """
+        Test whether other is another :py:class:`~.ModuleElement` with same
+        module.
+        """
+        return isinstance(other, ModuleElement) and other.module == self.module
+
+    def unify(self, other):
+        """
+        Try to make a compatible pair of :py:class:`~.ModuleElement`, one
+        equivalent to this one, and one equivalent to the other.
+
+        Explanation
+        ===========
+
+        We search for the nearest common ancestor module for the pair of
+        elements, and represent each one there.
+
+        Returns
+        =======
+
+        Pair ``(e1, e2)``
+            Each ``ei`` is a :py:class:`~.ModuleElement`, they belong to the
+            same :py:class:`~.Module`, ``e1`` is equivalent to ``self``, and
+            ``e2`` is equivalent to ``other``.
+
+        Raises
+        ======
+
+        UnificationFailed
+            If ``self`` and ``other`` have no common ancestor module.
+
+        """
+        if self.module == other.module:
+            return self, other
+        nca = self.module.nearest_common_ancestor(other.module)
+        if nca is not None:
+            return self.to_ancestor(nca), other.to_ancestor(nca)
+        raise UnificationFailed(f"Cannot unify {self} with {other}")
+
+    def __eq__(self, other):
+        if self.is_compat(other):
+            return self.QQ_col == other.QQ_col
+        return NotImplemented
+
+    def equiv(self, other):
+        """
+        A :py:class:`~.ModuleElement` may test as equivalent to a rational
+        number or another :py:class:`~.ModuleElement`, if they represent the
+        same algebraic number.
+
+        Explanation
+        ===========
+
+        This method is intended to check equivalence only in those cases in
+        which it is easy to test; namely, when *other* is either a
+        :py:class:`~.ModuleElement` that can be unified with this one (i.e. one
+        which shares a common :py:class:`~.PowerBasis` ancestor), or else a
+        rational number (which is easy because every :py:class:`~.PowerBasis`
+        represents every rational number).
+
+        Parameters
+        ==========
+
+        other : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.ModuleElement`
+
+        Returns
+        =======
+
+        bool
+
+        Raises
+        ======
+
+        UnificationFailed
+            If ``self`` and ``other`` do not share a common
+            :py:class:`~.PowerBasis` ancestor.
+
+        """
+        if self == other:
+            return True
+        elif isinstance(other, ModuleElement):
+            a, b = self.unify(other)
+            return a == b
+        elif is_rat(other):
+            if isinstance(self, PowerBasisElement):
+                return self == self.module(0) * other
+            else:
+                return self.over_power_basis().equiv(other)
+        return False
+
+    def __add__(self, other):
+        """
+        A :py:class:`~.ModuleElement` can be added to a rational number, or to
+        another :py:class:`~.ModuleElement`.
+
+        Explanation
+        ===========
+
+        When the other summand is a rational number, it will be converted into
+        a :py:class:`~.ModuleElement` (belonging to the first ancestor of this
+        module that starts with unity).
+
+        In all cases, the sum belongs to the nearest common ancestor (NCA) of
+        the modules of the two summands. If the NCA does not exist, we return
+        ``NotImplemented``.
+        """
+        if self.is_compat(other):
+            d, e = self.denom, other.denom
+            m = ilcm(d, e)
+            u, v = m // d, m // e
+            col = to_col([u * a + v * b for a, b in zip(self.coeffs, other.coeffs)])
+            return type(self)(self.module, col, denom=m).reduced()
+        elif isinstance(other, ModuleElement):
+            try:
+                a, b = self.unify(other)
+            except UnificationFailed:
+                return NotImplemented
+            return a + b
+        elif is_rat(other):
+            return self + self.module.element_from_rational(other)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return self * -1
+
+    def __sub__(self, other):
+        return self + (-other)
+
+    def __rsub__(self, other):
+        return -self + other
+
+    def __mul__(self, other):
+        """
+        A :py:class:`~.ModuleElement` can be multiplied by a rational number,
+        or by another :py:class:`~.ModuleElement`.
+
+        Explanation
+        ===========
+
+        When the multiplier is a rational number, the product is computed by
+        operating directly on the coefficients of this
+        :py:class:`~.ModuleElement`.
+
+        When the multiplier is another :py:class:`~.ModuleElement`, the product
+        will belong to the nearest common ancestor (NCA) of the modules of the
+        two operands, and that NCA must have a multiplication table. If the NCA
+        does not exist, we return ``NotImplemented``. If the NCA does not have
+        a mult. table, ``ClosureFailure`` will be raised.
+        """
+        if self.is_compat(other):
+            M = self.module.mult_tab()
+            A, B = self.col.flat(), other.col.flat()
+            n = self.n
+            C = [0] * n
+            for u in range(n):
+                for v in range(u, n):
+                    c = A[u] * B[v]
+                    if v > u:
+                        c += A[v] * B[u]
+                    if c != 0:
+                        R = M[u][v]
+                        for k in range(n):
+                            C[k] += c * R[k]
+            d = self.denom * other.denom
+            return self.from_int_list(self.module, C, denom=d)
+        elif isinstance(other, ModuleElement):
+            try:
+                a, b = self.unify(other)
+            except UnificationFailed:
+                return NotImplemented
+            return a * b
+        elif is_rat(other):
+            a, b = get_num_denom(other)
+            if a == b == 1:
+                return self
+            else:
+                return make_mod_elt(self.module,
+                                 self.col * a, denom=self.denom * b).reduced()
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def _zeroth_power(self):
+        return self.module.one()
+
+    def _first_power(self):
+        return self
+
+    def __floordiv__(self, a):
+        if is_rat(a):
+            a = QQ(a)
+            return self * (1/a)
+        elif isinstance(a, ModuleElement):
+            return self * (1//a)
+        return NotImplemented
+
+    def __rfloordiv__(self, a):
+        return a // self.over_power_basis()
+
+    def __mod__(self, m):
+        r"""
+        Reduce this :py:class:`~.ModuleElement` mod a :py:class:`~.Submodule`.
+
+        Parameters
+        ==========
+
+        m : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.Submodule`
+            If a :py:class:`~.Submodule`, reduce ``self`` relative to this.
+            If an integer or rational, reduce relative to the
+            :py:class:`~.Submodule` that is our own module times this constant.
+
+        See Also
+        ========
+
+        .Submodule.reduce_element
+
+        """
+        if is_rat(m):
+            m = m * self.module.whole_submodule()
+        if isinstance(m, Submodule) and m.parent == self.module:
+            return m.reduce_element(self)
+        return NotImplemented
+
+
+class PowerBasisElement(ModuleElement):
+    r"""
+    Subclass for :py:class:`~.ModuleElement` instances whose module is a
+    :py:class:`~.PowerBasis`.
+    """
+
+    @property
+    def T(self):
+        """Access the defining polynomial of the :py:class:`~.PowerBasis`."""
+        return self.module.T
+
+    def numerator(self, x=None):
+        """Obtain the numerator as a polynomial over :ref:`ZZ`."""
+        x = x or self.T.gen
+        return Poly(reversed(self.coeffs), x, domain=ZZ)
+
+    def poly(self, x=None):
+        """Obtain the number as a polynomial over :ref:`QQ`."""
+        return self.numerator(x=x) // self.denom
+
+    @property
+    def is_rational(self):
+        """Say whether this element represents a rational number."""
+        return self.col[1:, :].is_zero_matrix
+
+    @property
+    def generator(self):
+        """
+        Return a :py:class:`~.Symbol` to be used when expressing this element
+        as a polynomial.
+
+        If we have an associated :py:class:`~.AlgebraicField` whose primitive
+        element has an alias symbol, we use that. Otherwise we use the variable
+        of the minimal polynomial defining the power basis to which we belong.
+        """
+        K = self.module.number_field
+        return K.ext.alias if K and K.ext.is_aliased else self.T.gen
+
+    def as_expr(self, x=None):
+        """Create a Basic expression from ``self``. """
+        return self.poly(x or self.generator).as_expr()
+
+    def norm(self, T=None):
+        """Compute the norm of this number."""
+        T = T or self.T
+        x = T.gen
+        A = self.numerator(x=x)
+        return T.resultant(A) // self.denom ** self.n
+
+    def inverse(self):
+        f = self.poly()
+        f_inv = f.invert(self.T)
+        return self.module.element_from_poly(f_inv)
+
+    def __rfloordiv__(self, a):
+        return self.inverse() * a
+
+    def _negative_power(self, e, modulo=None):
+        return self.inverse() ** abs(e)
+
+    def to_ANP(self):
+        """Convert to an equivalent :py:class:`~.ANP`. """
+        return ANP(list(reversed(self.QQ_col.flat())), QQ.map(self.T.rep.rep), QQ)
+
+    def to_alg_num(self):
+        """
+        Try to convert to an equivalent :py:class:`~.AlgebraicNumber`.
+
+        Explanation
+        ===========
+
+        In general, the conversion from an :py:class:`~.AlgebraicNumber` to a
+        :py:class:`~.PowerBasisElement` throws away information, because an
+        :py:class:`~.AlgebraicNumber` specifies a complex embedding, while a
+        :py:class:`~.PowerBasisElement` does not. However, in some cases it is
+        possible to convert a :py:class:`~.PowerBasisElement` back into an
+        :py:class:`~.AlgebraicNumber`, namely when the associated
+        :py:class:`~.PowerBasis` has a reference to an
+        :py:class:`~.AlgebraicField`.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicNumber`
+
+        Raises
+        ======
+
+        StructureError
+            If the :py:class:`~.PowerBasis` to which this element belongs does
+            not have an associated :py:class:`~.AlgebraicField`.
+
+        """
+        K = self.module.number_field
+        if K:
+            return K.to_alg_num(self.to_ANP())
+        raise StructureError("No associated AlgebraicField")
+
+
+class ModuleHomomorphism:
+    r"""A homomorphism from one module to another."""
+
+    def __init__(self, domain, codomain, mapping):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain of the mapping.
+
+        codomain : :py:class:`~.Module`
+            The codomain of the mapping.
+
+        mapping : callable
+            An arbitrary callable is accepted, but should be chosen so as
+            to represent an actual module homomorphism. In particular, should
+            accept elements of *domain* and return elements of *codomain*.
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, ModuleHomomorphism
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_gens([2*A(j) for j in range(4)])
+        >>> phi = ModuleHomomorphism(A, B, lambda x: 6*x)
+        >>> print(phi.matrix())  # doctest: +SKIP
+        DomainMatrix([[3, 0, 0, 0], [0, 3, 0, 0], [0, 0, 3, 0], [0, 0, 0, 3]], (4, 4), ZZ)
+
+        """
+        self.domain = domain
+        self.codomain = codomain
+        self.mapping = mapping
+
+    def matrix(self, modulus=None):
+        r"""
+        Compute the matrix of this homomorphism.
+
+        Parameters
+        ==========
+
+        modulus : int, optional
+            A positive prime number $p$ if the matrix should be reduced mod
+            $p$.
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix`
+            The matrix is over :ref:`ZZ`, or else over :ref:`GF(p)` if a
+            modulus was given.
+
+        """
+        basis = self.domain.basis_elements()
+        cols = [self.codomain.represent(self.mapping(elt)) for elt in basis]
+        if not cols:
+            return DomainMatrix.zeros((self.codomain.n, 0), ZZ).to_dense()
+        M = cols[0].hstack(*cols[1:])
+        if modulus:
+            M = M.convert_to(FF(modulus))
+        return M
+
+    def kernel(self, modulus=None):
+        r"""
+        Compute a Submodule representing the kernel of this homomorphism.
+
+        Parameters
+        ==========
+
+        modulus : int, optional
+            A positive prime number $p$ if the kernel should be computed mod
+            $p$.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+            This submodule's generators span the kernel of this
+            homomorphism over :ref:`ZZ`, or else over :ref:`GF(p)` if a
+            modulus was given.
+
+        """
+        M = self.matrix(modulus=modulus)
+        if modulus is None:
+            M = M.convert_to(QQ)
+        # Note: Even when working over a finite field, what we want here is
+        # the pullback into the integers, so in this case the conversion to ZZ
+        # below is appropriate. When working over ZZ, the kernel should be a
+        # ZZ-submodule, so, while the conversion to QQ above was required in
+        # order for the nullspace calculation to work, conversion back to ZZ
+        # afterward should always work.
+        # TODO:
+        #  Watch <https://github.com/sympy/sympy/issues/21834>, which calls
+        #  for fraction-free algorithms. If this is implemented, we can skip
+        #  the conversion to `QQ` above.
+        K = M.nullspace().convert_to(ZZ).transpose()
+        return self.domain.submodule_from_matrix(K)
+
+
+class ModuleEndomorphism(ModuleHomomorphism):
+    r"""A homomorphism from one module to itself."""
+
+    def __init__(self, domain, mapping):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The common domain and codomain of the mapping.
+
+        mapping : callable
+            An arbitrary callable is accepted, but should be chosen so as
+            to represent an actual module endomorphism. In particular, should
+            accept and return elements of *domain*.
+
+        """
+        super().__init__(domain, domain, mapping)
+
+
+class InnerEndomorphism(ModuleEndomorphism):
+    r"""
+    An inner endomorphism on a module, i.e. the endomorphism corresponding to
+    multiplication by a fixed element.
+    """
+
+    def __init__(self, domain, multiplier):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain and codomain of the endomorphism.
+
+        multiplier : :py:class:`~.ModuleElement`
+            The element $a$ defining the mapping as $x \mapsto a x$.
+
+        """
+        super().__init__(domain, lambda x: multiplier * x)
+        self.multiplier = multiplier
+
+
+class EndomorphismRing:
+    r"""The ring of endomorphisms on a module."""
+
+    def __init__(self, domain):
+        """
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain and codomain of the endomorphisms.
+
+        """
+        self.domain = domain
+
+    def inner_endomorphism(self, multiplier):
+        r"""
+        Form an inner endomorphism belonging to this endomorphism ring.
+
+        Parameters
+        ==========
+
+        multiplier : :py:class:`~.ModuleElement`
+            Element $a$ defining the inner endomorphism $x \mapsto a x$.
+
+        Returns
+        =======
+
+        :py:class:`~.InnerEndomorphism`
+
+        """
+        return InnerEndomorphism(self.domain, multiplier)
+
+    def represent(self, element):
+        r"""
+        Represent an element of this endomorphism ring, as a single column
+        vector.
+
+        Explanation
+        ===========
+
+        Let $M$ be a module, and $E$ its ring of endomorphisms. Let $N$ be
+        another module, and consider a homomorphism $\varphi: N \rightarrow E$.
+        In the event that $\varphi$ is to be represented by a matrix $A$, each
+        column of $A$ must represent an element of $E$. This is possible when
+        the elements of $E$ are themselves representable as matrices, by
+        stacking the columns of such a matrix into a single column.
+
+        This method supports calculating such matrices $A$, by representing
+        an element of this endomorphism ring first as a matrix, and then
+        stacking that matrix's columns into a single column.
+
+        Examples
+        ========
+
+        Note that in these examples we print matrix transposes, to make their
+        columns easier to inspect.
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> from sympy.polys.numberfields.modules import ModuleHomomorphism
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> M = PowerBasis(T)
+        >>> E = M.endomorphism_ring()
+
+        Let $\zeta$ be a primitive 5th root of unity, a generator of our field,
+        and consider the inner endomorphism $\tau$ on the ring of integers,
+        induced by $\zeta$:
+
+        >>> zeta = M(1)
+        >>> tau = E.inner_endomorphism(zeta)
+        >>> tau.matrix().transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [-1, -1, -1, -1]],
+            (4, 4), ZZ)
+
+        The matrix representation of $\tau$ is as expected. The first column
+        shows that multiplying by $\zeta$ carries $1$ to $\zeta$, the second
+        column that it carries $\zeta$ to $\zeta^2$, and so forth.
+
+        The ``represent`` method of the endomorphism ring ``E`` stacks these
+        into a single column:
+
+        >>> E.represent(tau).transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1]],
+            (1, 16), ZZ)
+
+        This is useful when we want to consider a homomorphism $\varphi$ having
+        ``E`` as codomain:
+
+        >>> phi = ModuleHomomorphism(M, E, lambda x: E.inner_endomorphism(x))
+
+        and we want to compute the matrix of such a homomorphism:
+
+        >>> phi.matrix().transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+            [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1],
+            [0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1, 1, 0, 0, 0],
+            [0, 0, 0, 1, -1, -1, -1, -1, 1, 0, 0, 0, 0, 1, 0, 0]],
+            (4, 16), ZZ)
+
+        Note that the stacked matrix of $\tau$ occurs as the second column in
+        this example. This is because $\zeta$ is the second basis element of
+        ``M``, and $\varphi(\zeta) = \tau$.
+
+        Parameters
+        ==========
+
+        element : :py:class:`~.ModuleEndomorphism` belonging to this ring.
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix`
+            Column vector equalling the vertical stacking of all the columns
+            of the matrix that represents the given *element* as a mapping.
+
+        """
+        if isinstance(element, ModuleEndomorphism) and element.domain == self.domain:
+            M = element.matrix()
+            # Transform the matrix into a single column, which should reproduce
+            # the original columns, one after another.
+            m, n = M.shape
+            if n == 0:
+                return M
+            return M[:, 0].vstack(*[M[:, j] for j in range(1, n)])
+        raise NotImplementedError
+
+
+def find_min_poly(alpha, domain, x=None, powers=None):
+    r"""
+    Find a polynomial of least degree (not necessarily irreducible) satisfied
+    by an element of a finitely-generated ring with unity.
+
+    Examples
+    ========
+
+    For the $n$th cyclotomic field, $n$ an odd prime, consider the quadratic
+    equation whose roots are the two periods of length $(n-1)/2$. Article 356
+    of Gauss tells us that we should get $x^2 + x - (n-1)/4$ or
+    $x^2 + x + (n+1)/4$ according to whether $n$ is 1 or 3 mod 4, respectively.
+
+    >>> from sympy import Poly, cyclotomic_poly, primitive_root, QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.modules import PowerBasis, find_min_poly
+    >>> n = 13
+    >>> g = primitive_root(n)
+    >>> C = PowerBasis(Poly(cyclotomic_poly(n, x)))
+    >>> ee = [g**(2*k+1) % n for k in range((n-1)//2)]
+    >>> eta = sum(C(e) for e in ee)
+    >>> print(find_min_poly(eta, QQ, x=x).as_expr())
+    x**2 + x - 3
+    >>> n = 19
+    >>> g = primitive_root(n)
+    >>> C = PowerBasis(Poly(cyclotomic_poly(n, x)))
+    >>> ee = [g**(2*k+2) % n for k in range((n-1)//2)]
+    >>> eta = sum(C(e) for e in ee)
+    >>> print(find_min_poly(eta, QQ, x=x).as_expr())
+    x**2 + x + 5
+
+    Parameters
+    ==========
+
+    alpha : :py:class:`~.ModuleElement`
+        The element whose min poly is to be found, and whose module has
+        multiplication and starts with unity.
+
+    domain : :py:class:`~.Domain`
+        The desired domain of the polynomial.
+
+    x : :py:class:`~.Symbol`, optional
+        The desired variable for the polynomial.
+
+    powers : list, optional
+        If desired, pass an empty list. The powers of *alpha* (as
+        :py:class:`~.ModuleElement` instances) from the zeroth up to the degree
+        of the min poly will be recorded here, as we compute them.
+
+    Returns
+    =======
+
+    :py:class:`~.Poly`, ``None``
+        The minimal polynomial for alpha, or ``None`` if no polynomial could be
+        found over the desired domain.
+
+    Raises
+    ======
+
+    MissingUnityError
+        If the module to which alpha belongs does not start with unity.
+    ClosureFailure
+        If the module to which alpha belongs is not closed under
+        multiplication.
+
+    """
+    R = alpha.module
+    if not R.starts_with_unity():
+        raise MissingUnityError("alpha must belong to finitely generated ring with unity.")
+    if powers is None:
+        powers = []
+    one = R(0)
+    powers.append(one)
+    powers_matrix = one.column(domain=domain)
+    ak = alpha
+    m = None
+    for k in range(1, R.n + 1):
+        powers.append(ak)
+        ak_col = ak.column(domain=domain)
+        try:
+            X = powers_matrix._solve(ak_col)[0]
+        except DMBadInputError:
+            # This means alpha^k still isn't in the domain-span of the lower powers.
+            powers_matrix = powers_matrix.hstack(ak_col)
+            ak *= alpha
+        else:
+            # alpha^k is in the domain-span of the lower powers, so we have found a
+            # minimal-degree poly for alpha.
+            coeffs = [1] + [-c for c in reversed(X.to_list_flat())]
+            x = x or Dummy('x')
+            if domain.is_FF:
+                m = Poly(coeffs, x, modulus=domain.mod)
+            else:
+                m = Poly(coeffs, x, domain=domain)
+            break
+    return m
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/primes.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/primes.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc0b689d0f1e53db6235d4167f840974edfc44ee
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/primes.py
@@ -0,0 +1,784 @@
+"""Prime ideals in number fields. """
+
+from sympy.polys.polytools import Poly
+from sympy.polys.domains.finitefield import FF
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.polyutils import IntegerPowerable
+from sympy.utilities.decorator import public
+from .basis import round_two, nilradical_mod_p
+from .exceptions import StructureError
+from .modules import ModuleEndomorphism, find_min_poly
+from .utilities import coeff_search, supplement_a_subspace
+
+
+def _check_formal_conditions_for_maximal_order(submodule):
+    r"""
+    Several functions in this module accept an argument which is to be a
+    :py:class:`~.Submodule` representing the maximal order in a number field,
+    such as returned by the :py:func:`~sympy.polys.numberfields.basis.round_two`
+    algorithm.
+
+    We do not attempt to check that the given ``Submodule`` actually represents
+    a maximal order, but we do check a basic set of formal conditions that the
+    ``Submodule`` must satisfy, at a minimum. The purpose is to catch an
+    obviously ill-formed argument.
+    """
+    prefix = 'The submodule representing the maximal order should '
+    cond = None
+    if not submodule.is_power_basis_submodule():
+        cond = 'be a direct submodule of a power basis.'
+    elif not submodule.starts_with_unity():
+        cond = 'have 1 as its first generator.'
+    elif not submodule.is_sq_maxrank_HNF():
+        cond = 'have square matrix, of maximal rank, in Hermite Normal Form.'
+    if cond is not None:
+        raise StructureError(prefix + cond)
+
+
+class PrimeIdeal(IntegerPowerable):
+    r"""
+    A prime ideal in a ring of algebraic integers.
+    """
+
+    def __init__(self, ZK, p, alpha, f, e=None):
+        """
+        Parameters
+        ==========
+
+        ZK : :py:class:`~.Submodule`
+            The maximal order where this ideal lives.
+        p : int
+            The rational prime this ideal divides.
+        alpha : :py:class:`~.PowerBasisElement`
+            Such that the ideal is equal to ``p*ZK + alpha*ZK``.
+        f : int
+            The inertia degree.
+        e : int, ``None``, optional
+            The ramification index, if already known. If ``None``, we will
+            compute it here.
+
+        """
+        _check_formal_conditions_for_maximal_order(ZK)
+        self.ZK = ZK
+        self.p = p
+        self.alpha = alpha
+        self.f = f
+        self._test_factor = None
+        self.e = e if e is not None else self.valuation(p * ZK)
+
+    def __str__(self):
+        if self.is_inert:
+            return f'({self.p})'
+        return f'({self.p}, {self.alpha.as_expr()})'
+
+    @property
+    def is_inert(self):
+        """
+        Say whether the rational prime we divide is inert, i.e. stays prime in
+        our ring of integers.
+        """
+        return self.f == self.ZK.n
+
+    def repr(self, field_gen=None, just_gens=False):
+        """
+        Print a representation of this prime ideal.
+
+        Examples
+        ========
+
+        >>> from sympy import cyclotomic_poly, QQ
+        >>> from sympy.abc import x, zeta
+        >>> T = cyclotomic_poly(7, x)
+        >>> K = QQ.algebraic_field((T, zeta))
+        >>> P = K.primes_above(11)
+        >>> print(P[0].repr())
+        [ (11, x**3 + 5*x**2 + 4*x - 1) e=1, f=3 ]
+        >>> print(P[0].repr(field_gen=zeta))
+        [ (11, zeta**3 + 5*zeta**2 + 4*zeta - 1) e=1, f=3 ]
+        >>> print(P[0].repr(field_gen=zeta, just_gens=True))
+        (11, zeta**3 + 5*zeta**2 + 4*zeta - 1)
+
+        Parameters
+        ==========
+
+        field_gen : :py:class:`~.Symbol`, ``None``, optional (default=None)
+            The symbol to use for the generator of the field. This will appear
+            in our representation of ``self.alpha``. If ``None``, we use the
+            variable of the defining polynomial of ``self.ZK``.
+        just_gens : bool, optional (default=False)
+            If ``True``, just print the "(p, alpha)" part, showing "just the
+            generators" of the prime ideal. Otherwise, print a string of the
+            form "[ (p, alpha) e=..., f=... ]", giving the ramification index
+            and inertia degree, along with the generators.
+
+        """
+        field_gen = field_gen or self.ZK.parent.T.gen
+        p, alpha, e, f = self.p, self.alpha, self.e, self.f
+        alpha_rep = str(alpha.numerator(x=field_gen).as_expr())
+        if alpha.denom > 1:
+            alpha_rep = f'({alpha_rep})/{alpha.denom}'
+        gens = f'({p}, {alpha_rep})'
+        if just_gens:
+            return gens
+        return f'[ {gens} e={e}, f={f} ]'
+
+    def __repr__(self):
+        return self.repr()
+
+    def as_submodule(self):
+        r"""
+        Represent this prime ideal as a :py:class:`~.Submodule`.
+
+        Explanation
+        ===========
+
+        The :py:class:`~.PrimeIdeal` class serves to bundle information about
+        a prime ideal, such as its inertia degree, ramification index, and
+        two-generator representation, as well as to offer helpful methods like
+        :py:meth:`~.PrimeIdeal.valuation` and
+        :py:meth:`~.PrimeIdeal.test_factor`.
+
+        However, in order to be added and multiplied by other ideals or
+        rational numbers, it must first be converted into a
+        :py:class:`~.Submodule`, which is a class that supports these
+        operations.
+
+        In many cases, the user need not perform this conversion deliberately,
+        since it is automatically performed by the arithmetic operator methods
+        :py:meth:`~.PrimeIdeal.__add__` and :py:meth:`~.PrimeIdeal.__mul__`.
+
+        Raising a :py:class:`~.PrimeIdeal` to a non-negative integer power is
+        also supported.
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly, prime_decomp
+        >>> T = Poly(cyclotomic_poly(7))
+        >>> P0 = prime_decomp(7, T)[0]
+        >>> print(P0**6 == 7*P0.ZK)
+        True
+
+        Note that, on both sides of the equation above, we had a
+        :py:class:`~.Submodule`. In the next equation we recall that adding
+        ideals yields their GCD. This time, we need a deliberate conversion
+        to :py:class:`~.Submodule` on the right:
+
+        >>> print(P0 + 7*P0.ZK == P0.as_submodule())
+        True
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+            Will be equal to ``self.p * self.ZK + self.alpha * self.ZK``.
+
+        See Also
+        ========
+
+        __add__
+        __mul__
+
+        """
+        M = self.p * self.ZK + self.alpha * self.ZK
+        # Pre-set expensive boolean properties whose value we already know:
+        M._starts_with_unity = False
+        M._is_sq_maxrank_HNF = True
+        return M
+
+    def __eq__(self, other):
+        if isinstance(other, PrimeIdeal):
+            return self.as_submodule() == other.as_submodule()
+        return NotImplemented
+
+    def __add__(self, other):
+        """
+        Convert to a :py:class:`~.Submodule` and add to another
+        :py:class:`~.Submodule`.
+
+        See Also
+        ========
+
+        as_submodule
+
+        """
+        return self.as_submodule() + other
+
+    __radd__ = __add__
+
+    def __mul__(self, other):
+        """
+        Convert to a :py:class:`~.Submodule` and multiply by another
+        :py:class:`~.Submodule` or a rational number.
+
+        See Also
+        ========
+
+        as_submodule
+
+        """
+        return self.as_submodule() * other
+
+    __rmul__ = __mul__
+
+    def _zeroth_power(self):
+        return self.ZK
+
+    def _first_power(self):
+        return self
+
+    def test_factor(self):
+        r"""
+        Compute a test factor for this prime ideal.
+
+        Explanation
+        ===========
+
+        Write $\mathfrak{p}$ for this prime ideal, $p$ for the rational prime
+        it divides. Then, for computing $\mathfrak{p}$-adic valuations it is
+        useful to have a number $\beta \in \mathbb{Z}_K$ such that
+        $p/\mathfrak{p} = p \mathbb{Z}_K + \beta \mathbb{Z}_K$.
+
+        Essentially, this is the same as the number $\Psi$ (or the "reagent")
+        from Kummer's 1847 paper (*Ueber die Zerlegung...*, Crelle vol. 35) in
+        which ideal divisors were invented.
+        """
+        if self._test_factor is None:
+            self._test_factor = _compute_test_factor(self.p, [self.alpha], self.ZK)
+        return self._test_factor
+
+    def valuation(self, I):
+        r"""
+        Compute the $\mathfrak{p}$-adic valuation of integral ideal I at this
+        prime ideal.
+
+        Parameters
+        ==========
+
+        I : :py:class:`~.Submodule`
+
+        See Also
+        ========
+
+        prime_valuation
+
+        """
+        return prime_valuation(I, self)
+
+    def reduce_element(self, elt):
+        """
+        Reduce a :py:class:`~.PowerBasisElement` to a "small representative"
+        modulo this prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.PowerBasisElement`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_ANP
+        reduce_alg_num
+        .Submodule.reduce_element
+
+        """
+        return self.as_submodule().reduce_element(elt)
+
+    def reduce_ANP(self, a):
+        """
+        Reduce an :py:class:`~.ANP` to a "small representative" modulo this
+        prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ANP`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.ANP`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_element
+        reduce_alg_num
+        .Submodule.reduce_element
+
+        """
+        elt = self.ZK.parent.element_from_ANP(a)
+        red = self.reduce_element(elt)
+        return red.to_ANP()
+
+    def reduce_alg_num(self, a):
+        """
+        Reduce an :py:class:`~.AlgebraicNumber` to a "small representative"
+        modulo this prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.AlgebraicNumber`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicNumber`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_element
+        reduce_ANP
+        .Submodule.reduce_element
+
+        """
+        elt = self.ZK.parent.element_from_alg_num(a)
+        red = self.reduce_element(elt)
+        return a.field_element(list(reversed(red.QQ_col.flat())))
+
+
+def _compute_test_factor(p, gens, ZK):
+    r"""
+    Compute the test factor for a :py:class:`~.PrimeIdeal` $\mathfrak{p}$.
+
+    Parameters
+    ==========
+
+    p : int
+        The rational prime $\mathfrak{p}$ divides
+
+    gens : list of :py:class:`PowerBasisElement`
+        A complete set of generators for $\mathfrak{p}$ over *ZK*, EXCEPT that
+        an element equivalent to rational *p* can and should be omitted (since
+        it has no effect except to waste time).
+
+    ZK : :py:class:`~.Submodule`
+        The maximal order where the prime ideal $\mathfrak{p}$ lives.
+
+    Returns
+    =======
+
+    :py:class:`~.PowerBasisElement`
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+    (See Proposition 4.8.15.)
+
+    """
+    _check_formal_conditions_for_maximal_order(ZK)
+    E = ZK.endomorphism_ring()
+    matrices = [E.inner_endomorphism(g).matrix(modulus=p) for g in gens]
+    B = DomainMatrix.zeros((0, ZK.n), FF(p)).vstack(*matrices)
+    # A nonzero element of the nullspace of B will represent a
+    # lin comb over the omegas which (i) is not a multiple of p
+    # (since it is nonzero over FF(p)), while (ii) is such that
+    # its product with each g in gens _is_ a multiple of p (since
+    # B represents multiplication by these generators). Theory
+    # predicts that such an element must exist, so nullspace should
+    # be non-trivial.
+    x = B.nullspace()[0, :].transpose()
+    beta = ZK.parent(ZK.matrix * x, denom=ZK.denom)
+    return beta
+
+
+@public
+def prime_valuation(I, P):
+    r"""
+    Compute the *P*-adic valuation for an integral ideal *I*.
+
+    Examples
+    ========
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.numberfields import prime_valuation
+    >>> K = QQ.cyclotomic_field(5)
+    >>> P = K.primes_above(5)
+    >>> ZK = K.maximal_order()
+    >>> print(prime_valuation(25*ZK, P[0]))
+    8
+
+    Parameters
+    ==========
+
+    I : :py:class:`~.Submodule`
+        An integral ideal whose valuation is desired.
+
+    P : :py:class:`~.PrimeIdeal`
+        The prime at which to compute the valuation.
+
+    Returns
+    =======
+
+    int
+
+    See Also
+    ========
+
+    .PrimeIdeal.valuation
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 4.8.17.)
+
+    """
+    p, ZK = P.p, P.ZK
+    n, W, d = ZK.n, ZK.matrix, ZK.denom
+
+    A = W.convert_to(QQ).inv() * I.matrix * d / I.denom
+    # Although A must have integer entries, given that I is an integral ideal,
+    # as a DomainMatrix it will still be over QQ, so we convert back:
+    A = A.convert_to(ZZ)
+    D = A.det()
+    if D % p != 0:
+        return 0
+
+    beta = P.test_factor()
+
+    f = d ** n // W.det()
+    need_complete_test = (f % p == 0)
+    v = 0
+    while True:
+        # Entering the loop, the cols of A represent lin combs of omegas.
+        # Turn them into lin combs of thetas:
+        A = W * A
+        # And then one column at a time...
+        for j in range(n):
+            c = ZK.parent(A[:, j], denom=d)
+            c *= beta
+            # ...turn back into lin combs of omegas, after multiplying by beta:
+            c = ZK.represent(c).flat()
+            for i in range(n):
+                A[i, j] = c[i]
+        if A[n - 1, n - 1].element % p != 0:
+            break
+        A = A / p
+        # As noted above, domain converts to QQ even when division goes evenly.
+        # So must convert back, even when we don't "need_complete_test".
+        if need_complete_test:
+            # In this case, having a non-integer entry is actually just our
+            # halting condition.
+            try:
+                A = A.convert_to(ZZ)
+            except CoercionFailed:
+                break
+        else:
+            # In this case theory says we should not have any non-integer entries.
+            A = A.convert_to(ZZ)
+        v += 1
+    return v
+
+
+def _two_elt_rep(gens, ZK, p, f=None, Np=None):
+    r"""
+    Given a set of *ZK*-generators of a prime ideal, compute a set of just two
+    *ZK*-generators for the same ideal, one of which is *p* itself.
+
+    Parameters
+    ==========
+
+    gens : list of :py:class:`PowerBasisElement`
+        Generators for the prime ideal over *ZK*, the ring of integers of the
+        field $K$.
+
+    ZK : :py:class:`~.Submodule`
+        The maximal order in $K$.
+
+    p : int
+        The rational prime divided by the prime ideal.
+
+    f : int, optional
+        The inertia degree of the prime ideal, if known.
+
+    Np : int, optional
+        The norm $p^f$ of the prime ideal, if known.
+        NOTE: There is no reason to supply both *f* and *Np*. Either one will
+        save us from having to compute the norm *Np* ourselves. If both are known,
+        *Np* is preferred since it saves one exponentiation.
+
+    Returns
+    =======
+
+    :py:class:`~.PowerBasisElement` representing a single algebraic integer
+    alpha such that the prime ideal is equal to ``p*ZK + alpha*ZK``.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+    (See Algorithm 4.7.10.)
+
+    """
+    _check_formal_conditions_for_maximal_order(ZK)
+    pb = ZK.parent
+    T = pb.T
+    # Detect the special cases in which either (a) all generators are multiples
+    # of p, or (b) there are no generators (so `all` is vacuously true):
+    if all((g % p).equiv(0) for g in gens):
+        return pb.zero()
+
+    if Np is None:
+        if f is not None:
+            Np = p**f
+        else:
+            Np = abs(pb.submodule_from_gens(gens).matrix.det())
+
+    omega = ZK.basis_element_pullbacks()
+    beta = [p*om for om in omega[1:]]  # note: we omit omega[0] == 1
+    beta += gens
+    search = coeff_search(len(beta), 1)
+    for c in search:
+        alpha = sum(ci*betai for ci, betai in zip(c, beta))
+        # Note: It may be tempting to reduce alpha mod p here, to try to work
+        # with smaller numbers, but must not do that, as it can result in an
+        # infinite loop! E.g. try factoring 2 in Q(sqrt(-7)).
+        n = alpha.norm(T) // Np
+        if n % p != 0:
+            # Now can reduce alpha mod p.
+            return alpha % p
+
+
+def _prime_decomp_easy_case(p, ZK):
+    r"""
+    Compute the decomposition of rational prime *p* in the ring of integers
+    *ZK* (given as a :py:class:`~.Submodule`), in the "easy case", i.e. the
+    case where *p* does not divide the index of $\theta$ in *ZK*, where
+    $\theta$ is the generator of the ``PowerBasis`` of which *ZK* is a
+    ``Submodule``.
+    """
+    T = ZK.parent.T
+    T_bar = Poly(T, modulus=p)
+    lc, fl = T_bar.factor_list()
+    if len(fl) == 1 and fl[0][1] == 1:
+        return [PrimeIdeal(ZK, p, ZK.parent.zero(), ZK.n, 1)]
+    return [PrimeIdeal(ZK, p,
+                       ZK.parent.element_from_poly(Poly(t, domain=ZZ)),
+                       t.degree(), e)
+            for t, e in fl]
+
+
+def _prime_decomp_compute_kernel(I, p, ZK):
+    r"""
+    Parameters
+    ==========
+
+    I : :py:class:`~.Module`
+        An ideal of ``ZK/pZK``.
+    p : int
+        The rational prime being factored.
+    ZK : :py:class:`~.Submodule`
+        The maximal order.
+
+    Returns
+    =======
+
+    Pair ``(N, G)``, where:
+
+        ``N`` is a :py:class:`~.Module` representing the kernel of the map
+        ``a |--> a**p - a`` on ``(O/pO)/I``, guaranteed to be a module with
+        unity.
+
+        ``G`` is a :py:class:`~.Module` representing a basis for the separable
+        algebra ``A = O/I`` (see Cohen).
+
+    """
+    W = I.matrix
+    n, r = W.shape
+    # Want to take the Fp-basis given by the columns of I, adjoin (1, 0, ..., 0)
+    # (which we know is not already in there since I is a basis for a prime ideal)
+    # and then supplement this with additional columns to make an invertible n x n
+    # matrix. This will then represent a full basis for ZK, whose first r columns
+    # are pullbacks of the basis for I.
+    if r == 0:
+        B = W.eye(n, ZZ)
+    else:
+        B = W.hstack(W.eye(n, ZZ)[:, 0])
+    if B.shape[1] < n:
+        B = supplement_a_subspace(B.convert_to(FF(p))).convert_to(ZZ)
+
+    G = ZK.submodule_from_matrix(B)
+    # Must compute G's multiplication table _before_ discarding the first r
+    # columns. (See Step 9 in Alg 6.2.9 in Cohen, where the betas are actually
+    # needed in order to represent each product of gammas. However, once we've
+    # found the representations, then we can ignore the betas.)
+    G.compute_mult_tab()
+    G = G.discard_before(r)
+
+    phi = ModuleEndomorphism(G, lambda x: x**p - x)
+    N = phi.kernel(modulus=p)
+    assert N.starts_with_unity()
+    return N, G
+
+
+def _prime_decomp_maximal_ideal(I, p, ZK):
+    r"""
+    We have reached the case where we have a maximal (hence prime) ideal *I*,
+    which we know because the quotient ``O/I`` is a field.
+
+    Parameters
+    ==========
+
+    I : :py:class:`~.Module`
+        An ideal of ``O/pO``.
+    p : int
+        The rational prime being factored.
+    ZK : :py:class:`~.Submodule`
+        The maximal order.
+
+    Returns
+    =======
+
+    :py:class:`~.PrimeIdeal` instance representing this prime
+
+    """
+    m, n = I.matrix.shape
+    f = m - n
+    G = ZK.matrix * I.matrix
+    gens = [ZK.parent(G[:, j], denom=ZK.denom) for j in range(G.shape[1])]
+    alpha = _two_elt_rep(gens, ZK, p, f=f)
+    return PrimeIdeal(ZK, p, alpha, f)
+
+
+def _prime_decomp_split_ideal(I, p, N, G, ZK):
+    r"""
+    Perform the step in the prime decomposition algorithm where we have determined
+    the the quotient ``ZK/I`` is _not_ a field, and we want to perform a non-trivial
+    factorization of *I* by locating an idempotent element of ``ZK/I``.
+    """
+    assert I.parent == ZK and G.parent is ZK and N.parent is G
+    # Since ZK/I is not a field, the kernel computed in the previous step contains
+    # more than just the prime field Fp, and our basis N for the nullspace therefore
+    # contains at least a second column (which represents an element outside Fp).
+    # Let alpha be such an element:
+    alpha = N(1).to_parent()
+    assert alpha.module is G
+
+    alpha_powers = []
+    m = find_min_poly(alpha, FF(p), powers=alpha_powers)
+    # TODO (future work):
+    #  We don't actually need full factorization, so might use a faster method
+    #  to just break off a single non-constant factor m1?
+    lc, fl = m.factor_list()
+    m1 = fl[0][0]
+    m2 = m.quo(m1)
+    U, V, g = m1.gcdex(m2)
+    # Sanity check: theory says m is squarefree, so m1, m2 should be coprime:
+    assert g == 1
+    E = list(reversed(Poly(U * m1, domain=ZZ).rep.rep))
+    eps1 = sum(E[i]*alpha_powers[i] for i in range(len(E)))
+    eps2 = 1 - eps1
+    idemps = [eps1, eps2]
+    factors = []
+    for eps in idemps:
+        e = eps.to_parent()
+        assert e.module is ZK
+        D = I.matrix.convert_to(FF(p)).hstack(*[
+            (e * om).column(domain=FF(p)) for om in ZK.basis_elements()
+        ])
+        W = D.columnspace().convert_to(ZZ)
+        H = ZK.submodule_from_matrix(W)
+        factors.append(H)
+    return factors
+
+
+@public
+def prime_decomp(p, T=None, ZK=None, dK=None, radical=None):
+    r"""
+    Compute the decomposition of rational prime *p* in a number field.
+
+    Explanation
+    ===========
+
+    Ordinarily this should be accessed through the
+    :py:meth:`~.AlgebraicField.primes_above` method of an
+    :py:class:`~.AlgebraicField`.
+
+    Examples
+    ========
+
+    >>> from sympy import Poly, QQ
+    >>> from sympy.abc import x, theta
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> K = QQ.algebraic_field((T, theta))
+    >>> print(K.primes_above(2))
+    [[ (2, x**2 + 1) e=1, f=1 ], [ (2, (x**2 + 3*x + 2)/2) e=1, f=1 ],
+     [ (2, (3*x**2 + 3*x)/2) e=1, f=1 ]]
+
+    Parameters
+    ==========
+
+    p : int
+        The rational prime whose decomposition is desired.
+
+    T : :py:class:`~.Poly`, optional
+        Monic irreducible polynomial defining the number field $K$ in which to
+        factor. NOTE: at least one of *T* or *ZK* must be provided.
+
+    ZK : :py:class:`~.Submodule`, optional
+        The maximal order for $K$, if already known.
+        NOTE: at least one of *T* or *ZK* must be provided.
+
+    dK : int, optional
+        The discriminant of the field $K$, if already known.
+
+    radical : :py:class:`~.Submodule`, optional
+        The nilradical mod *p* in the integers of $K$, if already known.
+
+    Returns
+    =======
+
+    List of :py:class:`~.PrimeIdeal` instances.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 6.2.9.)
+
+    """
+    if T is None and ZK is None:
+        raise ValueError('At least one of T or ZK must be provided.')
+    if ZK is not None:
+        _check_formal_conditions_for_maximal_order(ZK)
+    if T is None:
+        T = ZK.parent.T
+    radicals = {}
+    if dK is None or ZK is None:
+        ZK, dK = round_two(T, radicals=radicals)
+    dT = T.discriminant()
+    f_squared = dT // dK
+    if f_squared % p != 0:
+        return _prime_decomp_easy_case(p, ZK)
+    radical = radical or radicals.get(p) or nilradical_mod_p(ZK, p)
+    stack = [radical]
+    primes = []
+    while stack:
+        I = stack.pop()
+        N, G = _prime_decomp_compute_kernel(I, p, ZK)
+        if N.n == 1:
+            P = _prime_decomp_maximal_ideal(I, p, ZK)
+            primes.append(P)
+        else:
+            I1, I2 = _prime_decomp_split_ideal(I, p, N, G, ZK)
+            stack.extend([I1, I2])
+    return primes
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/resolvent_lookup.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/resolvent_lookup.py
new file mode 100644
index 0000000000000000000000000000000000000000..71812c0d7aec6501039eefe4f3602b1916628071
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/resolvent_lookup.py
@@ -0,0 +1,456 @@
+"""Lookup table for Galois resolvents for polys of degree 4 through 6. """
+# This table was generated by a call to
+# `sympy.polys.numberfields.galois_resolvents.generate_lambda_lookup()`.
+# The entire job took 543.23s.
+# Of this, Case (6, 1) took 539.03s.
+# The final polynomial of Case (6, 1) alone took 455.09s.
+resolvent_coeff_lambdas = {
+    (4, 0): [
+        lambda s1, s2, s3, s4: (-2*s1*s2 + 6*s3),
+        lambda s1, s2, s3, s4: (2*s1**3*s3 + s1**2*s2**2 + s1**2*s4 - 17*s1*s2*s3 + 2*s2**3 - 8*s2*s4 + 24*s3**2),
+        lambda s1, s2, s3, s4: (-2*s1**5*s4 - 2*s1**4*s2*s3 + 10*s1**3*s2*s4 + 8*s1**3*s3**2 + 10*s1**2*s2**2*s3 -
+12*s1**2*s3*s4 - 2*s1*s2**4 - 54*s1*s2*s3**2 + 32*s1*s4**2 + 8*s2**3*s3 - 32*s2*s3*s4
++ 56*s3**3),
+        lambda s1, s2, s3, s4: (2*s1**6*s2*s4 + s1**6*s3**2 - 5*s1**5*s3*s4 - 11*s1**4*s2**2*s4 - 13*s1**4*s2*s3**2
++ 7*s1**4*s4**2 + 3*s1**3*s2**3*s3 + 30*s1**3*s2*s3*s4 + 22*s1**3*s3**3 + 10*s1**2*s2**3*s4
++ 33*s1**2*s2**2*s3**2 - 72*s1**2*s2*s4**2 - 36*s1**2*s3**2*s4 - 13*s1*s2**4*s3 +
+48*s1*s2**2*s3*s4 - 116*s1*s2*s3**3 + 144*s1*s3*s4**2 + s2**6 - 12*s2**4*s4 + 22*s2**3*s3**2
++ 48*s2**2*s4**2 - 120*s2*s3**2*s4 + 96*s3**4 - 64*s4**3),
+        lambda s1, s2, s3, s4: (-2*s1**8*s3*s4 - s1**7*s4**2 + 22*s1**6*s2*s3*s4 + 2*s1**6*s3**3 - 2*s1**5*s2**3*s4
+- s1**5*s2**2*s3**2 - 29*s1**5*s3**2*s4 - 60*s1**4*s2**2*s3*s4 - 19*s1**4*s2*s3**3
++ 38*s1**4*s3*s4**2 + 9*s1**3*s2**4*s4 + 10*s1**3*s2**3*s3**2 + 24*s1**3*s2**2*s4**2
++ 134*s1**3*s2*s3**2*s4 + 28*s1**3*s3**4 + 16*s1**3*s4**3 - s1**2*s2**5*s3 - 4*s1**2*s2**3*s3*s4
++ 34*s1**2*s2**2*s3**3 - 288*s1**2*s2*s3*s4**2 - 104*s1**2*s3**3*s4 - 19*s1*s2**4*s3**2
++ 120*s1*s2**2*s3**2*s4 - 128*s1*s2*s3**4 + 336*s1*s3**2*s4**2 + 2*s2**6*s3 - 24*s2**4*s3*s4
++ 28*s2**3*s3**3 + 96*s2**2*s3*s4**2 - 176*s2*s3**3*s4 + 96*s3**5 - 128*s3*s4**3),
+        lambda s1, s2, s3, s4: (s1**10*s4**2 - 11*s1**8*s2*s4**2 - 2*s1**8*s3**2*s4 + s1**7*s2**2*s3*s4 + 15*s1**7*s3*s4**2
++ 45*s1**6*s2**2*s4**2 + 17*s1**6*s2*s3**2*s4 + s1**6*s3**4 - 5*s1**6*s4**3 - 12*s1**5*s2**3*s3*s4
+- 133*s1**5*s2*s3*s4**2 - 22*s1**5*s3**3*s4 + s1**4*s2**5*s4 - 76*s1**4*s2**3*s4**2
+- 6*s1**4*s2**2*s3**2*s4 - 12*s1**4*s2*s3**4 + 32*s1**4*s2*s4**3 + 128*s1**4*s3**2*s4**2
++ 29*s1**3*s2**4*s3*s4 + 2*s1**3*s2**3*s3**3 + 344*s1**3*s2**2*s3*s4**2 + 48*s1**3*s2*s3**3*s4
++ 16*s1**3*s3**5 - 48*s1**3*s3*s4**3 - 4*s1**2*s2**6*s4 + 32*s1**2*s2**4*s4**2 - 134*s1**2*s2**3*s3**2*s4
++ 36*s1**2*s2**2*s3**4 - 64*s1**2*s2**2*s4**3 - 648*s1**2*s2*s3**2*s4**2 - 48*s1**2*s3**4*s4
++ 16*s1*s2**5*s3*s4 - 12*s1*s2**4*s3**3 - 128*s1*s2**3*s3*s4**2 + 296*s1*s2**2*s3**3*s4
+- 96*s1*s2*s3**5 + 256*s1*s2*s3*s4**3 + 416*s1*s3**3*s4**2 + s2**6*s3**2 - 28*s2**4*s3**2*s4
++ 16*s2**3*s3**4 + 176*s2**2*s3**2*s4**2 - 224*s2*s3**4*s4 + 64*s3**6 - 320*s3**2*s4**3)
+    ],
+    (4, 1): [
+        lambda s1, s2, s3, s4: (-s2),
+        lambda s1, s2, s3, s4: (s1*s3 - 4*s4),
+        lambda s1, s2, s3, s4: (-s1**2*s4 + 4*s2*s4 - s3**2)
+    ],
+    (5, 1): [
+        lambda s1, s2, s3, s4, s5: (-2*s1*s3 + 8*s4),
+        lambda s1, s2, s3, s4, s5: (-8*s1**3*s5 + 2*s1**2*s2*s4 + s1**2*s3**2 + 30*s1*s2*s5 - 14*s1*s3*s4 - 6*s2**2*s4
++ 2*s2*s3**2 - 50*s3*s5 + 40*s4**2),
+        lambda s1, s2, s3, s4, s5: (16*s1**4*s3*s5 - 2*s1**4*s4**2 - 2*s1**3*s2**2*s5 - 2*s1**3*s2*s3*s4 - 44*s1**3*s4*s5
+- 66*s1**2*s2*s3*s5 + 21*s1**2*s2*s4**2 + 6*s1**2*s3**2*s4 - 50*s1**2*s5**2 + 9*s1*s2**3*s5
++ 5*s1*s2**2*s3*s4 - 2*s1*s2*s3**3 + 190*s1*s2*s4*s5 + 120*s1*s3**2*s5 - 80*s1*s3*s4**2
+- 15*s2**2*s3*s5 - 40*s2**2*s4**2 + 21*s2*s3**2*s4 + 125*s2*s5**2 - 2*s3**4 - 400*s3*s4*s5
++ 160*s4**3),
+        lambda s1, s2, s3, s4, s5: (16*s1**6*s5**2 - 8*s1**5*s2*s4*s5 - 8*s1**5*s3**2*s5 + 2*s1**5*s3*s4**2 + 2*s1**4*s2**2*s3*s5
++ s1**4*s2**2*s4**2 - 120*s1**4*s2*s5**2 + 68*s1**4*s3*s4*s5 - 8*s1**4*s4**3 + 46*s1**3*s2**2*s4*s5
++ 28*s1**3*s2*s3**2*s5 - 19*s1**3*s2*s3*s4**2 + 250*s1**3*s3*s5**2 - 144*s1**3*s4**2*s5
+- 9*s1**2*s2**3*s3*s5 - 6*s1**2*s2**3*s4**2 + 3*s1**2*s2**2*s3**2*s4 + 225*s1**2*s2**2*s5**2
+- 354*s1**2*s2*s3*s4*s5 + 76*s1**2*s2*s4**3 - 70*s1**2*s3**3*s5 + 41*s1**2*s3**2*s4**2
+- 200*s1**2*s4*s5**2 - 54*s1*s2**3*s4*s5 + 45*s1*s2**2*s3**2*s5 + 30*s1*s2**2*s3*s4**2
+- 19*s1*s2*s3**3*s4 - 875*s1*s2*s3*s5**2 + 640*s1*s2*s4**2*s5 + 2*s1*s3**5 + 630*s1*s3**2*s4*s5
+- 264*s1*s3*s4**3 + 9*s2**4*s4**2 - 6*s2**3*s3**2*s4 + s2**2*s3**4 + 90*s2**2*s3*s4*s5
+- 136*s2**2*s4**3 - 50*s2*s3**3*s5 + 76*s2*s3**2*s4**2 + 500*s2*s4*s5**2 - 8*s3**4*s4
++ 625*s3**2*s5**2 - 1400*s3*s4**2*s5 + 400*s4**4),
+        lambda s1, s2, s3, s4, s5: (-32*s1**7*s3*s5**2 + 8*s1**7*s4**2*s5 + 8*s1**6*s2**2*s5**2 + 8*s1**6*s2*s3*s4*s5
+- 2*s1**6*s2*s4**3 + 48*s1**6*s4*s5**2 - 2*s1**5*s2**3*s4*s5 + 264*s1**5*s2*s3*s5**2
+- 94*s1**5*s2*s4**2*s5 - 24*s1**5*s3**2*s4*s5 + 6*s1**5*s3*s4**3 - 56*s1**5*s5**3
+- 66*s1**4*s2**3*s5**2 - 50*s1**4*s2**2*s3*s4*s5 + 19*s1**4*s2**2*s4**3 + 8*s1**4*s2*s3**3*s5
+- 2*s1**4*s2*s3**2*s4**2 - 318*s1**4*s2*s4*s5**2 - 352*s1**4*s3**2*s5**2 + 166*s1**4*s3*s4**2*s5
++ 3*s1**4*s4**4 + 15*s1**3*s2**4*s4*s5 - 2*s1**3*s2**3*s3**2*s5 - s1**3*s2**3*s3*s4**2
+- 574*s1**3*s2**2*s3*s5**2 + 347*s1**3*s2**2*s4**2*s5 + 194*s1**3*s2*s3**2*s4*s5 -
+89*s1**3*s2*s3*s4**3 + 350*s1**3*s2*s5**3 - 8*s1**3*s3**4*s5 + 4*s1**3*s3**3*s4**2
++ 1090*s1**3*s3*s4*s5**2 - 364*s1**3*s4**3*s5 + 162*s1**2*s2**4*s5**2 + 33*s1**2*s2**3*s3*s4*s5
+- 51*s1**2*s2**3*s4**3 - 32*s1**2*s2**2*s3**3*s5 + 28*s1**2*s2**2*s3**2*s4**2 + 305*s1**2*s2**2*s4*s5**2
+- 2*s1**2*s2*s3**4*s4 + 1340*s1**2*s2*s3**2*s5**2 - 901*s1**2*s2*s3*s4**2*s5 + 76*s1**2*s2*s4**4
+- 234*s1**2*s3**3*s4*s5 + 102*s1**2*s3**2*s4**3 - 750*s1**2*s3*s5**3 - 550*s1**2*s4**2*s5**2
+- 27*s1*s2**5*s4*s5 + 9*s1*s2**4*s3**2*s5 + 3*s1*s2**4*s3*s4**2 - s1*s2**3*s3**3*s4
++ 180*s1*s2**3*s3*s5**2 - 366*s1*s2**3*s4**2*s5 - 231*s1*s2**2*s3**2*s4*s5 + 212*s1*s2**2*s3*s4**3
+- 375*s1*s2**2*s5**3 + 112*s1*s2*s3**4*s5 - 89*s1*s2*s3**3*s4**2 - 3075*s1*s2*s3*s4*s5**2
++ 1640*s1*s2*s4**3*s5 + 6*s1*s3**5*s4 - 850*s1*s3**3*s5**2 + 1220*s1*s3**2*s4**2*s5
+- 384*s1*s3*s4**4 + 2500*s1*s4*s5**3 - 108*s2**5*s5**2 + 117*s2**4*s3*s4*s5 + 32*s2**4*s4**3
+- 31*s2**3*s3**3*s5 - 51*s2**3*s3**2*s4**2 + 525*s2**3*s4*s5**2 + 19*s2**2*s3**4*s4
+- 325*s2**2*s3**2*s5**2 + 260*s2**2*s3*s4**2*s5 - 256*s2**2*s4**4 - 2*s2*s3**6 + 105*s2*s3**3*s4*s5
++ 76*s2*s3**2*s4**3 + 625*s2*s3*s5**3 - 500*s2*s4**2*s5**2 - 58*s3**5*s5 + 3*s3**4*s4**2
++ 2750*s3**2*s4*s5**2 - 2400*s3*s4**3*s5 + 512*s4**5 - 3125*s5**4),
+        lambda s1, s2, s3, s4, s5: (16*s1**8*s3**2*s5**2 - 8*s1**8*s3*s4**2*s5 + s1**8*s4**4 - 8*s1**7*s2**2*s3*s5**2
++ 2*s1**7*s2**2*s4**2*s5 - 48*s1**7*s3*s4*s5**2 + 12*s1**7*s4**3*s5 + s1**6*s2**4*s5**2
++ 12*s1**6*s2**2*s4*s5**2 - 144*s1**6*s2*s3**2*s5**2 + 88*s1**6*s2*s3*s4**2*s5 - 13*s1**6*s2*s4**4
++ 56*s1**6*s3*s5**3 + 86*s1**6*s4**2*s5**2 + 72*s1**5*s2**3*s3*s5**2 - 22*s1**5*s2**3*s4**2*s5
+- 4*s1**5*s2**2*s3**2*s4*s5 + s1**5*s2**2*s3*s4**3 - 14*s1**5*s2**2*s5**3 + 304*s1**5*s2*s3*s4*s5**2
+- 148*s1**5*s2*s4**3*s5 + 152*s1**5*s3**3*s5**2 - 54*s1**5*s3**2*s4**2*s5 + 5*s1**5*s3*s4**4
+- 468*s1**5*s4*s5**3 - 9*s1**4*s2**5*s5**2 + s1**4*s2**4*s3*s4*s5 - 76*s1**4*s2**3*s4*s5**2
++ 370*s1**4*s2**2*s3**2*s5**2 - 287*s1**4*s2**2*s3*s4**2*s5 + 65*s1**4*s2**2*s4**4
+- 28*s1**4*s2*s3**3*s4*s5 + 5*s1**4*s2*s3**2*s4**3 - 200*s1**4*s2*s3*s5**3 - 294*s1**4*s2*s4**2*s5**2
++ 8*s1**4*s3**5*s5 - 2*s1**4*s3**4*s4**2 - 676*s1**4*s3**2*s4*s5**2 + 180*s1**4*s3*s4**3*s5
++ 17*s1**4*s4**5 + 625*s1**4*s5**4 - 210*s1**3*s2**4*s3*s5**2 + 76*s1**3*s2**4*s4**2*s5
++ 43*s1**3*s2**3*s3**2*s4*s5 - 15*s1**3*s2**3*s3*s4**3 + 50*s1**3*s2**3*s5**3 - 6*s1**3*s2**2*s3**4*s5
++ 2*s1**3*s2**2*s3**3*s4**2 - 397*s1**3*s2**2*s3*s4*s5**2 + 514*s1**3*s2**2*s4**3*s5
+- 700*s1**3*s2*s3**3*s5**2 + 447*s1**3*s2*s3**2*s4**2*s5 - 118*s1**3*s2*s3*s4**4 +
+2300*s1**3*s2*s4*s5**3 - 12*s1**3*s3**4*s4*s5 + 6*s1**3*s3**3*s4**3 + 250*s1**3*s3**2*s5**3
++ 1470*s1**3*s3*s4**2*s5**2 - 276*s1**3*s4**4*s5 + 27*s1**2*s2**6*s5**2 - 9*s1**2*s2**5*s3*s4*s5
++ s1**2*s2**5*s4**3 + s1**2*s2**4*s3**3*s5 + 141*s1**2*s2**4*s4*s5**2 - 185*s1**2*s2**3*s3**2*s5**2
++ 168*s1**2*s2**3*s3*s4**2*s5 - 128*s1**2*s2**3*s4**4 + 93*s1**2*s2**2*s3**3*s4*s5
++ 19*s1**2*s2**2*s3**2*s4**3 - 125*s1**2*s2**2*s3*s5**3 - 610*s1**2*s2**2*s4**2*s5**2
+- 36*s1**2*s2*s3**5*s5 + 5*s1**2*s2*s3**4*s4**2 + 1995*s1**2*s2*s3**2*s4*s5**2 - 1174*s1**2*s2*s3*s4**3*s5
+- 16*s1**2*s2*s4**5 - 3125*s1**2*s2*s5**4 + 375*s1**2*s3**4*s5**2 - 172*s1**2*s3**3*s4**2*s5
++ 82*s1**2*s3**2*s4**4 - 3500*s1**2*s3*s4*s5**3 - 1450*s1**2*s4**3*s5**2 + 198*s1*s2**5*s3*s5**2
+- 78*s1*s2**5*s4**2*s5 - 95*s1*s2**4*s3**2*s4*s5 + 44*s1*s2**4*s3*s4**3 + 25*s1*s2**3*s3**4*s5
+- 15*s1*s2**3*s3**3*s4**2 + 15*s1*s2**3*s3*s4*s5**2 - 384*s1*s2**3*s4**3*s5 + s1*s2**2*s3**5*s4
++ 525*s1*s2**2*s3**3*s5**2 - 528*s1*s2**2*s3**2*s4**2*s5 + 384*s1*s2**2*s3*s4**4 -
+1750*s1*s2**2*s4*s5**3 - 29*s1*s2*s3**4*s4*s5 - 118*s1*s2*s3**3*s4**3 + 625*s1*s2*s3**2*s5**3
+- 850*s1*s2*s3*s4**2*s5**2 + 1760*s1*s2*s4**4*s5 + 38*s1*s3**6*s5 + 5*s1*s3**5*s4**2
+- 2050*s1*s3**3*s4*s5**2 + 780*s1*s3**2*s4**3*s5 - 192*s1*s3*s4**5 + 3125*s1*s3*s5**4
++ 7500*s1*s4**2*s5**3 - 27*s2**7*s5**2 + 18*s2**6*s3*s4*s5 - 4*s2**6*s4**3 - 4*s2**5*s3**3*s5
++ s2**5*s3**2*s4**2 - 99*s2**5*s4*s5**2 - 150*s2**4*s3**2*s5**2 + 196*s2**4*s3*s4**2*s5
++ 48*s2**4*s4**4 + 12*s2**3*s3**3*s4*s5 - 128*s2**3*s3**2*s4**3 + 1200*s2**3*s4**2*s5**2
+- 12*s2**2*s3**5*s5 + 65*s2**2*s3**4*s4**2 - 725*s2**2*s3**2*s4*s5**2 - 160*s2**2*s3*s4**3*s5
+- 192*s2**2*s4**5 + 3125*s2**2*s5**4 - 13*s2*s3**6*s4 - 125*s2*s3**4*s5**2 + 590*s2*s3**3*s4**2*s5
+- 16*s2*s3**2*s4**4 - 1250*s2*s3*s4*s5**3 - 2000*s2*s4**3*s5**2 + s3**8 - 124*s3**5*s4*s5
++ 17*s3**4*s4**3 + 3250*s3**2*s4**2*s5**2 - 1600*s3*s4**4*s5 + 256*s4**6 - 9375*s4*s5**4)
+    ],
+    (6, 1): [
+        lambda s1, s2, s3, s4, s5, s6: (8*s1*s5 - 2*s2*s4 - 18*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-50*s1**2*s4*s6 + 40*s1**2*s5**2 + 30*s1*s2*s3*s6 - 14*s1*s2*s4*s5 - 6*s1*s3**2*s5
++ 2*s1*s3*s4**2 - 30*s1*s5*s6 - 8*s2**3*s6 + 2*s2**2*s3*s5 + s2**2*s4**2 + 114*s2*s4*s6
+- 50*s2*s5**2 - 54*s3**2*s6 + 30*s3*s4*s5 - 8*s4**3 - 135*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (125*s1**3*s3*s6**2 - 400*s1**3*s4*s5*s6 + 160*s1**3*s5**3 - 50*s1**2*s2**2*s6**2 +
+190*s1**2*s2*s3*s5*s6 + 120*s1**2*s2*s4**2*s6 - 80*s1**2*s2*s4*s5**2 - 15*s1**2*s3**2*s4*s6
+- 40*s1**2*s3**2*s5**2 + 21*s1**2*s3*s4**2*s5 - 2*s1**2*s4**4 + 900*s1**2*s4*s6**2
+- 80*s1**2*s5**2*s6 - 44*s1*s2**3*s5*s6 - 66*s1*s2**2*s3*s4*s6 + 21*s1*s2**2*s3*s5**2
++ 6*s1*s2**2*s4**2*s5 + 9*s1*s2*s3**3*s6 + 5*s1*s2*s3**2*s4*s5 - 2*s1*s2*s3*s4**3
+- 990*s1*s2*s3*s6**2 + 920*s1*s2*s4*s5*s6 - 400*s1*s2*s5**3 - 135*s1*s3**2*s5*s6 -
+126*s1*s3*s4**2*s6 + 190*s1*s3*s4*s5**2 - 44*s1*s4**3*s5 - 2070*s1*s5*s6**2 + 16*s2**4*s4*s6
+- 2*s2**4*s5**2 - 2*s2**3*s3**2*s6 - 2*s2**3*s3*s4*s5 + 304*s2**3*s6**2 - 126*s2**2*s3*s5*s6
+- 232*s2**2*s4**2*s6 + 120*s2**2*s4*s5**2 + 198*s2*s3**2*s4*s6 - 15*s2*s3**2*s5**2
+- 66*s2*s3*s4**2*s5 + 16*s2*s4**4 - 1440*s2*s4*s6**2 + 900*s2*s5**2*s6 - 27*s3**4*s6
++ 9*s3**3*s4*s5 - 2*s3**2*s4**3 + 1350*s3**2*s6**2 - 990*s3*s4*s5*s6 + 125*s3*s5**3
++ 304*s4**3*s6 - 50*s4**2*s5**2 + 3240*s6**3),
+        lambda s1, s2, s3, s4, s5, s6: (500*s1**4*s3*s5*s6**2 + 625*s1**4*s4**2*s6**2 - 1400*s1**4*s4*s5**2*s6 + 400*s1**4*s5**4
+- 200*s1**3*s2**2*s5*s6**2 - 875*s1**3*s2*s3*s4*s6**2 + 640*s1**3*s2*s3*s5**2*s6 +
+630*s1**3*s2*s4**2*s5*s6 - 264*s1**3*s2*s4*s5**3 + 90*s1**3*s3**2*s4*s5*s6 - 136*s1**3*s3**2*s5**3
+- 50*s1**3*s3*s4**3*s6 + 76*s1**3*s3*s4**2*s5**2 - 1125*s1**3*s3*s6**3 - 8*s1**3*s4**4*s5
++ 2550*s1**3*s4*s5*s6**2 - 200*s1**3*s5**3*s6 + 250*s1**2*s2**3*s4*s6**2 - 144*s1**2*s2**3*s5**2*s6
++ 225*s1**2*s2**2*s3**2*s6**2 - 354*s1**2*s2**2*s3*s4*s5*s6 + 76*s1**2*s2**2*s3*s5**3
+- 70*s1**2*s2**2*s4**3*s6 + 41*s1**2*s2**2*s4**2*s5**2 + 450*s1**2*s2**2*s6**3 - 54*s1**2*s2*s3**3*s5*s6
++ 45*s1**2*s2*s3**2*s4**2*s6 + 30*s1**2*s2*s3**2*s4*s5**2 - 19*s1**2*s2*s3*s4**3*s5
+- 2880*s1**2*s2*s3*s5*s6**2 + 2*s1**2*s2*s4**5 - 3480*s1**2*s2*s4**2*s6**2 + 4692*s1**2*s2*s4*s5**2*s6
+- 1400*s1**2*s2*s5**4 + 9*s1**2*s3**4*s5**2 - 6*s1**2*s3**3*s4**2*s5 + s1**2*s3**2*s4**4
++ 1485*s1**2*s3**2*s4*s6**2 - 522*s1**2*s3**2*s5**2*s6 - 1257*s1**2*s3*s4**2*s5*s6
++ 640*s1**2*s3*s4*s5**3 + 218*s1**2*s4**4*s6 - 144*s1**2*s4**3*s5**2 + 1350*s1**2*s4*s6**3
+- 5175*s1**2*s5**2*s6**2 - 120*s1*s2**4*s3*s6**2 + 68*s1*s2**4*s4*s5*s6 - 8*s1*s2**4*s5**3
++ 46*s1*s2**3*s3**2*s5*s6 + 28*s1*s2**3*s3*s4**2*s6 - 19*s1*s2**3*s3*s4*s5**2 + 868*s1*s2**3*s5*s6**2
+- 9*s1*s2**2*s3**3*s4*s6 - 6*s1*s2**2*s3**3*s5**2 + 3*s1*s2**2*s3**2*s4**2*s5 + 2484*s1*s2**2*s3*s4*s6**2
+- 1257*s1*s2**2*s3*s5**2*s6 - 1356*s1*s2**2*s4**2*s5*s6 + 630*s1*s2**2*s4*s5**3 -
+891*s1*s2*s3**3*s6**2 + 882*s1*s2*s3**2*s4*s5*s6 + 90*s1*s2*s3**2*s5**3 + 84*s1*s2*s3*s4**3*s6
+- 354*s1*s2*s3*s4**2*s5**2 + 3240*s1*s2*s3*s6**3 + 68*s1*s2*s4**4*s5 - 4392*s1*s2*s4*s5*s6**2
++ 2550*s1*s2*s5**3*s6 + 54*s1*s3**4*s5*s6 - 54*s1*s3**3*s4**2*s6 - 54*s1*s3**3*s4*s5**2
++ 46*s1*s3**2*s4**3*s5 + 2727*s1*s3**2*s5*s6**2 - 8*s1*s3*s4**5 + 756*s1*s3*s4**2*s6**2
+- 2880*s1*s3*s4*s5**2*s6 + 500*s1*s3*s5**4 + 868*s1*s4**3*s5*s6 - 200*s1*s4**2*s5**3
++ 8100*s1*s5*s6**3 + 16*s2**6*s6**2 - 8*s2**5*s3*s5*s6 - 8*s2**5*s4**2*s6 + 2*s2**5*s4*s5**2
++ 2*s2**4*s3**2*s4*s6 + s2**4*s3**2*s5**2 - 688*s2**4*s4*s6**2 + 218*s2**4*s5**2*s6
++ 234*s2**3*s3**2*s6**2 + 84*s2**3*s3*s4*s5*s6 - 50*s2**3*s3*s5**3 + 168*s2**3*s4**3*s6
+- 70*s2**3*s4**2*s5**2 - 1224*s2**3*s6**3 - 54*s2**2*s3**3*s5*s6 - 144*s2**2*s3**2*s4**2*s6
++ 45*s2**2*s3**2*s4*s5**2 + 28*s2**2*s3*s4**3*s5 + 756*s2**2*s3*s5*s6**2 - 8*s2**2*s4**5
++ 4320*s2**2*s4**2*s6**2 - 3480*s2**2*s4*s5**2*s6 + 625*s2**2*s5**4 + 27*s2*s3**4*s4*s6
+- 9*s2*s3**3*s4**2*s5 + 2*s2*s3**2*s4**4 - 4752*s2*s3**2*s4*s6**2 + 1485*s2*s3**2*s5**2*s6
++ 2484*s2*s3*s4**2*s5*s6 - 875*s2*s3*s4*s5**3 - 688*s2*s4**4*s6 + 250*s2*s4**3*s5**2
+- 4536*s2*s4*s6**3 + 1350*s2*s5**2*s6**2 + 972*s3**4*s6**2 - 891*s3**3*s4*s5*s6 +
+234*s3**2*s4**3*s6 + 225*s3**2*s4**2*s5**2 - 1944*s3**2*s6**3 - 120*s3*s4**4*s5 +
+3240*s3*s4*s5*s6**2 - 1125*s3*s5**3*s6 + 16*s4**6 - 1224*s4**3*s6**2 + 450*s4**2*s5**2*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-3125*s1**6*s6**4 + 2500*s1**5*s2*s5*s6**3 + 625*s1**5*s3*s4*s6**3 - 500*s1**5*s3*s5**2*s6**2
++ 2750*s1**5*s4**2*s5*s6**2 - 2400*s1**5*s4*s5**3*s6 + 512*s1**5*s5**5 - 750*s1**4*s2**2*s4*s6**3
+- 550*s1**4*s2**2*s5**2*s6**2 - 375*s1**4*s2*s3**2*s6**3 - 3075*s1**4*s2*s3*s4*s5*s6**2
++ 1640*s1**4*s2*s3*s5**3*s6 - 850*s1**4*s2*s4**3*s6**2 + 1220*s1**4*s2*s4**2*s5**2*s6
+- 384*s1**4*s2*s4*s5**4 + 22500*s1**4*s2*s6**4 + 525*s1**4*s3**3*s5*s6**2 - 325*s1**4*s3**2*s4**2*s6**2
++ 260*s1**4*s3**2*s4*s5**2*s6 - 256*s1**4*s3**2*s5**4 + 105*s1**4*s3*s4**3*s5*s6 +
+76*s1**4*s3*s4**2*s5**3 + 375*s1**4*s3*s5*s6**3 - 58*s1**4*s4**5*s6 + 3*s1**4*s4**4*s5**2
+- 12750*s1**4*s4**2*s6**3 + 3700*s1**4*s4*s5**2*s6**2 + 640*s1**4*s5**4*s6 + 350*s1**3*s2**3*s3*s6**3
++ 1090*s1**3*s2**3*s4*s5*s6**2 - 364*s1**3*s2**3*s5**3*s6 + 305*s1**3*s2**2*s3**2*s5*s6**2
++ 1340*s1**3*s2**2*s3*s4**2*s6**2 - 901*s1**3*s2**2*s3*s4*s5**2*s6 + 76*s1**3*s2**2*s3*s5**4
+- 234*s1**3*s2**2*s4**3*s5*s6 + 102*s1**3*s2**2*s4**2*s5**3 - 16650*s1**3*s2**2*s5*s6**3
++ 180*s1**3*s2*s3**3*s4*s6**2 - 366*s1**3*s2*s3**3*s5**2*s6 - 231*s1**3*s2*s3**2*s4**2*s5*s6
++ 212*s1**3*s2*s3**2*s4*s5**3 + 112*s1**3*s2*s3*s4**4*s6 - 89*s1**3*s2*s3*s4**3*s5**2
++ 10950*s1**3*s2*s3*s4*s6**3 + 1555*s1**3*s2*s3*s5**2*s6**2 + 6*s1**3*s2*s4**5*s5
+- 9540*s1**3*s2*s4**2*s5*s6**2 + 9016*s1**3*s2*s4*s5**3*s6 - 2400*s1**3*s2*s5**5 -
+108*s1**3*s3**5*s6**2 + 117*s1**3*s3**4*s4*s5*s6 + 32*s1**3*s3**4*s5**3 - 31*s1**3*s3**3*s4**3*s6
+- 51*s1**3*s3**3*s4**2*s5**2 - 2025*s1**3*s3**3*s6**3 + 19*s1**3*s3**2*s4**4*s5 +
+2955*s1**3*s3**2*s4*s5*s6**2 - 1436*s1**3*s3**2*s5**3*s6 - 2*s1**3*s3*s4**6 + 2770*s1**3*s3*s4**3*s6**2
+- 5123*s1**3*s3*s4**2*s5**2*s6 + 1640*s1**3*s3*s4*s5**4 - 40500*s1**3*s3*s6**4 + 914*s1**3*s4**4*s5*s6
+- 364*s1**3*s4**3*s5**3 + 53550*s1**3*s4*s5*s6**3 - 17930*s1**3*s5**3*s6**2 - 56*s1**2*s2**5*s6**3
+- 318*s1**2*s2**4*s3*s5*s6**2 - 352*s1**2*s2**4*s4**2*s6**2 + 166*s1**2*s2**4*s4*s5**2*s6
++ 3*s1**2*s2**4*s5**4 - 574*s1**2*s2**3*s3**2*s4*s6**2 + 347*s1**2*s2**3*s3**2*s5**2*s6
++ 194*s1**2*s2**3*s3*s4**2*s5*s6 - 89*s1**2*s2**3*s3*s4*s5**3 - 8*s1**2*s2**3*s4**4*s6
++ 4*s1**2*s2**3*s4**3*s5**2 + 560*s1**2*s2**3*s4*s6**3 + 3662*s1**2*s2**3*s5**2*s6**2
++ 162*s1**2*s2**2*s3**4*s6**2 + 33*s1**2*s2**2*s3**3*s4*s5*s6 - 51*s1**2*s2**2*s3**3*s5**3
+- 32*s1**2*s2**2*s3**2*s4**3*s6 + 28*s1**2*s2**2*s3**2*s4**2*s5**2 + 270*s1**2*s2**2*s3**2*s6**3
+- 2*s1**2*s2**2*s3*s4**4*s5 + 4872*s1**2*s2**2*s3*s4*s5*s6**2 - 5123*s1**2*s2**2*s3*s5**3*s6
++ 2144*s1**2*s2**2*s4**3*s6**2 - 2812*s1**2*s2**2*s4**2*s5**2*s6 + 1220*s1**2*s2**2*s4*s5**4
+- 37800*s1**2*s2**2*s6**4 - 27*s1**2*s2*s3**5*s5*s6 + 9*s1**2*s2*s3**4*s4**2*s6 +
+3*s1**2*s2*s3**4*s4*s5**2 - s1**2*s2*s3**3*s4**3*s5 - 3078*s1**2*s2*s3**3*s5*s6**2
+- 4014*s1**2*s2*s3**2*s4**2*s6**2 + 5412*s1**2*s2*s3**2*s4*s5**2*s6 + 260*s1**2*s2*s3**2*s5**4
+- 310*s1**2*s2*s3*s4**3*s5*s6 - 901*s1**2*s2*s3*s4**2*s5**3 - 3780*s1**2*s2*s3*s5*s6**3
++ 166*s1**2*s2*s4**4*s5**2 + 40320*s1**2*s2*s4**2*s6**3 - 25344*s1**2*s2*s4*s5**2*s6**2
++ 3700*s1**2*s2*s5**4*s6 + 918*s1**2*s3**4*s4*s6**2 + 27*s1**2*s3**4*s5**2*s6 - 342*s1**2*s3**3*s4**2*s5*s6
+- 366*s1**2*s3**3*s4*s5**3 + 32*s1**2*s3**2*s4**4*s6 + 347*s1**2*s3**2*s4**3*s5**2
+- 4590*s1**2*s3**2*s4*s6**3 + 594*s1**2*s3**2*s5**2*s6**2 - 94*s1**2*s3*s4**5*s5 +
+3618*s1**2*s3*s4**2*s5*s6**2 + 1555*s1**2*s3*s4*s5**3*s6 - 500*s1**2*s3*s5**5 + 8*s1**2*s4**7
+- 7192*s1**2*s4**4*s6**2 + 3662*s1**2*s4**3*s5**2*s6 - 550*s1**2*s4**2*s5**4 - 48600*s1**2*s4*s6**4
++ 1080*s1**2*s5**2*s6**3 + 48*s1*s2**6*s5*s6**2 + 264*s1*s2**5*s3*s4*s6**2 - 94*s1*s2**5*s3*s5**2*s6
+- 24*s1*s2**5*s4**2*s5*s6 + 6*s1*s2**5*s4*s5**3 - 66*s1*s2**4*s3**3*s6**2 - 50*s1*s2**4*s3**2*s4*s5*s6
++ 19*s1*s2**4*s3**2*s5**3 + 8*s1*s2**4*s3*s4**3*s6 - 2*s1*s2**4*s3*s4**2*s5**2 - 552*s1*s2**4*s3*s6**3
+- 2560*s1*s2**4*s4*s5*s6**2 + 914*s1*s2**4*s5**3*s6 + 15*s1*s2**3*s3**4*s5*s6 - 2*s1*s2**3*s3**3*s4**2*s6
+- s1*s2**3*s3**3*s4*s5**2 + 1602*s1*s2**3*s3**2*s5*s6**2 - 608*s1*s2**3*s3*s4**2*s6**2
+- 310*s1*s2**3*s3*s4*s5**2*s6 + 105*s1*s2**3*s3*s5**4 + 600*s1*s2**3*s4**3*s5*s6 -
+234*s1*s2**3*s4**2*s5**3 + 31368*s1*s2**3*s5*s6**3 + 756*s1*s2**2*s3**3*s4*s6**2 -
+342*s1*s2**2*s3**3*s5**2*s6 + 216*s1*s2**2*s3**2*s4**2*s5*s6 - 231*s1*s2**2*s3**2*s4*s5**3
+- 192*s1*s2**2*s3*s4**4*s6 + 194*s1*s2**2*s3*s4**3*s5**2 - 39096*s1*s2**2*s3*s4*s6**3
++ 3618*s1*s2**2*s3*s5**2*s6**2 - 24*s1*s2**2*s4**5*s5 + 9408*s1*s2**2*s4**2*s5*s6**2
+- 9540*s1*s2**2*s4*s5**3*s6 + 2750*s1*s2**2*s5**5 - 162*s1*s2*s3**5*s6**2 - 378*s1*s2*s3**4*s4*s5*s6
++ 117*s1*s2*s3**4*s5**3 + 150*s1*s2*s3**3*s4**3*s6 + 33*s1*s2*s3**3*s4**2*s5**2 +
+10044*s1*s2*s3**3*s6**3 - 50*s1*s2*s3**2*s4**4*s5 - 8640*s1*s2*s3**2*s4*s5*s6**2 +
+2955*s1*s2*s3**2*s5**3*s6 + 8*s1*s2*s3*s4**6 + 6144*s1*s2*s3*s4**3*s6**2 + 4872*s1*s2*s3*s4**2*s5**2*s6
+- 3075*s1*s2*s3*s4*s5**4 + 174960*s1*s2*s3*s6**4 - 2560*s1*s2*s4**4*s5*s6 + 1090*s1*s2*s4**3*s5**3
+- 148824*s1*s2*s4*s5*s6**3 + 53550*s1*s2*s5**3*s6**2 + 81*s1*s3**6*s5*s6 - 27*s1*s3**5*s4**2*s6
+- 27*s1*s3**5*s4*s5**2 + 15*s1*s3**4*s4**3*s5 + 2430*s1*s3**4*s5*s6**2 - 2*s1*s3**3*s4**5
+- 2052*s1*s3**3*s4**2*s6**2 - 3078*s1*s3**3*s4*s5**2*s6 + 525*s1*s3**3*s5**4 + 1602*s1*s3**2*s4**3*s5*s6
++ 305*s1*s3**2*s4**2*s5**3 + 18144*s1*s3**2*s5*s6**3 - 104*s1*s3*s4**5*s6 - 318*s1*s3*s4**4*s5**2
+- 33696*s1*s3*s4**2*s6**3 - 3780*s1*s3*s4*s5**2*s6**2 + 375*s1*s3*s5**4*s6 + 48*s1*s4**6*s5
++ 31368*s1*s4**3*s5*s6**2 - 16650*s1*s4**2*s5**3*s6 + 2500*s1*s4*s5**5 + 77760*s1*s5*s6**4
+- 32*s2**7*s4*s6**2 + 8*s2**7*s5**2*s6 + 8*s2**6*s3**2*s6**2 + 8*s2**6*s3*s4*s5*s6
+- 2*s2**6*s3*s5**3 + 96*s2**6*s6**3 - 2*s2**5*s3**3*s5*s6 - 104*s2**5*s3*s5*s6**2
++ 416*s2**5*s4**2*s6**2 - 58*s2**5*s5**4 - 312*s2**4*s3**2*s4*s6**2 + 32*s2**4*s3**2*s5**2*s6
+- 192*s2**4*s3*s4**2*s5*s6 + 112*s2**4*s3*s4*s5**3 - 8*s2**4*s4**3*s5**2 + 4224*s2**4*s4*s6**3
+- 7192*s2**4*s5**2*s6**2 + 54*s2**3*s3**4*s6**2 + 150*s2**3*s3**3*s4*s5*s6 - 31*s2**3*s3**3*s5**3
+- 32*s2**3*s3**2*s4**2*s5**2 - 864*s2**3*s3**2*s6**3 + 8*s2**3*s3*s4**4*s5 + 6144*s2**3*s3*s4*s5*s6**2
++ 2770*s2**3*s3*s5**3*s6 - 4032*s2**3*s4**3*s6**2 + 2144*s2**3*s4**2*s5**2*s6 - 850*s2**3*s4*s5**4
+- 16416*s2**3*s6**4 - 27*s2**2*s3**5*s5*s6 + 9*s2**2*s3**4*s4*s5**2 - 2*s2**2*s3**3*s4**3*s5
+- 2052*s2**2*s3**3*s5*s6**2 + 2376*s2**2*s3**2*s4**2*s6**2 - 4014*s2**2*s3**2*s4*s5**2*s6
+- 325*s2**2*s3**2*s5**4 - 608*s2**2*s3*s4**3*s5*s6 + 1340*s2**2*s3*s4**2*s5**3 - 33696*s2**2*s3*s5*s6**3
++ 416*s2**2*s4**5*s6 - 352*s2**2*s4**4*s5**2 - 6048*s2**2*s4**2*s6**3 + 40320*s2**2*s4*s5**2*s6**2
+- 12750*s2**2*s5**4*s6 - 324*s2*s3**4*s4*s6**2 + 918*s2*s3**4*s5**2*s6 + 756*s2*s3**3*s4**2*s5*s6
++ 180*s2*s3**3*s4*s5**3 - 312*s2*s3**2*s4**4*s6 - 574*s2*s3**2*s4**3*s5**2 + 43416*s2*s3**2*s4*s6**3
+- 4590*s2*s3**2*s5**2*s6**2 + 264*s2*s3*s4**5*s5 - 39096*s2*s3*s4**2*s5*s6**2 + 10950*s2*s3*s4*s5**3*s6
++ 625*s2*s3*s5**5 - 32*s2*s4**7 + 4224*s2*s4**4*s6**2 + 560*s2*s4**3*s5**2*s6 - 750*s2*s4**2*s5**4
++ 85536*s2*s4*s6**4 - 48600*s2*s5**2*s6**3 - 162*s3**5*s4*s5*s6 - 108*s3**5*s5**3
++ 54*s3**4*s4**3*s6 + 162*s3**4*s4**2*s5**2 - 11664*s3**4*s6**3 - 66*s3**3*s4**4*s5
++ 10044*s3**3*s4*s5*s6**2 - 2025*s3**3*s5**3*s6 + 8*s3**2*s4**6 - 864*s3**2*s4**3*s6**2
++ 270*s3**2*s4**2*s5**2*s6 - 375*s3**2*s4*s5**4 - 163296*s3**2*s6**4 - 552*s3*s4**4*s5*s6
++ 350*s3*s4**3*s5**3 + 174960*s3*s4*s5*s6**3 - 40500*s3*s5**3*s6**2 + 96*s4**6*s6
+- 56*s4**5*s5**2 - 16416*s4**3*s6**3 - 37800*s4**2*s5**2*s6**2 + 22500*s4*s5**4*s6
+- 3125*s5**6 - 93312*s6**5),
+        lambda s1, s2, s3, s4, s5, s6: (-9375*s1**7*s5*s6**4 + 3125*s1**6*s2*s4*s6**4 + 7500*s1**6*s2*s5**2*s6**3 + 3125*s1**6*s3**2*s6**4
+- 1250*s1**6*s3*s4*s5*s6**3 - 2000*s1**6*s3*s5**3*s6**2 + 3250*s1**6*s4**2*s5**2*s6**2
+- 1600*s1**6*s4*s5**4*s6 + 256*s1**6*s5**6 + 40625*s1**6*s6**5 - 3125*s1**5*s2**2*s3*s6**4
+- 3500*s1**5*s2**2*s4*s5*s6**3 - 1450*s1**5*s2**2*s5**3*s6**2 - 1750*s1**5*s2*s3**2*s5*s6**3
++ 625*s1**5*s2*s3*s4**2*s6**3 - 850*s1**5*s2*s3*s4*s5**2*s6**2 + 1760*s1**5*s2*s3*s5**4*s6
+- 2050*s1**5*s2*s4**3*s5*s6**2 + 780*s1**5*s2*s4**2*s5**3*s6 - 192*s1**5*s2*s4*s5**5
++ 35000*s1**5*s2*s5*s6**4 + 1200*s1**5*s3**3*s5**2*s6**2 - 725*s1**5*s3**2*s4**2*s5*s6**2
+- 160*s1**5*s3**2*s4*s5**3*s6 - 192*s1**5*s3**2*s5**5 - 125*s1**5*s3*s4**4*s6**2 +
+590*s1**5*s3*s4**3*s5**2*s6 - 16*s1**5*s3*s4**2*s5**4 - 20625*s1**5*s3*s4*s6**4 +
+17250*s1**5*s3*s5**2*s6**3 - 124*s1**5*s4**5*s5*s6 + 17*s1**5*s4**4*s5**3 - 20250*s1**5*s4**2*s5*s6**3
++ 1900*s1**5*s4*s5**3*s6**2 + 1344*s1**5*s5**5*s6 + 625*s1**4*s2**4*s6**4 + 2300*s1**4*s2**3*s3*s5*s6**3
++ 250*s1**4*s2**3*s4**2*s6**3 + 1470*s1**4*s2**3*s4*s5**2*s6**2 - 276*s1**4*s2**3*s5**4*s6
+- 125*s1**4*s2**2*s3**2*s4*s6**3 - 610*s1**4*s2**2*s3**2*s5**2*s6**2 + 1995*s1**4*s2**2*s3*s4**2*s5*s6**2
+- 1174*s1**4*s2**2*s3*s4*s5**3*s6 - 16*s1**4*s2**2*s3*s5**5 + 375*s1**4*s2**2*s4**4*s6**2
+- 172*s1**4*s2**2*s4**3*s5**2*s6 + 82*s1**4*s2**2*s4**2*s5**4 - 7750*s1**4*s2**2*s4*s6**4
+- 46650*s1**4*s2**2*s5**2*s6**3 + 15*s1**4*s2*s3**3*s4*s5*s6**2 - 384*s1**4*s2*s3**3*s5**3*s6
++ 525*s1**4*s2*s3**2*s4**3*s6**2 - 528*s1**4*s2*s3**2*s4**2*s5**2*s6 + 384*s1**4*s2*s3**2*s4*s5**4
+- 10125*s1**4*s2*s3**2*s6**4 - 29*s1**4*s2*s3*s4**4*s5*s6 - 118*s1**4*s2*s3*s4**3*s5**3
++ 36700*s1**4*s2*s3*s4*s5*s6**3 + 2410*s1**4*s2*s3*s5**3*s6**2 + 38*s1**4*s2*s4**6*s6
++ 5*s1**4*s2*s4**5*s5**2 + 5550*s1**4*s2*s4**3*s6**3 - 10040*s1**4*s2*s4**2*s5**2*s6**2
++ 5800*s1**4*s2*s4*s5**4*s6 - 1600*s1**4*s2*s5**6 - 292500*s1**4*s2*s6**5 - 99*s1**4*s3**5*s5*s6**2
+- 150*s1**4*s3**4*s4**2*s6**2 + 196*s1**4*s3**4*s4*s5**2*s6 + 48*s1**4*s3**4*s5**4
++ 12*s1**4*s3**3*s4**3*s5*s6 - 128*s1**4*s3**3*s4**2*s5**3 - 6525*s1**4*s3**3*s5*s6**3
+- 12*s1**4*s3**2*s4**5*s6 + 65*s1**4*s3**2*s4**4*s5**2 + 225*s1**4*s3**2*s4**2*s6**3
++ 80*s1**4*s3**2*s4*s5**2*s6**2 - 13*s1**4*s3*s4**6*s5 + 5145*s1**4*s3*s4**3*s5*s6**2
+- 6746*s1**4*s3*s4**2*s5**3*s6 + 1760*s1**4*s3*s4*s5**5 - 103500*s1**4*s3*s5*s6**4
++ s1**4*s4**8 + 954*s1**4*s4**5*s6**2 + 449*s1**4*s4**4*s5**2*s6 - 276*s1**4*s4**3*s5**4
++ 70125*s1**4*s4**2*s6**4 + 58900*s1**4*s4*s5**2*s6**3 - 23310*s1**4*s5**4*s6**2 -
+468*s1**3*s2**5*s5*s6**3 - 200*s1**3*s2**4*s3*s4*s6**3 - 294*s1**3*s2**4*s3*s5**2*s6**2
+- 676*s1**3*s2**4*s4**2*s5*s6**2 + 180*s1**3*s2**4*s4*s5**3*s6 + 17*s1**3*s2**4*s5**5
++ 50*s1**3*s2**3*s3**3*s6**3 - 397*s1**3*s2**3*s3**2*s4*s5*s6**2 + 514*s1**3*s2**3*s3**2*s5**3*s6
+- 700*s1**3*s2**3*s3*s4**3*s6**2 + 447*s1**3*s2**3*s3*s4**2*s5**2*s6 - 118*s1**3*s2**3*s3*s4*s5**4
++ 11700*s1**3*s2**3*s3*s6**4 - 12*s1**3*s2**3*s4**4*s5*s6 + 6*s1**3*s2**3*s4**3*s5**3
++ 10360*s1**3*s2**3*s4*s5*s6**3 + 11404*s1**3*s2**3*s5**3*s6**2 + 141*s1**3*s2**2*s3**4*s5*s6**2
+- 185*s1**3*s2**2*s3**3*s4**2*s6**2 + 168*s1**3*s2**2*s3**3*s4*s5**2*s6 - 128*s1**3*s2**2*s3**3*s5**4
++ 93*s1**3*s2**2*s3**2*s4**3*s5*s6 + 19*s1**3*s2**2*s3**2*s4**2*s5**3 + 5895*s1**3*s2**2*s3**2*s5*s6**3
+- 36*s1**3*s2**2*s3*s4**5*s6 + 5*s1**3*s2**2*s3*s4**4*s5**2 - 12020*s1**3*s2**2*s3*s4**2*s6**3
+- 5698*s1**3*s2**2*s3*s4*s5**2*s6**2 - 6746*s1**3*s2**2*s3*s5**4*s6 + 5064*s1**3*s2**2*s4**3*s5*s6**2
+- 762*s1**3*s2**2*s4**2*s5**3*s6 + 780*s1**3*s2**2*s4*s5**5 + 93900*s1**3*s2**2*s5*s6**4
++ 198*s1**3*s2*s3**5*s4*s6**2 - 78*s1**3*s2*s3**5*s5**2*s6 - 95*s1**3*s2*s3**4*s4**2*s5*s6
++ 44*s1**3*s2*s3**4*s4*s5**3 + 25*s1**3*s2*s3**3*s4**4*s6 - 15*s1**3*s2*s3**3*s4**3*s5**2
++ 1935*s1**3*s2*s3**3*s4*s6**3 - 2808*s1**3*s2*s3**3*s5**2*s6**2 + s1**3*s2*s3**2*s4**5*s5
+- 4844*s1**3*s2*s3**2*s4**2*s5*s6**2 + 8996*s1**3*s2*s3**2*s4*s5**3*s6 - 160*s1**3*s2*s3**2*s5**5
+- 3616*s1**3*s2*s3*s4**4*s6**2 + 500*s1**3*s2*s3*s4**3*s5**2*s6 - 1174*s1**3*s2*s3*s4**2*s5**4
++ 72900*s1**3*s2*s3*s4*s6**4 - 55665*s1**3*s2*s3*s5**2*s6**3 + 128*s1**3*s2*s4**5*s5*s6
++ 180*s1**3*s2*s4**4*s5**3 + 16240*s1**3*s2*s4**2*s5*s6**3 - 9330*s1**3*s2*s4*s5**3*s6**2
++ 1900*s1**3*s2*s5**5*s6 - 27*s1**3*s3**7*s6**2 + 18*s1**3*s3**6*s4*s5*s6 - 4*s1**3*s3**6*s5**3
+- 4*s1**3*s3**5*s4**3*s6 + s1**3*s3**5*s4**2*s5**2 + 54*s1**3*s3**5*s6**3 + 1143*s1**3*s3**4*s4*s5*s6**2
+- 820*s1**3*s3**4*s5**3*s6 + 923*s1**3*s3**3*s4**3*s6**2 + 57*s1**3*s3**3*s4**2*s5**2*s6
+- 384*s1**3*s3**3*s4*s5**4 + 29700*s1**3*s3**3*s6**4 - 547*s1**3*s3**2*s4**4*s5*s6
++ 514*s1**3*s3**2*s4**3*s5**3 - 10305*s1**3*s3**2*s4*s5*s6**3 - 7405*s1**3*s3**2*s5**3*s6**2
++ 108*s1**3*s3*s4**6*s6 - 148*s1**3*s3*s4**5*s5**2 - 11360*s1**3*s3*s4**3*s6**3 +
+22209*s1**3*s3*s4**2*s5**2*s6**2 + 2410*s1**3*s3*s4*s5**4*s6 - 2000*s1**3*s3*s5**6
++ 432000*s1**3*s3*s6**5 + 12*s1**3*s4**7*s5 - 22624*s1**3*s4**4*s5*s6**2 + 11404*s1**3*s4**3*s5**3*s6
+- 1450*s1**3*s4**2*s5**5 - 242100*s1**3*s4*s5*s6**4 + 58430*s1**3*s5**3*s6**3 + 56*s1**2*s2**6*s4*s6**3
++ 86*s1**2*s2**6*s5**2*s6**2 - 14*s1**2*s2**5*s3**2*s6**3 + 304*s1**2*s2**5*s3*s4*s5*s6**2
+- 148*s1**2*s2**5*s3*s5**3*s6 + 152*s1**2*s2**5*s4**3*s6**2 - 54*s1**2*s2**5*s4**2*s5**2*s6
++ 5*s1**2*s2**5*s4*s5**4 - 2472*s1**2*s2**5*s6**4 - 76*s1**2*s2**4*s3**3*s5*s6**2
++ 370*s1**2*s2**4*s3**2*s4**2*s6**2 - 287*s1**2*s2**4*s3**2*s4*s5**2*s6 + 65*s1**2*s2**4*s3**2*s5**4
+- 28*s1**2*s2**4*s3*s4**3*s5*s6 + 5*s1**2*s2**4*s3*s4**2*s5**3 - 8092*s1**2*s2**4*s3*s5*s6**3
++ 8*s1**2*s2**4*s4**5*s6 - 2*s1**2*s2**4*s4**4*s5**2 + 1096*s1**2*s2**4*s4**2*s6**3
+- 5144*s1**2*s2**4*s4*s5**2*s6**2 + 449*s1**2*s2**4*s5**4*s6 - 210*s1**2*s2**3*s3**4*s4*s6**2
++ 76*s1**2*s2**3*s3**4*s5**2*s6 + 43*s1**2*s2**3*s3**3*s4**2*s5*s6 - 15*s1**2*s2**3*s3**3*s4*s5**3
+- 6*s1**2*s2**3*s3**2*s4**4*s6 + 2*s1**2*s2**3*s3**2*s4**3*s5**2 + 1962*s1**2*s2**3*s3**2*s4*s6**3
++ 3181*s1**2*s2**3*s3**2*s5**2*s6**2 + 1684*s1**2*s2**3*s3*s4**2*s5*s6**2 + 500*s1**2*s2**3*s3*s4*s5**3*s6
++ 590*s1**2*s2**3*s3*s5**5 - 168*s1**2*s2**3*s4**4*s6**2 - 494*s1**2*s2**3*s4**3*s5**2*s6
+- 172*s1**2*s2**3*s4**2*s5**4 - 22080*s1**2*s2**3*s4*s6**4 + 58894*s1**2*s2**3*s5**2*s6**3
++ 27*s1**2*s2**2*s3**6*s6**2 - 9*s1**2*s2**2*s3**5*s4*s5*s6 + s1**2*s2**2*s3**5*s5**3
++ s1**2*s2**2*s3**4*s4**3*s6 - 486*s1**2*s2**2*s3**4*s6**3 + 1071*s1**2*s2**2*s3**3*s4*s5*s6**2
++ 57*s1**2*s2**2*s3**3*s5**3*s6 + 2262*s1**2*s2**2*s3**2*s4**3*s6**2 - 2742*s1**2*s2**2*s3**2*s4**2*s5**2*s6
+- 528*s1**2*s2**2*s3**2*s4*s5**4 - 29160*s1**2*s2**2*s3**2*s6**4 + 772*s1**2*s2**2*s3*s4**4*s5*s6
++ 447*s1**2*s2**2*s3*s4**3*s5**3 - 96732*s1**2*s2**2*s3*s4*s5*s6**3 + 22209*s1**2*s2**2*s3*s5**3*s6**2
+- 160*s1**2*s2**2*s4**6*s6 - 54*s1**2*s2**2*s4**5*s5**2 - 7992*s1**2*s2**2*s4**3*s6**3
++ 8634*s1**2*s2**2*s4**2*s5**2*s6**2 - 10040*s1**2*s2**2*s4*s5**4*s6 + 3250*s1**2*s2**2*s5**6
++ 529200*s1**2*s2**2*s6**5 - 351*s1**2*s2*s3**5*s5*s6**2 - 1215*s1**2*s2*s3**4*s4**2*s6**2
+- 360*s1**2*s2*s3**4*s4*s5**2*s6 + 196*s1**2*s2*s3**4*s5**4 + 741*s1**2*s2*s3**3*s4**3*s5*s6
++ 168*s1**2*s2*s3**3*s4**2*s5**3 + 11718*s1**2*s2*s3**3*s5*s6**3 - 106*s1**2*s2*s3**2*s4**5*s6
+- 287*s1**2*s2*s3**2*s4**4*s5**2 + 22572*s1**2*s2*s3**2*s4**2*s6**3 - 8892*s1**2*s2*s3**2*s4*s5**2*s6**2
++ 80*s1**2*s2*s3**2*s5**4*s6 + 88*s1**2*s2*s3*s4**6*s5 + 22144*s1**2*s2*s3*s4**3*s5*s6**2
+- 5698*s1**2*s2*s3*s4**2*s5**3*s6 - 850*s1**2*s2*s3*s4*s5**5 + 169560*s1**2*s2*s3*s5*s6**4
+- 8*s1**2*s2*s4**8 + 3032*s1**2*s2*s4**5*s6**2 - 5144*s1**2*s2*s4**4*s5**2*s6 + 1470*s1**2*s2*s4**3*s5**4
+- 249480*s1**2*s2*s4**2*s6**4 - 105390*s1**2*s2*s4*s5**2*s6**3 + 58900*s1**2*s2*s5**4*s6**2
++ 162*s1**2*s3**6*s4*s6**2 + 216*s1**2*s3**6*s5**2*s6 - 216*s1**2*s3**5*s4**2*s5*s6
+- 78*s1**2*s3**5*s4*s5**3 + 36*s1**2*s3**4*s4**4*s6 + 76*s1**2*s3**4*s4**3*s5**2 -
+3564*s1**2*s3**4*s4*s6**3 + 8802*s1**2*s3**4*s5**2*s6**2 - 22*s1**2*s3**3*s4**5*s5
+- 11475*s1**2*s3**3*s4**2*s5*s6**2 - 2808*s1**2*s3**3*s4*s5**3*s6 + 1200*s1**2*s3**3*s5**5
++ 2*s1**2*s3**2*s4**7 + 222*s1**2*s3**2*s4**4*s6**2 + 3181*s1**2*s3**2*s4**3*s5**2*s6
+- 610*s1**2*s3**2*s4**2*s5**4 - 165240*s1**2*s3**2*s4*s6**4 + 118260*s1**2*s3**2*s5**2*s6**3
++ 572*s1**2*s3*s4**5*s5*s6 - 294*s1**2*s3*s4**4*s5**3 - 32616*s1**2*s3*s4**2*s5*s6**3
+- 55665*s1**2*s3*s4*s5**3*s6**2 + 17250*s1**2*s3*s5**5*s6 - 232*s1**2*s4**7*s6 + 86*s1**2*s4**6*s5**2
++ 48408*s1**2*s4**4*s6**3 + 58894*s1**2*s4**3*s5**2*s6**2 - 46650*s1**2*s4**2*s5**4*s6
++ 7500*s1**2*s4*s5**6 - 129600*s1**2*s4*s6**5 + 41040*s1**2*s5**2*s6**4 - 48*s1*s2**7*s4*s5*s6**2
++ 12*s1*s2**7*s5**3*s6 + 12*s1*s2**6*s3**2*s5*s6**2 - 144*s1*s2**6*s3*s4**2*s6**2
++ 88*s1*s2**6*s3*s4*s5**2*s6 - 13*s1*s2**6*s3*s5**4 + 1680*s1*s2**6*s5*s6**3 + 72*s1*s2**5*s3**3*s4*s6**2
+- 22*s1*s2**5*s3**3*s5**2*s6 - 4*s1*s2**5*s3**2*s4**2*s5*s6 + s1*s2**5*s3**2*s4*s5**3
+- 144*s1*s2**5*s3*s4*s6**3 + 572*s1*s2**5*s3*s5**2*s6**2 + 736*s1*s2**5*s4**2*s5*s6**2
++ 128*s1*s2**5*s4*s5**3*s6 - 124*s1*s2**5*s5**5 - 9*s1*s2**4*s3**5*s6**2 + s1*s2**4*s3**4*s4*s5*s6
++ 36*s1*s2**4*s3**3*s6**3 - 2028*s1*s2**4*s3**2*s4*s5*s6**2 - 547*s1*s2**4*s3**2*s5**3*s6
+- 480*s1*s2**4*s3*s4**3*s6**2 + 772*s1*s2**4*s3*s4**2*s5**2*s6 - 29*s1*s2**4*s3*s4*s5**4
++ 6336*s1*s2**4*s3*s6**4 - 12*s1*s2**4*s4**3*s5**3 + 4368*s1*s2**4*s4*s5*s6**3 - 22624*s1*s2**4*s5**3*s6**2
++ 441*s1*s2**3*s3**4*s5*s6**2 + 336*s1*s2**3*s3**3*s4**2*s6**2 + 741*s1*s2**3*s3**3*s4*s5**2*s6
++ 12*s1*s2**3*s3**3*s5**4 - 868*s1*s2**3*s3**2*s4**3*s5*s6 + 93*s1*s2**3*s3**2*s4**2*s5**3
++ 11016*s1*s2**3*s3**2*s5*s6**3 + 176*s1*s2**3*s3*s4**5*s6 - 28*s1*s2**3*s3*s4**4*s5**2
++ 14784*s1*s2**3*s3*s4**2*s6**3 + 22144*s1*s2**3*s3*s4*s5**2*s6**2 + 5145*s1*s2**3*s3*s5**4*s6
+- 11344*s1*s2**3*s4**3*s5*s6**2 + 5064*s1*s2**3*s4**2*s5**3*s6 - 2050*s1*s2**3*s4*s5**5
+- 346896*s1*s2**3*s5*s6**4 - 54*s1*s2**2*s3**5*s4*s6**2 - 216*s1*s2**2*s3**5*s5**2*s6
++ 324*s1*s2**2*s3**4*s4**2*s5*s6 - 95*s1*s2**2*s3**4*s4*s5**3 - 80*s1*s2**2*s3**3*s4**4*s6
++ 43*s1*s2**2*s3**3*s4**3*s5**2 - 12204*s1*s2**2*s3**3*s4*s6**3 - 11475*s1*s2**2*s3**3*s5**2*s6**2
+- 4*s1*s2**2*s3**2*s4**5*s5 - 3888*s1*s2**2*s3**2*s4**2*s5*s6**2 - 4844*s1*s2**2*s3**2*s4*s5**3*s6
+- 725*s1*s2**2*s3**2*s5**5 - 1312*s1*s2**2*s3*s4**4*s6**2 + 1684*s1*s2**2*s3*s4**3*s5**2*s6
++ 1995*s1*s2**2*s3*s4**2*s5**4 + 139104*s1*s2**2*s3*s4*s6**4 - 32616*s1*s2**2*s3*s5**2*s6**3
++ 736*s1*s2**2*s4**5*s5*s6 - 676*s1*s2**2*s4**4*s5**3 + 131040*s1*s2**2*s4**2*s5*s6**3
++ 16240*s1*s2**2*s4*s5**3*s6**2 - 20250*s1*s2**2*s5**5*s6 - 27*s1*s2*s3**6*s4*s5*s6
++ 18*s1*s2*s3**6*s5**3 + 9*s1*s2*s3**5*s4**3*s6 - 9*s1*s2*s3**5*s4**2*s5**2 + 1944*s1*s2*s3**5*s6**3
++ s1*s2*s3**4*s4**4*s5 + 6156*s1*s2*s3**4*s4*s5*s6**2 + 1143*s1*s2*s3**4*s5**3*s6
++ 324*s1*s2*s3**3*s4**3*s6**2 + 1071*s1*s2*s3**3*s4**2*s5**2*s6 + 15*s1*s2*s3**3*s4*s5**4
+- 7776*s1*s2*s3**3*s6**4 - 2028*s1*s2*s3**2*s4**4*s5*s6 - 397*s1*s2*s3**2*s4**3*s5**3
++ 112860*s1*s2*s3**2*s4*s5*s6**3 - 10305*s1*s2*s3**2*s5**3*s6**2 + 336*s1*s2*s3*s4**6*s6
++ 304*s1*s2*s3*s4**5*s5**2 - 68976*s1*s2*s3*s4**3*s6**3 - 96732*s1*s2*s3*s4**2*s5**2*s6**2
++ 36700*s1*s2*s3*s4*s5**4*s6 - 1250*s1*s2*s3*s5**6 - 1477440*s1*s2*s3*s6**5 - 48*s1*s2*s4**7*s5
++ 4368*s1*s2*s4**4*s5*s6**2 + 10360*s1*s2*s4**3*s5**3*s6 - 3500*s1*s2*s4**2*s5**5
++ 935280*s1*s2*s4*s5*s6**4 - 242100*s1*s2*s5**3*s6**3 - 972*s1*s3**6*s5*s6**2 - 351*s1*s3**5*s4*s5**2*s6
+- 99*s1*s3**5*s5**4 + 441*s1*s3**4*s4**3*s5*s6 + 141*s1*s3**4*s4**2*s5**3 - 36936*s1*s3**4*s5*s6**3
+- 84*s1*s3**3*s4**5*s6 - 76*s1*s3**3*s4**4*s5**2 + 17496*s1*s3**3*s4**2*s6**3 + 11718*s1*s3**3*s4*s5**2*s6**2
+- 6525*s1*s3**3*s5**4*s6 + 12*s1*s3**2*s4**6*s5 + 11016*s1*s3**2*s4**3*s5*s6**2 +
+5895*s1*s3**2*s4**2*s5**3*s6 - 1750*s1*s3**2*s4*s5**5 - 252720*s1*s3**2*s5*s6**4 -
+2544*s1*s3*s4**5*s6**2 - 8092*s1*s3*s4**4*s5**2*s6 + 2300*s1*s3*s4**3*s5**4 + 536544*s1*s3*s4**2*s6**4
++ 169560*s1*s3*s4*s5**2*s6**3 - 103500*s1*s3*s5**4*s6**2 + 1680*s1*s4**6*s5*s6 - 468*s1*s4**5*s5**3
+- 346896*s1*s4**3*s5*s6**3 + 93900*s1*s4**2*s5**3*s6**2 + 35000*s1*s4*s5**5*s6 - 9375*s1*s5**7
++ 108864*s1*s5*s6**5 + 16*s2**8*s4**2*s6**2 - 8*s2**8*s4*s5**2*s6 + s2**8*s5**4 -
+8*s2**7*s3**2*s4*s6**2 + 2*s2**7*s3**2*s5**2*s6 - 96*s2**7*s4*s6**3 - 232*s2**7*s5**2*s6**2
++ s2**6*s3**4*s6**2 + 24*s2**6*s3**2*s6**3 + 336*s2**6*s3*s4*s5*s6**2 + 108*s2**6*s3*s5**3*s6
+- 32*s2**6*s4**3*s6**2 - 160*s2**6*s4**2*s5**2*s6 + 38*s2**6*s4*s5**4 + 144*s2**6*s6**4
+- 84*s2**5*s3**3*s5*s6**2 + 8*s2**5*s3**2*s4**2*s6**2 - 106*s2**5*s3**2*s4*s5**2*s6
+- 12*s2**5*s3**2*s5**4 + 176*s2**5*s3*s4**3*s5*s6 - 36*s2**5*s3*s4**2*s5**3 - 2544*s2**5*s3*s5*s6**3
+- 32*s2**5*s4**5*s6 + 8*s2**5*s4**4*s5**2 - 3072*s2**5*s4**2*s6**3 + 3032*s2**5*s4*s5**2*s6**2
++ 954*s2**5*s5**4*s6 + 36*s2**4*s3**4*s5**2*s6 - 80*s2**4*s3**3*s4**2*s5*s6 + 25*s2**4*s3**3*s4*s5**3
++ 16*s2**4*s3**2*s4**4*s6 - 6*s2**4*s3**2*s4**3*s5**2 + 2520*s2**4*s3**2*s4*s6**3
++ 222*s2**4*s3**2*s5**2*s6**2 - 1312*s2**4*s3*s4**2*s5*s6**2 - 3616*s2**4*s3*s4*s5**3*s6
+- 125*s2**4*s3*s5**5 + 1296*s2**4*s4**4*s6**2 - 168*s2**4*s4**3*s5**2*s6 + 375*s2**4*s4**2*s5**4
++ 19296*s2**4*s4*s6**4 + 48408*s2**4*s5**2*s6**3 + 9*s2**3*s3**5*s4*s5*s6 - 4*s2**3*s3**5*s5**3
+- 2*s2**3*s3**4*s4**3*s6 + s2**3*s3**4*s4**2*s5**2 - 432*s2**3*s3**4*s6**3 + 324*s2**3*s3**3*s4*s5*s6**2
++ 923*s2**3*s3**3*s5**3*s6 - 752*s2**3*s3**2*s4**3*s6**2 + 2262*s2**3*s3**2*s4**2*s5**2*s6
++ 525*s2**3*s3**2*s4*s5**4 - 9936*s2**3*s3**2*s6**4 - 480*s2**3*s3*s4**4*s5*s6 - 700*s2**3*s3*s4**3*s5**3
+- 68976*s2**3*s3*s4*s5*s6**3 - 11360*s2**3*s3*s5**3*s6**2 - 32*s2**3*s4**6*s6 + 152*s2**3*s4**5*s5**2
++ 6912*s2**3*s4**3*s6**3 - 7992*s2**3*s4**2*s5**2*s6**2 + 5550*s2**3*s4*s5**4*s6 -
+29376*s2**3*s6**5 + 108*s2**2*s3**4*s4**2*s6**2 - 1215*s2**2*s3**4*s4*s5**2*s6 - 150*s2**2*s3**4*s5**4
++ 336*s2**2*s3**3*s4**3*s5*s6 - 185*s2**2*s3**3*s4**2*s5**3 + 17496*s2**2*s3**3*s5*s6**3
++ 8*s2**2*s3**2*s4**5*s6 + 370*s2**2*s3**2*s4**4*s5**2 - 864*s2**2*s3**2*s4**2*s6**3
++ 22572*s2**2*s3**2*s4*s5**2*s6**2 + 225*s2**2*s3**2*s5**4*s6 - 144*s2**2*s3*s4**6*s5
++ 14784*s2**2*s3*s4**3*s5*s6**2 - 12020*s2**2*s3*s4**2*s5**3*s6 + 625*s2**2*s3*s4*s5**5
++ 536544*s2**2*s3*s5*s6**4 + 16*s2**2*s4**8 - 3072*s2**2*s4**5*s6**2 + 1096*s2**2*s4**4*s5**2*s6
++ 250*s2**2*s4**3*s5**4 - 93744*s2**2*s4**2*s6**4 - 249480*s2**2*s4*s5**2*s6**3 +
+70125*s2**2*s5**4*s6**2 + 162*s2*s3**6*s5**2*s6 - 54*s2*s3**5*s4**2*s5*s6 + 198*s2*s3**5*s4*s5**3
+- 210*s2*s3**4*s4**3*s5**2 - 3564*s2*s3**4*s5**2*s6**2 + 72*s2*s3**3*s4**5*s5 - 12204*s2*s3**3*s4**2*s5*s6**2
++ 1935*s2*s3**3*s4*s5**3*s6 - 8*s2*s3**2*s4**7 + 2520*s2*s3**2*s4**4*s6**2 + 1962*s2*s3**2*s4**3*s5**2*s6
+- 125*s2*s3**2*s4**2*s5**4 - 178848*s2*s3**2*s4*s6**4 - 165240*s2*s3**2*s5**2*s6**3
+- 144*s2*s3*s4**5*s5*s6 - 200*s2*s3*s4**4*s5**3 + 139104*s2*s3*s4**2*s5*s6**3 + 72900*s2*s3*s4*s5**3*s6**2
+- 20625*s2*s3*s5**5*s6 - 96*s2*s4**7*s6 + 56*s2*s4**6*s5**2 + 19296*s2*s4**4*s6**3
+- 22080*s2*s4**3*s5**2*s6**2 - 7750*s2*s4**2*s5**4*s6 + 3125*s2*s4*s5**6 + 248832*s2*s4*s6**5
+- 129600*s2*s5**2*s6**4 - 27*s3**7*s5**3 + 27*s3**6*s4**2*s5**2 - 9*s3**5*s4**4*s5
++ 1944*s3**5*s4*s5*s6**2 + 54*s3**5*s5**3*s6 + s3**4*s4**6 - 432*s3**4*s4**3*s6**2
+- 486*s3**4*s4**2*s5**2*s6 + 46656*s3**4*s6**4 + 36*s3**3*s4**4*s5*s6 + 50*s3**3*s4**3*s5**3
+- 7776*s3**3*s4*s5*s6**3 + 29700*s3**3*s5**3*s6**2 + 24*s3**2*s4**6*s6 - 14*s3**2*s4**5*s5**2
+- 9936*s3**2*s4**3*s6**3 - 29160*s3**2*s4**2*s5**2*s6**2 - 10125*s3**2*s4*s5**4*s6
++ 3125*s3**2*s5**6 + 1026432*s3**2*s6**5 + 6336*s3*s4**4*s5*s6**2 + 11700*s3*s4**3*s5**3*s6
+- 3125*s3*s4**2*s5**5 - 1477440*s3*s4*s5*s6**4 + 432000*s3*s5**3*s6**3 + 144*s4**6*s6**2
+- 2472*s4**5*s5**2*s6 + 625*s4**4*s5**4 - 29376*s4**3*s6**4 + 529200*s4**2*s5**2*s6**3
+- 292500*s4*s5**4*s6**2 + 40625*s5**6*s6 - 186624*s6**6)
+    ],
+    (6, 2): [
+        lambda s1, s2, s3, s4, s5, s6: (-s3),
+        lambda s1, s2, s3, s4, s5, s6: (-s1*s5 + s2*s4 - 9*s6),
+        lambda s1, s2, s3, s4, s5, s6: (s1*s2*s6 + 2*s1*s3*s5 - s1*s4**2 - s2**2*s5 + 6*s3*s6 + s4*s5),
+        lambda s1, s2, s3, s4, s5, s6: (s1**2*s4*s6 - s1**2*s5**2 - 3*s1*s2*s3*s6 + s1*s2*s4*s5 + 9*s1*s5*s6 + s2**3*s6 -
+9*s2*s4*s6 + s2*s5**2 + 3*s3**2*s6 - 3*s3*s4*s5 + s4**3 + 27*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (-2*s1**3*s6**2 + 2*s1**2*s2*s5*s6 + 2*s1**2*s3*s4*s6 - s1**2*s3*s5**2 - s1*s2**2*s4*s6
+- 3*s1*s2*s6**2 - 16*s1*s3*s5*s6 + 4*s1*s4**2*s6 + 2*s1*s4*s5**2 + 4*s2**2*s5*s6 +
+s2*s3*s4*s6 + 2*s2*s3*s5**2 - s2*s4**2*s5 - 9*s3*s6**2 - 3*s4*s5*s6 - 2*s5**3),
+        lambda s1, s2, s3, s4, s5, s6: (s1**3*s3*s6**2 - 3*s1**3*s4*s5*s6 + s1**3*s5**3 - s1**2*s2**2*s6**2 + s1**2*s2*s3*s5*s6
+- 2*s1**2*s4*s6**2 + 6*s1**2*s5**2*s6 + 16*s1*s2*s3*s6**2 - 3*s1*s2*s5**3 - s1*s3**2*s5*s6
+- 2*s1*s3*s4**2*s6 + s1*s3*s4*s5**2 - 30*s1*s5*s6**2 - 4*s2**3*s6**2 - 2*s2**2*s3*s5*s6
++ s2**2*s4**2*s6 + 18*s2*s4*s6**2 - 2*s2*s5**2*s6 - 15*s3**2*s6**2 + 16*s3*s4*s5*s6
++ s3*s5**3 - 4*s4**3*s6 - s4**2*s5**2 - 27*s6**3),
+        lambda s1, s2, s3, s4, s5, s6: (s1**4*s5*s6**2 + 2*s1**3*s2*s4*s6**2 - s1**3*s2*s5**2*s6 - s1**3*s3**2*s6**2 + 9*s1**3*s6**3
+- 14*s1**2*s2*s5*s6**2 - 11*s1**2*s3*s4*s6**2 + 6*s1**2*s3*s5**2*s6 + 3*s1**2*s4**2*s5*s6
+- s1**2*s4*s5**3 + 3*s1*s2**2*s5**2*s6 + 3*s1*s2*s3**2*s6**2 - s1*s2*s3*s4*s5*s6 +
+39*s1*s3*s5*s6**2 - 14*s1*s4*s5**2*s6 + s1*s5**4 - 11*s2*s3*s5**2*s6 + 2*s2*s4*s5**3
+- 3*s3**3*s6**2 + 3*s3**2*s4*s5*s6 - s3**2*s5**3 + 9*s5**3*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-s1**4*s2*s6**3 + s1**4*s3*s5*s6**2 - 4*s1**3*s3*s6**3 + 10*s1**3*s4*s5*s6**2 - 4*s1**3*s5**3*s6
++ 8*s1**2*s2**2*s6**3 - 8*s1**2*s2*s3*s5*s6**2 - 2*s1**2*s2*s4**2*s6**2 + s1**2*s2*s4*s5**2*s6
++ s1**2*s3**2*s4*s6**2 - 6*s1**2*s4*s6**3 - 7*s1**2*s5**2*s6**2 - 24*s1*s2*s3*s6**3
+- 4*s1*s2*s4*s5*s6**2 + 10*s1*s2*s5**3*s6 + 8*s1*s3**2*s5*s6**2 + 8*s1*s3*s4**2*s6**2
+- 8*s1*s3*s4*s5**2*s6 + s1*s3*s5**4 + 36*s1*s5*s6**3 + 8*s2**2*s3*s5*s6**2 - 2*s2**2*s4*s5**2*s6
+- 2*s2*s3**2*s4*s6**2 + s2*s3**2*s5**2*s6 - 6*s2*s5**2*s6**2 + 18*s3**2*s6**3 - 24*s3*s4*s5*s6**2
+- 4*s3*s5**3*s6 + 8*s4**2*s5**2*s6 - s4*s5**4),
+        lambda s1, s2, s3, s4, s5, s6: (-s1**5*s4*s6**3 - 2*s1**4*s5*s6**3 + 3*s1**3*s2*s5**2*s6**2 + 3*s1**3*s3**2*s6**3
+- s1**3*s3*s4*s5*s6**2 - 8*s1**3*s6**4 + 16*s1**2*s2*s5*s6**3 + 8*s1**2*s3*s4*s6**3
+- 6*s1**2*s3*s5**2*s6**2 - 8*s1**2*s4**2*s5*s6**2 + 3*s1**2*s4*s5**3*s6 - 8*s1*s2**2*s5**2*s6**2
+- 8*s1*s2*s3**2*s6**3 + 8*s1*s2*s3*s4*s5*s6**2 - s1*s2*s3*s5**3*s6 - s1*s3**3*s5*s6**2
+- 24*s1*s3*s5*s6**3 + 16*s1*s4*s5**2*s6**2 - 2*s1*s5**4*s6 + 8*s2*s3*s5**2*s6**2 -
+s2*s5**5 + 8*s3**3*s6**3 - 8*s3**2*s4*s5*s6**2 + 3*s3**2*s5**3*s6 - 8*s5**3*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (s1**6*s6**4 - 4*s1**4*s2*s6**4 - 2*s1**4*s3*s5*s6**3 + s1**4*s4**2*s6**3 + 8*s1**3*s3*s6**4
+- 4*s1**3*s4*s5*s6**3 + 2*s1**3*s5**3*s6**2 + 8*s1**2*s2*s3*s5*s6**3 - 2*s1**2*s2*s4*s5**2*s6**2
+- 2*s1**2*s3**2*s4*s6**3 + s1**2*s3**2*s5**2*s6**2 - 4*s1*s2*s5**3*s6**2 - 12*s1*s3**2*s5*s6**3
++ 8*s1*s3*s4*s5**2*s6**2 - 2*s1*s3*s5**4*s6 + s2**2*s5**4*s6 - 2*s2*s3**2*s5**2*s6**2
++ s3**4*s6**3 + 8*s3*s5**3*s6**2 - 4*s4*s5**4*s6 + s5**6)
+    ],
+}
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/subfield.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/subfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b76186dace09bd901a5a1944165c926a78384ba
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/subfield.py
@@ -0,0 +1,507 @@
+r"""
+Functions in ``polys.numberfields.subfield`` solve the "Subfield Problem" and
+allied problems, for algebraic number fields.
+
+Following Cohen (see [Cohen93]_ Section 4.5), we can define the main problem as
+follows:
+
+* **Subfield Problem:**
+
+  Given two number fields $\mathbb{Q}(\alpha)$, $\mathbb{Q}(\beta)$
+  via the minimal polynomials for their generators $\alpha$ and $\beta$, decide
+  whether one field is isomorphic to a subfield of the other.
+
+From a solution to this problem flow solutions to the following problems as
+well:
+
+* **Primitive Element Problem:**
+
+  Given several algebraic numbers
+  $\alpha_1, \ldots, \alpha_m$, compute a single algebraic number $\theta$
+  such that $\mathbb{Q}(\alpha_1, \ldots, \alpha_m) = \mathbb{Q}(\theta)$.
+
+* **Field Isomorphism Problem:**
+
+  Decide whether two number fields
+  $\mathbb{Q}(\alpha)$, $\mathbb{Q}(\beta)$ are isomorphic.
+
+* **Field Membership Problem:**
+
+  Given two algebraic numbers $\alpha$,
+  $\beta$, decide whether $\alpha \in \mathbb{Q}(\beta)$, and if so write
+  $\alpha = f(\beta)$ for some $f(x) \in \mathbb{Q}[x]$.
+"""
+
+from sympy.core.add import Add
+from sympy.core.numbers import AlgebraicNumber
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify, _sympify
+from sympy.ntheory import sieve
+from sympy.polys.densetools import dup_eval
+from sympy.polys.domains import QQ
+from sympy.polys.numberfields.minpoly import _choose_factor, minimal_polynomial
+from sympy.polys.polyerrors import IsomorphismFailed
+from sympy.polys.polytools import Poly, PurePoly, factor_list
+from sympy.utilities import public
+
+from mpmath import MPContext
+
+
+def is_isomorphism_possible(a, b):
+    """Necessary but not sufficient test for isomorphism. """
+    n = a.minpoly.degree()
+    m = b.minpoly.degree()
+
+    if m % n != 0:
+        return False
+
+    if n == m:
+        return True
+
+    da = a.minpoly.discriminant()
+    db = b.minpoly.discriminant()
+
+    i, k, half = 1, m//n, db//2
+
+    while True:
+        p = sieve[i]
+        P = p**k
+
+        if P > half:
+            break
+
+        if ((da % p) % 2) and not (db % P):
+            return False
+
+        i += 1
+
+    return True
+
+
+def field_isomorphism_pslq(a, b):
+    """Construct field isomorphism using PSLQ algorithm. """
+    if not a.root.is_real or not b.root.is_real:
+        raise NotImplementedError("PSLQ doesn't support complex coefficients")
+
+    f = a.minpoly
+    g = b.minpoly.replace(f.gen)
+
+    n, m, prev = 100, b.minpoly.degree(), None
+    ctx = MPContext()
+
+    for i in range(1, 5):
+        A = a.root.evalf(n)
+        B = b.root.evalf(n)
+
+        basis = [1, B] + [ B**i for i in range(2, m) ] + [-A]
+
+        ctx.dps = n
+        coeffs = ctx.pslq(basis, maxcoeff=10**10, maxsteps=1000)
+
+        if coeffs is None:
+            # PSLQ can't find an integer linear combination. Give up.
+            break
+
+        if coeffs != prev:
+            prev = coeffs
+        else:
+            # Increasing precision didn't produce anything new. Give up.
+            break
+
+        # We have
+        #   c0 + c1*B + c2*B^2 + ... + cm-1*B^(m-1) - cm*A ~ 0.
+        # So bring cm*A to the other side, and divide through by cm,
+        # for an approximate representation of A as a polynomial in B.
+        # (We know cm != 0 since `b.minpoly` is irreducible.)
+        coeffs = [S(c)/coeffs[-1] for c in coeffs[:-1]]
+
+        # Throw away leading zeros.
+        while not coeffs[-1]:
+            coeffs.pop()
+
+        coeffs = list(reversed(coeffs))
+        h = Poly(coeffs, f.gen, domain='QQ')
+
+        # We only have A ~ h(B). We must check whether the relation is exact.
+        if f.compose(h).rem(g).is_zero:
+            # Now we know that h(b) is in fact equal to _some conjugate of_ a.
+            # But from the very precise approximation A ~ h(B) we can assume
+            # the conjugate is a itself.
+            return coeffs
+        else:
+            n *= 2
+
+    return None
+
+
+def field_isomorphism_factor(a, b):
+    """Construct field isomorphism via factorization. """
+    _, factors = factor_list(a.minpoly, extension=b)
+    for f, _ in factors:
+        if f.degree() == 1:
+            # Any linear factor f(x) represents some conjugate of a in QQ(b).
+            # We want to know whether this linear factor represents a itself.
+            # Let f = x - c
+            c = -f.rep.TC()
+            # Write c as polynomial in b
+            coeffs = c.to_sympy_list()
+            d, terms = len(coeffs) - 1, []
+            for i, coeff in enumerate(coeffs):
+                terms.append(coeff*b.root**(d - i))
+            r = Add(*terms)
+            # Check whether we got the number a
+            if a.minpoly.same_root(r, a):
+                return coeffs
+
+    # If none of the linear factors represented a in QQ(b), then in fact a is
+    # not an element of QQ(b).
+    return None
+
+
+@public
+def field_isomorphism(a, b, *, fast=True):
+    r"""
+    Find an embedding of one number field into another.
+
+    Explanation
+    ===========
+
+    This function looks for an isomorphism from $\mathbb{Q}(a)$ onto some
+    subfield of $\mathbb{Q}(b)$. Thus, it solves the Subfield Problem.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, field_isomorphism, I
+    >>> print(field_isomorphism(3, sqrt(2)))  # doctest: +SKIP
+    [3]
+    >>> print(field_isomorphism( I*sqrt(3), I*sqrt(3)/2))  # doctest: +SKIP
+    [2, 0]
+
+    Parameters
+    ==========
+
+    a : :py:class:`~.Expr`
+        Any expression representing an algebraic number.
+    b : :py:class:`~.Expr`
+        Any expression representing an algebraic number.
+    fast : boolean, optional (default=True)
+        If ``True``, we first attempt a potentially faster way of computing the
+        isomorphism, falling back on a slower method if this fails. If
+        ``False``, we go directly to the slower method, which is guaranteed to
+        return a result.
+
+    Returns
+    =======
+
+    List of rational numbers, or None
+        If $\mathbb{Q}(a)$ is not isomorphic to some subfield of
+        $\mathbb{Q}(b)$, then return ``None``. Otherwise, return a list of
+        rational numbers representing an element of $\mathbb{Q}(b)$ to which
+        $a$ may be mapped, in order to define a monomorphism, i.e. an
+        isomorphism from $\mathbb{Q}(a)$ to some subfield of $\mathbb{Q}(b)$.
+        The elements of the list are the coefficients of falling powers of $b$.
+
+    """
+    a, b = sympify(a), sympify(b)
+
+    if not a.is_AlgebraicNumber:
+        a = AlgebraicNumber(a)
+
+    if not b.is_AlgebraicNumber:
+        b = AlgebraicNumber(b)
+
+    a = a.to_primitive_element()
+    b = b.to_primitive_element()
+
+    if a == b:
+        return a.coeffs()
+
+    n = a.minpoly.degree()
+    m = b.minpoly.degree()
+
+    if n == 1:
+        return [a.root]
+
+    if m % n != 0:
+        return None
+
+    if fast:
+        try:
+            result = field_isomorphism_pslq(a, b)
+
+            if result is not None:
+                return result
+        except NotImplementedError:
+            pass
+
+    return field_isomorphism_factor(a, b)
+
+
+def _switch_domain(g, K):
+    # An algebraic relation f(a, b) = 0 over Q can also be written
+    # g(b) = 0 where g is in Q(a)[x] and h(a) = 0 where h is in Q(b)[x].
+    # This function transforms g into h where Q(b) = K.
+    frep = g.rep.inject()
+    hrep = frep.eject(K, front=True)
+
+    return g.new(hrep, g.gens[0])
+
+
+def _linsolve(p):
+    # Compute root of linear polynomial.
+    c, d = p.rep.rep
+    return -d/c
+
+
+@public
+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
+
+
+@public
+def to_number_field(extension, theta=None, *, gen=None, alias=None):
+    r"""
+    Express one algebraic number in the field generated by another.
+
+    Explanation
+    ===========
+
+    Given two algebraic numbers $\eta, \theta$, this function either expresses
+    $\eta$ as an element of $\mathbb{Q}(\theta)$, or else raises an exception
+    if $\eta \not\in \mathbb{Q}(\theta)$.
+
+    This function is essentially just a convenience, utilizing
+    :py:func:`~.field_isomorphism` (our solution of the Subfield Problem) to
+    solve this, the Field Membership Problem.
+
+    As an additional convenience, this function allows you to pass a list of
+    algebraic numbers $\alpha_1, \alpha_2, \ldots, \alpha_n$ instead of $\eta$.
+    It then computes $\eta$ for you, as a solution of the Primitive Element
+    Problem, using :py:func:`~.primitive_element` on the list of $\alpha_i$.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, to_number_field
+    >>> eta = sqrt(2)
+    >>> theta = sqrt(2) + sqrt(3)
+    >>> a = to_number_field(eta, theta)
+    >>> print(type(a))
+    <class 'sympy.core.numbers.AlgebraicNumber'>
+    >>> a.root
+    sqrt(2) + sqrt(3)
+    >>> print(a)
+    sqrt(2)
+    >>> a.coeffs()
+    [1/2, 0, -9/2, 0]
+
+    We get an :py:class:`~.AlgebraicNumber`, whose ``.root`` is $\theta$, whose
+    value is $\eta$, and whose ``.coeffs()`` show how to write $\eta$ as a
+    $\mathbb{Q}$-linear combination in falling powers of $\theta$.
+
+    Parameters
+    ==========
+
+    extension : :py:class:`~.Expr` or list of :py:class:`~.Expr`
+        Either the algebraic number that is to be expressed in the other field,
+        or else a list of algebraic numbers, a primitive element for which is
+        to be expressed in the other field.
+    theta : :py:class:`~.Expr`, None, optional (default=None)
+        If an :py:class:`~.Expr` representing an algebraic number, behavior is
+        as described under **Explanation**. If ``None``, then this function
+        reduces to a shorthand for calling :py:func:`~.primitive_element` on
+        ``extension`` and turning the computed primitive element into an
+        :py:class:`~.AlgebraicNumber`.
+    gen : :py:class:`~.Symbol`, None, optional (default=None)
+        If provided, this will be used as the generator symbol for the minimal
+        polynomial in the returned :py:class:`~.AlgebraicNumber`.
+    alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+        If provided, this will be used as the alias symbol for the returned
+        :py:class:`~.AlgebraicNumber`.
+
+    Returns
+    =======
+
+    AlgebraicNumber
+        Belonging to $\mathbb{Q}(\theta)$ and equaling $\eta$.
+
+    Raises
+    ======
+
+    IsomorphismFailed
+        If $\eta \not\in \mathbb{Q}(\theta)$.
+
+    See Also
+    ========
+
+    field_isomorphism
+    primitive_element
+
+    """
+    if hasattr(extension, '__iter__'):
+        extension = list(extension)
+    else:
+        extension = [extension]
+
+    if len(extension) == 1 and isinstance(extension[0], tuple):
+        return AlgebraicNumber(extension[0], alias=alias)
+
+    minpoly, coeffs = primitive_element(extension, gen, polys=True)
+    root = sum([ coeff*ext for coeff, ext in zip(coeffs, extension) ])
+
+    if theta is None:
+        return AlgebraicNumber((minpoly, root), alias=alias)
+    else:
+        theta = sympify(theta)
+
+        if not theta.is_AlgebraicNumber:
+            theta = AlgebraicNumber(theta, gen=gen, alias=alias)
+
+        coeffs = field_isomorphism(root, theta)
+
+        if coeffs is not None:
+            return AlgebraicNumber(theta, coeffs, alias=alias)
+        else:
+            raise IsomorphismFailed(
+                "%s is not in a subfield of %s" % (root, theta.root))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_basis.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_basis.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0ed017936cc5c24da63ac02ceca0480f1945feb
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_basis.py
@@ -0,0 +1,85 @@
+from sympy.abc import x
+from sympy.core import S
+from sympy.core.numbers import AlgebraicNumber
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.domains import QQ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.numberfields.basis import round_two
+from sympy.testing.pytest import raises
+
+
+def test_round_two():
+    # Poly must be irreducible, and over ZZ or QQ:
+    raises(ValueError, lambda: round_two(Poly(x ** 2 - 1)))
+    raises(ValueError, lambda: round_two(Poly(x ** 2 + sqrt(2))))
+
+    # Test on many fields:
+    cases = (
+        # A couple of cyclotomic fields:
+        (cyclotomic_poly(5), DomainMatrix.eye(4, QQ), 125),
+        (cyclotomic_poly(7), DomainMatrix.eye(6, QQ), -16807),
+        # A couple of quadratic fields (one 1 mod 4, one 3 mod 4):
+        (x ** 2 - 5, DM([[1, (1, 2)], [0, (1, 2)]], QQ), 5),
+        (x ** 2 - 7, DM([[1, 0], [0, 1]], QQ), 28),
+        # Dedekind's example of a field with 2 as essential disc divisor:
+        (x ** 3 + x ** 2 - 2 * x + 8, DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+        # A bunch of cubics with various forms for F -- all of these require
+        # second or third enlargements. (Five of them require a third, while the rest require just a second.)
+        # F = 2^2
+        (x**3 + 3 * x**2 - 4 * x + 4, DM([((1, 2), (1, 4), (1, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -83),
+        # F = 2^2 * 3
+        (x**3 + 3 * x**2 + 3 * x - 3, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -108),
+        # F = 2^3
+        (x**3 + 5 * x**2 - x + 3, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -31),
+        # F = 2^2 * 5
+        (x**3 + 5 * x**2 - 5 * x - 5, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 1300),
+        # F = 3^2
+        (x**3 + 3 * x**2 + 5, DM([((1, 3), (1, 3), (1, 3)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -135),
+        # F = 3^3
+        (x**3 + 6 * x**2 + 3 * x - 1, DM([((1, 3), (1, 3), (1, 3)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 81),
+        # F = 2^2 * 3^2
+        (x**3 + 6 * x**2 + 4, DM([((1, 3), (2, 3), (1, 3)), (0, 1, 0), (0, 0, (1, 2))], QQ).transpose(), -108),
+        # F = 2^3 * 7
+        (x**3 + 7 * x**2 + 7 * x - 7, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), 49),
+        # F = 2^2 * 13
+        (x**3 + 7 * x**2 - x + 5, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -2028),
+        # F = 2^4
+        (x**3 + 7 * x**2 - 5 * x + 5, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -140),
+        # F = 5^2
+        (x**3 + 4 * x**2 - 3 * x + 7, DM([((1, 5), (4, 5), (4, 5)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -175),
+        # F = 7^2
+        (x**3 + 8 * x**2 + 5 * x - 1, DM([((1, 7), (6, 7), (2, 7)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 49),
+        # F = 2 * 5 * 7
+        (x**3 + 8 * x**2 - 2 * x + 6, DM([(1, 0, 0), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -14700),
+        # F = 2^2 * 3 * 5
+        (x**3 + 6 * x**2 - 3 * x + 8, DM([(1, 0, 0), (0, (1, 4), (1, 4)), (0, 0, 1)], QQ).transpose(), -675),
+        # F = 2 * 3^2 * 7
+        (x**3 + 9 * x**2 + 6 * x - 8, DM([(1, 0, 0), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), 3969),
+        # F = 2^2 * 3^2 * 7
+        (x**3 + 15 * x**2 - 9 * x + 13, DM([((1, 6), (1, 3), (1, 6)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -5292),
+        # Polynomial need not be monic
+        (5*x**3 + 5*x**2 - 10 * x + 40, DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+        # Polynomial can have non-integer rational coeffs
+        (QQ(5, 3)*x**3 + QQ(5, 3)*x**2 - QQ(10, 3)*x + QQ(40, 3), DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+    )
+    for f, B_exp, d_exp in cases:
+        K = QQ.alg_field_from_poly(f)
+        B = K.maximal_order().QQ_matrix
+        d = K.discriminant()
+        assert d == d_exp
+        # The computed basis need not equal the expected one, but their quotient
+        # must be unimodular:
+        assert (B.inv()*B_exp).det()**2 == 1
+
+
+def test_AlgebraicField_integral_basis():
+    alpha = AlgebraicNumber(sqrt(5), alias='alpha')
+    k = QQ.algebraic_field(alpha)
+    B0 = k.integral_basis()
+    B1 = k.integral_basis(fmt='sympy')
+    B2 = k.integral_basis(fmt='alg')
+    assert B0 == [k([1]), k([S.Half, S.Half])]
+    assert B1 == [1, S.Half + alpha/2]
+    assert B2 == [k.ext.field_element([1]),
+                  k.ext.field_element([S.Half, S.Half])]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_galoisgroups.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_galoisgroups.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4cb3d51bcdfad7764b3f6f62dbd2049e466e9e1
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_galoisgroups.py
@@ -0,0 +1,143 @@
+"""Tests for computing Galois groups. """
+
+from sympy.abc import x
+from sympy.combinatorics.galois import (
+    S1TransitiveSubgroups, S2TransitiveSubgroups, S3TransitiveSubgroups,
+    S4TransitiveSubgroups, S5TransitiveSubgroups, S6TransitiveSubgroups,
+)
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.numberfields.galoisgroups import (
+    tschirnhausen_transformation,
+    galois_group,
+    _galois_group_degree_4_root_approx,
+    _galois_group_degree_5_hybrid,
+)
+from sympy.polys.numberfields.subfield import field_isomorphism
+from sympy.polys.polytools import Poly
+from sympy.testing.pytest import raises
+
+
+def test_tschirnhausen_transformation():
+    for T in [
+        Poly(x**2 - 2),
+        Poly(x**2 + x + 1),
+        Poly(x**4 + 1),
+        Poly(x**4 - x**3 + x**2 - x + 1),
+    ]:
+        _, U = tschirnhausen_transformation(T)
+        assert U.degree() == T.degree()
+        assert U.is_monic
+        assert U.is_irreducible
+        K = QQ.alg_field_from_poly(T)
+        L = QQ.alg_field_from_poly(U)
+        assert field_isomorphism(K.ext, L.ext) is not None
+
+
+# Test polys are from:
+# Cohen, H. *A Course in Computational Algebraic Number Theory*.
+test_polys_by_deg = {
+    # Degree 1
+    1: [
+        (x, S1TransitiveSubgroups.S1, True)
+    ],
+    # Degree 2
+    2: [
+        (x**2 + x + 1, S2TransitiveSubgroups.S2, False)
+    ],
+    # Degree 3
+    3: [
+        (x**3 + x**2 - 2*x - 1, S3TransitiveSubgroups.A3, True),
+        (x**3 + 2, S3TransitiveSubgroups.S3, False),
+    ],
+    # Degree 4
+    4: [
+        (x**4 + x**3 + x**2 + x + 1, S4TransitiveSubgroups.C4, False),
+        (x**4 + 1, S4TransitiveSubgroups.V, True),
+        (x**4 - 2, S4TransitiveSubgroups.D4, False),
+        (x**4 + 8*x + 12, S4TransitiveSubgroups.A4, True),
+        (x**4 + x + 1, S4TransitiveSubgroups.S4, False),
+    ],
+    # Degree 5
+    5: [
+        (x**5 + x**4 - 4*x**3 - 3*x**2 + 3*x + 1, S5TransitiveSubgroups.C5, True),
+        (x**5 - 5*x + 12, S5TransitiveSubgroups.D5, True),
+        (x**5 + 2, S5TransitiveSubgroups.M20, False),
+        (x**5 + 20*x + 16, S5TransitiveSubgroups.A5, True),
+        (x**5 - x + 1, S5TransitiveSubgroups.S5, False),
+    ],
+    # Degree 6
+    6: [
+        (x**6 + x**5 + x**4 + x**3 + x**2 + x + 1, S6TransitiveSubgroups.C6, False),
+        (x**6 + 108, S6TransitiveSubgroups.S3, False),
+        (x**6 + 2, S6TransitiveSubgroups.D6, False),
+        (x**6 - 3*x**2 - 1, S6TransitiveSubgroups.A4, True),
+        (x**6 + 3*x**3 + 3, S6TransitiveSubgroups.G18, False),
+        (x**6 - 3*x**2 + 1, S6TransitiveSubgroups.A4xC2, False),
+        (x**6 - 4*x**2 - 1, S6TransitiveSubgroups.S4p, True),
+        (x**6 - 3*x**5 + 6*x**4 - 7*x**3 + 2*x**2 + x - 4, S6TransitiveSubgroups.S4m, False),
+        (x**6 + 2*x**3 - 2, S6TransitiveSubgroups.G36m, False),
+        (x**6 + 2*x**2 + 2, S6TransitiveSubgroups.S4xC2, False),
+        (x**6 + 10*x**5 + 55*x**4 + 140*x**3 + 175*x**2 + 170*x + 25, S6TransitiveSubgroups.PSL2F5, True),
+        (x**6 + 10*x**5 + 55*x**4 + 140*x**3 + 175*x**2 - 3019*x + 25, S6TransitiveSubgroups.PGL2F5, False),
+        (x**6 + 6*x**4 + 2*x**3 + 9*x**2 + 6*x - 4, S6TransitiveSubgroups.G36p, True),
+        (x**6 + 2*x**4 + 2*x**3 + x**2 + 2*x + 2, S6TransitiveSubgroups.G72, False),
+        (x**6 + 24*x - 20, S6TransitiveSubgroups.A6, True),
+        (x**6 + x + 1, S6TransitiveSubgroups.S6, False),
+    ],
+}
+
+
+def test_galois_group():
+    """
+    Try all the test polys.
+    """
+    for deg in range(1, 7):
+        polys = test_polys_by_deg[deg]
+        for T, G, alt in polys:
+            assert galois_group(T, by_name=True) == (G, alt)
+
+
+def test_galois_group_degree_out_of_bounds():
+    raises(ValueError, lambda: galois_group(Poly(0, x)))
+    raises(ValueError, lambda: galois_group(Poly(1, x)))
+    raises(ValueError, lambda: galois_group(Poly(x ** 7 + 1)))
+
+
+def test_galois_group_not_by_name():
+    """
+    Check at least one polynomial of each supported degree, to see that
+    conversion from name to group works.
+    """
+    for deg in range(1, 7):
+        T, G_name, _ = test_polys_by_deg[deg][0]
+        G, _ = galois_group(T)
+        assert G == G_name.get_perm_group()
+
+
+def test_galois_group_not_monic_over_ZZ():
+    """
+    Check that we can work with polys that are not monic over ZZ.
+    """
+    for deg in range(1, 7):
+        T, G, alt = test_polys_by_deg[deg][0]
+        assert galois_group(T/2, by_name=True) == (G, alt)
+
+
+def test__galois_group_degree_4_root_approx():
+    for T, G, alt in test_polys_by_deg[4]:
+        assert _galois_group_degree_4_root_approx(Poly(T)) == (G, alt)
+
+
+def test__galois_group_degree_5_hybrid():
+    for T, G, alt in test_polys_by_deg[5]:
+        assert _galois_group_degree_5_hybrid(Poly(T)) == (G, alt)
+
+
+def test_AlgebraicField_galois_group():
+    k = QQ.alg_field_from_poly(Poly(x**4 + 1))
+    G, _ = k.galois_group(by_name=True)
+    assert G == S4TransitiveSubgroups.V
+
+    k = QQ.alg_field_from_poly(Poly(x**4 - 2))
+    G, _ = k.galois_group(by_name=True)
+    assert G == S4TransitiveSubgroups.D4
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_minpoly.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_minpoly.py
new file mode 100644
index 0000000000000000000000000000000000000000..18d786e1bd10cd2c6dd8d63121ce293a5600424a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_minpoly.py
@@ -0,0 +1,474 @@
+"""Tests for minimal polynomials. """
+
+from sympy.core.function import expand
+from sympy.core import (GoldenRatio, TribonacciConstant)
+from sympy.core.numbers import (AlgebraicNumber, I, Rational, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.solvers.solveset import nonlinsolve
+from sympy.geometry import Circle, intersection
+from sympy.testing.pytest import raises, slow
+from sympy.sets.sets import FiniteSet
+from sympy.geometry.point import Point2D
+from sympy.polys.numberfields.minpoly import (
+    minimal_polynomial,
+    _choose_factor,
+    _minpoly_op_algebraic_element,
+    _separate_sq,
+    _minpoly_groebner,
+)
+from sympy.polys.partfrac import apart
+from sympy.polys.polyerrors import (
+    NotAlgebraic,
+    GeneratorsError,
+)
+
+from sympy.polys.domains import QQ
+from sympy.polys.rootoftools import rootof
+from sympy.polys.polytools import degree
+
+from sympy.abc import x, y, z
+
+Q = Rational
+
+
+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_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_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_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_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))
+
+
+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_minpoly_issue_23677():
+    r1 = CRootOf(4000000*x**3 - 239960000*x**2 + 4782399900*x - 31663998001, 0)
+    r2 = CRootOf(4000000*x**3 - 239960000*x**2 + 4782399900*x - 31663998001, 1)
+    num = (7680000000000000000*r1**4*r2**4 - 614323200000000000000*r1**4*r2**3
+            + 18458112576000000000000*r1**4*r2**2 - 246896663036160000000000*r1**4*r2
+            + 1240473830323209600000000*r1**4 - 614323200000000000000*r1**3*r2**4
+            - 1476464424954240000000000*r1**3*r2**2 - 99225501687553535904000000*r1**3
+            + 18458112576000000000000*r1**2*r2**4 - 1476464424954240000000000*r1**2*r2**3
+            - 593391458458356671712000000*r1**2*r2 + 2981354896834339226880720000*r1**2
+            - 246896663036160000000000*r1*r2**4 - 593391458458356671712000000*r1*r2**2
+            - 39878756418031796275267195200*r1 + 1240473830323209600000000*r2**4
+            - 99225501687553535904000000*r2**3 + 2981354896834339226880720000*r2**2 -
+            39878756418031796275267195200*r2 + 200361370275616536577343808012)
+    mp = (x**3 + 59426520028417434406408556687919*x**2 +
+        1161475464966574421163316896737773190861975156439163671112508400*x +
+        7467465541178623874454517208254940823818304424383315270991298807299003671748074773558707779600)
+    assert minimal_polynomial(num, x) == mp
+
+
+def test_minpoly_issue_7574():
+    ex = -(-1)**Rational(1, 3) + (-1)**Rational(2,3)
+    assert minimal_polynomial(ex, x) == x + 1
+
+
+def test_choose_factor():
+    # Test that this does not enter an infinite loop:
+    bad_factors = [Poly(x-2, x), Poly(x+2, x)]
+    raises(NotImplementedError, lambda: _choose_factor(bad_factors, x, sqrt(3)))
+
+
+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))
+
+@slow
+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_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_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_issue_18248():
+    assert nonlinsolve([x*y**3-sqrt(2)/3, x*y**6-4/(9*(sqrt(3)))],x,y) == \
+            FiniteSet((sqrt(3)/2, sqrt(6)/3), (sqrt(3)/2, -sqrt(6)/6 - sqrt(2)*I/2),
+            (sqrt(3)/2, -sqrt(6)/6 + sqrt(2)*I/2))
+
+
+def test_issue_13230():
+    c1 = Circle(Point2D(3, sqrt(5)), 5)
+    c2 = Circle(Point2D(4, sqrt(7)), 6)
+    assert intersection(c1, c2) == [Point2D(-1 + (-sqrt(7) + sqrt(5))*(-2*sqrt(7)/29
+    + 9*sqrt(5)/29 + sqrt(196*sqrt(35) + 1941)/29), -2*sqrt(7)/29 + 9*sqrt(5)/29
+    + sqrt(196*sqrt(35) + 1941)/29), Point2D(-1 + (-sqrt(7) + sqrt(5))*(-sqrt(196*sqrt(35)
+    + 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29), -sqrt(196*sqrt(35) + 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29)]
+
+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 test_issue_20163():
+    assert apart(1/(x**6+1), extension=[sqrt(3), I]) == \
+        (sqrt(3) + I)/(2*x + sqrt(3) + I)/6 + \
+        (sqrt(3) - I)/(2*x + sqrt(3) - I)/6 - \
+        (sqrt(3) - I)/(2*x - sqrt(3) + I)/6 - \
+        (sqrt(3) + I)/(2*x - sqrt(3) - I)/6 + \
+        I/(x + I)/6 - I/(x - I)/6
+
+
+def test_issue_22559():
+    alpha = AlgebraicNumber(sqrt(2))
+    assert minimal_polynomial(alpha**3, x) == x**2 - 8
+
+
+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_separate_sq_not_impl():
+    raises(NotImplementedError, lambda: _separate_sq(x**(S(1)/3) + x))
+
+
+def test_minpoly_op_algebraic_element_not_impl():
+    raises(NotImplementedError,
+           lambda: _minpoly_op_algebraic_element(Pow, sqrt(2), sqrt(3), x, QQ))
+
+
+def test_minpoly_groebner():
+    assert _minpoly_groebner(S(2)/3, x, Poly) == 3*x - 2
+    assert _minpoly_groebner(
+        (sqrt(2) + 3)*(sqrt(2) + 1), x, Poly) == x**2 - 10*x - 7
+    assert _minpoly_groebner((sqrt(2) + 3)**(S(1)/3)*(sqrt(2) + 1)**(S(1)/3),
+                             x, Poly) == x**6 - 10*x**3 - 7
+    assert _minpoly_groebner((sqrt(2) + 3)**(-S(1)/3)*(sqrt(2) + 1)**(S(1)/3),
+                             x, Poly) == 7*x**6 - 2*x**3 - 1
+    raises(NotAlgebraic, lambda: _minpoly_groebner(pi**2, x, Poly))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_modules.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3c61c98e33d3c78e79eeed45efcfa1f74478645
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_modules.py
@@ -0,0 +1,752 @@
+from sympy.abc import x, zeta
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.domains import FF, QQ, ZZ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.numberfields.exceptions import (
+    ClosureFailure, MissingUnityError, StructureError
+)
+from sympy.polys.numberfields.modules import (
+    Module, ModuleElement, ModuleEndomorphism, PowerBasis, PowerBasisElement,
+    find_min_poly, is_sq_maxrank_HNF, make_mod_elt, to_col,
+)
+from sympy.polys.numberfields.utilities import is_int
+from sympy.polys.polyerrors import UnificationFailed
+from sympy.testing.pytest import raises
+
+
+def test_to_col():
+    c = [1, 2, 3, 4]
+    m = to_col(c)
+    assert m.domain.is_ZZ
+    assert m.shape == (4, 1)
+    assert m.flat() == c
+
+
+def test_Module_NotImplemented():
+    M = Module()
+    raises(NotImplementedError, lambda: M.n)
+    raises(NotImplementedError, lambda: M.mult_tab())
+    raises(NotImplementedError, lambda: M.represent(None))
+    raises(NotImplementedError, lambda: M.starts_with_unity())
+    raises(NotImplementedError, lambda: M.element_from_rational(QQ(2, 3)))
+
+
+def test_Module_ancestors():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = B.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert C.ancestors(include_self=True) == [A, B, C]
+    assert D.ancestors(include_self=True) == [A, B, D]
+    assert C.power_basis_ancestor() == A
+    assert C.nearest_common_ancestor(D) == B
+    M = Module()
+    assert M.power_basis_ancestor() is None
+
+
+def test_Module_compat_col():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    col = to_col([1, 2, 3, 4])
+    row = col.transpose()
+    assert A.is_compat_col(col) is True
+    assert A.is_compat_col(row) is False
+    assert A.is_compat_col(1) is False
+    assert A.is_compat_col(DomainMatrix.eye(3, ZZ)[:, 0]) is False
+    assert A.is_compat_col(DomainMatrix.eye(4, QQ)[:, 0]) is False
+    assert A.is_compat_col(DomainMatrix.eye(4, ZZ)[:, 0]) is True
+
+
+def test_Module_call():
+    T = Poly(cyclotomic_poly(5, x))
+    B = PowerBasis(T)
+    assert B(0).col.flat() == [1, 0, 0, 0]
+    assert B(1).col.flat() == [0, 1, 0, 0]
+    col = DomainMatrix.eye(4, ZZ)[:, 2]
+    assert B(col).col == col
+    raises(ValueError, lambda: B(-1))
+
+
+def test_Module_starts_with_unity():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.starts_with_unity() is True
+    assert B.starts_with_unity() is False
+
+
+def test_Module_basis_elements():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    basis = B.basis_elements()
+    bp = B.basis_element_pullbacks()
+    for i, (e, p) in enumerate(zip(basis, bp)):
+        c = [0] * 4
+        assert e.module == B
+        assert p.module == A
+        c[i] = 1
+        assert e == B(to_col(c))
+        c[i] = 2
+        assert p == A(to_col(c))
+
+
+def test_Module_zero():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.zero().col.flat() == [0, 0, 0, 0]
+    assert A.zero().module == A
+    assert B.zero().col.flat() == [0, 0, 0, 0]
+    assert B.zero().module == B
+
+
+def test_Module_one():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.one().col.flat() == [1, 0, 0, 0]
+    assert A.one().module == A
+    assert B.one().col.flat() == [1, 0, 0, 0]
+    assert B.one().module == A
+
+
+def test_Module_element_from_rational():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    rA = A.element_from_rational(QQ(22, 7))
+    rB = B.element_from_rational(QQ(22, 7))
+    assert rA.coeffs == [22, 0, 0, 0]
+    assert rA.denom == 7
+    assert rA.module == A
+    assert rB.coeffs == [22, 0, 0, 0]
+    assert rB.denom == 7
+    assert rB.module == A
+
+
+def test_Module_submodule_from_gens():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    gens = [2*A(0), 2*A(1), 6*A(0), 6*A(1)]
+    B = A.submodule_from_gens(gens)
+    # Because the 3rd and 4th generators do not add anything new, we expect
+    # the cols of the matrix of B to just reproduce the first two gens:
+    M = gens[0].column().hstack(gens[1].column())
+    assert B.matrix == M
+    # At least one generator must be provided:
+    raises(ValueError, lambda: A.submodule_from_gens([]))
+    # All generators must belong to A:
+    raises(ValueError, lambda: A.submodule_from_gens([3*A(0), B(0)]))
+
+
+def test_Module_submodule_from_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    e = B(to_col([1, 2, 3, 4]))
+    f = e.to_parent()
+    assert f.col.flat() == [2, 4, 6, 8]
+    # Matrix must be over ZZ:
+    raises(ValueError, lambda: A.submodule_from_matrix(DomainMatrix.eye(4, QQ)))
+    # Number of rows of matrix must equal number of generators of module A:
+    raises(ValueError, lambda: A.submodule_from_matrix(2 * DomainMatrix.eye(5, ZZ)))
+
+
+def test_Module_whole_submodule():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.whole_submodule()
+    e = B(to_col([1, 2, 3, 4]))
+    f = e.to_parent()
+    assert f.col.flat() == [1, 2, 3, 4]
+    e0, e1, e2, e3 = B(0), B(1), B(2), B(3)
+    assert e2 * e3 == e0
+    assert e3 ** 2 == e1
+
+
+def test_PowerBasis_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    assert repr(A) == 'PowerBasis(x**4 + x**3 + x**2 + x + 1)'
+
+
+def test_PowerBasis_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = PowerBasis(T)
+    assert A == B
+
+
+def test_PowerBasis_mult_tab():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    M = A.mult_tab()
+    exp = {0: {0: [1, 0, 0, 0], 1: [0, 1, 0, 0], 2: [0, 0, 1, 0], 3: [0, 0, 0, 1]},
+           1: {1: [0, 0, 1, 0], 2: [0, 0, 0, 1], 3: [-1, -1, -1, -1]},
+           2: {2: [-1, -1, -1, -1], 3: [1, 0, 0, 0]},
+           3: {3: [0, 1, 0, 0]}}
+    # We get the table we expect:
+    assert M == exp
+    # And all entries are of expected type:
+    assert all(is_int(c) for u in M for v in M[u] for c in M[u][v])
+
+
+def test_PowerBasis_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    col = to_col([1, 2, 3, 4])
+    a = A(col)
+    assert A.represent(a) == col
+    b = A(col, denom=2)
+    raises(ClosureFailure, lambda: A.represent(b))
+
+
+def test_PowerBasis_element_from_poly():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    f = Poly(1 + 2*x)
+    g = Poly(x**4)
+    h = Poly(0, x)
+    assert A.element_from_poly(f).coeffs == [1, 2, 0, 0]
+    assert A.element_from_poly(g).coeffs == [-1, -1, -1, -1]
+    assert A.element_from_poly(h).coeffs == [0, 0, 0, 0]
+
+
+def test_PowerBasis_element__conversions():
+    k = QQ.cyclotomic_field(5)
+    L = QQ.cyclotomic_field(7)
+    B = PowerBasis(k)
+
+    # ANP --> PowerBasisElement
+    a = k([QQ(1, 2), QQ(1, 3), 5, 7])
+    e = B.element_from_ANP(a)
+    assert e.coeffs == [42, 30, 2, 3]
+    assert e.denom == 6
+
+    # PowerBasisElement --> ANP
+    assert e.to_ANP() == a
+
+    # Cannot convert ANP from different field
+    d = L([QQ(1, 2), QQ(1, 3), 5, 7])
+    raises(UnificationFailed, lambda: B.element_from_ANP(d))
+
+    # AlgebraicNumber --> PowerBasisElement
+    alpha = k.to_alg_num(a)
+    eps = B.element_from_alg_num(alpha)
+    assert eps.coeffs == [42, 30, 2, 3]
+    assert eps.denom == 6
+
+    # PowerBasisElement --> AlgebraicNumber
+    assert eps.to_alg_num() == alpha
+
+    # Cannot convert AlgebraicNumber from different field
+    delta = L.to_alg_num(d)
+    raises(UnificationFailed, lambda: B.element_from_alg_num(delta))
+
+    # When we don't know the field:
+    C = PowerBasis(k.ext.minpoly)
+    # Can convert from AlgebraicNumber:
+    eps = C.element_from_alg_num(alpha)
+    assert eps.coeffs == [42, 30, 2, 3]
+    assert eps.denom == 6
+    # But can't convert back:
+    raises(StructureError, lambda: eps.to_alg_num())
+
+
+def test_Submodule_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert repr(B) == 'Submodule[[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]/3'
+
+
+def test_Submodule_reduced():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    D = C.reduced()
+    assert D.denom == 1 and D == C == B
+
+
+def test_Submodule_discard_before():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    B.compute_mult_tab()
+    C = B.discard_before(2)
+    assert C.parent == B.parent
+    assert B.is_sq_maxrank_HNF() and not C.is_sq_maxrank_HNF()
+    assert C.matrix == B.matrix[:, 2:]
+    assert C.mult_tab() == {0: {0: [-2, -2], 1: [0, 0]}, 1: {1: [0, 0]}}
+
+
+def test_Submodule_QQ_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert C.QQ_matrix == B.QQ_matrix
+
+
+def test_Submodule_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    a0 = A(to_col([6, 12, 18, 24]))
+    a1 = A(to_col([2, 4, 6, 8]))
+    a2 = A(to_col([1, 3, 5, 7]))
+
+    b1 = B.represent(a1)
+    assert b1.flat() == [1, 2, 3, 4]
+
+    c0 = C.represent(a0)
+    assert c0.flat() == [1, 2, 3, 4]
+
+    Y = A.submodule_from_matrix(DomainMatrix([
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+    ], (3, 4), ZZ).transpose())
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    z0 = Z(to_col([1, 2, 3, 4, 5, 6]))
+
+    raises(ClosureFailure, lambda: Y.represent(A(3)))
+    raises(ClosureFailure, lambda: B.represent(a2))
+    raises(ClosureFailure, lambda: B.represent(z0))
+
+
+def test_Submodule_is_compat_submodule():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = C.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert B.is_compat_submodule(C) is True
+    assert B.is_compat_submodule(A) is False
+    assert B.is_compat_submodule(D) is False
+
+
+def test_Submodule_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert C == B
+
+
+def test_Submodule_add():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(DomainMatrix([
+        [4, 0, 0, 0],
+        [0, 4, 0, 0],
+    ], (2, 4), ZZ).transpose(), denom=6)
+    C = A.submodule_from_matrix(DomainMatrix([
+        [0, 10, 0, 0],
+        [0,  0, 7, 0],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    D = A.submodule_from_matrix(DomainMatrix([
+        [20,  0,  0, 0],
+        [ 0, 20,  0, 0],
+        [ 0,  0, 14, 0],
+    ], (3, 4), ZZ).transpose(), denom=30)
+    assert B + C == D
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    Y = Z.submodule_from_gens([Z(0), Z(1)])
+    raises(TypeError, lambda: B + Y)
+
+
+def test_Submodule_mul():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(DomainMatrix([
+        [0, 10, 0, 0],
+        [0, 0, 7, 0],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    C1 = A.submodule_from_matrix(DomainMatrix([
+        [0, 20, 0, 0],
+        [0, 0, 14, 0],
+    ], (2, 4), ZZ).transpose(), denom=3)
+    C2 = A.submodule_from_matrix(DomainMatrix([
+        [0, 0, 10, 0],
+        [0, 0,  0, 7],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    C3_unred = A.submodule_from_matrix(DomainMatrix([
+        [0, 0, 100, 0],
+        [0, 0, 0, 70],
+        [0, 0, 0, 70],
+        [-49, -49, -49, -49]
+    ], (4, 4), ZZ).transpose(), denom=225)
+    C3 = A.submodule_from_matrix(DomainMatrix([
+        [4900, 4900, 0, 0],
+        [4410, 4410, 10, 0],
+        [2107, 2107, 7, 7]
+    ], (3, 4), ZZ).transpose(), denom=225)
+    assert C * 1 == C
+    assert C ** 1 == C
+    assert C * 10 == C1
+    assert C * A(1) == C2
+    assert C.mul(C, hnf=False) == C3_unred
+    assert C * C == C3
+    assert C ** 2 == C3
+
+
+def test_Submodule_reduce_element():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.whole_submodule()
+    b = B(to_col([90, 84, 80, 75]), denom=120)
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=2)
+    b_bar_expected = B(to_col([30, 24, 20, 15]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=4)
+    b_bar_expected = B(to_col([0, 24, 20, 15]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=8)
+    b_bar_expected = B(to_col([0, 9, 5, 0]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    a = A(to_col([1, 2, 3, 4]))
+    raises(NotImplementedError, lambda: C.reduce_element(a))
+
+    C = B.submodule_from_matrix(DomainMatrix([
+        [5, 4, 3, 2],
+        [0, 8, 7, 6],
+        [0, 0,11,12],
+        [0, 0, 0, 1]
+    ], (4, 4), ZZ).transpose())
+    raises(StructureError, lambda: C.reduce_element(b))
+
+
+def test_is_HNF():
+    M = DM([
+        [3, 2, 1],
+        [0, 2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    M1 = DM([
+        [3, 2, 1],
+        [0, -2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    M2 = DM([
+        [3, 2, 3],
+        [0, 2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    assert is_sq_maxrank_HNF(M) is True
+    assert is_sq_maxrank_HNF(M1) is False
+    assert is_sq_maxrank_HNF(M2) is False
+
+
+def test_make_mod_elt():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    col = to_col([1, 2, 3, 4])
+    eA = make_mod_elt(A, col)
+    eB = make_mod_elt(B, col)
+    assert isinstance(eA, PowerBasisElement)
+    assert not isinstance(eB, PowerBasisElement)
+
+
+def test_ModuleElement_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=2)
+    assert repr(e) == '[1, 2, 3, 4]/2'
+
+
+def test_ModuleElement_reduced():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([2, 4, 6, 8]), denom=2)
+    f = e.reduced()
+    assert f.denom == 1 and f == e
+
+
+def test_ModuleElement_reduced_mod_p():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([20, 40, 60, 80]))
+    f = e.reduced_mod_p(7)
+    assert f.coeffs == [-1, -2, -3, 3]
+
+
+def test_ModuleElement_from_int_list():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    c = [1, 2, 3, 4]
+    assert ModuleElement.from_int_list(A, c).coeffs == c
+
+
+def test_ModuleElement_len():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(0)
+    assert len(e) == 4
+
+
+def test_ModuleElement_column():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(0)
+    col1 = e.column()
+    assert col1 == e.col and col1 is not e.col
+    col2 = e.column(domain=FF(5))
+    assert col2.domain.is_FF
+
+
+def test_ModuleElement_QQ_col():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e.QQ_col == f.QQ_col
+
+
+def test_ModuleElement_to_ancestors():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = C.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    eD = D(0)
+    eC = eD.to_parent()
+    eB = eD.to_ancestor(B)
+    eA = eD.over_power_basis()
+    assert eC.module is C and eC.coeffs == [5, 0, 0, 0]
+    assert eB.module is B and eB.coeffs == [15, 0, 0, 0]
+    assert eA.module is A and eA.coeffs == [30, 0, 0, 0]
+
+    a = A(0)
+    raises(ValueError, lambda: a.to_parent())
+
+
+def test_ModuleElement_compatibility():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = B.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert C(0).is_compat(C(1)) is True
+    assert C(0).is_compat(D(0)) is False
+    u, v = C(0).unify(D(0))
+    assert u.module is B and v.module is B
+    assert C(C.represent(u)) == C(0) and D(D.represent(v)) == D(0)
+
+    u, v = C(0).unify(C(1))
+    assert u == C(0) and v == C(1)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(UnificationFailed, lambda: C(0).unify(Z(1)))
+
+
+def test_ModuleElement_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e == f
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    assert e != Z(0)
+    assert e != 3.14
+
+
+def test_ModuleElement_equiv():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e.equiv(f)
+
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    g = C(to_col([1, 2, 3, 4]), denom=1)
+    h = A(to_col([3, 6, 9, 12]), denom=1)
+    assert g.equiv(h)
+    assert C(to_col([5, 0, 0, 0]), denom=7).equiv(QQ(15, 7))
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(UnificationFailed, lambda: e.equiv(Z(0)))
+
+    assert e.equiv(3.14) is False
+
+
+def test_ModuleElement_add():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([1, 2, 3, 4]), denom=6)
+    f = A(to_col([5, 6, 7, 8]), denom=10)
+    g = C(to_col([1, 1, 1, 1]), denom=2)
+    assert e + f == A(to_col([10, 14, 18, 22]), denom=15)
+    assert e - f == A(to_col([-5, -4, -3, -2]), denom=15)
+    assert e + g == A(to_col([10, 11, 12, 13]), denom=6)
+    assert e + QQ(7, 10) == A(to_col([26, 10, 15, 20]), denom=30)
+    assert g + QQ(7, 10) == A(to_col([22, 15, 15, 15]), denom=10)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(TypeError, lambda: e + Z(0))
+    raises(TypeError, lambda: e + 3.14)
+
+
+def test_ModuleElement_mul():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    f = A(to_col([0, 0, 0, 7]), denom=5)
+    g = C(to_col([0, 0, 0, 1]), denom=2)
+    h = A(to_col([0, 0, 3, 1]), denom=7)
+    assert e * f == A(to_col([-14, -14, -14, -14]), denom=15)
+    assert e * g == A(to_col([-1, -1, -1, -1]))
+    assert e * h == A(to_col([-2, -2, -2, 4]), denom=21)
+    assert e * QQ(6, 5) == A(to_col([0, 4, 0, 0]), denom=5)
+    assert (g * QQ(10, 21)).equiv(A(to_col([0, 0, 0, 5]), denom=7))
+    assert e // QQ(6, 5) == A(to_col([0, 5, 0, 0]), denom=9)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(TypeError, lambda: e * Z(0))
+    raises(TypeError, lambda: e * 3.14)
+    raises(TypeError, lambda: e // 3.14)
+    raises(ZeroDivisionError, lambda: e // 0)
+
+
+def test_ModuleElement_div():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    f = A(to_col([0, 0, 0, 7]), denom=5)
+    g = C(to_col([1, 1, 1, 1]))
+    assert e // f == 10*A(3)//21
+    assert e // g == -2*A(2)//9
+    assert 3 // g == -A(1)
+
+
+def test_ModuleElement_pow():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    g = C(to_col([0, 0, 0, 1]), denom=2)
+    assert e ** 3 == A(to_col([0, 0, 0, 8]), denom=27)
+    assert g ** 2 == C(to_col([0, 3, 0, 0]), denom=4)
+    assert e ** 0 == A(to_col([1, 0, 0, 0]))
+    assert g ** 0 == A(to_col([1, 0, 0, 0]))
+    assert e ** 1 == e
+    assert g ** 1 == g
+
+
+def test_ModuleElement_mod():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 15, 8, 0]), denom=2)
+    assert e % 7 == A(to_col([1, 1, 8, 0]), denom=2)
+    assert e % QQ(1, 2) == A.zero()
+    assert e % QQ(1, 3) == A(to_col([1, 1, 0, 0]), denom=6)
+
+    B = A.submodule_from_gens([A(0), 5*A(1), 3*A(2), A(3)])
+    assert e % B == A(to_col([1, 5, 2, 0]), denom=2)
+
+    C = B.whole_submodule()
+    raises(TypeError, lambda: e % C)
+
+
+def test_PowerBasisElement_polys():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 15, 8, 0]), denom=2)
+    assert e.numerator(x=zeta) == Poly(8 * zeta ** 2 + 15 * zeta + 1, domain=ZZ)
+    assert e.poly(x=zeta) == Poly(4 * zeta ** 2 + QQ(15, 2) * zeta + QQ(1, 2), domain=QQ)
+
+
+def test_PowerBasisElement_norm():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    lam = A(to_col([1, -1, 0, 0]))
+    assert lam.norm() == 5
+
+
+def test_PowerBasisElement_inverse():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 1, 1, 1]))
+    assert 2 // e == -2*A(1)
+    assert e ** -3 == -A(3)
+
+
+def test_ModuleHomomorphism_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    phi = ModuleEndomorphism(A, lambda a: a ** 2)
+    M = phi.matrix()
+    assert M == DomainMatrix([
+        [1, 0, -1, 0],
+        [0, 0, -1, 1],
+        [0, 1, -1, 0],
+        [0, 0, -1, 0]
+    ], (4, 4), ZZ)
+
+
+def test_ModuleHomomorphism_kernel():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    phi = ModuleEndomorphism(A, lambda a: a ** 5)
+    N = phi.kernel()
+    assert N.n == 3
+
+
+def test_EndomorphismRing_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    R = A.endomorphism_ring()
+    phi = R.inner_endomorphism(A(1))
+    col = R.represent(phi)
+    assert col.transpose() == DomainMatrix([
+        [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1]
+    ], (1, 16), ZZ)
+
+    B = A.submodule_from_matrix(DomainMatrix.zeros((4, 0), ZZ))
+    S = B.endomorphism_ring()
+    psi = S.inner_endomorphism(A(1))
+    col = S.represent(psi)
+    assert col == DomainMatrix([], (0, 0), ZZ)
+
+    raises(NotImplementedError, lambda: R.represent(3.14))
+
+
+def test_find_min_poly():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    powers = []
+    m = find_min_poly(A(1), QQ, x=x, powers=powers)
+    assert m == Poly(T, domain=QQ)
+    assert len(powers) == 5
+
+    # powers list need not be passed
+    m = find_min_poly(A(1), QQ, x=x)
+    assert m == Poly(T, domain=QQ)
+
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    raises(MissingUnityError, lambda: find_min_poly(B(1), QQ))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_numbers.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8f350719cc740901a29d03e45ae9f3978446f31
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_numbers.py
@@ -0,0 +1,202 @@
+"""Tests on algebraic numbers. """
+
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (AlgebraicNumber, I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import Poly
+from sympy.polys.numberfields.subfield import to_number_field
+from sympy.polys.polyclasses import DMP
+from sympy.polys.domains import QQ
+from sympy.polys.rootoftools import CRootOf
+from sympy.abc import x, y
+
+
+def test_AlgebraicNumber():
+    minpoly, root = x**2 - 2, sqrt(2)
+
+    a = AlgebraicNumber(root, gen=x)
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S.Zero]
+    assert a.native_coeffs() == [QQ(1), QQ(0)]
+
+    a = AlgebraicNumber(root, gen=x, alias='y')
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    a = AlgebraicNumber(root, gen=x, alias=Symbol('y'))
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    assert AlgebraicNumber(sqrt(2), []).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), ()).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), (0, 0)).rep == DMP([], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [8]).rep == DMP([QQ(8)], QQ)
+    assert AlgebraicNumber(sqrt(2), [Rational(8, 3)]).rep == DMP([QQ(8, 3)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [7, 3]).rep == DMP([QQ(7), QQ(3)], QQ)
+    assert AlgebraicNumber(
+        sqrt(2), [Rational(7, 9), Rational(3, 2)]).rep == DMP([QQ(7, 9), QQ(3, 2)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [1, 2, 3]).rep == DMP([QQ(2), QQ(5)], QQ)
+
+    a = AlgebraicNumber(AlgebraicNumber(root, gen=x), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S(2)]
+    assert a.native_coeffs() == [QQ(1), QQ(2)]
+
+    a = AlgebraicNumber((minpoly, root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    a = AlgebraicNumber((Poly(minpoly), root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert AlgebraicNumber( sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+    assert AlgebraicNumber(-sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(2))
+
+    assert a == b
+
+    c = AlgebraicNumber(sqrt(2), gen=x)
+
+    assert a == b
+    assert a == c
+
+    a = AlgebraicNumber(sqrt(2), [1, 2])
+    b = AlgebraicNumber(sqrt(2), [1, 3])
+
+    assert a != b and a != sqrt(2) + 3
+
+    assert (a == x) is False and (a != x) is True
+
+    a = AlgebraicNumber(sqrt(2), [1, 0])
+    b = AlgebraicNumber(sqrt(2), [1, 0], alias=y)
+
+    assert a.as_poly(x) == Poly(x, domain='QQ')
+    assert b.as_poly() == Poly(y, domain='QQ')
+
+    assert a.as_expr() == sqrt(2)
+    assert a.as_expr(x) == x
+    assert b.as_expr() == sqrt(2)
+    assert b.as_expr(x) == x
+
+    a = AlgebraicNumber(sqrt(2), [2, 3])
+    b = AlgebraicNumber(sqrt(2), [2, 3], alias=y)
+
+    p = a.as_poly()
+
+    assert p == Poly(2*p.gen + 3)
+
+    assert a.as_poly(x) == Poly(2*x + 3, domain='QQ')
+    assert b.as_poly() == Poly(2*y + 3, domain='QQ')
+
+    assert a.as_expr() == 2*sqrt(2) + 3
+    assert a.as_expr(x) == 2*x + 3
+    assert b.as_expr() == 2*sqrt(2) + 3
+    assert b.as_expr(x) == 2*x + 3
+
+    a = AlgebraicNumber(sqrt(2))
+    b = to_number_field(sqrt(2))
+    assert a.args == b.args == (sqrt(2), Tuple(1, 0))
+    b = AlgebraicNumber(sqrt(2), alias='alpha')
+    assert b.args == (sqrt(2), Tuple(1, 0), Symbol('alpha'))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2, 3])
+    assert a.args == (sqrt(2), Tuple(1, 2, 3))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2], "alpha")
+    b = AlgebraicNumber(a)
+    c = AlgebraicNumber(a, alias="gamma")
+    assert a == b
+    assert c.alias.name == "gamma"
+
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0])
+    b = AlgebraicNumber(a, [1, 0, 0])
+    assert b.root == a.root
+    assert a.to_root() == sqrt(2)
+    assert b.to_root() == 2
+
+    a = AlgebraicNumber(2)
+    assert a.is_primitive_element is True
+
+
+def test_to_algebraic_integer():
+    a = AlgebraicNumber(sqrt(3), gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 3
+    assert a.root == sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(2*sqrt(3), gen=x).to_algebraic_integer()
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, [Rational(7, 19), 3], gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(7, 19), QQ(3)], QQ)
+
+
+def test_AlgebraicNumber_to_root():
+    assert AlgebraicNumber(sqrt(2)).to_root() == sqrt(2)
+
+    zeta5_squared = AlgebraicNumber(CRootOf(x**5 - 1, 4), coeffs=[1, 0, 0])
+    assert zeta5_squared.to_root() == CRootOf(x**4 + x**3 + x**2 + x + 1, 1)
+
+    zeta3_squared = AlgebraicNumber(CRootOf(x**3 - 1, 2), coeffs=[1, 0, 0])
+    assert zeta3_squared.to_root() == -S(1)/2 - sqrt(3)*I/2
+    assert zeta3_squared.to_root(radicals=False) == CRootOf(x**2 + x + 1, 0)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_primes.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_primes.py
new file mode 100644
index 0000000000000000000000000000000000000000..f121d60d272fe65345de773748828a8a67eb0028
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_primes.py
@@ -0,0 +1,296 @@
+from math import prod
+
+from sympy import QQ, ZZ
+from sympy.abc import x, theta
+from sympy.ntheory import factorint
+from sympy.ntheory.residue_ntheory import n_order
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.matrices import DomainMatrix
+from sympy.polys.numberfields.basis import round_two
+from sympy.polys.numberfields.exceptions import StructureError
+from sympy.polys.numberfields.modules import PowerBasis, to_col
+from sympy.polys.numberfields.primes import (
+    prime_decomp, _two_elt_rep,
+    _check_formal_conditions_for_maximal_order,
+)
+from sympy.testing.pytest import raises
+
+
+def test_check_formal_conditions_for_maximal_order():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = A.submodule_from_matrix(DomainMatrix.eye(4, ZZ)[:, :-1])
+    # Is a direct submodule of a power basis, but lacks 1 as first generator:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(B))
+    # Is not a direct submodule of a power basis:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(C))
+    # Is direct submod of pow basis, and starts with 1, but not sq/max rank/HNF:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(D))
+
+
+def test_two_elt_rep():
+    ell = 7
+    T = Poly(cyclotomic_poly(ell))
+    ZK, dK = round_two(T)
+    for p in [29, 13, 11, 5]:
+        P = prime_decomp(p, T)
+        for Pi in P:
+            # We have Pi in two-element representation, and, because we are
+            # looking at a cyclotomic field, this was computed by the "easy"
+            # method that just factors T mod p. We will now convert this to
+            # a set of Z-generators, then convert that back into a two-element
+            # rep. The latter need not be identical to the two-elt rep we
+            # already have, but it must have the same HNF.
+            H = p*ZK + Pi.alpha*ZK
+            gens = H.basis_element_pullbacks()
+            # Note: we could supply f = Pi.f, but prefer to test behavior without it.
+            b = _two_elt_rep(gens, ZK, p)
+            if b != Pi.alpha:
+                H2 = p*ZK + b*ZK
+                assert H2 == H
+
+
+def test_valuation_at_prime_ideal():
+    p = 7
+    T = Poly(cyclotomic_poly(p))
+    ZK, dK = round_two(T)
+    P = prime_decomp(p, T, dK=dK, ZK=ZK)
+    assert len(P) == 1
+    P0 = P[0]
+    v = P0.valuation(p*ZK)
+    assert v == P0.e
+    # Test easy 0 case:
+    assert P0.valuation(5*ZK) == 0
+
+
+def test_decomp_1():
+    # All prime decompositions in cyclotomic fields are in the "easy case,"
+    # since the index is unity.
+    # Here we check the ramified prime.
+    T = Poly(cyclotomic_poly(7))
+    raises(ValueError, lambda: prime_decomp(7))
+    P = prime_decomp(7, T)
+    assert len(P) == 1
+    P0 = P[0]
+    assert P0.e == 6
+    assert P0.f == 1
+    # Test powers:
+    assert P0**0 == P0.ZK
+    assert P0**1 == P0
+    assert P0**6 == 7 * P0.ZK
+
+
+def test_decomp_2():
+    # More easy cyclotomic cases, but here we check unramified primes.
+    ell = 7
+    T = Poly(cyclotomic_poly(ell))
+    for p in [29, 13, 11, 5]:
+        f_exp = n_order(p, ell)
+        g_exp = (ell - 1) // f_exp
+        P = prime_decomp(p, T)
+        assert len(P) == g_exp
+        for Pi in P:
+            assert Pi.e == 1
+            assert Pi.f == f_exp
+
+
+def test_decomp_3():
+    T = Poly(x ** 2 - 35)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    # 35 is 3 mod 4, so field disc is 4*5*7, and theory says each of the
+    # rational primes 2, 5, 7 should be the square of a prime ideal.
+    for p in [2, 5, 7]:
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        assert len(P) == 1
+        assert P[0].e == 2
+        assert P[0]**2 == p*ZK
+
+
+def test_decomp_4():
+    T = Poly(x ** 2 - 21)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    # 21 is 1 mod 4, so field disc is 3*7, and theory says the
+    # rational primes 3, 7 should be the square of a prime ideal.
+    for p in [3, 7]:
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        assert len(P) == 1
+        assert P[0].e == 2
+        assert P[0]**2 == p*ZK
+
+
+def test_decomp_5():
+    # Here is our first test of the "hard case" of prime decomposition.
+    # We work in a quadratic extension Q(sqrt(d)) where d is 1 mod 4, and
+    # we consider the factorization of the rational prime 2, which divides
+    # the index.
+    # Theory says the form of p's factorization depends on the residue of
+    # d mod 8, so we consider both cases, d = 1 mod 8 and d = 5 mod 8.
+    for d in [-7, -3]:
+        T = Poly(x ** 2 - d)
+        rad = {}
+        ZK, dK = round_two(T, radicals=rad)
+        p = 2
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        if d % 8 == 1:
+            assert len(P) == 2
+            assert all(P[i].e == 1 and P[i].f == 1 for i in range(2))
+            assert prod(Pi**Pi.e for Pi in P) == p * ZK
+        else:
+            assert d % 8 == 5
+            assert len(P) == 1
+            assert P[0].e == 1
+            assert P[0].f == 2
+            assert P[0].as_submodule() == p * ZK
+
+
+def test_decomp_6():
+    # Another case where 2 divides the index. This is Dedekind's example of
+    # an essential discriminant divisor. (See Cohen, Exercise 6.10.)
+    T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    p = 2
+    P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+    assert len(P) == 3
+    assert all(Pi.e == Pi.f == 1 for Pi in P)
+    assert prod(Pi**Pi.e for Pi in P) == p*ZK
+
+
+def test_decomp_7():
+    # Try working through an AlgebraicField
+    T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    K = QQ.alg_field_from_poly(T)
+    p = 2
+    P = K.primes_above(p)
+    ZK = K.maximal_order()
+    assert len(P) == 3
+    assert all(Pi.e == Pi.f == 1 for Pi in P)
+    assert prod(Pi**Pi.e for Pi in P) == p*ZK
+
+
+def test_decomp_8():
+    # This time we consider various cubics, and try factoring all primes
+    # dividing the index.
+    cases = (
+        x ** 3 + 3 * x ** 2 - 4 * x + 4,
+        x ** 3 + 3 * x ** 2 + 3 * x - 3,
+        x ** 3 + 5 * x ** 2 - x + 3,
+        x ** 3 + 5 * x ** 2 - 5 * x - 5,
+        x ** 3 + 3 * x ** 2 + 5,
+        x ** 3 + 6 * x ** 2 + 3 * x - 1,
+        x ** 3 + 6 * x ** 2 + 4,
+        x ** 3 + 7 * x ** 2 + 7 * x - 7,
+        x ** 3 + 7 * x ** 2 - x + 5,
+        x ** 3 + 7 * x ** 2 - 5 * x + 5,
+        x ** 3 + 4 * x ** 2 - 3 * x + 7,
+        x ** 3 + 8 * x ** 2 + 5 * x - 1,
+        x ** 3 + 8 * x ** 2 - 2 * x + 6,
+        x ** 3 + 6 * x ** 2 - 3 * x + 8,
+        x ** 3 + 9 * x ** 2 + 6 * x - 8,
+        x ** 3 + 15 * x ** 2 - 9 * x + 13,
+    )
+    def display(T, p, radical, P, I, J):
+        """Useful for inspection, when running test manually."""
+        print('=' * 20)
+        print(T, p, radical)
+        for Pi in P:
+            print(f'  ({Pi!r})')
+        print("I: ", I)
+        print("J: ", J)
+        print(f'Equal: {I == J}')
+    inspect = False
+    for g in cases:
+        T = Poly(g)
+        rad = {}
+        ZK, dK = round_two(T, radicals=rad)
+        dT = T.discriminant()
+        f_squared = dT // dK
+        F = factorint(f_squared)
+        for p in F:
+            radical = rad.get(p)
+            P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=radical)
+            I = prod(Pi**Pi.e for Pi in P)
+            J = p * ZK
+            if inspect:
+                display(T, p, radical, P, I, J)
+            assert I == J
+
+
+def test_PrimeIdeal_eq():
+    # `==` should fail on objects of different types, so even a completely
+    # inert PrimeIdeal should test unequal to the rational prime it divides.
+    T = Poly(cyclotomic_poly(7))
+    P0 = prime_decomp(5, T)[0]
+    assert P0.f == 6
+    assert P0.as_submodule() == 5 * P0.ZK
+    assert P0 != 5
+
+
+def test_PrimeIdeal_add():
+    T = Poly(cyclotomic_poly(7))
+    P0 = prime_decomp(7, T)[0]
+    # Adding ideals computes their GCD, so adding the ramified prime dividing
+    # 7 to 7 itself should reproduce this prime (as a submodule).
+    assert P0 + 7 * P0.ZK == P0.as_submodule()
+
+
+def test_str():
+    # Without alias:
+    k = QQ.alg_field_from_poly(Poly(x**2 + 7))
+    frp = k.primes_above(2)[0]
+    assert str(frp) == '(2, 3*_x/2 + 1/2)'
+
+    frp = k.primes_above(3)[0]
+    assert str(frp) == '(3)'
+
+    # With alias:
+    k = QQ.alg_field_from_poly(Poly(x ** 2 + 7), alias='alpha')
+    frp = k.primes_above(2)[0]
+    assert str(frp) == '(2, 3*alpha/2 + 1/2)'
+
+    frp = k.primes_above(3)[0]
+    assert str(frp) == '(3)'
+
+
+def test_repr():
+    T = Poly(x**2 + 7)
+    ZK, dK = round_two(T)
+    P = prime_decomp(2, T, dK=dK, ZK=ZK)
+    assert repr(P[0]) == '[ (2, (3*x + 1)/2) e=1, f=1 ]'
+    assert P[0].repr(field_gen=theta) == '[ (2, (3*theta + 1)/2) e=1, f=1 ]'
+    assert P[0].repr(field_gen=theta, just_gens=True) == '(2, (3*theta + 1)/2)'
+
+
+def test_PrimeIdeal_reduce():
+    k = QQ.alg_field_from_poly(Poly(x ** 3 + x ** 2 - 2 * x + 8))
+    Zk = k.maximal_order()
+    P = k.primes_above(2)
+    frp = P[2]
+
+    # reduce_element
+    a = Zk.parent(to_col([23, 20, 11]), denom=6)
+    a_bar_expected = Zk.parent(to_col([11, 5, 2]), denom=6)
+    a_bar = frp.reduce_element(a)
+    assert a_bar == a_bar_expected
+
+    # reduce_ANP
+    a = k([QQ(11, 6), QQ(20, 6), QQ(23, 6)])
+    a_bar_expected = k([QQ(2, 6), QQ(5, 6), QQ(11, 6)])
+    a_bar = frp.reduce_ANP(a)
+    assert a_bar == a_bar_expected
+
+    # reduce_alg_num
+    a = k.to_alg_num(a)
+    a_bar_expected = k.to_alg_num(a_bar_expected)
+    a_bar = frp.reduce_alg_num(a)
+    assert a_bar == a_bar_expected
+
+
+def test_issue_23402():
+    k = QQ.alg_field_from_poly(Poly(x ** 3 + x ** 2 - 2 * x + 8))
+    P = k.primes_above(3)
+    assert P[0].alpha.equiv(0)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_subfield.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_subfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..34b93229ce0821a88761eefc8c4d94a5a246ab66
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_subfield.py
@@ -0,0 +1,304 @@
+"""Tests for the subfield problem and allied problems. """
+
+from sympy.core.numbers import (AlgebraicNumber, I, pi, Rational)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.external.gmpy import MPQ
+from sympy.polys.numberfields.subfield import (
+    is_isomorphism_possible,
+    field_isomorphism_pslq,
+    field_isomorphism,
+    primitive_element,
+    to_number_field,
+)
+from sympy.polys.polyerrors import IsomorphismFailed
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.testing.pytest import raises
+
+from sympy.abc import x
+
+Q = Rational
+
+
+def test_field_isomorphism_pslq():
+    a = AlgebraicNumber(I)
+    b = AlgebraicNumber(I*sqrt(3))
+
+    raises(NotImplementedError, lambda: field_isomorphism_pslq(a, b))
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(3))
+    c = AlgebraicNumber(sqrt(7))
+    d = AlgebraicNumber(sqrt(2) + sqrt(3))
+    e = AlgebraicNumber(sqrt(2) + sqrt(3) + sqrt(7))
+
+    assert field_isomorphism_pslq(a, a) == [1, 0]
+    assert field_isomorphism_pslq(a, b) is None
+    assert field_isomorphism_pslq(a, c) is None
+    assert field_isomorphism_pslq(a, d) == [Q(1, 2), 0, -Q(9, 2), 0]
+    assert field_isomorphism_pslq(
+        a, e) == [Q(1, 80), 0, -Q(1, 2), 0, Q(59, 20), 0]
+
+    assert field_isomorphism_pslq(b, a) is None
+    assert field_isomorphism_pslq(b, b) == [1, 0]
+    assert field_isomorphism_pslq(b, c) is None
+    assert field_isomorphism_pslq(b, d) == [-Q(1, 2), 0, Q(11, 2), 0]
+    assert field_isomorphism_pslq(b, e) == [-Q(
+        3, 640), 0, Q(67, 320), 0, -Q(297, 160), 0, Q(313, 80), 0]
+
+    assert field_isomorphism_pslq(c, a) is None
+    assert field_isomorphism_pslq(c, b) is None
+    assert field_isomorphism_pslq(c, c) == [1, 0]
+    assert field_isomorphism_pslq(c, d) is None
+    assert field_isomorphism_pslq(c, e) == [Q(
+        3, 640), 0, -Q(71, 320), 0, Q(377, 160), 0, -Q(469, 80), 0]
+
+    assert field_isomorphism_pslq(d, a) is None
+    assert field_isomorphism_pslq(d, b) is None
+    assert field_isomorphism_pslq(d, c) is None
+    assert field_isomorphism_pslq(d, d) == [1, 0]
+    assert field_isomorphism_pslq(d, e) == [-Q(
+        3, 640), 0, Q(71, 320), 0, -Q(377, 160), 0, Q(549, 80), 0]
+
+    assert field_isomorphism_pslq(e, a) is None
+    assert field_isomorphism_pslq(e, b) is None
+    assert field_isomorphism_pslq(e, c) is None
+    assert field_isomorphism_pslq(e, d) is None
+    assert field_isomorphism_pslq(e, e) == [1, 0]
+
+    f = AlgebraicNumber(3*sqrt(2) + 8*sqrt(7) - 5)
+
+    assert field_isomorphism_pslq(
+        f, e) == [Q(3, 80), 0, -Q(139, 80), 0, Q(347, 20), 0, -Q(761, 20), -5]
+
+
+def test_field_isomorphism():
+    assert field_isomorphism(3, sqrt(2)) == [3]
+
+    assert field_isomorphism( I*sqrt(3), I*sqrt(3)/2) == [ 2, 0]
+    assert field_isomorphism(-I*sqrt(3), I*sqrt(3)/2) == [-2, 0]
+
+    assert field_isomorphism( I*sqrt(3), -I*sqrt(3)/2) == [-2, 0]
+    assert field_isomorphism(-I*sqrt(3), -I*sqrt(3)/2) == [ 2, 0]
+
+    assert field_isomorphism( 2*I*sqrt(3)/7, 5*I*sqrt(3)/3) == [ Rational(6, 35), 0]
+    assert field_isomorphism(-2*I*sqrt(3)/7, 5*I*sqrt(3)/3) == [Rational(-6, 35), 0]
+
+    assert field_isomorphism( 2*I*sqrt(3)/7, -5*I*sqrt(3)/3) == [Rational(-6, 35), 0]
+    assert field_isomorphism(-2*I*sqrt(3)/7, -5*I*sqrt(3)/3) == [ Rational(6, 35), 0]
+
+    assert field_isomorphism(
+        2*I*sqrt(3)/7 + 27, 5*I*sqrt(3)/3) == [ Rational(6, 35), 27]
+    assert field_isomorphism(
+        -2*I*sqrt(3)/7 + 27, 5*I*sqrt(3)/3) == [Rational(-6, 35), 27]
+
+    assert field_isomorphism(
+        2*I*sqrt(3)/7 + 27, -5*I*sqrt(3)/3) == [Rational(-6, 35), 27]
+    assert field_isomorphism(
+        -2*I*sqrt(3)/7 + 27, -5*I*sqrt(3)/3) == [ Rational(6, 35), 27]
+
+    p = AlgebraicNumber( sqrt(2) + sqrt(3))
+    q = AlgebraicNumber(-sqrt(2) + sqrt(3))
+    r = AlgebraicNumber( sqrt(2) - sqrt(3))
+    s = AlgebraicNumber(-sqrt(2) - sqrt(3))
+
+    pos_coeffs = [ S.Half, S.Zero, Rational(-9, 2), S.Zero]
+    neg_coeffs = [Rational(-1, 2), S.Zero, Rational(9, 2), S.Zero]
+
+    a = AlgebraicNumber(sqrt(2))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_coeffs
+
+    a = AlgebraicNumber(-sqrt(2))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == pos_coeffs
+    assert field_isomorphism(a, r, fast=True) == neg_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == pos_coeffs
+    assert field_isomorphism(a, r, fast=False) == neg_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    pos_coeffs = [ S.Half, S.Zero, Rational(-11, 2), S.Zero]
+    neg_coeffs = [Rational(-1, 2), S.Zero, Rational(11, 2), S.Zero]
+
+    a = AlgebraicNumber(sqrt(3))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    a = AlgebraicNumber(-sqrt(3))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_coeffs
+    assert field_isomorphism(a, q, fast=True) == pos_coeffs
+    assert field_isomorphism(a, r, fast=True) == neg_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_coeffs
+    assert field_isomorphism(a, q, fast=False) == pos_coeffs
+    assert field_isomorphism(a, r, fast=False) == neg_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_coeffs
+
+    pos_coeffs = [ Rational(3, 2), S.Zero, Rational(-33, 2), -S(8)]
+    neg_coeffs = [Rational(-3, 2), S.Zero, Rational(33, 2), -S(8)]
+
+    a = AlgebraicNumber(3*sqrt(3) - 8)
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    a = AlgebraicNumber(3*sqrt(2) + 2*sqrt(3) + 1)
+
+    pos_1_coeffs = [ S.Half, S.Zero, Rational(-5, 2), S.One]
+    neg_5_coeffs = [Rational(-5, 2), S.Zero, Rational(49, 2), S.One]
+    pos_5_coeffs = [ Rational(5, 2), S.Zero, Rational(-49, 2), S.One]
+    neg_1_coeffs = [Rational(-1, 2), S.Zero, Rational(5, 2), S.One]
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_1_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_5_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_5_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_1_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_1_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_5_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_5_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_1_coeffs
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(3))
+    c = AlgebraicNumber(sqrt(7))
+
+    assert is_isomorphism_possible(a, b) is True
+    assert is_isomorphism_possible(b, a) is True
+
+    assert is_isomorphism_possible(c, p) is False
+
+    assert field_isomorphism(sqrt(2), sqrt(3), fast=True) is None
+    assert field_isomorphism(sqrt(3), sqrt(2), fast=True) is None
+
+    assert field_isomorphism(sqrt(2), sqrt(3), fast=False) is None
+    assert field_isomorphism(sqrt(3), sqrt(2), fast=False) is None
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(2 ** (S(1) / 3))
+
+    assert is_isomorphism_possible(a, b) is False
+    assert field_isomorphism(a, b) is None
+
+
+def test_primitive_element():
+    assert primitive_element([sqrt(2)], x) == (x**2 - 2, [1])
+    assert primitive_element(
+        [sqrt(2), sqrt(3)], x) == (x**4 - 10*x**2 + 1, [1, 1])
+
+    assert primitive_element([sqrt(2)], x, polys=True) == (Poly(x**2 - 2, domain='QQ'), [1])
+    assert primitive_element([sqrt(
+        2), sqrt(3)], x, polys=True) == (Poly(x**4 - 10*x**2 + 1, domain='QQ'), [1, 1])
+
+    assert primitive_element(
+        [sqrt(2)], x, ex=True) == (x**2 - 2, [1], [[1, 0]])
+    assert primitive_element([sqrt(2), sqrt(3)], x, ex=True) == \
+        (x**4 - 10*x**2 + 1, [1, 1], [[Q(1, 2), 0, -Q(9, 2), 0], [-
+         Q(1, 2), 0, Q(11, 2), 0]])
+
+    assert primitive_element(
+        [sqrt(2)], x, ex=True, polys=True) == (Poly(x**2 - 2, domain='QQ'), [1], [[1, 0]])
+    assert primitive_element([sqrt(2), sqrt(3)], x, ex=True, polys=True) == \
+        (Poly(x**4 - 10*x**2 + 1, domain='QQ'), [1, 1], [[Q(1, 2), 0, -Q(9, 2),
+         0], [-Q(1, 2), 0, Q(11, 2), 0]])
+
+    assert primitive_element([sqrt(2)], polys=True) == (Poly(x**2 - 2), [1])
+
+    raises(ValueError, lambda: primitive_element([], x, ex=False))
+    raises(ValueError, lambda: primitive_element([], x, ex=True))
+
+    # Issue 14117
+    a, b = I*sqrt(2*sqrt(2) + 3), I*sqrt(-2*sqrt(2) + 3)
+    assert primitive_element([a, b, I], x) == (x**4 + 6*x**2 + 1, [1, 0, 0])
+
+    assert primitive_element([sqrt(2), 0], x) == (x**2 - 2, [1, 0])
+    assert primitive_element([0, sqrt(2)], x) == (x**2 - 2, [1, 1])
+    assert primitive_element([sqrt(2), 0], x, ex=True) == (x**2 - 2, [1, 0], [[MPQ(1,1), MPQ(0,1)], []])
+    assert primitive_element([0, sqrt(2)], x, ex=True) == (x**2 - 2, [1, 1], [[], [MPQ(1,1), MPQ(0,1)]])
+
+
+def test_to_number_field():
+    assert to_number_field(sqrt(2)) == AlgebraicNumber(sqrt(2))
+    assert to_number_field(
+        [sqrt(2), sqrt(3)]) == AlgebraicNumber(sqrt(2) + sqrt(3))
+
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S.Half, S.Zero, Rational(-9, 2), S.Zero])
+
+    assert to_number_field(sqrt(2), sqrt(2) + sqrt(3)) == a
+    assert to_number_field(sqrt(2), AlgebraicNumber(sqrt(2) + sqrt(3))) == a
+
+    raises(IsomorphismFailed, lambda: to_number_field(sqrt(2), sqrt(3)))
+
+
+def test_issue_22561():
+    a = to_number_field(sqrt(2), sqrt(2) + sqrt(3))
+    b = to_number_field(sqrt(2), sqrt(2) + sqrt(5))
+    assert field_isomorphism(a, b) == [1, 0]
+
+
+def test_issue_22736():
+    a = CRootOf(x**4 + x**3 + x**2 + x + 1, -1)
+    a._reset()
+    b = exp(2*I*pi/5)
+    assert field_isomorphism(a, b) == [1, 0]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/utilities.py b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/utilities.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cf8e42e9823277ecd0483eab538fc927cb84b8b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/polys/numberfields/utilities.py
@@ -0,0 +1,474 @@
+"""Utilities for algebraic number theory. """
+
+from sympy.core.sympify import sympify
+from sympy.ntheory.factor_ import factorint
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.exceptions import DMRankError
+from sympy.polys.numberfields.minpoly import minpoly
+from sympy.printing.lambdarepr import IntervalPrinter
+from sympy.utilities.decorator import public
+from sympy.utilities.lambdify import lambdify
+
+from mpmath import mp
+
+
+def is_rat(c):
+    r"""
+    Test whether an argument is of an acceptable type to be used as a rational
+    number.
+
+    Explanation
+    ===========
+
+    Returns ``True`` on any argument of type ``int``, :ref:`ZZ`, or :ref:`QQ`.
+
+    See Also
+    ========
+
+    is_int
+
+    """
+    # ``c in QQ`` is too accepting (e.g. ``3.14 in QQ`` is ``True``),
+    # ``QQ.of_type(c)`` is too demanding (e.g. ``QQ.of_type(3)`` is ``False``).
+    #
+    # Meanwhile, if gmpy2 is installed then ``ZZ.of_type()`` accepts only
+    # ``mpz``, not ``int``, so we need another clause to ensure ``int`` is
+    # accepted.
+    return isinstance(c, int) or ZZ.of_type(c) or QQ.of_type(c)
+
+
+def is_int(c):
+    r"""
+    Test whether an argument is of an acceptable type to be used as an integer.
+
+    Explanation
+    ===========
+
+    Returns ``True`` on any argument of type ``int`` or :ref:`ZZ`.
+
+    See Also
+    ========
+
+    is_rat
+
+    """
+    # If gmpy2 is installed then ``ZZ.of_type()`` accepts only
+    # ``mpz``, not ``int``, so we need another clause to ensure ``int`` is
+    # accepted.
+    return isinstance(c, int) or ZZ.of_type(c)
+
+
+def get_num_denom(c):
+    r"""
+    Given any argument on which :py:func:`~.is_rat` is ``True``, return the
+    numerator and denominator of this number.
+
+    See Also
+    ========
+
+    is_rat
+
+    """
+    r = QQ(c)
+    return r.numerator, r.denominator
+
+
+@public
+def extract_fundamental_discriminant(a):
+    r"""
+    Extract a fundamental discriminant from an integer *a*.
+
+    Explanation
+    ===========
+
+    Given any rational integer *a* that is 0 or 1 mod 4, write $a = d f^2$,
+    where $d$ is either 1 or a fundamental discriminant, and return a pair
+    of dictionaries ``(D, F)`` giving the prime factorizations of $d$ and $f$
+    respectively, in the same format returned by :py:func:`~.factorint`.
+
+    A fundamental discriminant $d$ is different from unity, and is either
+    1 mod 4 and squarefree, or is 0 mod 4 and such that $d/4$ is squarefree
+    and 2 or 3 mod 4. This is the same as being the discriminant of some
+    quadratic field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.utilities import extract_fundamental_discriminant
+    >>> print(extract_fundamental_discriminant(-432))
+    ({3: 1, -1: 1}, {2: 2, 3: 1})
+
+    For comparison:
+
+    >>> from sympy import factorint
+    >>> print(factorint(-432))
+    {2: 4, 3: 3, -1: 1}
+
+    Parameters
+    ==========
+
+    a: int, must be 0 or 1 mod 4
+
+    Returns
+    =======
+
+    Pair ``(D, F)``  of dictionaries.
+
+    Raises
+    ======
+
+    ValueError
+        If *a* is not 0 or 1 mod 4.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Prop. 5.1.3)
+
+    """
+    if a % 4 not in [0, 1]:
+        raise ValueError('To extract fundamental discriminant, number must be 0 or 1 mod 4.')
+    if a == 0:
+        return {}, {0: 1}
+    if a == 1:
+        return {}, {}
+    a_factors = factorint(a)
+    D = {}
+    F = {}
+    # First pass: just make d squarefree, and a/d a perfect square.
+    # We'll count primes (and units! i.e. -1) that are 3 mod 4 and present in d.
+    num_3_mod_4 = 0
+    for p, e in a_factors.items():
+        if e % 2 == 1:
+            D[p] = 1
+            if p % 4 == 3:
+                num_3_mod_4 += 1
+            if e >= 3:
+                F[p] = (e - 1) // 2
+        else:
+            F[p] = e // 2
+    # Second pass: if d is cong. to 2 or 3 mod 4, then we must steal away
+    # another factor of 4 from f**2 and give it to d.
+    even = 2 in D
+    if even or num_3_mod_4 % 2 == 1:
+        e2 = F[2]
+        assert e2 > 0
+        if e2 == 1:
+            del F[2]
+        else:
+            F[2] = e2 - 1
+        D[2] = 3 if even else 2
+    return D, F
+
+
+@public
+class AlgIntPowers:
+    r"""
+    Compute the powers of an algebraic integer.
+
+    Explanation
+    ===========
+
+    Given an algebraic integer $\theta$ by its monic irreducible polynomial
+    ``T`` over :ref:`ZZ`, this class computes representations of arbitrarily
+    high powers of $\theta$, as :ref:`ZZ`-linear combinations over
+    $\{1, \theta, \ldots, \theta^{n-1}\}$, where $n = \deg(T)$.
+
+    The representations are computed using the linear recurrence relations for
+    powers of $\theta$, derived from the polynomial ``T``. See [1], Sec. 4.2.2.
+
+    Optionally, the representations may be reduced with respect to a modulus.
+
+    Examples
+    ========
+
+    >>> from sympy import Poly, cyclotomic_poly
+    >>> from sympy.polys.numberfields.utilities import AlgIntPowers
+    >>> T = Poly(cyclotomic_poly(5))
+    >>> zeta_pow = AlgIntPowers(T)
+    >>> print(zeta_pow[0])
+    [1, 0, 0, 0]
+    >>> print(zeta_pow[1])
+    [0, 1, 0, 0]
+    >>> print(zeta_pow[4])  # doctest: +SKIP
+    [-1, -1, -1, -1]
+    >>> print(zeta_pow[24])  # doctest: +SKIP
+    [-1, -1, -1, -1]
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+
+    """
+
+    def __init__(self, T, modulus=None):
+        """
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`
+            The monic irreducible polynomial over :ref:`ZZ` defining the
+            algebraic integer.
+
+        modulus : int, None, optional
+            If not ``None``, all representations will be reduced w.r.t. this.
+
+        """
+        self.T = T
+        self.modulus = modulus
+        self.n = T.degree()
+        self.powers_n_and_up = [[-c % self for c in reversed(T.rep.rep)][:-1]]
+        self.max_so_far = self.n
+
+    def red(self, exp):
+        return exp if self.modulus is None else exp % self.modulus
+
+    def __rmod__(self, other):
+        return self.red(other)
+
+    def compute_up_through(self, e):
+        m = self.max_so_far
+        if e <= m: return
+        n = self.n
+        r = self.powers_n_and_up
+        c = r[0]
+        for k in range(m+1, e+1):
+            b = r[k-1-n][n-1]
+            r.append(
+                [c[0]*b % self] + [
+                    (r[k-1-n][i-1] + c[i]*b) % self for i in range(1, n)
+                ]
+            )
+        self.max_so_far = e
+
+    def get(self, e):
+        n = self.n
+        if e < 0:
+            raise ValueError('Exponent must be non-negative.')
+        elif e < n:
+            return [1 if i == e else 0 for i in range(n)]
+        else:
+            self.compute_up_through(e)
+            return self.powers_n_and_up[e - n]
+
+    def __getitem__(self, item):
+        return self.get(item)
+
+
+@public
+def coeff_search(m, R):
+    r"""
+    Generate coefficients for searching through polynomials.
+
+    Explanation
+    ===========
+
+    Lead coeff is always non-negative. Explore all combinations with coeffs
+    bounded in absolute value before increasing the bound. Skip the all-zero
+    list, and skip any repeats. See examples.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.utilities import coeff_search
+    >>> cs = coeff_search(2, 1)
+    >>> C = [next(cs) for i in range(13)]
+    >>> print(C)
+    [[1, 1], [1, 0], [1, -1], [0, 1], [2, 2], [2, 1], [2, 0], [2, -1], [2, -2],
+     [1, 2], [1, -2], [0, 2], [3, 3]]
+
+    Parameters
+    ==========
+
+    m : int
+        Length of coeff list.
+    R : int
+        Initial max abs val for coeffs (will increase as search proceeds).
+
+    Returns
+    =======
+
+    generator
+        Infinite generator of lists of coefficients.
+
+    """
+    R0 = R
+    c = [R] * m
+    while True:
+        if R == R0 or R in c or -R in c:
+            yield c[:]
+        j = m - 1
+        while c[j] == -R:
+            j -= 1
+        c[j] -= 1
+        for i in range(j + 1, m):
+            c[i] = R
+        for j in range(m):
+            if c[j] != 0:
+                break
+        else:
+            R += 1
+            c = [R] * m
+
+
+def supplement_a_subspace(M):
+    r"""
+    Extend a basis for a subspace to a basis for the whole space.
+
+    Explanation
+    ===========
+
+    Given an $n \times r$ matrix *M* of rank $r$ (so $r \leq n$), this function
+    computes an invertible $n \times n$ matrix $B$ such that the first $r$
+    columns of $B$ equal *M*.
+
+    This operation can be interpreted as a way of extending a basis for a
+    subspace, to give a basis for the whole space.
+
+    To be precise, suppose you have an $n$-dimensional vector space $V$, with
+    basis $\{v_1, v_2, \ldots, v_n\}$, and an $r$-dimensional subspace $W$ of
+    $V$, spanned by a basis $\{w_1, w_2, \ldots, w_r\}$, where the $w_j$ are
+    given as linear combinations of the $v_i$. If the columns of *M* represent
+    the $w_j$ as such linear combinations, then the columns of the matrix $B$
+    computed by this function give a new basis $\{u_1, u_2, \ldots, u_n\}$ for
+    $V$, again relative to the $\{v_i\}$ basis, and such that $u_j = w_j$
+    for $1 \leq j \leq r$.
+
+    Examples
+    ========
+
+    Note: The function works in terms of columns, so in these examples we
+    print matrix transposes in order to make the columns easier to inspect.
+
+    >>> from sympy.polys.matrices import DM
+    >>> from sympy import QQ, FF
+    >>> from sympy.polys.numberfields.utilities import supplement_a_subspace
+    >>> M = DM([[1, 7, 0], [2, 3, 4]], QQ).transpose()
+    >>> print(supplement_a_subspace(M).to_Matrix().transpose())
+    Matrix([[1, 7, 0], [2, 3, 4], [1, 0, 0]])
+
+    >>> M2 = M.convert_to(FF(7))
+    >>> print(M2.to_Matrix().transpose())
+    Matrix([[1, 0, 0], [2, 3, -3]])
+    >>> print(supplement_a_subspace(M2).to_Matrix().transpose())
+    Matrix([[1, 0, 0], [2, 3, -3], [0, 1, 0]])
+
+    Parameters
+    ==========
+
+    M : :py:class:`~.DomainMatrix`
+        The columns give the basis for the subspace.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        This matrix is invertible and its first $r$ columns equal *M*.
+
+    Raises
+    ======
+
+    DMRankError
+        If *M* was not of maximal rank.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*
+       (See Sec. 2.3.2.)
+
+    """
+    n, r = M.shape
+    # Let In be the n x n identity matrix.
+    # Form the augmented matrix [M | In] and compute RREF.
+    Maug = M.hstack(M.eye(n, M.domain))
+    R, pivots = Maug.rref()
+    if pivots[:r] != tuple(range(r)):
+        raise DMRankError('M was not of maximal rank')
+    # Let J be the n x r matrix equal to the first r columns of In.
+    # Since M is of rank r, RREF reduces [M | In] to [J | A], where A is the product of
+    # elementary matrices Ei corresp. to the row ops performed by RREF. Since the Ei are
+    # invertible, so is A. Let B = A^(-1).
+    A = R[:, r:]
+    B = A.inv()
+    # Then B is the desired matrix. It is invertible, since B^(-1) == A.
+    # And A * [M | In] == [J | A]
+    #  => A * M == J
+    #  => M == B * J == the first r columns of B.
+    return B
+
+
+@public
+def isolate(alg, eps=None, fast=False):
+    """
+    Find a rational isolating interval for a real algebraic number.
+
+    Examples
+    ========
+
+    >>> from sympy import isolate, sqrt, Rational
+    >>> print(isolate(sqrt(2)))  # doctest: +SKIP
+    (1, 2)
+    >>> print(isolate(sqrt(2), eps=Rational(1, 100)))
+    (24/17, 17/12)
+
+    Parameters
+    ==========
+
+    alg : str, int, :py:class:`~.Expr`
+        The algebraic number to be isolated. Must be a real number, to use this
+        particular function. However, see also :py:meth:`.Poly.intervals`,
+        which isolates complex roots when you pass ``all=True``.
+    eps : positive element of :ref:`QQ`, None, optional (default=None)
+        Precision to be passed to :py:meth:`.Poly.refine_root`
+    fast : boolean, optional (default=False)
+        Say whether fast refinement procedure should be used.
+        (Will be passed to :py:meth:`.Poly.refine_root`.)
+
+    Returns
+    =======
+
+    Pair of rational numbers defining an isolating interval for the given
+    algebraic number.
+
+    See Also
+    ========
+
+    .Poly.intervals
+
+    """
+    alg = sympify(alg)
+
+    if alg.is_Rational:
+        return (alg, alg)
+    elif not alg.is_real:
+        raise NotImplementedError(
+            "complex algebraic numbers are not supported")
+
+    func = lambdify((), alg, modules="mpmath", printer=IntervalPrinter())
+
+    poly = minpoly(alg, polys=True)
+    intervals = poly.intervals(sqf=True)
+
+    dps, done = mp.dps, False
+
+    try:
+        while not done:
+            alg = func()
+
+            for a, b in intervals:
+                if a <= alg.a and alg.b <= b:
+                    done = True
+                    break
+            else:
+                mp.dps *= 2
+    finally:
+        mp.dps = dps
+
+    if eps is not None:
+        a, b = poly.refine_root(a, b, eps=eps, fast=fast)
+
+    return (a, b)