fixing sympy tests #581

Schefflera-Arboricola · 2025-04-30T11:40:34Z

Description

Kindly take a look at CONTRIBUTING.md.

Please describe the purpose of this pull request. Reference and link to any relevant issues or pull requests.

resolves #579

Failure messages from CI : https://github.com/scikit-hep/vector/actions/runs/14703378893

=================================== FAILURES ===================================
_____________________________ test_lorentz_object ______________________________

    def test_lorentz_object():
        v1 = vector.MomentumSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyZ(z),
            vector.backends.sympy.TemporalSympyTau(t),
        )
        v2 = vector.MomentumSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(nx, ny),
            vector.backends.sympy.LongitudinalSympyZ(nz),
            vector.backends.sympy.TemporalSympyTau(nt),
        )
>       assert v1.deltaRapidityPhi(v2) == sympy.sqrt(
            0.25
            * (
                -sympy.log(
                    (nz + sympy.sqrt(nt**2 + nx**2 + ny**2 + nz**2))
                    / (-nz + sympy.sqrt(nt**2 + nx**2 + ny**2 + nz**2))
                )
                + sympy.log(
                    (z + sympy.sqrt(t**2 + x**2 + y**2 + z**2))
                    / (-z + sympy.sqrt(t**2 + x**2 + y**2 + z**2))
                )
            )
            ** 2
            + (
                sympy.Mod(-sympy.atan2(ny, nx) + sympy.atan2(y, x) + sympy.pi, 2 * sympy.pi)
                - sympy.pi
            )
            ** 2
        )
