Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/12.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a79c26837e5e1261bb8df5f53463bca0955fe1cbc767306114215d135deb4265
+size 33555612

ckpts/universal/global_step80/zero/12.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:945610025c9bd8455ff2af170585cbd5081a9105c2fc68a9aff6dfd9d5b05edb
+size 33555627

ckpts/universal/global_step80/zero/12.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ef41b1c3339126dc370ebbd5ed7ad118c5703680f21b886bef02c0218d2462b
+size 33555533

ckpts/universal/global_step80/zero/23.attention.dense.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b954caf5c36821e0a54a0b1b7fad4fd058494fa54b382d80859cb3261b9e258e
+size 16778396

ckpts/universal/global_step80/zero/23.attention.dense.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e768a62dc459a94256304a9d1359f93dda912be3d366faabe653958d76e949c
+size 16778411

ckpts/universal/global_step80/zero/6.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37e66bc6b72bd770b0e41e08bbce4eca34577ee11ca51e39c03f105876542248
+size 33555612

ckpts/universal/global_step80/zero/6.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2cb6d3a787f0a7ad6e85e4762e6e4b24f07a1f692a4944aec56fcdb476b5b00
+size 33555627

ckpts/universal/global_step80/zero/6.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4835f3a8bfd698242f3933033f5064cd06c6e678f73c4ed9c0b832c2c9496255
+size 33555533

ckpts/universal/global_step80/zero/6.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:daf06bb8e3b1f13cac3f6bcb5737a0f75d79b6b42fb73a599fd8d1b6526a0a51
+size 33555627

venv/lib/python3.10/site-packages/sympy/polys/domains/tests/test_domains.py

