def test___eq__():
assert not QQ.inject(x) == ZZ.inject(x)
assert not QQ.inject(x).field == ZZ.inject(x).field
assert EX(1) != EX(2)
F11 = FF(11)
assert F11(2) != F11(3)
assert F11(2) != object()
def test_Domain_field():
assert EX.field == EX
assert ZZ.field == QQ
assert QQ.field == QQ
assert RR.field == RR
assert ALG.field == ALG
assert ZZ.inject(x).field == ZZ.frac_field(x)
assert QQ.inject(x).field == QQ.frac_field(x)
assert ZZ.inject(x, y).field == ZZ.frac_field(x, y)
assert QQ.inject(x, y).field == QQ.frac_field(x, y)
def test_methods():
R = QQ.inject(x)
X = R.convert(x)
assert R.is_normal(-X) is False
assert R.is_normal(+X) is True
assert R.gcdex(X**3 - X, X**2) == (-1, X, X)
F = QQ.inject(y).field
Y = F.convert(y)
assert F.is_normal(-Y) is False
assert F.is_normal(+Y) is True
def test_sympyissue_21460():
R = ZZ.inject('x')
r = R.gcd(R(4), R(6))
assert type(r) is R.dtype and r == 2
R = QQ.inject('x')
r = R.gcd(R(4), R(6))
assert type(r) is R.dtype and r == 1
def test_Domain___eq__():
assert (ZZ.inject(x, y) == ZZ.inject(x, y)) is True
assert (QQ.inject(x, y) == QQ.inject(x, y)) is True
assert (ZZ.inject(x, y) == QQ.inject(x, y)) is False
assert (QQ.inject(x, y) == ZZ.inject(x, y)) is False
assert (ZZ.inject(x, y).field == ZZ.inject(x, y).field) is True
assert (QQ.inject(x, y).field == QQ.inject(x, y).field) is True
assert (ZZ.inject(x, y).field == QQ.inject(x, y).field) is False
assert (QQ.inject(x, y).field == ZZ.inject(x, y).field) is False
def test_globalring():
Qxy = QQ.inject(x, y).field
R = QQ.inject(x, y)
X = R.convert(x)
Y = R.convert(y)
assert x in R
assert 1 / x not in R
assert 1 / (1 + x) not in R
assert Y in R
assert X.ring == R.ring
assert X * (Y**2 + 1) == R.convert(x * (y**2 + 1))
assert X * Y == R.convert(x * y)
assert X + Y == R.convert(x + y)
assert X - Y == R.convert(x - y)
assert X + 1 == R.convert(x + 1)
assert X**2 // X == X
assert R.convert(ZZ.inject(x, y).convert(x), ZZ.inject(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
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.inject(x).get_exact() == ZZ.inject(x)
assert QQ.inject(x).get_exact() == QQ.inject(x)
assert ZZ.inject(x, y).get_exact() == ZZ.inject(x, y)
assert QQ.inject(x, y).get_exact() == QQ.inject(x, y)
assert ZZ.inject(x).field.get_exact() == ZZ.inject(x).field
assert QQ.inject(x).field.get_exact() == QQ.inject(x).field
assert ZZ.inject(x, y).field.get_exact() == ZZ.inject(x, y).field
assert QQ.inject(x, y).field.get_exact() == QQ.inject(x, y).field
def test_units():
R = QQ.inject(x)
assert R.convert(1) == R.one
assert R.convert(x) != R.one
assert R.convert(1 + x) != R.one
R = QQ.poly_ring(x, order='ilex')
assert R.convert(1) == R.one
assert R.convert(x) != R.one
R = ZZ.inject(x)
assert R.convert(1) == R.one
assert R.convert(2) != R.one
assert R.convert(x) != R.one
assert R.convert(1 + x) != R.one
def test_conversion():
L = QQ.poly_ring(x, y, order='ilex')
G = QQ.inject(x, y)
assert L.convert(x) == L.convert(G.convert(x), G)
assert G.convert(x) == G.convert(L.convert(x), L)
pytest.raises(CoercionFailed, lambda: G.convert(L.convert(1 / (1 + x)), L))
R = ALG.inject(x, y)
assert R.convert(ALG(1), ALG) == R(1)
pytest.raises(CoercionFailed,
lambda: R.convert(ALG(1), QQ.algebraic_field(sqrt(2))))
R = R.drop(y)
pytest.raises(CoercionFailed, lambda: R.convert(G(y), R))
pytest.raises(CoercionFailed, lambda: R.convert(FF(8)(2)))
def test_localring():
Qxy = QQ.inject(x, y).field
R = QQ.poly_ring(x, y, order='ilex')
X = R.convert(x)
Y = R.convert(y)
assert x in R
assert 1 / x not in R
assert Y in R
assert X.ring == R.ring
assert X + Y == R.convert(x + y)
assert X - Y == R.convert(x - y)
assert X + 1 == R.convert(x + 1)
assert X**2 // X == X
assert R.convert(ZZ.inject(x, y).convert(x), ZZ.inject(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
def test_Domain_preprocess():
assert Domain.preprocess(ZZ) == ZZ
assert Domain.preprocess(QQ) == QQ
assert Domain.preprocess(EX) == EX
assert Domain.preprocess(FF(2)) == FF(2)
assert Domain.preprocess(ZZ.inject(x, y)) == ZZ.inject(x, y)
assert Domain.preprocess('Z') == ZZ
assert Domain.preprocess('Q') == QQ
assert Domain.preprocess('ZZ') == ZZ
assert Domain.preprocess('QQ') == QQ
assert Domain.preprocess('EX') == EX
assert Domain.preprocess('FF(23)') == FF(23)
assert Domain.preprocess('GF(23)') == GF(23)
pytest.raises(OptionError, lambda: Domain.preprocess('Z[]'))
assert Domain.preprocess('Z[x]') == ZZ.inject(x)
assert Domain.preprocess('Q[x]') == QQ.inject(x)
assert Domain.preprocess('ZZ[x]') == ZZ.inject(x)
assert Domain.preprocess('QQ[x]') == QQ.inject(x)
assert Domain.preprocess('Z[x,y]') == ZZ.inject(x, y)
assert Domain.preprocess('Q[x,y]') == QQ.inject(x, y)
assert Domain.preprocess('ZZ[x,y]') == ZZ.inject(x, y)
assert Domain.preprocess('QQ[x,y]') == QQ.inject(x, y)
pytest.raises(OptionError, lambda: Domain.preprocess('Z()'))
assert Domain.preprocess('Z(x)') == ZZ.inject(x).field
assert Domain.preprocess('Q(x)') == QQ.inject(x).field
assert Domain.preprocess('ZZ(x)') == ZZ.inject(x).field
assert Domain.preprocess('QQ(x)') == QQ.inject(x).field
assert Domain.preprocess('Z(x,y)') == ZZ.inject(x, y).field
assert Domain.preprocess('Q(x,y)') == QQ.inject(x, y).field
assert Domain.preprocess('ZZ(x,y)') == ZZ.inject(x, y).field
assert Domain.preprocess('QQ(x,y)') == QQ.inject(x, y).field
assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
assert Domain.preprocess('QQ<sqrt(2), I>') == QQ.algebraic_field(
sqrt(2), I)
pytest.raises(OptionError, lambda: Domain.preprocess('abc'))
assert Domain.preprocess('RR') == RR
assert Domain.preprocess('RR_5') == RealField(prec=5)
assert Domain.preprocess('CC') == CC
assert Domain.preprocess('CC_5') == ComplexField(prec=5)
pytest.raises(OptionError, lambda: Domain.preprocess(()))
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.inject(x, y)) is True
assert (0 in QQ.inject(x, y)) is True
assert (0 in RR.inject(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.inject(x, y)) is True
assert (-7 in QQ.inject(x, y)) is True
assert (-7 in RR.inject(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.inject(x, y)) is True
assert (17 in QQ.inject(x, y)) is True
assert (17 in RR.inject(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.inject(x, y)) is False
assert (-Rational(1, 7) in QQ.inject(x, y)) is True
assert (-Rational(1, 7) in RR.inject(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.inject(x, y)) is False
assert (Rational(3, 5) in QQ.inject(x, y)) is True
assert (Rational(3, 5) in RR.inject(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.inject(x, y)) is True
assert (3.0 in QQ.inject(x, y)) is True
assert (3.0 in RR.inject(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.inject(x, y)) is False
assert (3.14 in QQ.inject(x, y)) is True
assert (3.14 in RR.inject(x, y)) is True
assert (oo in EX) is True
assert (oo in ZZ) is False
assert (oo in QQ) is False
assert (oo in RR) is True
assert (oo in CC) is True
assert (oo in ALG) is False
assert (oo in ZZ.inject(x, y)) is False
assert (oo in QQ.inject(x, y)) is False
assert (oo in RR.inject(x, y)) is True
assert (-oo in EX) is True
assert (-oo in ZZ) is False
assert (-oo in QQ) is False
assert (-oo in RR) is True
assert (-oo in CC) is True
assert (-oo in ALG) is False
assert (-oo in ZZ.inject(x, y)) is False
assert (-oo in QQ.inject(x, y)) is False
assert (-oo in RR.inject(x, y)) is True
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.inject(x, y)) is False
assert (sqrt(7) in QQ.inject(x, y)) is False
assert (sqrt(7) in RR.inject(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.inject(x, y)) is False
assert (2 * sqrt(3) + 1 in QQ.inject(x, y)) is False
assert (2 * sqrt(3) + 1 in RR.inject(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.inject(x, y)) is False
assert (sin(1) in QQ.inject(x, y)) is False
assert (sin(1) in RR.inject(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.inject(x)) is True
assert (x**2 + 1 in QQ.inject(x)) is True
assert (x**2 + 1 in RR.inject(x)) is True
assert (x**2 + 1 in ZZ.inject(x, y)) is True
assert (x**2 + 1 in QQ.inject(x, y)) is True
assert (x**2 + 1 in RR.inject(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.inject(x)) is False
assert (x**2 + y**2 in QQ.inject(x)) is False
assert (x**2 + y**2 in RR.inject(x)) is False
assert (x**2 + y**2 in ZZ.inject(x, y)) is True
assert (x**2 + y**2 in QQ.inject(x, y)) is True
assert (x**2 + y**2 in RR.inject(x, y)) is True
assert (Rational(3, 2) * x / (y + 1) - z in QQ.inject(x, y, z)) is False
R = QQ.inject(x)
assert R(1) in ZZ
F = R.field
assert F(1) in ZZ
def test_PrettyPoly():
F = QQ.inject(x, y).field
R = QQ.inject(x, y)
assert sstr(F.convert(x / (x + y))) == sstr(x / (x + y))
assert sstr(R.convert(x + y)) == sstr(x + y)
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == F3
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ.inject(x)) == F3.inject(x)
assert unify(F3, ZZ.inject(x).field) == F3.inject(x).field
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == F3
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.inject(x)) == ZZ.inject(x)
assert unify(ZZ, ZZ.inject(x).field) == ZZ.inject(x).field
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.inject(x)) == QQ.inject(x)
assert unify(QQ, ZZ.inject(x).field) == QQ.inject(x).field
assert unify(QQ, 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.inject(x)) == RR.inject(x)
assert unify(RR, ZZ.inject(x).field) == RR.inject(x).field
assert unify(RR, EX) == EX
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.inject(x)) == CC.inject(x)
assert unify(CC, ZZ.inject(x).field) == CC.inject(x).field
assert unify(CC, EX) == EX
CC2 = ComplexField(prec=20)
assert unify(CC, CC2) == unify(CC2, CC) == ComplexField(prec=CC.precision,
tol=CC2.tolerance)
RR2 = RealField(prec=20)
assert unify(RR, RR2) == unify(RR2, RR) == RealField(prec=RR.precision,
tol=RR2.tolerance)
assert unify(ZZ.inject(x), F3) == F3.inject(x)
assert unify(ZZ.inject(x), ZZ) == ZZ.inject(x)
assert unify(ZZ.inject(x), QQ) == QQ.inject(x)
assert unify(ZZ.inject(x), ALG) == ALG.inject(x)
assert unify(ZZ.inject(x), RR) == RR.inject(x)
assert unify(ZZ.inject(x), CC) == CC.inject(x)
assert unify(ZZ.inject(x), ZZ.inject(x)) == ZZ.inject(x)
assert unify(ZZ.inject(x), ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x), EX) == EX
assert unify(ZZ.inject(x).field, F3) == F3.inject(x).field
assert unify(ZZ.inject(x).field, ZZ) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, QQ) == QQ.inject(x).field
assert unify(ZZ.inject(x).field, ALG) == ALG.inject(x).field
assert unify(ZZ.inject(x).field, RR) == RR.inject(x).field
assert unify(ZZ.inject(x).field, CC) == CC.inject(x).field
assert unify(ZZ.inject(x).field, ZZ.inject(x)) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, 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.inject(x)) == EX
assert unify(EX, ZZ.inject(x).field) == EX
assert unify(EX, EX) == EX
def test_Domain_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ.inject(x).has_assoc_Ring is True
assert QQ.inject(x).has_assoc_Ring is True
assert ZZ.inject(x, y).has_assoc_Ring is True
assert QQ.inject(x, y).has_assoc_Ring is True
assert ZZ.inject(x).field.has_assoc_Ring is True
assert QQ.inject(x).field.has_assoc_Ring is True
assert ZZ.inject(x, y).field.has_assoc_Ring is True
assert QQ.inject(x, y).field.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.ring == ZZ
assert QQ.ring == ZZ
assert ZZ.inject(x).ring == ZZ.inject(x)
assert QQ.inject(x).ring == QQ.inject(x)
assert ZZ.inject(x, y).ring == ZZ.inject(x, y)
assert QQ.inject(x, y).ring == QQ.inject(x, y)
assert ZZ.inject(x).field.ring == ZZ.inject(x)
assert QQ.inject(x).field.ring == QQ.inject(x)
assert ZZ.inject(x, y).field.ring == ZZ.inject(x, y)
assert QQ.inject(x, y).field.ring == QQ.inject(x, y)
assert EX.ring == EX
pytest.raises(AttributeError, lambda: RR.ring)
pytest.raises(NotImplementedError, lambda: ALG.ring)
def test_construct_domain():
assert construct_domain([1, 2, 3]) == (ZZ, [ZZ(1), ZZ(2), ZZ(3)])
assert construct_domain([1, 2, 3],
field=True) == (QQ, [QQ(1), QQ(2),
QQ(3)])
assert construct_domain([Integer(1), Integer(2),
Integer(3)]) == (ZZ, [ZZ(1), ZZ(2),
ZZ(3)])
assert construct_domain(
[Integer(1), Integer(2), Integer(3)],
field=True) == (QQ, [QQ(1), QQ(2), QQ(3)])
assert construct_domain([Rational(1, 2),
Integer(2)]) == (QQ, [QQ(1, 2), QQ(2)])
assert construct_domain([3.14, 1, Rational(1, 2)
]) == (RR, [RR(3.14), RR(1.0),
RR(0.5)])
assert construct_domain([3.14, sqrt(2)],
extension=False) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([3.14, sqrt(2)]) == (EX, [EX(3.14), EX(sqrt(2))])
assert construct_domain([sqrt(2), 3.14]) == (EX, [EX(sqrt(2)), EX(3.14)])
assert construct_domain([1, sqrt(2)],
extension=False) == (EX, [EX(1),
EX(sqrt(2))])
assert construct_domain([x, sqrt(x)]) == (EX, [EX(x), EX(sqrt(x))])
assert construct_domain([x, sqrt(x), sqrt(y)
]) == (EX, [EX(x),
EX(sqrt(x)),
EX(sqrt(y))])
alg = QQ.algebraic_field(sqrt(2))
assert (construct_domain(
[7, Rational(1, 2),
sqrt(2)]) == (alg, [alg([7]),
alg([Rational(1, 2)]),
alg([1, 0])]))
alg = QQ.algebraic_field(sqrt(2) + sqrt(3))
assert (construct_domain([7, sqrt(2), sqrt(3)]) == (alg, [
alg([7]), alg.from_expr(sqrt(2)),
alg.from_expr(sqrt(3))
]))
dom = ZZ.inject(x)
assert construct_domain([2 * x, 3]) == (dom, [dom(2 * x), dom(3)])
dom = ZZ.inject(x, y)
assert construct_domain([2 * x, 3 * y]) == (dom, [dom(2 * x), dom(3 * y)])
dom = QQ.inject(x)
assert construct_domain([x / 2, 3]) == (dom, [dom(x / 2), dom(3)])
dom = QQ.inject(x, y)
assert construct_domain([x / 2, 3 * y]) == (dom, [dom(x / 2), dom(3 * y)])
dom = RR.inject(x)
assert construct_domain([x / 2, 3.5]) == (dom, [dom(x / 2), dom(3.5)])
dom = RR.inject(x, y)
assert construct_domain([x / 2,
3.5 * y]) == (dom, [dom(x / 2),
dom(3.5 * y)])
dom = ZZ.inject(x).field
assert construct_domain([2 / x, 3]) == (dom, [dom(2 / x), dom(3)])
dom = ZZ.inject(x, y).field
assert construct_domain([2 / x, 3 * y]) == (dom, [dom(2 / x), dom(3 * y)])
dom = RR.inject(x).field
assert construct_domain([2 / x, 3.5]) == (dom, [dom(2 / x), dom(3.5)])
dom = RR.inject(x, y).field
assert construct_domain([2 / x,
3.5 * y]) == (dom, [dom(2 / x),
dom(3.5 * y)])
assert construct_domain(2) == (ZZ, ZZ(2))
assert construct_domain(Rational(2, 3)) == (QQ, QQ(2, 3))
assert construct_domain({}) == (ZZ, {})
assert construct_domain([-x * y + x * (y + 42) - 42 * x
]) == (EX, [EX(-x * y + x * (y + 42) - 42 * x)])
def test_poly_frac():
pytest.raises(GeneratorsNeeded, lambda: QQ.inject())
pytest.raises(GeneratorsNeeded, lambda: QQ.inject().field)
def test_Domain_unify_composite():
assert unify(ZZ.inject(x), ZZ) == ZZ.inject(x)
assert unify(ZZ.inject(x), QQ) == QQ.inject(x)
assert unify(QQ.inject(x), ZZ) == QQ.inject(x)
assert unify(QQ.inject(x), QQ) == QQ.inject(x)
assert unify(ZZ, ZZ.inject(x)) == ZZ.inject(x)
assert unify(QQ, ZZ.inject(x)) == QQ.inject(x)
assert unify(ZZ, QQ.inject(x)) == QQ.inject(x)
assert unify(QQ, QQ.inject(x)) == QQ.inject(x)
assert unify(ZZ.inject(x, y), ZZ) == ZZ.inject(x, y)
assert unify(ZZ.inject(x, y), QQ) == QQ.inject(x, y)
assert unify(QQ.inject(x, y), ZZ) == QQ.inject(x, y)
assert unify(QQ.inject(x, y), QQ) == QQ.inject(x, y)
assert unify(ZZ, ZZ.inject(x, y)) == ZZ.inject(x, y)
assert unify(QQ, ZZ.inject(x, y)) == QQ.inject(x, y)
assert unify(ZZ, QQ.inject(x, y)) == QQ.inject(x, y)
assert unify(QQ, QQ.inject(x, y)) == QQ.inject(x, y)
assert unify(ZZ.inject(x).field, ZZ) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, QQ) == QQ.inject(x).field
assert unify(QQ.inject(x).field, ZZ) == QQ.inject(x).field
assert unify(QQ.inject(x).field, QQ) == QQ.inject(x).field
assert unify(ZZ, ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(QQ, ZZ.inject(x).field) == QQ.inject(x).field
assert unify(ZZ, QQ.inject(x).field) == QQ.inject(x).field
assert unify(QQ, QQ.inject(x).field) == QQ.inject(x).field
assert unify(ZZ.inject(x, y).field, ZZ) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x, y).field, QQ) == QQ.inject(x, y).field
assert unify(QQ.inject(x, y).field, ZZ) == QQ.inject(x, y).field
assert unify(QQ.inject(x, y).field, QQ) == QQ.inject(x, y).field
assert unify(ZZ, ZZ.inject(x, y).field) == ZZ.inject(x, y).field
assert unify(QQ, ZZ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(ZZ, QQ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(QQ, QQ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(ZZ.inject(x), ZZ.inject(x)) == ZZ.inject(x)
assert unify(ZZ.inject(x), QQ.inject(x)) == QQ.inject(x)
assert unify(QQ.inject(x), ZZ.inject(x)) == QQ.inject(x)
assert unify(QQ.inject(x), QQ.inject(x)) == QQ.inject(x)
assert unify(ZZ.inject(x, y), ZZ.inject(x)) == ZZ.inject(x, y)
assert unify(ZZ.inject(x, y), QQ.inject(x)) == QQ.inject(x, y)
assert unify(QQ.inject(x, y), ZZ.inject(x)) == QQ.inject(x, y)
assert unify(QQ.inject(x, y), QQ.inject(x)) == QQ.inject(x, y)
assert unify(ZZ.inject(x), ZZ.inject(x, y)) == ZZ.inject(x, y)
assert unify(ZZ.inject(x), QQ.inject(x, y)) == QQ.inject(x, y)
assert unify(QQ.inject(x), ZZ.inject(x, y)) == QQ.inject(x, y)
assert unify(QQ.inject(x), QQ.inject(x, y)) == QQ.inject(x, y)
assert unify(ZZ.inject(x, y), ZZ.inject(x, z)) == ZZ.inject(x, y, z)
assert unify(ZZ.inject(x, y), QQ.inject(x, z)) == QQ.inject(x, y, z)
assert unify(QQ.inject(x, y), ZZ.inject(x, z)) == QQ.inject(x, y, z)
assert unify(QQ.inject(x, y), QQ.inject(x, z)) == QQ.inject(x, y, z)
assert unify(ZZ.inject(x).field, ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, QQ.inject(x).field) == QQ.inject(x).field
assert unify(QQ.inject(x).field, ZZ.inject(x).field) == QQ.inject(x).field
assert unify(QQ.inject(x).field, QQ.inject(x).field) == QQ.inject(x).field
assert unify(ZZ.inject(x, y).field,
ZZ.inject(x).field) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x, y).field,
QQ.inject(x).field) == QQ.inject(x, y).field
assert unify(QQ.inject(x, y).field,
ZZ.inject(x).field) == QQ.inject(x, y).field
assert unify(QQ.inject(x, y).field,
QQ.inject(x).field) == QQ.inject(x, y).field
assert unify(ZZ.inject(x).field,
ZZ.inject(x, y).field) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x).field,
QQ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(QQ.inject(x).field,
ZZ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(QQ.inject(x).field,
QQ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(ZZ.inject(x, y).field,
ZZ.inject(x, z).field) == ZZ.inject(x, y, z).field
assert unify(ZZ.inject(x, y).field,
QQ.inject(x, z).field) == QQ.inject(x, y, z).field
assert unify(QQ.inject(x, y).field,
ZZ.inject(x, z).field) == QQ.inject(x, y, z).field
assert unify(QQ.inject(x, y).field,
QQ.inject(x, z).field) == QQ.inject(x, y, z).field
assert unify(ZZ.inject(x), ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x), QQ.inject(x).field) == ZZ.inject(x).field
assert unify(QQ.inject(x), ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(QQ.inject(x), QQ.inject(x).field) == QQ.inject(x).field
assert unify(ZZ.inject(x, y), ZZ.inject(x).field) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x, y), QQ.inject(x).field) == ZZ.inject(x, y).field
assert unify(QQ.inject(x, y), ZZ.inject(x).field) == ZZ.inject(x, y).field
assert unify(QQ.inject(x, y), QQ.inject(x).field) == QQ.inject(x, y).field
assert unify(ZZ.inject(x), ZZ.inject(x, y).field) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x), QQ.inject(x, y).field) == ZZ.inject(x, y).field
assert unify(QQ.inject(x), ZZ.inject(x, y).field) == ZZ.inject(x, y).field
assert unify(QQ.inject(x), QQ.inject(x, y).field) == QQ.inject(x, y).field
assert unify(ZZ.inject(x, y),
ZZ.inject(x, z).field) == ZZ.inject(x, y, z).field
assert unify(ZZ.inject(x, y),
QQ.inject(x, z).field) == ZZ.inject(x, y, z).field
assert unify(QQ.inject(x, y),
ZZ.inject(x, z).field) == ZZ.inject(x, y, z).field
assert unify(QQ.inject(x, y),
QQ.inject(x, z).field) == QQ.inject(x, y, z).field
assert unify(ZZ.inject(x).field, ZZ.inject(x)) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, QQ.inject(x)) == ZZ.inject(x).field
assert unify(QQ.inject(x).field, ZZ.inject(x)) == ZZ.inject(x).field
assert unify(QQ.inject(x).field, QQ.inject(x)) == QQ.inject(x).field
assert unify(ZZ.inject(x, y).field, ZZ.inject(x)) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x, y).field, QQ.inject(x)) == ZZ.inject(x, y).field
assert unify(QQ.inject(x, y).field, ZZ.inject(x)) == ZZ.inject(x, y).field
assert unify(QQ.inject(x, y).field, QQ.inject(x)) == QQ.inject(x, y).field
assert unify(ZZ.inject(x).field, ZZ.inject(x, y)) == ZZ.inject(x, y).field
assert unify(ZZ.inject(x).field, QQ.inject(x, y)) == ZZ.inject(x, y).field
assert unify(QQ.inject(x).field, ZZ.inject(x, y)) == ZZ.inject(x, y).field
assert unify(QQ.inject(x).field, QQ.inject(x, y)) == QQ.inject(x, y).field
assert unify(ZZ.inject(x, y).field, ZZ.inject(x, z)) == ZZ.inject(x, y,
z).field
assert unify(ZZ.inject(x, y).field, QQ.inject(x, z)) == ZZ.inject(x, y,
z).field
assert unify(QQ.inject(x, y).field, ZZ.inject(x, z)) == ZZ.inject(x, y,
z).field
assert unify(QQ.inject(x, y).field, QQ.inject(x, z)) == QQ.inject(x, y,
z).field