E       assert sqrt((-0.5*log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + 0.5*log((z + ...2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2) == sqrt(0.25*(-log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + log((z + sqr...2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2)
E        +  where sqrt((-0.5*log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + 0.5*log((z + ...2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2) = deltaRapidityPhi(MomentumSympy4D(px=nx, py=ny, pz=nz, mass=nt))
E        +    where deltaRapidityPhi = MomentumSympy4D(px=x, py=y, pz=z, mass=t).deltaRapidityPhi
E        +  and   sqrt(0.25*(-log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + log((z + sqr...2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2) = <function sqrt at 0x7f3a3ec289a0>(((0.25 * ((-log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + log((z + sqrt(t**2 + x**2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2)))) ** 2)) + ((Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi) ** 2)))
E        +    where <function sqrt at 0x7f3a3ec[289](https://github.com/scikit-hep/vector/actions/runs/14703378893/job/41257579268#step:7:290)a0> = sympy.sqrt
E        +    and   log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) = log(((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2)) / (-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))))
E        +      where log = sympy.log
E        +      and   sqrt(nt**2 + nx**2 + ny**2 + nz**2) = <function sqrt at 0x7f3a3ec289a0>(((((nt ** 2) + (nx ** 2)) + (ny ** 2)) + (nz ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   sqrt(nt**2 + nx**2 + ny**2 + nz**2) = <function sqrt at 0x7f3a3ec289a0>(((((nt ** 2) + (nx ** 2)) + (ny ** 2)) + (nz ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   log((z + sqrt(t**2 + x**2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))) = log(((z + sqrt(t**2 + x**2 + y**2 + z**2)) / (-z + sqrt(t**2 + x**2 + y**2 + z**2))))
E        +      where log = sympy.log
E        +      and   sqrt(t**2 + x**2 + y**2 + z**2) = <function sqrt at 0x7f3a3ec289a0>(((((t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   sqrt(t**2 + x**2 + y**2 + z**2) = <function sqrt at 0x7f3a3ec289a0>(((((t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) = Mod(((-atan2(ny, nx) + atan2(y, x)) + pi), (2 * pi))
E        +      where Mod = sympy.Mod
E        +      and   atan2(ny, nx) = atan2(ny, nx)
E        +        where atan2 = sympy.atan2
E        +      and   atan2(y, x) = atan2(y, x)
E        +        where atan2 = sympy.atan2
E        +      and   pi = sympy.pi
E        +      and   pi = sympy.pi
E        +    and   pi = sympy.pi

tests/compute/sympy/lorentz/test_deltaRapidityPhi.py:31: AssertionError
______________________________ test_lorentz_sympy ______________________________

    def test_lorentz_sympy():
        v1 = vector.MomentumSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyZ(z),
            vector.backends.sympy.TemporalSympyTau(t),
        )
        v2 = vector.MomentumSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(nx, ny),
            vector.backends.sympy.LongitudinalSympyZ(nz),
            vector.backends.sympy.TemporalSympyTau(nt),
        )
>       assert (
            v1.deltaRapidityPhi2(v2)
            == 0.25
            * (
                -sympy.log(
                    (nz + sympy.sqrt(nt**2 + nx**2 + ny**2 + nz**2))
                    / (-nz + sympy.sqrt(nt**2 + nx**2 + ny**2 + nz**2))
                )
                + sympy.log(
                    (z + sympy.sqrt(t**2 + x**2 + y**2 + z**2))
                    / (-z + sympy.sqrt(t**2 + x**2 + y**2 + z**2))
                )
            )
            ** 2
            + (
                sympy.Mod(-sympy.atan2(ny, nx) + sympy.atan2(y, x) + sympy.pi, 2 * sympy.pi)
                - sympy.pi
            )
            ** 2
        )
E       assert (-0.5*log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + 0.5*log((z + sqrt(...*2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2 == ((0.25 * ((-log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + log((z + sqrt(t**2 + x**2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2)))) ** 2)) + ((Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi) ** 2))
E        +  where (-0.5*log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) + 0.5*log((z + sqrt(...*2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))))**2 + (Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) - pi)**2 = deltaRapidityPhi2(MomentumSympy4D(px=nx, py=ny, pz=nz, mass=nt))
E        +    where deltaRapidityPhi2 = MomentumSympy4D(px=x, py=y, pz=z, mass=t).deltaRapidityPhi2
E        +  and   log((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))/(-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))) = log(((nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2)) / (-nz + sqrt(nt**2 + nx**2 + ny**2 + nz**2))))
E        +    where log = sympy.log
E        +    and   sqrt(nt**2 + nx**2 + ny**2 + nz**2) = <function sqrt at 0x7f3a3ec289a0>(((((nt ** 2) + (nx ** 2)) + (ny ** 2)) + (nz ** 2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   sqrt(nt**2 + nx**2 + ny**2 + nz**2) = <function sqrt at 0x7f3a3ec289a0>(((((nt ** 2) + (nx ** 2)) + (ny ** 2)) + (nz ** 2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +  and   log((z + sqrt(t**2 + x**2 + y**2 + z**2))/(-z + sqrt(t**2 + x**2 + y**2 + z**2))) = log(((z + sqrt(t**2 + x**2 + y**2 + z**2)) / (-z + sqrt(t**2 + x**2 + y**2 + z**2))))
E        +    where log = sympy.log
E        +    and   sqrt(t**2 + x**2 + y**2 + z**2) = <function sqrt at 0x7f3a3ec289a0>(((((t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   sqrt(t**2 + x**2 + y**2 + z**2) = <function sqrt at 0x7f3a3ec289a0>(((((t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +  and   Mod(-atan2(ny, nx) + atan2(y, x) + pi, 2*pi) = Mod(((-atan2(ny, nx) + atan2(y, x)) + pi), (2 * pi))
E        +    where Mod = sympy.Mod
E        +    and   atan2(ny, nx) = atan2(ny, nx)
E        +      where atan2 = sympy.atan2
E        +    and   atan2(y, x) = atan2(y, x)
E        +      where atan2 = sympy.atan2
E        +    and   pi = sympy.pi
E        +    and   pi = sympy.pi
E        +  and   pi = sympy.pi

tests/compute/sympy/lorentz/test_deltaRapidityPhi2.py:31: AssertionError
________________________________ test_xy_eta_t _________________________________

    def test_xy_eta_t():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyXY(x, y),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyT(t),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.gamma == t / sympy.sqrt(
            sympy.Abs(
                t**2
                - 0.25
                * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
                * (x**2 + y**2)
                * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            )
        )
E       assert t/sqrt(Abs(t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) == (t / sqrt(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))))
E        +  where t/sqrt(Abs(t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), t=t).gamma
E        +  and   sqrt(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) = <function sqrt at 0x7f3a3ec289a0>(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)))))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)))) = Abs(((t ** 2) - (((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2))))))
E        +      where Abs = sympy.Abs
E        +      and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +        where exp = sympy.exp
E        +        and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +          where asinh = sympy.asinh
E        +          and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +            where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +        where exp = sympy.exp
E        +        and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +          where asinh = sympy.asinh
E        +          and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +            where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt

tests/compute/sympy/lorentz/test_gamma.py:81: AssertionError
_______________________________ test_xy_eta_tau ________________________________

    def test_xy_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyXY(x, y),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.gamma == sympy.sqrt(
            0.25
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * (x**2 + y**2)
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        ) / sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
E       assert sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2))/sqrt(Abs(-t**2 + x**2 + y**2 + z**2)) == (sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) / sqrt(Abs(-t**2 + x**2 + y**2 + z**2)))
E        +  where sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2))/sqrt(Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), tau=sqrt(Abs(-t**2 + x**2 + y**2 + z**2))).gamma
E        +  and   sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs
E        +  and   sqrt(Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(Abs(-t**2 + x**2 + y**2 + z**2))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_gamma.py:104: AssertionError
______________________________ test_rhophi_eta_t _______________________________

    def test_rhophi_eta_t():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(sympy.asinh(z / rho)),
            temporal=vector.backends.sympy.TemporalSympyT(t),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.gamma == t / sympy.sqrt(
            sympy.Abs(
                0.25
                * rho**2
                * (1 + sympy.exp(-2 * sympy.asinh(z / rho))) ** 2
                * sympy.exp(2 * sympy.asinh(z / rho))
                - t**2
            )
        )
E       assert t/sqrt(Abs(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2)) == (t / sqrt(Abs(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2)))
E        +  where t/sqrt(Abs(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2)) = VectorSympy4D(rho=rho, phi=phi, eta=asinh(z/rho), t=t).gamma
E        +  and   sqrt(Abs(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2)) = <function sqrt at 0x7f3a3ec289a0>(Abs(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) - t**2) = Abs(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) - (t ** 2)))
E        +      where Abs = sympy.Abs
E        +      and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh
E        +      and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh

tests/compute/sympy/lorentz/test_gamma.py:173: AssertionError
_____________________________ test_rhophi_eta_tau ______________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(sympy.asinh(z / rho)),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(rho**2 - t**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.gamma == sympy.sqrt(
            0.25
            * rho**2
            * (1 + sympy.exp(-2 * sympy.asinh(z / rho))) ** 2
            * sympy.exp(2 * sympy.asinh(z / rho))
            + sympy.Abs(rho**2 - t**2 + z**2)
        ) / sympy.sqrt(sympy.Abs(rho**2 - t**2 + z**2))
E       assert sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2))/sqrt(Abs(rho**2 - t**2 + z**2)) == (sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) / sqrt(Abs(rho**2 - t**2 + z**2)))
E        +  where sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2))/sqrt(Abs(rho**2 - t**2 + z**2)) = VectorSympy4D(rho=rho, phi=phi, eta=asinh(z/rho), tau=sqrt(Abs(rho**2 - t**2 + z**2))).gamma
E        +  and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) + Abs(rho**2 - t**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +      where exp = sympy.exp
E        +      and   asinh(z/rho) = asinh((z / rho))
E        +        where asinh = sympy.asinh
E        +    and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +      where exp = sympy.exp
E        +      and   asinh(z/rho) = asinh((z / rho))
E        +        where asinh = sympy.asinh
E        +    and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs
E        +  and   sqrt(Abs(rho**2 - t**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(Abs(rho**2 - t**2 + z**2))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_gamma.py:194: AssertionError
_____________________________ test_rhophi_eta_tau ______________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            vector.backends.sympy.LongitudinalSympyEta(sympy.asinh(z / rho)),
            vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(rho**2 - t**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.rapidity == 0.5 * sympy.log(
            (
                z
                + sympy.sqrt(
                    0.25
                    * rho**2
                    * (1 + sympy.exp(-2 * sympy.asinh(z / rho))) ** 2
                    * sympy.exp(2 * sympy.asinh(z / rho))
                    + sympy.Abs(rho**2 - t**2 + z**2)
                )
            )
            / (
                -z
                + sympy.sqrt(
                    0.25
                    * rho**2
                    * (1 + sympy.exp(-2 * sympy.asinh(z / rho))) ** 2
                    * sympy.exp(2 * sympy.asinh(z / rho))
                    + sympy.Abs(rho**2 - t**2 + z**2)
                )
            )
        )
E       assert 0.5*log((z + sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))/(-z + sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))) == (0.5 * log((z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))/(-z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))))
E        +  where 0.5*log((z + sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))/(-z + sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))) = VectorSympy4D(rho=rho, phi=phi, eta=asinh(z/rho), tau=sqrt(Abs(rho**2 - t**2 + z**2))).rapidity
E        +  and   log((z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))/(-z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))) = log(((z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2))) / (-z + sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)))))
E        +    where log = sympy.log
E        +    and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) + Abs(rho**2 - t**2 + z**2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh
E        +      and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh
E        +      and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +        where Abs = sympy.Abs
E        +    and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) + Abs(rho**2 - t**2 + z**2)))
E        +      where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh
E        +      and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +        where exp = sympy.exp
E        +        and   asinh(z/rho) = asinh((z / rho))
E        +          where asinh = sympy.asinh
E        +      and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +        where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_rapidity.py:217: AssertionError
_______________________________ test_xy_eta_tau ________________________________

    def test_xy_eta_tau():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.t == sympy.sqrt(
            0.25
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * (x**2 + y**2)
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
E       assert sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) == sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2))
E        +  where sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), tau=sqrt(Abs(-t**2 + x**2 + y**2 + z**2))).t
E        +  and   sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_t.py:95: AssertionError
_____________________________ test_rhophi_eta_tau ______________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            vector.backends.sympy.LongitudinalSympyEta(sympy.asinh(z / rho)),
            vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(rho**2 - t**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.t == sympy.sqrt(
            0.25
            * rho**2
            * (1 + sympy.exp(-2 * sympy.asinh(z / rho))) ** 2
            * sympy.exp(2 * sympy.asinh(z / rho))
            + sympy.Abs(rho**2 - t**2 + z**2)
        )
E       assert sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) == sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2))
E        +  where sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) = VectorSympy4D(rho=rho, phi=phi, eta=asinh(z/rho), tau=sqrt(Abs(rho**2 - t**2 + z**2))).t
E        +  and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) + Abs(rho**2 - t**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +      where exp = sympy.exp
E        +      and   asinh(z/rho) = asinh((z / rho))
E        +        where asinh = sympy.asinh
E        +    and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +      where exp = sympy.exp
E        +      and   asinh(z/rho) = asinh((z / rho))
E        +        where asinh = sympy.asinh
E        +    and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_t.py:176: AssertionError
_______________________________ test_xy_eta_tau ________________________________

    def test_xy_eta_tau():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.t2 == 0.25 * (
            1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
        ) ** 2 * (x**2 + y**2) * sympy.exp(
            2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2))
        ) + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
