pymc-extras 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

tests/distributions/test_discrete_markov_chain.py

@@ -1,258 +0,0 @@
-import numpy as np
-import pymc as pm
-
-# general imports
-import pytensor.tensor as pt
-import pytest
-
-from pymc.distributions import Categorical
-from pymc.distributions.shape_utils import change_dist_size
-from pymc.logprob.utils import ParameterValueError
-from pymc.sampling.mcmc import assign_step_methods
-
-from pymc_extras.distributions.timeseries import (
-    DiscreteMarkovChain,
-    DiscreteMarkovChainGibbsMetropolis,
-)
-
-
-def transition_probability_tests(steps, n_states, n_lags, n_draws, atol):
-    P = np.full((n_states,) * (n_lags + 1), 1 / n_states)
-    x0 = pm.Categorical.dist(p=np.ones(n_states) / n_states)
-
-    chain = DiscreteMarkovChain.dist(
-        P=pt.as_tensor_variable(P), init_dist=x0, steps=steps, n_lags=n_lags
-    )
-
-    draws = pm.draw(chain, n_draws, random_seed=172)
-
-    # Test x0 is uniform over n_states
-    for i in range(n_lags):
-        assert np.allclose(
-            np.histogram(draws[:, ..., i], bins=n_states)[0] / n_draws, 1 / n_states, atol=atol
-        )
-
-    n_grams = [[tuple(row[i : i + n_lags + 1]) for i in range(len(row) - n_lags)] for row in draws]
-    freq_table = np.zeros((n_states,) * (n_lags + 1))
-
-    for row in n_grams:
-        for ngram in row:
-            freq_table[ngram] += 1
-    freq_table /= freq_table.sum(axis=-1)[:, None]
-
-    # Test continuation probabilities match P
-    assert np.allclose(P, freq_table, atol=atol)
-
-
-class TestDiscreteMarkovRV:
-    def test_fail_if_P_not_square(self):
-        P = pt.eye(3, 2)
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=3)
-        with pytest.raises(ParameterValueError):
-            pm.logp(chain, np.zeros((3,))).eval()
-
-    def test_fail_if_P_not_valid(self):
-        P = pt.zeros((3, 3))
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=3)
-        with pytest.raises(ParameterValueError):
-            pm.logp(chain, np.zeros((3,))).eval()
-
-    def test_high_dimensional_P(self):
-        P = pm.Dirichlet.dist(a=pt.ones(3), size=(3, 3, 3))
-        n_lags = 3
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-        chain = DiscreteMarkovChain.dist(P=P, steps=10, init_dist=x0, n_lags=n_lags)
-        draws = pm.draw(chain, 10)
-        logp = pm.logp(chain, draws)
-
-    def test_default_init_dist_warns_user(self):
-        P = pt.as_tensor_variable(np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]]))
-
-        with pytest.warns(UserWarning):
-            DiscreteMarkovChain.dist(P=P, steps=3)
-
-    def test_logp_shape(self):
-        P = pt.as_tensor_variable(np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]]))
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-        # Test with steps
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=3)
-        draws = pm.draw(chain, 5)
-        logp = pm.logp(chain, draws).eval()
-
-        assert logp.shape == (5,)
-
-        # Test with shape
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, shape=(3,))
-        draws = pm.draw(chain, 5)
-        logp = pm.logp(chain, draws).eval()
-
-        assert logp.shape == (5,)
-
-    def test_logp_with_default_init_dist(self):
-        P = pt.as_tensor_variable(np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]]))
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-        value = np.array([0, 1, 2])
-        logp_expected = np.log((1 / 3) * 0.5 * 0.3)
-
-        # Test dist directly
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=3)
-        logp_eval = pm.logp(chain, value).eval()
-        np.testing.assert_allclose(logp_eval, logp_expected, rtol=1e-6)
-
-        # Test via Model
-        with pm.Model() as m:
-            DiscreteMarkovChain("chain", P=P, init_dist=x0, steps=3)
-        model_logp_eval = m.compile_logp()({"chain": value})
-        np.testing.assert_allclose(model_logp_eval, logp_expected, rtol=1e-6)
-
-    def test_logp_with_user_defined_init_dist(self):
-        P = pt.as_tensor_variable(np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]]))
-        x0 = pm.Categorical.dist(p=[0.2, 0.6, 0.2])
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=3)
-
-        logp = pm.logp(chain, [0, 1, 2]).eval()
-        assert logp == np.log(0.2 * 0.5 * 0.3)
-
-    def test_moment_function(self):
-        P_np = np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]])
-
-        x0_np = np.array([0, 1, 0])
-
-        P = pt.as_tensor_variable(P_np)
-        x0 = pm.Categorical.dist(p=x0_np.tolist())
-        n_steps = 3
-
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, steps=n_steps)
-
-        chain_np = np.empty(shape=n_steps + 1, dtype="int8")
-        chain_np[0] = np.argmax(x0_np)
-        for i in range(n_steps):
-            state = chain_np[i]
-            chain_np[i + 1] = np.argmax(P_np[state])
-
-        dmc_chain = pm.distributions.distribution.support_point(chain).eval()
-
-        assert np.allclose(dmc_chain, chain_np)
-
-    def test_define_steps_via_shape_arg(self):
-        P = pt.full((3, 3), 1 / 3)
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, shape=(3,))
-        assert chain.eval().shape == (3,)
-
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, shape=(3, 2))
-        assert chain.eval().shape == (3, 2)
-
-    def test_define_steps_via_dim_arg(self):
-        coords = {"steps": [1, 2, 3]}
-
-        with pm.Model(coords=coords):
-            P = pt.full((3, 3), 1 / 3)
-            x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-            chain = DiscreteMarkovChain("chain", P=P, init_dist=x0, dims=["steps"])
-
-        assert chain.eval().shape == (3,)
-
-    def test_dims_when_steps_are_defined(self):
-        coords = {"steps": [1, 2, 3, 4]}
-
-        with pm.Model(coords=coords):
-            P = pt.full((3, 3), 1 / 3)
-            x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-            chain = DiscreteMarkovChain("chain", P=P, steps=3, init_dist=x0, dims=["steps"])
-
-        assert chain.eval().shape == (4,)
-
-    def test_multiple_dims_with_steps(self):
-        coords = {"steps": [1, 2, 3], "mc_chains": [1, 2, 3]}
-
-        with pm.Model(coords=coords):
-            P = pt.full((3, 3), 1 / 3)
-            x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-            chain = DiscreteMarkovChain(
-                "chain", P=P, steps=2, init_dist=x0, dims=["steps", "mc_chains"]
-            )
-
-        assert chain.eval().shape == (3, 3)
-
-    def test_mutiple_dims_with_steps_and_init_dist(self):
-        coords = {"steps": [1, 2, 3], "mc_chains": [1, 2, 3]}
-
-        with pm.Model(coords=coords):
-            P = pt.full((3, 3), 1 / 3)
-            x0 = pm.Categorical.dist(p=[0.1, 0.1, 0.8], size=(3,))
-            chain = DiscreteMarkovChain(
-                "chain", P=P, init_dist=x0, steps=2, dims=["steps", "mc_chains"]
-            )
-
-        assert chain.eval().shape == (3, 3)
-
-    def test_multiple_lags_with_data(self):
-        with pm.Model():
-            P = pt.full((3, 3, 3), 1 / 3)
-            x0 = pm.Categorical.dist(p=[0.1, 0.1, 0.8], size=2)
-            data = pm.draw(x0, 100)
-
-            chain = DiscreteMarkovChain("chain", P=P, init_dist=x0, n_lags=2, observed=data)
-
-        assert chain.eval().shape == (100, 2)
-
-    def test_random_draws(self):
-        transition_probability_tests(steps=3, n_states=2, n_lags=1, n_draws=2500, atol=0.05)
-        transition_probability_tests(steps=3, n_states=2, n_lags=3, n_draws=7500, atol=0.05)
-
-    def test_change_size_univariate(self):
-        P = pt.as_tensor_variable(np.array([[0.1, 0.5, 0.4], [0.3, 0.4, 0.3], [0.9, 0.05, 0.05]]))
-        x0 = pm.Categorical.dist(p=np.ones(3) / 3)
-
-        chain = DiscreteMarkovChain.dist(P=P, init_dist=x0, shape=(100, 5))
-
-        new_rw = change_dist_size(chain, new_size=(7,))
-        assert tuple(new_rw.shape.eval()) == (7, 5)
-
-        new_rw = change_dist_size(chain, new_size=(4, 3), expand=True)
-        assert tuple(new_rw.shape.eval()) == (4, 3, 100, 5)
-
-    def test_mcmc_sampling(self):
-        with pm.Model(coords={"step": range(100)}) as model:
-            init_dist = Categorical.dist(p=[0.5, 0.5])
-            markov_chain = DiscreteMarkovChain(
-                "markov_chain",
-                P=[[0.1, 0.9], [0.1, 0.9]],
-                init_dist=init_dist,
-                shape=(100,),
-                dims="step",
-            )
-
-            _, assigned_step_methods = assign_step_methods(model)
-            assert assigned_step_methods[DiscreteMarkovChainGibbsMetropolis] == [
-                model.rvs_to_values[markov_chain]
-            ]
-
-            # Sampler needs no tuning
-            idata = pm.sample(
-                tune=0, chains=4, draws=250, progressbar=False, compute_convergence_checks=False
-            )
-
-        np.testing.assert_allclose(
-            idata.posterior["markov_chain"].isel(step=0).mean(("chain", "draw")),
-            0.5,
-            atol=0.05,
-        )
-
-        np.testing.assert_allclose(
-            idata.posterior["markov_chain"].isel(step=slice(1, None)).mean(("chain", "draw")),
-            0.9,
-            atol=0.05,
-        )
-
-        assert pm.stats.ess(idata, method="tail").min() > 950