@@ -0,0 +1,1270 @@
+"""Tests for classes defining properties of ground domains, e.g. ZZ, QQ, ZZ[x] ... """
+
+from sympy.core.numbers import (AlgebraicNumber, E, Float, I, Integer,
+    Rational, oo, pi, _illegal)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import Poly
+from sympy.abc import x, y, z
+
+from sympy.external.gmpy import HAS_GMPY
+
+from sympy.polys.domains import (ZZ, QQ, RR, CC, FF, GF, EX, EXRAW, ZZ_gmpy,
+    ZZ_python, QQ_gmpy, QQ_python)
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.gaussiandomains import ZZ_I, QQ_I
+from sympy.polys.domains.polynomialring import PolynomialRing
+from sympy.polys.domains.realfield import RealField
+
+from sympy.polys.numberfields.subfield import field_isomorphism
+from sympy.polys.rings import ring
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.polys.fields import field
+
+from sympy.polys.agca.extensions import FiniteExtension
+
+from sympy.polys.polyerrors import (
+    UnificationFailed,
+    GeneratorsError,
+    CoercionFailed,
+    NotInvertible,
+    DomainError)
+
+from sympy.testing.pytest import raises
+
+from itertools import product
+
+ALG = QQ.algebraic_field(sqrt(2), sqrt(3))
+
+def unify(K0, K1):
+    return K0.unify(K1)
+
+def test_Domain_unify():
+    F3 = GF(3)
+
+    assert unify(F3, F3) == F3
+    assert unify(F3, ZZ) == ZZ
+    assert unify(F3, QQ) == QQ
+    assert unify(F3, ALG) == ALG
+    assert unify(F3, RR) == RR
+    assert unify(F3, CC) == CC
+    assert unify(F3, ZZ[x]) == ZZ[x]
+    assert unify(F3, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(F3, EX) == EX
+
+    assert unify(ZZ, F3) == ZZ
+    assert unify(ZZ, ZZ) == ZZ
+    assert unify(ZZ, QQ) == QQ
+    assert unify(ZZ, ALG) == ALG
+    assert unify(ZZ, RR) == RR
+    assert unify(ZZ, CC) == CC
+    assert unify(ZZ, ZZ[x]) == ZZ[x]
+    assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ, EX) == EX
+
+    assert unify(QQ, F3) == QQ
+    assert unify(QQ, ZZ) == QQ
+    assert unify(QQ, QQ) == QQ
+    assert unify(QQ, ALG) == ALG
+    assert unify(QQ, RR) == RR
+    assert unify(QQ, CC) == CC
+    assert unify(QQ, ZZ[x]) == QQ[x]
+    assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ, EX) == EX
+
+    assert unify(ZZ_I, F3) == ZZ_I
+    assert unify(ZZ_I, ZZ) == ZZ_I
+    assert unify(ZZ_I, ZZ_I) == ZZ_I
+    assert unify(ZZ_I, QQ) == QQ_I
+    assert unify(ZZ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
+    assert unify(ZZ_I, RR) == CC
+    assert unify(ZZ_I, CC) == CC
+    assert unify(ZZ_I, ZZ[x]) == ZZ_I[x]
+    assert unify(ZZ_I, ZZ_I[x]) == ZZ_I[x]
+    assert unify(ZZ_I, ZZ.frac_field(x)) == ZZ_I.frac_field(x)
+    assert unify(ZZ_I, ZZ_I.frac_field(x)) == ZZ_I.frac_field(x)
+    assert unify(ZZ_I, EX) == EX
+
+    assert unify(QQ_I, F3) == QQ_I
+    assert unify(QQ_I, ZZ) == QQ_I
+    assert unify(QQ_I, ZZ_I) == QQ_I
+    assert unify(QQ_I, QQ) == QQ_I
+    assert unify(QQ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
+    assert unify(QQ_I, RR) == CC
+    assert unify(QQ_I, CC) == CC
+    assert unify(QQ_I, ZZ[x]) == QQ_I[x]
+    assert unify(QQ_I, ZZ_I[x]) == QQ_I[x]
+    assert unify(QQ_I, QQ[x]) == QQ_I[x]
+    assert unify(QQ_I, QQ_I[x]) == QQ_I[x]
+    assert unify(QQ_I, ZZ.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, ZZ_I.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, QQ.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, QQ_I.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, EX) == EX
+
+    assert unify(RR, F3) == RR
+    assert unify(RR, ZZ) == RR
+    assert unify(RR, QQ) == RR
+    assert unify(RR, ALG) == RR
+    assert unify(RR, RR) == RR
+    assert unify(RR, CC) == CC
+    assert unify(RR, ZZ[x]) == RR[x]
+    assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
+    assert unify(RR, EX) == EX
+    assert RR[x].unify(ZZ.frac_field(y)) == RR.frac_field(x, y)
+
+    assert unify(CC, F3) == CC
+    assert unify(CC, ZZ) == CC
+    assert unify(CC, QQ) == CC
+    assert unify(CC, ALG) == CC
+    assert unify(CC, RR) == CC
+    assert unify(CC, CC) == CC
+    assert unify(CC, ZZ[x]) == CC[x]
+    assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
+    assert unify(CC, EX) == EX
+
+    assert unify(ZZ[x], F3) == ZZ[x]
+    assert unify(ZZ[x], ZZ) == ZZ[x]
+    assert unify(ZZ[x], QQ) == QQ[x]
+    assert unify(ZZ[x], ALG) == ALG[x]
+    assert unify(ZZ[x], RR) == RR[x]
+    assert unify(ZZ[x], CC) == CC[x]
+    assert unify(ZZ[x], ZZ[x]) == ZZ[x]
+    assert unify(ZZ[x], ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ[x], EX) == EX
+
+    assert unify(ZZ.frac_field(x), F3) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ALG) == ALG.frac_field(x)
+    assert unify(ZZ.frac_field(x), RR) == RR.frac_field(x)
+    assert unify(ZZ.frac_field(x), CC) == CC.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ[x]) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), EX) == EX
+
+    assert unify(EX, F3) == EX
+    assert unify(EX, ZZ) == EX
+    assert unify(EX, QQ) == EX
+    assert unify(EX, ALG) == EX
+    assert unify(EX, RR) == EX
+    assert unify(EX, CC) == EX
+    assert unify(EX, ZZ[x]) == EX
+    assert unify(EX, ZZ.frac_field(x)) == EX
+    assert unify(EX, EX) == EX
+
+def test_Domain_unify_composite():
+    assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
+    assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), ZZ) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), QQ) == QQ.poly_ring(x)
+
+    assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
+    assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(ZZ, QQ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ, QQ.poly_ring(x)) == QQ.poly_ring(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ, ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
+    assert unify(QQ, ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(ZZ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ) == QQ.frac_field(x)
+
+    assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(ZZ, QQ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ, QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
+
+    assert unify(ZZ, ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ, ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(ZZ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
+    assert unify(ZZ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), ZZ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x), ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x, z)) == ZZ.poly_ring(x, y, z)
+    assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+    assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+    assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ.frac_field(x)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), ZZ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+
+    assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.poly_ring(x), QQ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ.poly_ring(x), QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.poly_ring(x), QQ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.poly_ring(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+
+    assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ.poly_ring(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ.poly_ring(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x), QQ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), QQ.poly_ring(x, z)) == QQ.frac_field(x, y, z)
+
+def test_Domain_unify_algebraic():
+    sqrt5 = QQ.algebraic_field(sqrt(5))
+    sqrt7 = QQ.algebraic_field(sqrt(7))
+    sqrt57 = QQ.algebraic_field(sqrt(5), sqrt(7))
+
+    assert sqrt5.unify(sqrt7) == sqrt57
+
+    assert sqrt5.unify(sqrt5[x, y]) == sqrt5[x, y]
+    assert sqrt5[x, y].unify(sqrt5) == sqrt5[x, y]
+
+    assert sqrt5.unify(sqrt5.frac_field(x, y)) == sqrt5.frac_field(x, y)
+    assert sqrt5.frac_field(x, y).unify(sqrt5) == sqrt5.frac_field(x, y)
+
+    assert sqrt5.unify(sqrt7[x, y]) == sqrt57[x, y]
+    assert sqrt5[x, y].unify(sqrt7) == sqrt57[x, y]
+
+    assert sqrt5.unify(sqrt7.frac_field(x, y)) == sqrt57.frac_field(x, y)
+    assert sqrt5.frac_field(x, y).unify(sqrt7) == sqrt57.frac_field(x, y)
+
+def test_Domain_unify_FiniteExtension():
+    KxZZ = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ))
+    KxQQ = FiniteExtension(Poly(x**2 - 2, x, domain=QQ))
+    KxZZy = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y]))
+    KxQQy = FiniteExtension(Poly(x**2 - 2, x, domain=QQ[y]))
+
+    assert KxZZ.unify(KxZZ) == KxZZ
+    assert KxQQ.unify(KxQQ) == KxQQ
+    assert KxZZy.unify(KxZZy) == KxZZy
+    assert KxQQy.unify(KxQQy) == KxQQy
+
+    assert KxZZ.unify(ZZ) == KxZZ
+    assert KxZZ.unify(QQ) == KxQQ
+    assert KxQQ.unify(ZZ) == KxQQ
+    assert KxQQ.unify(QQ) == KxQQ
+
+    assert KxZZ.unify(ZZ[y]) == KxZZy
+    assert KxZZ.unify(QQ[y]) == KxQQy
+    assert KxQQ.unify(ZZ[y]) == KxQQy
+    assert KxQQ.unify(QQ[y]) == KxQQy
+
+    assert KxZZy.unify(ZZ) == KxZZy
+    assert KxZZy.unify(QQ) == KxQQy
+    assert KxQQy.unify(ZZ) == KxQQy
+    assert KxQQy.unify(QQ) == KxQQy
+
+    assert KxZZy.unify(ZZ[y]) == KxZZy
+    assert KxZZy.unify(QQ[y]) == KxQQy
+    assert KxQQy.unify(ZZ[y]) == KxQQy
+    assert KxQQy.unify(QQ[y]) == KxQQy
+
+    K = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y]))
+    assert K.unify(ZZ) == K
+    assert K.unify(ZZ[x]) == K
+    assert K.unify(ZZ[y]) == K
+    assert K.unify(ZZ[x, y]) == K
+
+    Kz = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y, z]))
+    assert K.unify(ZZ[z]) == Kz
+    assert K.unify(ZZ[x, z]) == Kz
+    assert K.unify(ZZ[y, z]) == Kz
+    assert K.unify(ZZ[x, y, z]) == Kz
+
+    Kx = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ))
+    Ky = FiniteExtension(Poly(y**2 - 2, y, domain=ZZ))
+    Kxy = FiniteExtension(Poly(y**2 - 2, y, domain=Kx))
+    assert Kx.unify(Kx) == Kx
+    assert Ky.unify(Ky) == Ky
+    assert Kx.unify(Ky) == Kxy
+    assert Ky.unify(Kx) == Kxy
+
+def test_Domain_unify_with_symbols():
+    raises(UnificationFailed, lambda: ZZ[x, y].unify_with_symbols(ZZ, (y, z)))
+    raises(UnificationFailed, lambda: ZZ.unify_with_symbols(ZZ[x, y], (y, z)))
+
+def test_Domain__contains__():
+    assert (0 in EX) is True
+    assert (0 in ZZ) is True
+    assert (0 in QQ) is True
+    assert (0 in RR) is True
+    assert (0 in CC) is True
+    assert (0 in ALG) is True
+    assert (0 in ZZ[x, y]) is True
+    assert (0 in QQ[x, y]) is True
+    assert (0 in RR[x, y]) is True
+
+    assert (-7 in EX) is True
+    assert (-7 in ZZ) is True
+    assert (-7 in QQ) is True
+    assert (-7 in RR) is True
+    assert (-7 in CC) is True
+    assert (-7 in ALG) is True
+    assert (-7 in ZZ[x, y]) is True
+    assert (-7 in QQ[x, y]) is True
+    assert (-7 in RR[x, y]) is True
+
+    assert (17 in EX) is True
+    assert (17 in ZZ) is True
+    assert (17 in QQ) is True
+    assert (17 in RR) is True
+    assert (17 in CC) is True
+    assert (17 in ALG) is True
+    assert (17 in ZZ[x, y]) is True
+    assert (17 in QQ[x, y]) is True
+    assert (17 in RR[x, y]) is True
+
+    assert (Rational(-1, 7) in EX) is True
+    assert (Rational(-1, 7) in ZZ) is False
+    assert (Rational(-1, 7) in QQ) is True
+    assert (Rational(-1, 7) in RR) is True
+    assert (Rational(-1, 7) in CC) is True
+    assert (Rational(-1, 7) in ALG) is True
+    assert (Rational(-1, 7) in ZZ[x, y]) is False
+    assert (Rational(-1, 7) in QQ[x, y]) is True
+    assert (Rational(-1, 7) in RR[x, y]) is True
+
+    assert (Rational(3, 5) in EX) is True
+    assert (Rational(3, 5) in ZZ) is False
+    assert (Rational(3, 5) in QQ) is True
+    assert (Rational(3, 5) in RR) is True
+    assert (Rational(3, 5) in CC) is True
+    assert (Rational(3, 5) in ALG) is True
+    assert (Rational(3, 5) in ZZ[x, y]) is False
+    assert (Rational(3, 5) in QQ[x, y]) is True
+    assert (Rational(3, 5) in RR[x, y]) is True
+
+    assert (3.0 in EX) is True
+    assert (3.0 in ZZ) is True
+    assert (3.0 in QQ) is True
+    assert (3.0 in RR) is True
+    assert (3.0 in CC) is True
+    assert (3.0 in ALG) is True
+    assert (3.0 in ZZ[x, y]) is True
+    assert (3.0 in QQ[x, y]) is True
+    assert (3.0 in RR[x, y]) is True
+
+    assert (3.14 in EX) is True
+    assert (3.14 in ZZ) is False
+    assert (3.14 in QQ) is True
+    assert (3.14 in RR) is True
+    assert (3.14 in CC) is True
+    assert (3.14 in ALG) is True
+    assert (3.14 in ZZ[x, y]) is False
+    assert (3.14 in QQ[x, y]) is True
+    assert (3.14 in RR[x, y]) is True
+
+    assert (oo in ALG) is False
+    assert (oo in ZZ[x, y]) is False
+    assert (oo in QQ[x, y]) is False
+
+    assert (-oo in ZZ) is False
+    assert (-oo in QQ) is False
+    assert (-oo in ALG) is False
+    assert (-oo in ZZ[x, y]) is False
+    assert (-oo in QQ[x, y]) is False
+
+    assert (sqrt(7) in EX) is True
+    assert (sqrt(7) in ZZ) is False
+    assert (sqrt(7) in QQ) is False
+    assert (sqrt(7) in RR) is True
+    assert (sqrt(7) in CC) is True
+    assert (sqrt(7) in ALG) is False
+    assert (sqrt(7) in ZZ[x, y]) is False
+    assert (sqrt(7) in QQ[x, y]) is False
+    assert (sqrt(7) in RR[x, y]) is True
+
+    assert (2*sqrt(3) + 1 in EX) is True
+    assert (2*sqrt(3) + 1 in ZZ) is False
+    assert (2*sqrt(3) + 1 in QQ) is False
+    assert (2*sqrt(3) + 1 in RR) is True
+    assert (2*sqrt(3) + 1 in CC) is True
+    assert (2*sqrt(3) + 1 in ALG) is True
+    assert (2*sqrt(3) + 1 in ZZ[x, y]) is False
+    assert (2*sqrt(3) + 1 in QQ[x, y]) is False
+    assert (2*sqrt(3) + 1 in RR[x, y]) is True
+
+    assert (sin(1) in EX) is True
+    assert (sin(1) in ZZ) is False
+    assert (sin(1) in QQ) is False
+    assert (sin(1) in RR) is True
+    assert (sin(1) in CC) is True
+    assert (sin(1) in ALG) is False
+    assert (sin(1) in ZZ[x, y]) is False
+    assert (sin(1) in QQ[x, y]) is False
+    assert (sin(1) in RR[x, y]) is True
+
+    assert (x**2 + 1 in EX) is True
+    assert (x**2 + 1 in ZZ) is False
+    assert (x**2 + 1 in QQ) is False
+    assert (x**2 + 1 in RR) is False
+    assert (x**2 + 1 in CC) is False
+    assert (x**2 + 1 in ALG) is False
+    assert (x**2 + 1 in ZZ[x]) is True
+    assert (x**2 + 1 in QQ[x]) is True
+    assert (x**2 + 1 in RR[x]) is True
+    assert (x**2 + 1 in ZZ[x, y]) is True
+    assert (x**2 + 1 in QQ[x, y]) is True
+    assert (x**2 + 1 in RR[x, y]) is True
+
+    assert (x**2 + y**2 in EX) is True
+    assert (x**2 + y**2 in ZZ) is False
+    assert (x**2 + y**2 in QQ) is False
+    assert (x**2 + y**2 in RR) is False
+    assert (x**2 + y**2 in CC) is False
+    assert (x**2 + y**2 in ALG) is False
+    assert (x**2 + y**2 in ZZ[x]) is False
+    assert (x**2 + y**2 in QQ[x]) is False
+    assert (x**2 + y**2 in RR[x]) is False
+    assert (x**2 + y**2 in ZZ[x, y]) is True
+    assert (x**2 + y**2 in QQ[x, y]) is True
+    assert (x**2 + y**2 in RR[x, y]) is True
+
+    assert (Rational(3, 2)*x/(y + 1) - z in QQ[x, y, z]) is False
+
+
+def test_issue_14433():
+    assert (Rational(2, 3)*x in QQ.frac_field(1/x)) is True
+    assert (1/x in QQ.frac_field(x)) is True
+    assert ((x**2 + y**2) in QQ.frac_field(1/x, 1/y)) is True
+    assert ((x + y) in QQ.frac_field(1/x, y)) is True
+    assert ((x - y) in QQ.frac_field(x, 1/y)) is True
+
+
+def test_Domain_get_ring():
+    assert ZZ.has_assoc_Ring is True
+    assert QQ.has_assoc_Ring is True
+    assert ZZ[x].has_assoc_Ring is True
+    assert QQ[x].has_assoc_Ring is True
+    assert ZZ[x, y].has_assoc_Ring is True
+    assert QQ[x, y].has_assoc_Ring is True
+    assert ZZ.frac_field(x).has_assoc_Ring is True
+    assert QQ.frac_field(x).has_assoc_Ring is True
+    assert ZZ.frac_field(x, y).has_assoc_Ring is True
+    assert QQ.frac_field(x, y).has_assoc_Ring is True
+
+    assert EX.has_assoc_Ring is False
+    assert RR.has_assoc_Ring is False
+    assert ALG.has_assoc_Ring is False
+
+    assert ZZ.get_ring() == ZZ
+    assert QQ.get_ring() == ZZ
+    assert ZZ[x].get_ring() == ZZ[x]
+    assert QQ[x].get_ring() == QQ[x]
+    assert ZZ[x, y].get_ring() == ZZ[x, y]
+    assert QQ[x, y].get_ring() == QQ[x, y]
+    assert ZZ.frac_field(x).get_ring() == ZZ[x]
+    assert QQ.frac_field(x).get_ring() == QQ[x]
+    assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
+    assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
+
+    assert EX.get_ring() == EX
+
+    assert RR.get_ring() == RR
+    # XXX: This should also be like RR
+    raises(DomainError, lambda: ALG.get_ring())
+
+
+def test_Domain_get_field():
+    assert EX.has_assoc_Field is True
+    assert ZZ.has_assoc_Field is True
+    assert QQ.has_assoc_Field is True
+    assert RR.has_assoc_Field is True
+    assert ALG.has_assoc_Field is True
+    assert ZZ[x].has_assoc_Field is True
+    assert QQ[x].has_assoc_Field is True
+    assert ZZ[x, y].has_assoc_Field is True
+    assert QQ[x, y].has_assoc_Field is True
+
+    assert EX.get_field() == EX
+    assert ZZ.get_field() == QQ
+    assert QQ.get_field() == QQ
+    assert RR.get_field() == RR
+    assert ALG.get_field() == ALG
+    assert ZZ[x].get_field() == ZZ.frac_field(x)
+    assert QQ[x].get_field() == QQ.frac_field(x)
+    assert ZZ[x, y].get_field() == ZZ.frac_field(x, y)
+    assert QQ[x, y].get_field() == QQ.frac_field(x, y)
+
+
+def test_Domain_get_exact():
+    assert EX.get_exact() == EX
+    assert ZZ.get_exact() == ZZ
+    assert QQ.get_exact() == QQ
+    assert RR.get_exact() == QQ
+    assert ALG.get_exact() == ALG
+    assert ZZ[x].get_exact() == ZZ[x]
+    assert QQ[x].get_exact() == QQ[x]
+    assert ZZ[x, y].get_exact() == ZZ[x, y]
+    assert QQ[x, y].get_exact() == QQ[x, y]
+    assert ZZ.frac_field(x).get_exact() == ZZ.frac_field(x)
+    assert QQ.frac_field(x).get_exact() == QQ.frac_field(x)
+    assert ZZ.frac_field(x, y).get_exact() == ZZ.frac_field(x, y)
+    assert QQ.frac_field(x, y).get_exact() == QQ.frac_field(x, y)
+
+
+def test_Domain_is_unit():
+    nums = [-2, -1, 0, 1, 2]
+    invring = [False, True, False, True, False]
+    invfield = [True, True, False, True, True]
+    ZZx, QQx, QQxf = ZZ[x], QQ[x], QQ.frac_field(x)
+    assert [ZZ.is_unit(ZZ(n)) for n in nums] == invring
+    assert [QQ.is_unit(QQ(n)) for n in nums] == invfield
+    assert [ZZx.is_unit(ZZx(n)) for n in nums] == invring
+    assert [QQx.is_unit(QQx(n)) for n in nums] == invfield
+    assert [QQxf.is_unit(QQxf(n)) for n in nums] == invfield
+    assert ZZx.is_unit(ZZx(x)) is False
+    assert QQx.is_unit(QQx(x)) is False
+    assert QQxf.is_unit(QQxf(x)) is True
+
+
+def test_Domain_convert():
+
+    def check_element(e1, e2, K1, K2, K3):
+        assert type(e1) is type(e2), '%s, %s: %s %s -> %s' % (e1, e2, K1, K2, K3)
+        assert e1 == e2, '%s, %s: %s %s -> %s' % (e1, e2, K1, K2, K3)
+
+    def check_domains(K1, K2):
+        K3 = K1.unify(K2)
+        check_element(K3.convert_from( K1.one, K1),  K3.one, K1, K2, K3)
+        check_element(K3.convert_from( K2.one, K2),  K3.one, K1, K2, K3)
+        check_element(K3.convert_from(K1.zero, K1), K3.zero, K1, K2, K3)
+        check_element(K3.convert_from(K2.zero, K2), K3.zero, K1, K2, K3)
+
+    def composite_domains(K):
+        domains = [
+            K,
+            K[y], K[z], K[y, z],
+            K.frac_field(y), K.frac_field(z), K.frac_field(y, z),
+            # XXX: These should be tested and made to work...
+            # K.old_poly_ring(y), K.old_frac_field(y),
+        ]
+        return domains
+
+    QQ2 = QQ.algebraic_field(sqrt(2))
+    QQ3 = QQ.algebraic_field(sqrt(3))
+    doms = [ZZ, QQ, QQ2, QQ3, QQ_I, ZZ_I, RR, CC]
+
+    for i, K1 in enumerate(doms):
+        for K2 in doms[i:]:
+            for K3 in composite_domains(K1):
+                for K4 in composite_domains(K2):
+                    check_domains(K3, K4)
+
+    assert QQ.convert(10e-52) == QQ(1684996666696915, 1684996666696914987166688442938726917102321526408785780068975640576)
+
+    R, xr = ring("x", ZZ)
+    assert ZZ.convert(xr - xr) == 0
+    assert ZZ.convert(xr - xr, R.to_domain()) == 0
+
+    assert CC.convert(ZZ_I(1, 2)) == CC(1, 2)
+    assert CC.convert(QQ_I(1, 2)) == CC(1, 2)
+
+    K1 = QQ.frac_field(x)
+    K2 = ZZ.frac_field(x)
+    K3 = QQ[x]
+    K4 = ZZ[x]
+    Ks = [K1, K2, K3, K4]
+    for Ka, Kb in product(Ks, Ks):
+        assert Ka.convert_from(Kb.from_sympy(x), Kb) == Ka.from_sympy(x)
+
+    assert K2.convert_from(QQ(1, 2), QQ) == K2(QQ(1, 2))
+
+
+def test_GlobalPolynomialRing_convert():
+    K1 = QQ.old_poly_ring(x)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+    K1 = QQ.old_poly_ring(x, y)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    #assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+    K1 = ZZ.old_poly_ring(x, y)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    #assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+
+def test_PolynomialRing__init():
+    R, = ring("", ZZ)
+    assert ZZ.poly_ring() == R.to_domain()
+
+
+def test_FractionField__init():
+    F, = field("", ZZ)
+    assert ZZ.frac_field() == F.to_domain()
+
+
+def test_FractionField_convert():
+    K = QQ.frac_field(x)
+    assert K.convert(QQ(2, 3), QQ) == K.from_sympy(Rational(2, 3))
+    K = QQ.frac_field(x)
+    assert K.convert(ZZ(2), ZZ) == K.from_sympy(Integer(2))
+
+
+def test_inject():
+    assert ZZ.inject(x, y, z) == ZZ[x, y, z]
+    assert ZZ[x].inject(y, z) == ZZ[x, y, z]
+    assert ZZ.frac_field(x).inject(y, z) == ZZ.frac_field(x, y, z)
+    raises(GeneratorsError, lambda: ZZ[x].inject(x))
+
+
+def test_drop():
+    assert ZZ.drop(x) == ZZ
+    assert ZZ[x].drop(x) == ZZ
+    assert ZZ[x, y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x).drop(x) == ZZ
+    assert ZZ.frac_field(x, y).drop(x) == ZZ.frac_field(y)
+    assert ZZ[x][y].drop(y) == ZZ[x]
+    assert ZZ[x][y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x)[y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x)[y].drop(y) == ZZ.frac_field(x)
+    Ky = FiniteExtension(Poly(x**2-1, x, domain=ZZ[y]))
+    K = FiniteExtension(Poly(x**2-1, x, domain=ZZ))
+    assert Ky.drop(y) == K
+    raises(GeneratorsError, lambda: Ky.drop(x))
+
+
+def test_Domain_map():
+    seq = ZZ.map([1, 2, 3, 4])
+
+    assert all(ZZ.of_type(elt) for elt in seq)
+
+    seq = ZZ.map([[1, 2, 3, 4]])
+
+    assert all(ZZ.of_type(elt) for elt in seq[0]) and len(seq) == 1
+
+
+def test_Domain___eq__():
+    assert (ZZ[x, y] == ZZ[x, y]) is True
+    assert (QQ[x, y] == QQ[x, y]) is True
+
+    assert (ZZ[x, y] == QQ[x, y]) is False
+    assert (QQ[x, y] == ZZ[x, y]) is False
+
+    assert (ZZ.frac_field(x, y) == ZZ.frac_field(x, y)) is True
+    assert (QQ.frac_field(x, y) == QQ.frac_field(x, y)) is True
+
+    assert (ZZ.frac_field(x, y) == QQ.frac_field(x, y)) is False
+    assert (QQ.frac_field(x, y) == ZZ.frac_field(x, y)) is False
+
+    assert RealField()[x] == RR[x]
+
+
+def test_Domain__algebraic_field():
+    alg = ZZ.algebraic_field(sqrt(2))
+    assert alg.ext.minpoly == Poly(x**2 - 2)
+    assert alg.dom == QQ
+
+    alg = QQ.algebraic_field(sqrt(2))
+    assert alg.ext.minpoly == Poly(x**2 - 2)
+    assert alg.dom == QQ
+
+    alg = alg.algebraic_field(sqrt(3))
+    assert alg.ext.minpoly == Poly(x**4 - 10*x**2 + 1)
+    assert alg.dom == QQ
+
+
+def test_Domain_alg_field_from_poly():
+    f = Poly(x**2 - 2)
+    g = Poly(x**2 - 3)
+    h = Poly(x**4 - 10*x**2 + 1)
+
+    alg = ZZ.alg_field_from_poly(f)
+    assert alg.ext.minpoly == f
+    assert alg.dom == QQ
+
+    alg = QQ.alg_field_from_poly(f)
+    assert alg.ext.minpoly == f
+    assert alg.dom == QQ
+
+    alg = alg.alg_field_from_poly(g)
+    assert alg.ext.minpoly == h
+    assert alg.dom == QQ
+
+
+def test_Domain_cyclotomic_field():
+    K = ZZ.cyclotomic_field(12)
+    assert K.ext.minpoly == Poly(cyclotomic_poly(12))
+    assert K.dom == QQ
+
+    F = QQ.cyclotomic_field(3)
+    assert F.ext.minpoly == Poly(cyclotomic_poly(3))
+    assert F.dom == QQ
+
+    E = F.cyclotomic_field(4)
+    assert field_isomorphism(E.ext, K.ext) is not None
+    assert E.dom == QQ
+
+
+def test_PolynomialRing_from_FractionField():
+    F, x,y = field("x,y", ZZ)
+    R, X,Y = ring("x,y", ZZ)
+
+    f = (x**2 + y**2)/(x + 1)
+    g = (x**2 + y**2)/4
+    h =  x**2 + y**2
+
+    assert R.to_domain().from_FractionField(f, F.to_domain()) is None
+    assert R.to_domain().from_FractionField(g, F.to_domain()) == X**2/4 + Y**2/4
+    assert R.to_domain().from_FractionField(h, F.to_domain()) == X**2 + Y**2
+
+    F, x,y = field("x,y", QQ)
+    R, X,Y = ring("x,y", QQ)
+
+    f = (x**2 + y**2)/(x + 1)
+    g = (x**2 + y**2)/4
+    h =  x**2 + y**2
+
+    assert R.to_domain().from_FractionField(f, F.to_domain()) is None
+    assert R.to_domain().from_FractionField(g, F.to_domain()) == X**2/4 + Y**2/4
+    assert R.to_domain().from_FractionField(h, F.to_domain()) == X**2 + Y**2
+
+def test_FractionField_from_PolynomialRing():
+    R, x,y = ring("x,y", QQ)
+    F, X,Y = field("x,y", ZZ)
+
+    f = 3*x**2 + 5*y**2
+    g = x**2/3 + y**2/5
+
+    assert F.to_domain().from_PolynomialRing(f, R.to_domain()) == 3*X**2 + 5*Y**2
+    assert F.to_domain().from_PolynomialRing(g, R.to_domain()) == (5*X**2 + 3*Y**2)/15
+
+def test_FF_of_type():
+    assert FF(3).of_type(FF(3)(1)) is True
+    assert FF(5).of_type(FF(5)(3)) is True
+    assert FF(5).of_type(FF(7)(3)) is False
+
+
+def test___eq__():
+    assert not QQ[x] == ZZ[x]
+    assert not QQ.frac_field(x) == ZZ.frac_field(x)
+
+
+def test_RealField_from_sympy():
+    assert RR.convert(S.Zero) == RR.dtype(0)
+    assert RR.convert(S(0.0)) == RR.dtype(0.0)
+    assert RR.convert(S.One) == RR.dtype(1)
+    assert RR.convert(S(1.0)) == RR.dtype(1.0)
+    assert RR.convert(sin(1)) == RR.dtype(sin(1).evalf())
+
+
+def test_not_in_any_domain():
+    check = list(_illegal) + [x] + [
+        float(i) for i in _illegal[:3]]
+    for dom in (ZZ, QQ, RR, CC, EX):
+        for i in check:
+            if i == x and dom == EX:
+                continue
+            assert i not in dom, (i, dom)
+            raises(CoercionFailed, lambda: dom.convert(i))
+
+
+def test_ModularInteger():
+    F3 = FF(3)
+
+    a = F3(0)
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(1)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(3)
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(4)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = F3(F3(0))
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(F3(1))
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(F3(2))
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(F3(3))
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(F3(4))
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = -F3(1)
+    assert isinstance(a, F3.dtype) and a == 2
+    a = -F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2 + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 3 - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 1 % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = F3(2)**0
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)**1
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(2)**2
+    assert isinstance(a, F3.dtype) and a == 1
+
+    F7 = FF(7)
+
+    a = F7(3)**100000000000
+    assert isinstance(a, F7.dtype) and a == 4
+    a = F7(3)**-100000000000
+    assert isinstance(a, F7.dtype) and a == 2
+    a = F7(3)**S(2)
+    assert isinstance(a, F7.dtype) and a == 2
+
+    assert bool(F3(3)) is False
+    assert bool(F3(4)) is True
+
+    F5 = FF(5)
+
+    a = F5(1)**(-1)
+    assert isinstance(a, F5.dtype) and a == 1
+    a = F5(2)**(-1)
+    assert isinstance(a, F5.dtype) and a == 3
+    a = F5(3)**(-1)
+    assert isinstance(a, F5.dtype) and a == 2
+    a = F5(4)**(-1)
+    assert isinstance(a, F5.dtype) and a == 4
+
+    assert (F5(1) < F5(2)) is True
+    assert (F5(1) <= F5(2)) is True
+    assert (F5(1) > F5(2)) is False
+    assert (F5(1) >= F5(2)) is False
+
+    assert (F5(3) < F5(2)) is False
+    assert (F5(3) <= F5(2)) is False
+    assert (F5(3) > F5(2)) is True
+    assert (F5(3) >= F5(2)) is True
+
+    assert (F5(1) < F5(7)) is True
+    assert (F5(1) <= F5(7)) is True
+    assert (F5(1) > F5(7)) is False
+    assert (F5(1) >= F5(7)) is False
+
+    assert (F5(3) < F5(7)) is False
+    assert (F5(3) <= F5(7)) is False
+    assert (F5(3) > F5(7)) is True
+    assert (F5(3) >= F5(7)) is True
+
+    assert (F5(1) < 2) is True
+    assert (F5(1) <= 2) is True
+    assert (F5(1) > 2) is False
+    assert (F5(1) >= 2) is False
+
+    assert (F5(3) < 2) is False
+    assert (F5(3) <= 2) is False
+    assert (F5(3) > 2) is True
+    assert (F5(3) >= 2) is True
+
+    assert (F5(1) < 7) is True
+    assert (F5(1) <= 7) is True
+    assert (F5(1) > 7) is False
+    assert (F5(1) >= 7) is False
+
+    assert (F5(3) < 7) is False
+    assert (F5(3) <= 7) is False
+    assert (F5(3) > 7) is True
+    assert (F5(3) >= 7) is True
+
+    raises(NotInvertible, lambda: F5(0)**(-1))
+    raises(NotInvertible, lambda: F5(5)**(-1))
+
+    raises(ValueError, lambda: FF(0))
+    raises(ValueError, lambda: FF(2.1))
+
+def test_QQ_int():
+    assert int(QQ(2**2000, 3**1250)) == 455431
+    assert int(QQ(2**100, 3)) == 422550200076076467165567735125
+
+def test_RR_double():
+    assert RR(3.14) > 1e-50
+    assert RR(1e-13) > 1e-50
+    assert RR(1e-14) > 1e-50
+    assert RR(1e-15) > 1e-50
+    assert RR(1e-20) > 1e-50
+    assert RR(1e-40) > 1e-50
+
+def test_RR_Float():
+    f1 = Float("1.01")
+    f2 = Float("1.0000000000000000000001")
+    assert f1._prec == 53
+    assert f2._prec == 80
+    assert RR(f1)-1 > 1e-50
+    assert RR(f2)-1 < 1e-50 # RR's precision is lower than f2's
+
+    RR2 = RealField(prec=f2._prec)
+    assert RR2(f1)-1 > 1e-50
+    assert RR2(f2)-1 > 1e-50 # RR's precision is equal to f2's
+
+
+def test_CC_double():
+    assert CC(3.14).real > 1e-50
+    assert CC(1e-13).real > 1e-50
+    assert CC(1e-14).real > 1e-50
+    assert CC(1e-15).real > 1e-50
+    assert CC(1e-20).real > 1e-50
+    assert CC(1e-40).real > 1e-50
+
+    assert CC(3.14j).imag > 1e-50
+    assert CC(1e-13j).imag > 1e-50
+    assert CC(1e-14j).imag > 1e-50
+    assert CC(1e-15j).imag > 1e-50
+    assert CC(1e-20j).imag > 1e-50
+    assert CC(1e-40j).imag > 1e-50
+
+
+def test_gaussian_domains():
+    I = S.ImaginaryUnit
+    a, b, c, d = [ZZ_I.convert(x) for x in (5, 2 + I, 3 - I, 5 - 5*I)]
+    assert ZZ_I.gcd(a, b) == b
+    assert ZZ_I.gcd(a, c) == b
+    assert ZZ_I.lcm(a, b) == a
+    assert ZZ_I.lcm(a, c) == d
+    assert ZZ_I(3, 4) != QQ_I(3, 4)  # XXX is this right or should QQ->ZZ if possible?
+    assert ZZ_I(3, 0) != 3           # and should this go to Integer?
+    assert QQ_I(S(3)/4, 0) != S(3)/4 # and this to Rational?
+    assert ZZ_I(0, 0).quadrant() == 0
+    assert ZZ_I(-1, 0).quadrant() == 2
+
+    assert QQ_I.convert(QQ(3, 2)) == QQ_I(QQ(3, 2), QQ(0))
+    assert QQ_I.convert(QQ(3, 2), QQ) == QQ_I(QQ(3, 2), QQ(0))
+
+    for G in (QQ_I, ZZ_I):
+
+        q = G(3, 4)
+        assert str(q) == '3 + 4*I'
+        assert q.parent() == G
+        assert q._get_xy(pi) == (None, None)
+        assert q._get_xy(2) == (2, 0)
+        assert q._get_xy(2*I) == (0, 2)
+
+        assert hash(q) == hash((3, 4))
+        assert G(1, 2) == G(1, 2)
+        assert G(1, 2) != G(1, 3)
+        assert G(3, 0) == G(3)
+
+        assert q + q == G(6, 8)
+        assert q - q == G(0, 0)
+        assert 3 - q  == -q + 3 == G(0, -4)
+        assert 3 + q == q + 3 == G(6, 4)
+        assert q * q == G(-7, 24)
+        assert 3 * q == q * 3 == G(9, 12)
+        assert q ** 0 == G(1, 0)
+        assert q ** 1 == q
+        assert q ** 2 == q * q == G(-7, 24)
+        assert q ** 3 == q * q * q == G(-117, 44)
+        assert 1 / q == q ** -1 == QQ_I(S(3)/25, - S(4)/25)
+        assert q / 1 == QQ_I(3, 4)
+        assert q / 2 == QQ_I(S(3)/2, 2)
+        assert q/3 == QQ_I(1, S(4)/3)
+        assert 3/q == QQ_I(S(9)/25, -S(12)/25)
+        i, r = divmod(q, 2)
+        assert 2*i + r == q
+        i, r = divmod(2, q)
+        assert q*i + r == G(2, 0)
+
+        raises(ZeroDivisionError, lambda: q % 0)
+        raises(ZeroDivisionError, lambda: q / 0)
+        raises(ZeroDivisionError, lambda: q // 0)
+        raises(ZeroDivisionError, lambda: divmod(q, 0))
+        raises(ZeroDivisionError, lambda: divmod(q, 0))
+        raises(TypeError, lambda: q + x)
+        raises(TypeError, lambda: q - x)
+        raises(TypeError, lambda: x + q)
+        raises(TypeError, lambda: x - q)
+        raises(TypeError, lambda: q * x)
+        raises(TypeError, lambda: x * q)
+        raises(TypeError, lambda: q / x)
+        raises(TypeError, lambda: x / q)
+        raises(TypeError, lambda: q // x)
+        raises(TypeError, lambda: x // q)
+
+        assert G.from_sympy(S(2)) == G(2, 0)
+        assert G.to_sympy(G(2, 0)) == S(2)
+        raises(CoercionFailed, lambda: G.from_sympy(pi))
+
+        PR = G.inject(x)
+        assert isinstance(PR, PolynomialRing)
+        assert PR.domain == G
+        assert len(PR.gens) == 1 and PR.gens[0].as_expr() == x
+
+        if G is QQ_I:
+            AF = G.as_AlgebraicField()
+            assert isinstance(AF, AlgebraicField)
+            assert AF.domain == QQ
+            assert AF.ext.args[0] == I
+
+        for qi in [G(-1, 0), G(1, 0), G(0, -1), G(0, 1)]:
+            assert G.is_negative(qi) is False
+            assert G.is_positive(qi) is False
+            assert G.is_nonnegative(qi) is False
+            assert G.is_nonpositive(qi) is False
+
+        domains = [ZZ_python(), QQ_python(), AlgebraicField(QQ, I)]
+        if HAS_GMPY:
+            domains += [ZZ_gmpy(), QQ_gmpy()]
+
+        for K in domains:
+            assert G.convert(K(2)) == G(2, 0)
+            assert G.convert(K(2), K) == G(2, 0)
+
+        for K in ZZ_I, QQ_I:
+            assert G.convert(K(1, 1)) == G(1, 1)
+            assert G.convert(K(1, 1), K) == G(1, 1)
+
+        if G == ZZ_I:
+            assert repr(q) == 'ZZ_I(3, 4)'
+            assert q//3 == G(1, 1)
+            assert 12//q == G(1, -2)
+            assert 12 % q == G(1, 2)
+            assert q % 2 == G(-1, 0)
+            assert i == G(0, 0)
+            assert r == G(2, 0)
+            assert G.get_ring() == G
+            assert G.get_field() == QQ_I
+        else:
+            assert repr(q) == 'QQ_I(3, 4)'
+            assert G.get_ring() == ZZ_I
+            assert G.get_field() == G
+            assert q//3 == G(1, S(4)/3)
+            assert 12//q == G(S(36)/25, -S(48)/25)
+            assert 12 % q == G(0, 0)
+            assert q % 2 == G(0, 0)
+            assert i == G(S(6)/25, -S(8)/25), (G,i)
+            assert r == G(0, 0)
+            q2 = G(S(3)/2, S(5)/3)
+            assert G.numer(q2) == ZZ_I(9, 10)
+            assert G.denom(q2) == ZZ_I(6)
+
+
+def test_EX_EXRAW():
+    assert EXRAW.zero is S.Zero
+    assert EXRAW.one is S.One
+
+    assert EX(1) == EX.Expression(1)
+    assert EX(1).ex is S.One
+    assert EXRAW(1) is S.One
+
+    # EX has cancelling but EXRAW does not
+    assert 2*EX((x + y*x)/x) == EX(2 + 2*y) != 2*((x + y*x)/x)
+    assert 2*EXRAW((x + y*x)/x) == 2*((x + y*x)/x) != (1 + y)
+
+    assert EXRAW.convert_from(EX(1), EX) is EXRAW.one
+    assert EX.convert_from(EXRAW(1), EXRAW) == EX.one
+
+    assert EXRAW.from_sympy(S.One) is S.One
+    assert EXRAW.to_sympy(EXRAW.one) is S.One
+    raises(CoercionFailed, lambda: EXRAW.from_sympy([]))
+
+    assert EXRAW.get_field() == EXRAW
+
+    assert EXRAW.unify(EX) == EXRAW
+    assert EX.unify(EXRAW) == EXRAW
+
+
+def test_canonical_unit():
+
+    for K in [ZZ, QQ, RR]: # CC?
+        assert K.canonical_unit(K(2)) == K(1)
+        assert K.canonical_unit(K(-2)) == K(-1)
+
+    for K in [ZZ_I, QQ_I]:
+        i = K.from_sympy(I)
+        assert K.canonical_unit(K(2)) == K(1)
+        assert K.canonical_unit(K(2)*i) == -i
+        assert K.canonical_unit(-K(2)) == K(-1)
+        assert K.canonical_unit(-K(2)*i) == i
+
+    K = ZZ[x]
+    assert K.canonical_unit(K(x + 1)) == K(1)
+    assert K.canonical_unit(K(-x + 1)) == K(-1)
+
+    K = ZZ_I[x]
+    assert K.canonical_unit(K.from_sympy(I*x)) == ZZ_I(0, -1)
+
+    K = ZZ_I.frac_field(x, y)
+    i = K.from_sympy(I)
+    assert i / i == K.one
+    assert (K.one + i)/(i - K.one) == -i
+
+
+def test_issue_18278():
+    assert str(RR(2).parent()) == 'RR'
+    assert str(CC(2).parent()) == 'CC'
+
+
+def test_Domain_is_negative():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_negative(a) == False
+    assert CC.is_negative(b) == False
+
+
+def test_Domain_is_positive():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_positive(a) == False
+    assert CC.is_positive(b) == False
+
+
+def test_Domain_is_nonnegative():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_nonnegative(a) == False
+    assert CC.is_nonnegative(b) == False
+
+
+def test_Domain_is_nonpositive():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_nonpositive(a) == False
+    assert CC.is_nonpositive(b) == False
+
+
+def test_exponential_domain():
+    K = ZZ[E]
+    eK = K.from_sympy(E)
+    assert K.from_sympy(exp(3)) == eK ** 3
+    assert K.convert(exp(3)) == eK ** 3
+
+
+def test_AlgebraicField_alias():
+    # No default alias:
+    k = QQ.algebraic_field(sqrt(2))
+    assert k.ext.alias is None
+
+    # For a single extension, its alias is used:
+    alpha = AlgebraicNumber(sqrt(2), alias='alpha')
+    k = QQ.algebraic_field(alpha)
+    assert k.ext.alias.name == 'alpha'
+
+    # Can override the alias of a single extension:
+    k = QQ.algebraic_field(alpha, alias='theta')
+    assert k.ext.alias.name == 'theta'
+
+    # With multiple extensions, no default alias:
+    k = QQ.algebraic_field(sqrt(2), sqrt(3))
+    assert k.ext.alias is None
+
+    # With multiple extensions, no default alias, even if one of
+    # the extensions has one:
+    k = QQ.algebraic_field(alpha, sqrt(3))
+    assert k.ext.alias is None
+
+    # With multiple extensions, may set an alias:
+    k = QQ.algebraic_field(sqrt(2), sqrt(3), alias='theta')
+    assert k.ext.alias.name == 'theta'
+
+    # Alias is passed to constructed field elements:
+    k = QQ.algebraic_field(alpha)
+    beta = k.to_alg_num(k([1, 2, 3]))
+    assert beta.alias is alpha.alias

venv/lib/python3.10/site-packages/sympy/polys/domains/tests/test_quotientring.py

@@ -0,0 +1,52 @@
+"""Tests for quotient rings."""
+
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.abc import x, y
+
+from sympy.polys.polyerrors import NotReversible
+
+from sympy.testing.pytest import raises
+
+
+def test_QuotientRingElement():
+    R = QQ.old_poly_ring(x)/[x**10]
+    X = R.convert(x)
+
+    assert X*(X + 1) == R.convert(x**2 + x)
+    assert X*x == R.convert(x**2)
+    assert x*X == R.convert(x**2)
+    assert X + x == R.convert(2*x)
+    assert x + X == 2*X
+    assert X**2 == R.convert(x**2)
+    assert 1/(1 - X) == R.convert(sum(x**i for i in range(10)))
+    assert X**10 == R.zero
+    assert X != x
+
+    raises(NotReversible, lambda: 1/X)
+
+
+def test_QuotientRing():
+    I = QQ.old_poly_ring(x).ideal(x**2 + 1)
+    R = QQ.old_poly_ring(x)/I
+
+    assert R == QQ.old_poly_ring(x)/[x**2 + 1]
+    assert R == QQ.old_poly_ring(x)/QQ.old_poly_ring(x).ideal(x**2 + 1)
+    assert R != QQ.old_poly_ring(x)
+
+    assert R.convert(1)/x == -x + I
+    assert -1 + I == x**2 + I
+    assert R.convert(ZZ(1), ZZ) == 1 + I
+    assert R.convert(R.convert(x), R) == R.convert(x)
+
+    X = R.convert(x)
+    Y = QQ.old_poly_ring(x).convert(x)
+    assert -1 + I == X**2 + I
+    assert -1 + I == Y**2 + I
+    assert R.to_sympy(X) == x
+
+    raises(ValueError, lambda: QQ.old_poly_ring(x)/QQ.old_poly_ring(x, y).ideal(x))
+
+    R = QQ.old_poly_ring(x, order="ilex")
+    I = R.ideal(x)
+    assert R.convert(1) + I == (R/I).convert(1)

venv/lib/python3.10/site-packages/sympy/polys/matrices/__init__.py

@@ -0,0 +1,15 @@
+"""
+
+sympy.polys.matrices package.
+
+The main export from this package is the DomainMatrix class which is a
+lower-level implementation of matrices based on the polys Domains. This
+implementation is typically a lot faster than SymPy's standard Matrix class
+but is a work in progress and is still experimental.
+
+"""
+from .domainmatrix import DomainMatrix, DM
+
+__all__ = [
+    'DomainMatrix', 'DM',
+]