E       assert (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2) == ((((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2))
E        +  where (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), tau=sqrt(Abs(-t**2 + x**2 + y**2 + z**2))).t2
E        +  and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +    where exp = sympy.exp
E        +    and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +      where asinh = sympy.asinh
E        +      and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +  and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +    where exp = sympy.exp
E        +    and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +      where asinh = sympy.asinh
E        +      and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +  and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +    where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_t2.py:95: AssertionError
_____________________________ test_rhophi_eta_tau ______________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            vector.backends.sympy.LongitudinalSympyEta(sympy.asinh(z / rho)),
            vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(rho**2 - t**2 + z**2))
            ),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.t2 == 0.25 * rho**2 * (
            1 + sympy.exp(-2 * sympy.asinh(z / rho))
        ) ** 2 * sympy.exp(2 * sympy.asinh(z / rho)) + sympy.Abs(rho**2 - t**2 + z**2)
E       assert rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2) == ((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/rho))) ** 2)) * exp(2*asinh(z/rho))) + Abs(rho**2 - t**2 + z**2))
E        +  where rho**2*(0.5 + 0.5*exp(-2*asinh(z/rho)))**2*exp(2*asinh(z/rho)) + Abs(rho**2 - t**2 + z**2) = VectorSympy4D(rho=rho, phi=phi, eta=asinh(z/rho), tau=sqrt(Abs(rho**2 - t**2 + z**2))).t2
E        +  and   exp(-2*asinh(z/rho)) = exp((-2 * asinh(z/rho)))
E        +    where exp = sympy.exp
E        +    and   asinh(z/rho) = asinh((z / rho))
E        +      where asinh = sympy.asinh
E        +  and   exp(2*asinh(z/rho)) = exp((2 * asinh(z/rho)))
E        +    where exp = sympy.exp
E        +    and   asinh(z/rho) = asinh((z / rho))
E        +      where asinh = sympy.asinh
E        +  and   Abs(rho**2 - t**2 + z**2) = Abs((((rho ** 2) - (t ** 2)) + (z ** 2)))
E        +    where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_t2.py:170: AssertionError
________________________________ test_xy_eta_t _________________________________

    def test_xy_eta_t():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            vector.backends.sympy.TemporalSympyT(t),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.tau == sympy.sqrt(
            sympy.Abs(
                t**2
                - 0.25
                * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
                * (x**2 + y**2)
                * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            )
        )