tests/distributions/test_multivariate.py

@@ -1,304 +0,0 @@
-import numpy as np
-import pymc as pm
-import pytensor
-import pytest
-
-import pymc_extras as pmx
-
-
-class TestR2D2M2CP:
-    @pytest.fixture(autouse=True)
-    def fast_compile(self):
-        with pytensor.config.change_flags(mode="FAST_COMPILE", exception_verbosity="high"):
-            yield
-
-    @pytest.fixture(autouse=True)
-    def model(self):
-        # every method is within a model
-        with pm.Model() as model:
-            yield model
-
-    @pytest.fixture(params=[True, False], ids=["centered", "non-centered"])
-    def centered(self, request):
-        return request.param
-
-    @pytest.fixture(params=[["a"], ["a", "b"], ["one"]])
-    def dims(self, model: pm.Model, request):
-        for i, c in enumerate(request.param):
-            if c == "one":
-                model.add_coord(c, range(1))
-            else:
-                model.add_coord(c, range((i + 2) ** 2))
-        return request.param
-
-    @pytest.fixture
-    def input_shape(self, dims, model):
-        return [int(model.dim_lengths[d].eval()) for d in dims]
-
-    @pytest.fixture
-    def output_shape(self, dims, model):
-        *hierarchy, _ = dims
-        return [int(model.dim_lengths[d].eval()) for d in hierarchy]
-
-    @pytest.fixture
-    def input_std(self, input_shape):
-        return np.ones(input_shape)
-
-    @pytest.fixture
-    def output_std(self, output_shape):
-        return np.ones(output_shape)
-
-    @pytest.fixture
-    def r2(self):
-        return 0.8
-
-    @pytest.fixture(params=[None, 0.1], ids=["r2-std", "no-r2-std"])
-    def r2_std(self, request):
-        return request.param
-
-    @pytest.fixture(params=["true", "false", "limit-1", "limit-0", "limit-all"])
-    def positive_probs(self, input_std, request):
-        if request.param == "true":
-            return np.full_like(input_std, 0.5)
-        elif request.param == "false":
-            return 0.5
-        elif request.param == "limit-1":
-            ret = np.full_like(input_std, 0.5)
-            ret[..., 0] = 1
-            return ret
-        elif request.param == "limit-0":
-            ret = np.full_like(input_std, 0.5)
-            ret[..., 0] = 0
-            return ret
-        elif request.param == "limit-all":
-            return np.full_like(input_std, 0)
-
-    @pytest.fixture(params=[True, False], ids=["probs-std", "no-probs-std"])
-    def positive_probs_std(self, positive_probs, request):
-        if request.param:
-            std = np.full_like(positive_probs, 0.1)
-            std[positive_probs == 0] = 0
-            std[positive_probs == 1] = 0
-            return std
-        else:
-            return None
-
-    @pytest.fixture(params=[None, "importance", "explained"])
-    def phi_args_base(self, request, input_shape):
-        if input_shape[-1] < 2 and request.param is not None:
-            pytest.skip("not compatible")
-        elif request.param is None:
-            return {}
-        elif request.param == "importance":
-            return {"variables_importance": np.full(input_shape, 2)}
-        else:
-            val = np.full(input_shape, 2)
-            return {"variance_explained": val / val.sum(-1, keepdims=True)}
-
-    @pytest.fixture(params=["concentration", "no-concentration"])
-    def phi_args(self, request, phi_args_base):
-        if request.param == "concentration":
-            phi_args_base["importance_concentration"] = 10
-        return phi_args_base
-
-    def test_init_r2(
-        self,
-        dims,
-        input_std,
-        output_std,
-        r2,
-        r2_std,
-        model: pm.Model,
-    ):
-        eps, beta = pmx.distributions.R2D2M2CP(
-            "beta",
-            output_std,
-            input_std,
-            dims=dims,
-            r2=r2,
-            r2_std=r2_std,
-        )
-        assert not np.isnan(beta.eval()).any()
-        assert eps.eval().shape == output_std.shape
-        assert beta.eval().shape == input_std.shape
-        # r2 rv is only created if r2 std is not None
-        assert "beta" in model.named_vars
-        assert ("beta::r2" in model.named_vars) == (r2_std is not None), set(model.named_vars)
-        # phi is only created if variable importance is not None and there is more than one var
-        assert np.isfinite(model.compile_logp()(model.initial_point()))
-
-    def test_init_importance(
-        self,
-        dims,
-        centered,
-        input_std,
-        output_std,
-        phi_args,
-        model: pm.Model,
-    ):
-        eps, beta = pmx.distributions.R2D2M2CP(
-            "beta",
-            output_std,
-            input_std,
-            dims=dims,
-            r2=1,
-            centered=centered,
-            **phi_args,
-        )
-        assert not np.isnan(beta.eval()).any()
-        assert eps.eval().shape == output_std.shape
-        assert beta.eval().shape == input_std.shape
-        # r2 rv is only created if r2 std is not None
-        assert "beta" in model.named_vars
-        # phi is only created if variable importance is not None and there is more than one var
-        assert ("beta::phi" in model.named_vars) == (
-            "variables_importance" in phi_args or "importance_concentration" in phi_args
-        ), set(model.named_vars)
-        assert np.isfinite(model.compile_logp()(model.initial_point()))
-
-    def test_init_positive_probs(
-        self,
-        dims,
-        centered,
-        input_std,
-        output_std,
-        positive_probs,
-        positive_probs_std,
-        model: pm.Model,
-    ):
-        eps, beta = pmx.distributions.R2D2M2CP(
-            "beta",
-            output_std,
-            input_std,
-            dims=dims,
-            r2=1.0,
-            centered=centered,
-            positive_probs_std=positive_probs_std,
-            positive_probs=positive_probs,
-        )
-        assert not np.isnan(beta.eval()).any()
-        assert eps.eval().shape == output_std.shape
-        assert beta.eval().shape == input_std.shape
-        # r2 rv is only created if r2 std is not None
-        assert "beta" in model.named_vars
-        # phi is only created if variable importance is not None and there is more than one var
-        assert ("beta::psi" in model.named_vars) == (
-            positive_probs_std is not None and positive_probs_std.any()
-        ), set(model.named_vars)
-        assert np.isfinite(sum(model.point_logps().values()))
-
-    def test_failing_importance(self, dims, input_shape, output_std, input_std):
-        if input_shape[-1] < 2:
-            with pytest.raises(TypeError, match="less than two variables"):
-                pmx.distributions.R2D2M2CP(
-                    "beta",
-                    output_std,
-                    input_std,
-                    dims=dims,
-                    r2=0.8,
-                    variables_importance=abs(input_std),
-                )
-        else:
-            pmx.distributions.R2D2M2CP(
-                "beta",
-                output_std,
-                input_std,
-                dims=dims,
-                r2=0.8,
-                variables_importance=abs(input_std),
-            )
-
-    def test_failing_variance_explained(self, dims, input_shape, output_std, input_std):
-        if input_shape[-1] < 2:
-            with pytest.raises(TypeError, match="less than two variables"):
-                pmx.distributions.R2D2M2CP(
-                    "beta",
-                    output_std,
-                    input_std,
-                    dims=dims,
-                    r2=0.8,
-                    variance_explained=abs(input_std),
-                )
-        else:
-            pmx.distributions.R2D2M2CP(
-                "beta", output_std, input_std, dims=dims, r2=0.8, variance_explained=abs(input_std)
-            )
-
-    def test_failing_mutual_exclusive(self, model: pm.Model):
-        with pytest.raises(TypeError, match="variable importance with variance explained"):
-            with model:
-                model.add_coord("a", range(2))
-            pmx.distributions.R2D2M2CP(
-                "beta",
-                1,
-                [1, 1],
-                dims="a",
-                r2=0.8,
-                variance_explained=[0.5, 0.5],
-                variables_importance=[1, 1],
-            )
-
-    def test_limit_case_requires_std_0(self, model: pm.Model):
-        model.add_coord("a", range(2))
-        with pytest.raises(ValueError, match="Can't have both positive_probs"):
-            pmx.distributions.R2D2M2CP(
-                "beta",
-                1,
-                [1, 1],
-                dims="a",
-                r2=0.8,
-                positive_probs=[0.5, 0],
-                positive_probs_std=[0.3, 0.1],
-            )
-        with pytest.raises(ValueError, match="Can't have both positive_probs"):
-            pmx.distributions.R2D2M2CP(
-                "beta",
-                1,
-                [1, 1],
-                dims="a",
-                r2=0.8,
-                positive_probs=[0.5, 1],
-                positive_probs_std=[0.3, 0.1],
-            )
-
-    def test_limit_case_creates_masked_vars(self, model: pm.Model, centered: bool):
-        model.add_coord("a", range(2))
-        pmx.distributions.R2D2M2CP(
-            "beta0",
-            1,
-            [1, 1],
-            dims="a",
-            r2=0.8,
-            positive_probs=[0.5, 1],
-            positive_probs_std=[0.3, 0],
-            centered=centered,
-        )
-        pmx.distributions.R2D2M2CP(
-            "beta1",
-            1,
-            [1, 1],
-            dims="a",
-            r2=0.8,
-            positive_probs=[0.5, 0],
-            positive_probs_std=[0.3, 0],
-            centered=centered,
-        )
-        if not centered:
-            assert "beta0::raw::masked" in model.named_vars, model.named_vars
-            assert "beta1::raw::masked" in model.named_vars, model.named_vars
-        else:
-            assert "beta0::masked" in model.named_vars, model.named_vars
-            assert "beta1::masked" in model.named_vars, model.named_vars
-        assert "beta1::psi::masked" in model.named_vars
-        assert "beta0::psi::masked" in model.named_vars
-
-    def test_zero_length_rvs_not_created(self, model: pm.Model):
-        model.add_coord("a", range(2))
-        # deterministic case which should not have any new variables
-        b = pmx.distributions.R2D2M2CP("b1", 1, [1, 1], r2=0.5, positive_probs=[1, 1], dims="a")
-        assert not model.free_RVs, model.free_RVs
-
-        b = pmx.distributions.R2D2M2CP(
-            "b2", 1, [1, 1], r2=0.5, positive_probs=[1, 1], positive_probs_std=[0, 0], dims="a"
-        )
-        assert not model.free_RVs, model.free_RVs