E       assert sqrt(Abs(t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) == sqrt(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)))))
E        +  where sqrt(Abs(t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), t=t).tau
E        +  and   sqrt(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))))) = <function sqrt at 0x7f3a3ec289a0>(Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)))))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(t**2 - 0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)))) = Abs(((t ** 2) - (((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2))))))
E        +      where Abs = sympy.Abs
E        +      and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +        where exp = sympy.exp
E        +        and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +          where asinh = sympy.asinh
E        +          and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +            where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +      and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +        where exp = sympy.exp
E        +        and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +          where asinh = sympy.asinh
E        +          and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +            where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt

tests/compute/sympy/lorentz/test_tau.py:77: AssertionError
________________________________ test_xy_eta_t _________________________________

    def test_xy_eta_t():
        vec = vector.VectorSympy4D(
            vector.backends.sympy.AzimuthalSympyXY(x, y),
            vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            vector.backends.sympy.TemporalSympyT(t),
        )
        # TODO: the expression blows up on simplifying?
>       assert vec.tau2 == t**2 - 0.25 * (
            1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
        ) ** 2 * (x**2 + y**2) * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
E       assert t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) == ((t ** 2) - (((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))))
E        +  where t**2 - (0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) = VectorSympy4D(x=x, y=y, eta=asinh(z/sqrt(x**2 + y**2)), t=t).tau2
E        +  and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +    where exp = sympy.exp
E        +    and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +      where asinh = sympy.asinh
E        +      and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +  and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +    where exp = sympy.exp
E        +    and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +      where asinh = sympy.asinh
E        +      and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +        where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt

tests/compute/sympy/lorentz/test_tau2.py:77: AssertionError
_______________________________ test_xy_eta_tau ________________________________

    def test_xy_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyXY(x, y),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        out = vec.to_beta3()
        assert isinstance(out, vector.backends.sympy.VectorSympy3D)
        assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
        assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
>       assert out.x == x / sympy.sqrt(
            0.25
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * (x**2 + y**2)
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
E       assert x/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) == (x / sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +  where x/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy3D(x=x/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)...**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)), eta=asinh(z/sqrt(x**2 + y**2))).x
E        +  and   sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_to_beta3.py:149: AssertionError
_____________________________ test_rhophi_eta_tau ______________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        out = vec.to_beta3()
        assert isinstance(out, vector.backends.sympy.VectorSympy3D)
        assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
        assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
>       assert out.x == rho * sympy.cos(phi) / sympy.sqrt(
            0.25
            * rho**2
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
E       assert rho*cos(phi)/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) == ((rho * cos(phi)) / sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +  where rho*cos(phi)/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy3D(rho=rho/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)), phi=phi, eta=asinh(z/sqrt(x**2 + y**2))).x
E        +  and   cos(phi) = cos(phi)
E        +    where cos = sympy.cos
E        +  and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x7f3a3ec289a0>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x7f3a3ec289a0>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x7f3a3ec289a0> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_to_beta3.py:[316](https://github.com/scikit-hep/vector/actions/runs/14703378893/job/41257579268#step:7:317): AssertionError

Failure messages local runs

========================================================= FAILURES =========================================================
_____________________________________________________ test_xy_eta_tau ______________________________________________________

    def test_xy_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyXY(x, y),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        out = vec.to_beta3()
        assert isinstance(out, vector.backends.sympy.VectorSympy3D)
        assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
        assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
        expected = x / sympy.sqrt(
            0.25
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * (x**2 + y**2)
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
        assert sympy.simplify(out.x -expected) == 0
>       assert out.y == y / sympy.sqrt(
            0.25
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * (x**2 + y**2)
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
E       assert y/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) == (y / sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +  where y/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy3D(x=x/sqrt((0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2)...**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)), eta=asinh(z/sqrt(x**2 + y**2))).y
E        +  and   sqrt(0.25*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*(x**2 + y**2)*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x1083f0540>(((((0.25 * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * ((x ** 2) + (y ** 2))) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x1083f0540>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x1083f0540>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_to_beta3.py:157: AssertionError
___________________________________________________ test_rhophi_eta_tau ____________________________________________________

    def test_rhophi_eta_tau():
        vec = vector.VectorSympy4D(
            azimuthal=vector.backends.sympy.AzimuthalSympyRhoPhi(rho, phi),
            longitudinal=vector.backends.sympy.LongitudinalSympyEta(
                sympy.asinh(z / sympy.sqrt(x**2 + y**2))
            ),
            temporal=vector.backends.sympy.TemporalSympyTau(
                sympy.sqrt(sympy.Abs(-(t**2) + x**2 + y**2 + z**2))
            ),
        )
        out = vec.to_beta3()
        assert isinstance(out, vector.backends.sympy.VectorSympy3D)
        assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
        assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
        expected = rho * sympy.cos(phi) / sympy.sqrt(
            0.25
            * rho**2
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
        assert sympy.simplify(out.x-expected) == 0
>       assert out.y == rho * sympy.sin(phi) / sympy.sqrt(
            0.25
            * rho**2
            * (1 + sympy.exp(-2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))) ** 2
            * sympy.exp(2 * sympy.asinh(z / sympy.sqrt(x**2 + y**2)))
            + sympy.Abs(-(t**2) + x**2 + y**2 + z**2)
        )
E       assert rho*sin(phi)/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) == ((rho * sin(phi)) / sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +  where rho*sin(phi)/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = VectorSympy3D(rho=rho/sqrt(rho**2*(0.5 + 0.5*exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)), phi=phi, eta=asinh(z/sqrt(x**2 + y**2))).y
E        +  and   sin(phi) = sin(phi)
E        +    where sin = sympy.sin
E        +  and   sqrt(0.25*rho**2*(1 + exp(-2*asinh(z/sqrt(x**2 + y**2))))**2*exp(2*asinh(z/sqrt(x**2 + y**2))) + Abs(-t**2 + x**2 + y**2 + z**2)) = <function sqrt at 0x1083f0540>(((((0.25 * (rho ** 2)) * ((1 + exp(-2*asinh(z/sqrt(x**2 + y**2)))) ** 2)) * exp(2*asinh(z/sqrt(x**2 + y**2)))) + Abs(-t**2 + x**2 + y**2 + z**2)))
E        +    where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   exp(-2*asinh(z/sqrt(x**2 + y**2))) = exp((-2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x1083f0540>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   exp(2*asinh(z/sqrt(x**2 + y**2))) = exp((2 * asinh(z/sqrt(x**2 + y**2))))
E        +      where exp = sympy.exp
E        +      and   asinh(z/sqrt(x**2 + y**2)) = asinh((z / sqrt(x**2 + y**2)))
E        +        where asinh = sympy.asinh
E        +        and   sqrt(x**2 + y**2) = <function sqrt at 0x1083f0540>(((x ** 2) + (y ** 2)))
E        +          where <function sqrt at 0x1083f0540> = sympy.sqrt
E        +    and   Abs(-t**2 + x**2 + y**2 + z**2) = Abs((((-(t ** 2) + (x ** 2)) + (y ** 2)) + (z ** 2)))
E        +      where Abs = sympy.Abs

tests/compute/sympy/lorentz/test_to_beta3.py:325: AssertionError

Checklist

Have you followed the guidelines in our Contributing document?
Have you checked to ensure there aren't any other open Pull Requests for the required change?
Does your submission pass pre-commit? ($ pre-commit run --all-files or $ nox -s lint)
Does your submission pass tests? ($ pytest or $ nox -s tests)
Does the documentation build with your changes? ($ cd docs; make clean; make html or $ nox -s docs)
Does your submission pass the doctests? ($ pytest --doctest-plus src/vector/ or $ nox -s doctests)

Before Merging

Summarize the commit messages into a brief review of the Pull request.

Saransh-cpp

Thanks for working on this, @Schefflera-Arboricola! The PR raises the question of structural (x == y) v/s symbolic (simplify(x - y) == 0 or Eq(x, y)) equality. Even though symbolic equality would be easier to maintain in the longer run, it would be better to use the structural equality wherever possible to be more strict as -

we test (or at least, aim to test when we drop Python 3.8 support (uncompyle6 does not support Python 3.9+)) the ability of vector's compute functions to operate only on data containers using the SymPy tests - https://github.com/scikit-hep/vector/blob/main/tests/test_compute_features.py
the SymPy tests don't fail often, so the maintainability is not that big of a problem

See my comment below to address this.

tests/compute/sympy/lorentz/test_deltaRapidityPhi.py

APN-Pucky · 2025-05-08T14:52:23Z

Tests failing without being mathematically wrong is bad IMO, since they will sooner or later fail with sympy updates (as is the case now from 1.13.1 -> 1.14.0). Hence I prefer symbolic comparison.

In fact it is quite similar to checking floating points by an epsilon range, since the backend computation can change, but the result is still right (wrt. the scope).

Saransh-cpp · 2025-06-01T20:50:29Z

Thanks, @APN-Pucky! My comment behind using structural equality was because the "symbolic" nature of our compute functions will solely be tested by SymPy once Python 3.8 is removed from GH Actions; hence, we would want these tests to be strict (unless we find another way - #531). But at the same time, I don't think this strictness is actually adding anything to the test suite - the symbolic equality will test the exact same thing but in a more flexible way.

Given that we use structural equality everywhere in the tests, I have reverted to keep using that for now. However, I will open an issue to discuss this further (and possibly change all equalities in the tests in the future).

Saransh-cpp

Thanks, @Schefflera-Arboricola! I'll merge this to fix the tests.

Schefflera-Arboricola · 2025-06-03T08:07:35Z

Thank you @Saransh-cpp !
And really sorry I missed this PR.

Saransh-cpp requested changes Apr 30, 2025

View reviewed changes

tests/compute/sympy/lorentz/test_deltaRapidityPhi.py Outdated Show resolved Hide resolved

Schefflera-Arboricola and others added 3 commits June 1, 2025 21:50

fixing sympy tests

0a9db8a

try structural equality

02c30d8

forgot assert

f5123a5

Saransh-cpp force-pushed the issue_579 branch from 42fa27b to f5123a5 Compare June 1, 2025 20:50

Saransh-cpp mentioned this pull request Jun 1, 2025

Structural v/s symbolic equality for SymPy tests #602

Open

Saransh-cpp approved these changes Jun 1, 2025

View reviewed changes

Saransh-cpp merged commit c3e4a5d into scikit-hep:main Jun 1, 2025
18 checks passed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

fixing sympy tests #581

fixing sympy tests #581

Uh oh!

Schefflera-Arboricola commented Apr 30, 2025 •

edited

Loading

Uh oh!

Saransh-cpp left a comment

Uh oh!

Uh oh!

APN-Pucky commented May 8, 2025 •

edited

Loading

Uh oh!

Saransh-cpp commented Jun 1, 2025

Uh oh!

Saransh-cpp left a comment

Uh oh!

Uh oh!

Schefflera-Arboricola commented Jun 3, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

fixing sympy tests #581

fixing sympy tests #581

Uh oh!

Conversation

Schefflera-Arboricola commented Apr 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

Checklist

Before Merging

Uh oh!

Saransh-cpp left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

APN-Pucky commented May 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Saransh-cpp commented Jun 1, 2025

Uh oh!

Saransh-cpp left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Schefflera-Arboricola commented Jun 3, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Schefflera-Arboricola commented Apr 30, 2025 •

edited

Loading

APN-Pucky commented May 8, 2025 •

edited

Loading