tests/distributions/test_transform.py

@@ -1,77 +0,0 @@
-#   Copyright 2025 The PyMC Developers
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-import numpy as np
-import pymc as pm
-
-from pymc_extras.distributions.transforms import PartialOrder
-
-
-class TestPartialOrder:
-    adj_mats = np.array(
-        [
-            # 0 < {1, 2} < 3
-            [[0, 1, 1, 0], [0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 0]],
-            # 1 < 0 < 3 < 2
-            [[0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
-        ]
-    )
-
-    valid_values = np.array([[0, 2, 1, 3], [1, 0, 3, 2]], dtype=float)
-
-    # Test that forward and backward are inverses of eachother
-    # And that it works when extra dimensions are added in data
-    def test_forward_backward_dimensionality(self):
-        po = PartialOrder(self.adj_mats)
-        po0 = PartialOrder(self.adj_mats[0])
-        vv = self.valid_values
-        vv0 = self.valid_values[0]
-
-        testsets = [
-            (vv, po),
-            (po.initvals(), po),
-            (vv0, po0),
-            (po0.initvals(), po0),
-            (np.tile(vv0, (2, 1)), po0),
-            (np.tile(vv0, (2, 3, 2, 1)), po0),
-            (np.tile(vv, (2, 3, 2, 1, 1)), po),
-        ]
-
-        for vv, po in testsets:
-            fw = po.forward(vv)
-            bw = po.backward(fw)
-            np.testing.assert_allclose(bw.eval(), vv)
-
-    def test_sample_model(self):
-        po = PartialOrder(self.adj_mats)
-        with pm.Model() as model:
-            x = pm.Normal(
-                "x",
-                size=(3, 2, 4),
-                transform=po,
-                initval=po.initvals(shape=(3, 2, 4), lower=-1, upper=1),
-            )
-            idata = pm.sample()
-
-        # Check that the order constraints are satisfied
-        # Move chain, draw and "3" dimensions to the back
-        xvs = idata.posterior.x.values.transpose(3, 4, 0, 1, 2)
-        x0 = xvs[0]  # 0 < {1, 2} < 3
-        assert (
-            (x0[0] < x0[1]).all()
-            and (x0[0] < x0[2]).all()
-            and (x0[1] < x0[3]).all()
-            and (x0[2] < x0[3]).all()
-        )
-        x1 = xvs[1]  # 1 < 0 < 3 < 2
-        assert (x1[1] < x1[0]).all() and (x1[0] < x1[3]).all() and (x1[3] < x1[2]).all()