diff --git a/.gitattributes b/.gitattributes
index 7d72bb6be9e1c39bff9bd66705d674d1bcef1231..d6b8384e4b9b8a846964d8e351f36b6e49319703 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1975,3 +1975,10 @@ miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/cluster/_hdbscan/_lin
 miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/cluster/_hdbscan/_reachability.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/cluster/_hdbscan/_tree.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/_svmlight_format_fast.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_cdnmf_fast.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_online_lda_fast.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_gradient_boosting.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/_predictor.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/histogram.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/splitting.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/linear_model/_cd_fast.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/api-v1-jdq-40589.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/api-v1-jdq-40589.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..49d394f0c458c02f7d9781445ef870cf8f747e0e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/api-v1-jdq-40589.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0f7973193eb35d19e99d1d8bca3c7f3a8b8d0410508af34ad571aee8ec5ab05
+size 913
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/data-v1-dl-4644182.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/data-v1-dl-4644182.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3c0efffc333c6ef0622ed3d3e3c95d3e319fc05f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40589/data-v1-dl-4644182.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c4226550827ceff3509c67179c473e14385cee206536362e57c5e0dfc7751bf
+size 4344
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jd-40675.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jd-40675.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b376ef7c9d32dd344e0fff0be5a30ae1e6dda779
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jd-40675.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a787772d60fbfcc21a0e96fd81906f03542e0b942d19dcc95dae47498953a4fd
+size 323
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdf-40675.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdf-40675.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d74f6d6f085d991634610476015839faf034ff2d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdf-40675.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d48d9679789d6baf7d0d3c346e3576d7589b663c3640942f9c1dba76e355faaa
+size 307
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1-s-dact.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1-s-dact.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..336782317369c6fdf4d987c6fd3fdee3309a50e1
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1-s-dact.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ed1ecc5d874956e951a9361f251afb2165adda92798c89ca5e2f97ae80dd8f
+size 317
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..577840cd46f47e22c75975d855fe21c9b997ee22
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-dv-1.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad0a4a5477605380f8819ce840dbb928a3d084267c512f6cb50d5be2f7c76bc2
+size 85
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-s-act-.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-s-act-.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..de6ccfccc5f28d446f34b7ffd7fcf83688cb00cf
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdl-dn-glass2-l-2-s-act-.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:141ba630e039ea44bbaef92a288e2d964fc3aa2ef805a9723b4aac738a26a627
+size 88
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdq-40675.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdq-40675.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..ed6cf27efa78d576427119132581c3a3fb3b76b3
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/api-v1-jdq-40675.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88fcdc3a6fed5697f36dc262f69bfffb814767ce336ff28a21def3aac937b08c
+size 886
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/data-v1-dl-4965250.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/data-v1-dl-4965250.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d1d26798a46116abdc22f357615f381a19bccf99
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40675/data-v1-dl-4965250.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:543d0887312f43d9f65a7e1d08be78a2436369f632d7382b4134cebb525a48a3
+size 3000
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jd-40945.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jd-40945.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..06446ec67eeede9b6d48f044d8ae402fe11bb90e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jd-40945.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02882c6b02c4e068ef2b16f37f33ae3d5e9dd17ca29d01662c6924e16427eb5d
+size 437
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdf-40945.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdf-40945.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..24e0e87d484661242d46a4cf18e2e6695736fa26
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdf-40945.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95f0938dfdf1b87d0ffc4d526f2c91e097ef7689480b693970126d908f291030
+size 320
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdq-40945.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdq-40945.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..adb1b0a58ae958ab00a906b0287f416a4ab48ace
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/api-v1-jdq-40945.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c7e5a46554ab6a8121832dc0cd9f7a60f5034cef1a5a7d61346bbd912516b54
+size 1042
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/data-v1-dl-16826755.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/data-v1-dl-16826755.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..5d8d5ae4fd5692b26e281928f6a1baad008f2008
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40945/data-v1-dl-16826755.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:516e961f519876e5f89b339a0364a08dd64160ac3a4d76d5ec62955bfd6d6ce5
+size 32243
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jd-40966.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jd-40966.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2b93281d0ded598bd03b1160a1b8a86df61b485c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jd-40966.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36c63c3ac8c9db59910acbf4c772cd53040ccd0eac0b0452611dd7ad8da50474
+size 1660
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdf-40966.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdf-40966.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..138ffc718b067282922ebeb107b22b8c3af08477
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdf-40966.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8adac8e2f8cbcbfa9677acdd4927a961430465d2c99401832160be455cfaced8
+size 3690
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-dv-4.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-dv-4.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..7e6491106a294f38733d8dfd6475c1afe42b8848
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-dv-4.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0c203b4627175cebbf527d81917a499911af915f6f2f46ee7248428a948d603
+size 325
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-s-act-.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-s-act-.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..ecd8d1b12a547833c2d00ed29be640a12167d082
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdl-dn-miceprotein-l-2-s-act-.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:301396b4a42c814b1a15038ddfcbcf5c8590501231747d0dc2a500b84b2fd0df
+size 328
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdq-40966.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdq-40966.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1d119ce6ec907e4689015911b16bcbfe8552b4e8
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/api-v1-jdq-40966.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dee83987fffa8ec20e23b3cabc00d42beb7a469af6bd803909998c1687fa634
+size 934
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/data-v1-dl-17928620.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/data-v1-dl-17928620.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c82d051bccb1b232214b31c73114f4f78749d810
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_40966/data-v1-dl-17928620.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c5fd93ffec7deb63a940fd698534dd7ebb7db349fc183930041cbf17e60e2cc
+size 6471
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jd-42074.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jd-42074.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a0f72505ffd12e41fdd34455ca1dfb6b224160f6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jd-42074.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fcb215595bb8223321943f0df50f5a5013445bf1819d53d3cb5bfa90d9e79c0
+size 595
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdf-42074.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdf-42074.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..89818ff01633a27976f11fd38a70cb1a652dce77
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdf-42074.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38b74e7f02a61ff55bcfac4d87103d5bffc43febb0c019d9aaa162f8f7693068
+size 272
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdq-42074.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdq-42074.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c152f7e5d9f72441b2fc6aa9f96af8f9ef9fc690
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/api-v1-jdq-42074.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8742a74bd5bc120acd9186c8a8737cb420ed9b009fade00b24e7ce5217797f2c
+size 722
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/data-v1-dl-21552912.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/data-v1-dl-21552912.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..010258ddd3f64ab3d63665f106946a34b241d68e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42074/data-v1-dl-21552912.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f623e777c0a36ae6c82fae10a7c2088cb383298ea244595bf8dc95449c9be4c4
+size 2326
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jd-42585.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jd-42585.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2d2b568ee4692ad61c20ab051723efceb318b816
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jd-42585.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ccbf138e0663895f9cf511136bc6395c153f6238af2eacb6a367e86e15d1a71
+size 1492
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdf-42585.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdf-42585.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..9564b2e437ee328b195f6289af99be51032c64d0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdf-42585.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0985045a454c8186b4e690ebefb6cea1ef7c13292c98d50abda470a0ff3ad425
+size 312
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdq-42585.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdq-42585.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a54754b666113a517f58ff509416f461e92636e4
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/api-v1-jdq-42585.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3736e7feb7ad30c68675c2c4e48a9fb262e80308c9083b100ddd0339da1fc282
+size 348
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/data-v1-dl-21854866.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/data-v1-dl-21854866.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2ad2b8b4fd397ee8d61b44fb77b26076f643335d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_42585/data-v1-dl-21854866.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8d00c6690576a9ec39e1cb77054e13296be0fdebab0fb35a64a0e8627b6e6f3
+size 4519
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jd-561.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jd-561.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..92ba4281fe86b5273792d24afaabb04eef03199d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jd-561.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1d38fdd601b67bb9c6d16152f53ddf166a0cfcfef4fa86438e899bfe449226c
+size 1798
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdf-561.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdf-561.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b2fce3413fd38f4c4f80ef7d6b198b4ac740a90a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdf-561.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:407424fb79cc30b8e9ff90900b3bf29244ac7f3797f278b5be602843f959b4ee
+size 425
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-dv-1.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-dv-1.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..52ae92392967d187709107d1c1bc9709c085b519
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-dv-1.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0703b0ae20b9ff75087dc601640ee58f1c2ad6768858ea21a245151da9ba8e4c
+size 301
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-s-act-.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-s-act-.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6bde2de0c6047726f26476a514d27a0d03c7d4b5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdl-dn-cpu-l-2-s-act-.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d4596ad879547863109da8675c2b789d07df66b526d7ebcbce9616c4c9b94c
+size 347
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdq-561.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdq-561.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..911f6823bb1bf0d9de5120e23e902e9a0a39a2bc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/api-v1-jdq-561.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8743b2d93d2c62a82fb47e1fbc002b97e25adcfb5bf1fcb26b58ad0bed15bd48
+size 1074
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/data-v1-dl-52739.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/data-v1-dl-52739.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..225208c948bd5270b3911828bead9d2fd3af3fbb
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_561/data-v1-dl-52739.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e96142b5e00dfec2617b0c22d7192b340ae2c28ec3ffc3a894c5be746b970a59
+size 3303
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jd-61.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jd-61.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a7ff82cef2a309d55bcae99900bdd51b6bbc675e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jd-61.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5c7e79aa41ef580838fb9fc1906280f076c47be1741fddd5004ddb500eb57fe
+size 898
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdf-61.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdf-61.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..466d7fab3f54e053ae4abc1044c671ac525accc0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdf-61.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33cbd6ae945ba04969370ab35604e9363c87256393493382b5118a89d59386d6
+size 268
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-dv-1.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-dv-1.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..76bb2da49d2e31a888153004b5177dc2a0c2f46c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-dv-1.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bce20aae7fd903796d96d5b3a3677b7058fbc5f3fe0996ee9d491e4ee23d132
+size 293
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-s-act-.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-s-act-.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c628aa1d9076067123d34c4c392a3a215dae524b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdl-dn-iris-l-2-s-act-.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9f4b9317997df63ed8d2bb073a3906344c0e0be017fd384eaec36ced8b94bae
+size 330
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdq-61.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdq-61.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..285c038aae89afa2eb0c334cdf28a9d0f6e2cb32
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdq-61.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:424cd47c12a51c7bb8d8169fac80fb5601f152bd78468b241d4b115bf7d22f20
+size 1121
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/data-v1-dl-61.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/data-v1-dl-61.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..25bb1bc7760d28c156677d8d257421b3805299c1
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_61/data-v1-dl-61.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afe4736924606638984e573235191025d419c545d31dc8874c96b72f5ec5db73
+size 2342
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jd-62.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jd-62.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..da14f86aac08c072962c2eecf6fe18cf319c5718
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jd-62.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ef3551ad47d48023c5a1f1cf077047a9a4b95544bb91d4a86097f8b574f8d07
+size 656
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdf-62.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdf-62.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..22da3f227189e339ed4d2b3861866ded65d999a6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdf-62.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:489b177126cb7f335cb220709233b946d3a0ad71d38bba6d48b79187146e585a
+size 817
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdq-62.json.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdq-62.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c8c1985e0bf13abce1abad45a5d872ccbcd44478
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdq-62.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:278a52a52d569f07d14c6a7877b104762c77daac429fb1fd9817a0378d6ec634
+size 805
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/data-v1-dl-52352.arff.gz b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/data-v1-dl-52352.arff.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b3ce4b7991c2223af6097adb8d1f553088d1ece0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/datasets/tests/data/openml/id_62/data-v1-dl-52352.arff.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb5830c82112f62a400c82ac1f1b5eb61c29c0a7cc72ba56d2aeff0fae8a60f9
+size 1625
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_cdnmf_fast.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_cdnmf_fast.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..8f6ccd5e23e586cce2644f5f5dd6f0c1c4970d78
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_cdnmf_fast.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7cde0bacb9b35d3d0c7aa3430c777a3a825e77e878f4e5833ceb5e40ab378785
+size 117512
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_online_lda_fast.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_online_lda_fast.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..6cca2cd63ba9b9e3087a86770c56eae2b5e55db4
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/decomposition/_online_lda_fast.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20b138a9be7ebe65e0b299dab51fe8a0835f654a45d64d19648c6936443517dc
+size 174504
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_gradient_boosting.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_gradient_boosting.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..df9b86ee1d32b675faa21b5c081d961d165f7afc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_gradient_boosting.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33ba4d691a4e44278747073f1eb3e3540c6a24bf31c857ba1ecec3092987f1ef
+size 127136
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/_predictor.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/_predictor.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..ee4447074f127780c32651e462189fb328668bd5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/_predictor.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2
+size 133897
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/histogram.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/histogram.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..23e307bfea4ddac9c150f6625dbfec9c86613e68
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/histogram.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47f2a719484ce7fb7a403d8d6b7d6fa70883dd703c7fec48c2bbc6e531267af1
+size 228569
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/splitting.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/splitting.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..a45d791f9b5d2ffa3f912e348bb09ccf414a8ecd
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/splitting.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16dcd84807f8186e7115dd5431fc4ac79543be8befe1c0516a470ed61abc2acd
+size 261345
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/linear_model/_cd_fast.cpython-310-x86_64-linux-gnu.so b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/linear_model/_cd_fast.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..ba46c9e66577e11609f6530c8b73574fe6856e8c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/linear_model/_cd_fast.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32e7cfd5f4833a6be03bad36850b5796ec579fc31fe7ecd1aa8eb14f54115923
+size 378624
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..67dd18fb94b593f0a3125c1f5833f3b9597614ba
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/__init__.py
@@ -0,0 +1,2 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/base.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..28020a2a74698b5ab8161421bf0e996834d3f0ef
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/base.py
@@ -0,0 +1,152 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import itertools
+
+from ... import __version__
+from ..._config import get_config
+from ..fixes import parse_version
+
+
+class _HTMLDocumentationLinkMixin:
+    """Mixin class allowing to generate a link to the API documentation.
+
+    This mixin relies on three attributes:
+    - `_doc_link_module`: it corresponds to the root module (e.g. `sklearn`). Using this
+      mixin, the default value is `sklearn`.
+    - `_doc_link_template`: it corresponds to the template used to generate the
+      link to the API documentation. Using this mixin, the default value is
+      `"https://scikit-learn.org/{version_url}/modules/generated/
+      {estimator_module}.{estimator_name}.html"`.
+    - `_doc_link_url_param_generator`: it corresponds to a function that generates the
+      parameters to be used in the template when the estimator module and name are not
+      sufficient.
+
+    The method :meth:`_get_doc_link` generates the link to the API documentation for a
+    given estimator.
+
+    This useful provides all the necessary states for
+    :func:`sklearn.utils.estimator_html_repr` to generate a link to the API
+    documentation for the estimator HTML diagram.
+
+    Examples
+    --------
+    If the default values for `_doc_link_module`, `_doc_link_template` are not suitable,
+    then you can override them and provide a method to generate the URL parameters:
+    >>> from sklearn.base import BaseEstimator
+    >>> doc_link_template = "https://address.local/{single_param}.html"
+    >>> def url_param_generator(estimator):
+    ...     return {"single_param": estimator.__class__.__name__}
+    >>> class MyEstimator(BaseEstimator):
+    ...     # use "builtins" since it is the associated module when declaring
+    ...     # the class in a docstring
+    ...     _doc_link_module = "builtins"
+    ...     _doc_link_template = doc_link_template
+    ...     _doc_link_url_param_generator = url_param_generator
+    >>> estimator = MyEstimator()
+    >>> estimator._get_doc_link()
+    'https://address.local/MyEstimator.html'
+
+    If instead of overriding the attributes inside the class definition, you want to
+    override a class instance, you can use `types.MethodType` to bind the method to the
+    instance:
+    >>> import types
+    >>> estimator = BaseEstimator()
+    >>> estimator._doc_link_template = doc_link_template
+    >>> estimator._doc_link_url_param_generator = types.MethodType(
+    ...     url_param_generator, estimator)
+    >>> estimator._get_doc_link()
+    'https://address.local/BaseEstimator.html'
+    """
+
+    _doc_link_module = "sklearn"
+    _doc_link_url_param_generator = None
+
+    @property
+    def _doc_link_template(self):
+        sklearn_version = parse_version(__version__)
+        if sklearn_version.dev is None:
+            version_url = f"{sklearn_version.major}.{sklearn_version.minor}"
+        else:
+            version_url = "dev"
+        return getattr(
+            self,
+            "__doc_link_template",
+            (
+                f"https://scikit-learn.org/{version_url}/modules/generated/"
+                "{estimator_module}.{estimator_name}.html"
+            ),
+        )
+
+    @_doc_link_template.setter
+    def _doc_link_template(self, value):
+        setattr(self, "__doc_link_template", value)
+
+    def _get_doc_link(self):
+        """Generates a link to the API documentation for a given estimator.
+
+        This method generates the link to the estimator's documentation page
+        by using the template defined by the attribute `_doc_link_template`.
+
+        Returns
+        -------
+        url : str
+            The URL to the API documentation for this estimator. If the estimator does
+            not belong to module `_doc_link_module`, the empty string (i.e. `""`) is
+            returned.
+        """
+        if self.__class__.__module__.split(".")[0] != self._doc_link_module:
+            return ""
+
+        if self._doc_link_url_param_generator is None:
+            estimator_name = self.__class__.__name__
+            # Construct the estimator's module name, up to the first private submodule.
+            # This works because in scikit-learn all public estimators are exposed at
+            # that level, even if they actually live in a private sub-module.
+            estimator_module = ".".join(
+                itertools.takewhile(
+                    lambda part: not part.startswith("_"),
+                    self.__class__.__module__.split("."),
+                )
+            )
+            return self._doc_link_template.format(
+                estimator_module=estimator_module, estimator_name=estimator_name
+            )
+        return self._doc_link_template.format(**self._doc_link_url_param_generator())
+
+
+class ReprHTMLMixin:
+    """Mixin to handle consistently the HTML representation.
+
+    When inheriting from this class, you need to define an attribute `_html_repr`
+    which is a callable that returns the HTML representation to be shown.
+    """
+
+    @property
+    def _repr_html_(self):
+        """HTML representation of estimator.
+        This is redundant with the logic of `_repr_mimebundle_`. The latter
+        should be favored in the long term, `_repr_html_` is only
+        implemented for consumers who do not interpret `_repr_mimbundle_`.
+        """
+        if get_config()["display"] != "diagram":
+            raise AttributeError(
+                "_repr_html_ is only defined when the "
+                "'display' configuration option is set to "
+                "'diagram'"
+            )
+        return self._repr_html_inner
+
+    def _repr_html_inner(self):
+        """This function is returned by the @property `_repr_html_` to make
+        `hasattr(estimator, "_repr_html_") return `True` or `False` depending
+        on `get_config()["display"]`.
+        """
+        return self._html_repr()
+
+    def _repr_mimebundle_(self, **kwargs):
+        """Mime bundle used by jupyter kernels to display estimator"""
+        output = {"text/plain": repr(self)}
+        if get_config()["display"] == "diagram":
+            output["text/html"] = self._html_repr()
+        return output
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.css b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.css
new file mode 100644
index 0000000000000000000000000000000000000000..ece8781c6bd76af4d3350b476430d6ecf2c9ed4c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.css
@@ -0,0 +1,413 @@
+#$id {
+  /* Definition of color scheme common for light and dark mode */
+  --sklearn-color-text: #000;
+  --sklearn-color-text-muted: #666;
+  --sklearn-color-line: gray;
+  /* Definition of color scheme for unfitted estimators */
+  --sklearn-color-unfitted-level-0: #fff5e6;
+  --sklearn-color-unfitted-level-1: #f6e4d2;
+  --sklearn-color-unfitted-level-2: #ffe0b3;
+  --sklearn-color-unfitted-level-3: chocolate;
+  /* Definition of color scheme for fitted estimators */
+  --sklearn-color-fitted-level-0: #f0f8ff;
+  --sklearn-color-fitted-level-1: #d4ebff;
+  --sklearn-color-fitted-level-2: #b3dbfd;
+  --sklearn-color-fitted-level-3: cornflowerblue;
+
+  /* Specific color for light theme */
+  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));
+  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));
+  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));
+  --sklearn-color-icon: #696969;
+
+  @media (prefers-color-scheme: dark) {
+    /* Redefinition of color scheme for dark theme */
+    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));
+    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));
+    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));
+    --sklearn-color-icon: #878787;
+  }
+}
+
+#$id {
+  color: var(--sklearn-color-text);
+}
+
+#$id pre {
+  padding: 0;
+}
+
+#$id input.sk-hidden--visually {
+  border: 0;
+  clip: rect(1px 1px 1px 1px);
+  clip: rect(1px, 1px, 1px, 1px);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  width: 1px;
+}
+
+#$id div.sk-dashed-wrapped {
+  border: 1px dashed var(--sklearn-color-line);
+  margin: 0 0.4em 0.5em 0.4em;
+  box-sizing: border-box;
+  padding-bottom: 0.4em;
+  background-color: var(--sklearn-color-background);
+}
+
+#$id div.sk-container {
+  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`
+     but bootstrap.min.css set `[hidden] { display: none !important; }`
+     so we also need the `!important` here to be able to override the
+     default hidden behavior on the sphinx rendered scikit-learn.org.
+     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */
+  display: inline-block !important;
+  position: relative;
+}
+
+#$id div.sk-text-repr-fallback {
+  display: none;
+}
+
+div.sk-parallel-item,
+div.sk-serial,
+div.sk-item {
+  /* draw centered vertical line to link estimators */
+  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));
+  background-size: 2px 100%;
+  background-repeat: no-repeat;
+  background-position: center center;
+}
+
+/* Parallel-specific style estimator block */
+
+#$id div.sk-parallel-item::after {
+  content: "";
+  width: 100%;
+  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);
+  flex-grow: 1;
+}
+
+#$id div.sk-parallel {
+  display: flex;
+  align-items: stretch;
+  justify-content: center;
+  background-color: var(--sklearn-color-background);
+  position: relative;
+}
+
+#$id div.sk-parallel-item {
+  display: flex;
+  flex-direction: column;
+}
+
+#$id div.sk-parallel-item:first-child::after {
+  align-self: flex-end;
+  width: 50%;
+}
+
+#$id div.sk-parallel-item:last-child::after {
+  align-self: flex-start;
+  width: 50%;
+}
+
+#$id div.sk-parallel-item:only-child::after {
+  width: 0;
+}
+
+/* Serial-specific style estimator block */
+
+#$id div.sk-serial {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  background-color: var(--sklearn-color-background);
+  padding-right: 1em;
+  padding-left: 1em;
+}
+
+
+/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is
+clickable and can be expanded/collapsed.
+- Pipeline and ColumnTransformer use this feature and define the default style
+- Estimators will overwrite some part of the style using the `sk-estimator` class
+*/
+
+/* Pipeline and ColumnTransformer style (default) */
+
+#$id div.sk-toggleable {
+  /* Default theme specific background. It is overwritten whether we have a
+  specific estimator or a Pipeline/ColumnTransformer */
+  background-color: var(--sklearn-color-background);
+}
+
+/* Toggleable label */
+#$id label.sk-toggleable__label {
+  cursor: pointer;
+  display: flex;
+  width: 100%;
+  margin-bottom: 0;
+  padding: 0.5em;
+  box-sizing: border-box;
+  text-align: center;
+  align-items: start;
+  justify-content: space-between;
+  gap: 0.5em;
+}
+
+#$id label.sk-toggleable__label .caption {
+  font-size: 0.6rem;
+  font-weight: lighter;
+  color: var(--sklearn-color-text-muted);
+}
+
+#$id label.sk-toggleable__label-arrow:before {
+  /* Arrow on the left of the label */
+  content: "▸";
+  float: left;
+  margin-right: 0.25em;
+  color: var(--sklearn-color-icon);
+}
+
+#$id label.sk-toggleable__label-arrow:hover:before {
+  color: var(--sklearn-color-text);
+}
+
+/* Toggleable content - dropdown */
+
+#$id div.sk-toggleable__content {
+  display: none;
+  text-align: left;
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-0);
+}
+
+#$id div.sk-toggleable__content.fitted {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-0);
+}
+
+#$id div.sk-toggleable__content pre {
+  margin: 0.2em;
+  border-radius: 0.25em;
+  color: var(--sklearn-color-text);
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-0);
+}
+
+#$id div.sk-toggleable__content.fitted pre {
+  /* unfitted */
+  background-color: var(--sklearn-color-fitted-level-0);
+}
+
+#$id input.sk-toggleable__control:checked~div.sk-toggleable__content {
+  /* Expand drop-down */
+  display: block;
+  width: 100%;
+  overflow: visible;
+}
+
+#$id input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {
+  content: "▾";
+}
+
+/* Pipeline/ColumnTransformer-specific style */
+
+#$id div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {
+  color: var(--sklearn-color-text);
+  background-color: var(--sklearn-color-unfitted-level-2);
+}
+
+#$id div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {
+  background-color: var(--sklearn-color-fitted-level-2);
+}
+
+/* Estimator-specific style */
+
+/* Colorize estimator box */
+#$id div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-2);
+}
+
+#$id div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-2);
+}
+
+#$id div.sk-label label.sk-toggleable__label,
+#$id div.sk-label label {
+  /* The background is the default theme color */
+  color: var(--sklearn-color-text-on-default-background);
+}
+
+/* On hover, darken the color of the background */
+#$id div.sk-label:hover label.sk-toggleable__label {
+  color: var(--sklearn-color-text);
+  background-color: var(--sklearn-color-unfitted-level-2);
+}
+
+/* Label box, darken color on hover, fitted */
+#$id div.sk-label.fitted:hover label.sk-toggleable__label.fitted {
+  color: var(--sklearn-color-text);
+  background-color: var(--sklearn-color-fitted-level-2);
+}
+
+/* Estimator label */
+
+#$id div.sk-label label {
+  font-family: monospace;
+  font-weight: bold;
+  display: inline-block;
+  line-height: 1.2em;
+}
+
+#$id div.sk-label-container {
+  text-align: center;
+}
+
+/* Estimator-specific */
+#$id div.sk-estimator {
+  font-family: monospace;
+  border: 1px dotted var(--sklearn-color-border-box);
+  border-radius: 0.25em;
+  box-sizing: border-box;
+  margin-bottom: 0.5em;
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-0);
+}
+
+#$id div.sk-estimator.fitted {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-0);
+}
+
+/* on hover */
+#$id div.sk-estimator:hover {
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-2);
+}
+
+#$id div.sk-estimator.fitted:hover {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-2);
+}
+
+/* Specification for estimator info (e.g. "i" and "?") */
+
+/* Common style for "i" and "?" */
+
+.sk-estimator-doc-link,
+a:link.sk-estimator-doc-link,
+a:visited.sk-estimator-doc-link {
+  float: right;
+  font-size: smaller;
+  line-height: 1em;
+  font-family: monospace;
+  background-color: var(--sklearn-color-background);
+  border-radius: 1em;
+  height: 1em;
+  width: 1em;
+  text-decoration: none !important;
+  margin-left: 0.5em;
+  text-align: center;
+  /* unfitted */
+  border: var(--sklearn-color-unfitted-level-1) 1pt solid;
+  color: var(--sklearn-color-unfitted-level-1);
+}
+
+.sk-estimator-doc-link.fitted,
+a:link.sk-estimator-doc-link.fitted,
+a:visited.sk-estimator-doc-link.fitted {
+  /* fitted */
+  border: var(--sklearn-color-fitted-level-1) 1pt solid;
+  color: var(--sklearn-color-fitted-level-1);
+}
+
+/* On hover */
+div.sk-estimator:hover .sk-estimator-doc-link:hover,
+.sk-estimator-doc-link:hover,
+div.sk-label-container:hover .sk-estimator-doc-link:hover,
+.sk-estimator-doc-link:hover {
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-3);
+  color: var(--sklearn-color-background);
+  text-decoration: none;
+}
+
+div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,
+.sk-estimator-doc-link.fitted:hover,
+div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,
+.sk-estimator-doc-link.fitted:hover {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-3);
+  color: var(--sklearn-color-background);
+  text-decoration: none;
+}
+
+/* Span, style for the box shown on hovering the info icon */
+.sk-estimator-doc-link span {
+  display: none;
+  z-index: 9999;
+  position: relative;
+  font-weight: normal;
+  right: .2ex;
+  padding: .5ex;
+  margin: .5ex;
+  width: min-content;
+  min-width: 20ex;
+  max-width: 50ex;
+  color: var(--sklearn-color-text);
+  box-shadow: 2pt 2pt 4pt #999;
+  /* unfitted */
+  background: var(--sklearn-color-unfitted-level-0);
+  border: .5pt solid var(--sklearn-color-unfitted-level-3);
+}
+
+.sk-estimator-doc-link.fitted span {
+  /* fitted */
+  background: var(--sklearn-color-fitted-level-0);
+  border: var(--sklearn-color-fitted-level-3);
+}
+
+.sk-estimator-doc-link:hover span {
+  display: block;
+}
+
+/* "?"-specific style due to the `<a>` HTML tag */
+
+#$id a.estimator_doc_link {
+  float: right;
+  font-size: 1rem;
+  line-height: 1em;
+  font-family: monospace;
+  background-color: var(--sklearn-color-background);
+  border-radius: 1rem;
+  height: 1rem;
+  width: 1rem;
+  text-decoration: none;
+  /* unfitted */
+  color: var(--sklearn-color-unfitted-level-1);
+  border: var(--sklearn-color-unfitted-level-1) 1pt solid;
+}
+
+#$id a.estimator_doc_link.fitted {
+  /* fitted */
+  border: var(--sklearn-color-fitted-level-1) 1pt solid;
+  color: var(--sklearn-color-fitted-level-1);
+}
+
+/* On hover */
+#$id a.estimator_doc_link:hover {
+  /* unfitted */
+  background-color: var(--sklearn-color-unfitted-level-3);
+  color: var(--sklearn-color-background);
+  text-decoration: none;
+}
+
+#$id a.estimator_doc_link.fitted:hover {
+  /* fitted */
+  background-color: var(--sklearn-color-fitted-level-3);
+}
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.js b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.js
new file mode 100644
index 0000000000000000000000000000000000000000..5de0a021c63bbaa9ef6e6493e7f57f11b73abdd8
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.js
@@ -0,0 +1,42 @@
+function copyToClipboard(text, element) {
+    // Get the parameter prefix from the closest toggleable content
+    const toggleableContent = element.closest('.sk-toggleable__content');
+    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';
+    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;
+
+    const originalStyle = element.style;
+    const computedStyle = window.getComputedStyle(element);
+    const originalWidth = computedStyle.width;
+    const originalHTML = element.innerHTML.replace('Copied!', '');
+
+    navigator.clipboard.writeText(fullParamName)
+        .then(() => {
+            element.style.width = originalWidth;
+            element.style.color = 'green';
+            element.innerHTML = "Copied!";
+
+            setTimeout(() => {
+                element.innerHTML = originalHTML;
+                element.style = originalStyle;
+            }, 2000);
+        })
+        .catch(err => {
+            console.error('Failed to copy:', err);
+            element.style.color = 'red';
+            element.innerHTML = "Failed!";
+            setTimeout(() => {
+                element.innerHTML = originalHTML;
+                element.style = originalStyle;
+            }, 2000);
+        });
+    return false;
+}
+
+document.querySelectorAll('.fa-regular.fa-copy').forEach(function(element) {
+    const toggleableContent = element.closest('.sk-toggleable__content');
+    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';
+    const paramName = element.parentElement.nextElementSibling.textContent.trim();
+    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;
+
+    element.setAttribute('title', fullParamName);
+});
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d101dde58d74be820fdd6797691e9cf1b23d0a8
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/estimator.py
@@ -0,0 +1,497 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import html
+from contextlib import closing
+from inspect import isclass
+from io import StringIO
+from pathlib import Path
+from string import Template
+
+from ... import config_context
+
+
+class _IDCounter:
+    """Generate sequential ids with a prefix."""
+
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self.count = 0
+
+    def get_id(self):
+        self.count += 1
+        return f"{self.prefix}-{self.count}"
+
+
+def _get_css_style():
+    estimator_css_file = Path(__file__).parent / "estimator.css"
+    params_css_file = Path(__file__).parent / "params.css"
+
+    estimator_css = estimator_css_file.read_text(encoding="utf-8")
+    params_css = params_css_file.read_text(encoding="utf-8")
+
+    return f"{estimator_css}\n{params_css}"
+
+
+_CONTAINER_ID_COUNTER = _IDCounter("sk-container-id")
+_ESTIMATOR_ID_COUNTER = _IDCounter("sk-estimator-id")
+_CSS_STYLE = _get_css_style()
+
+
+class _VisualBlock:
+    """HTML Representation of Estimator
+
+    Parameters
+    ----------
+    kind : {'serial', 'parallel', 'single'}
+        kind of HTML block
+
+    estimators : list of estimators or `_VisualBlock`s or a single estimator
+        If kind != 'single', then `estimators` is a list of
+        estimators.
+        If kind == 'single', then `estimators` is a single estimator.
+
+    names : list of str, default=None
+        If kind != 'single', then `names` corresponds to estimators.
+        If kind == 'single', then `names` is a single string corresponding to
+        the single estimator.
+
+    name_details : list of str, str, or None, default=None
+        If kind != 'single', then `name_details` corresponds to `names`.
+        If kind == 'single', then `name_details` is a single string
+        corresponding to the single estimator.
+
+    name_caption : str, default=None
+        The caption below the name. `None` stands for no caption.
+        Only active when kind == 'single'.
+
+    doc_link_label : str, default=None
+        The label for the documentation link. If provided, the label would be
+        "Documentation for {doc_link_label}". Otherwise it will look for `names`.
+        Only active when kind == 'single'.
+
+    dash_wrapped : bool, default=True
+        If true, wrapped HTML element will be wrapped with a dashed border.
+        Only active when kind != 'single'.
+    """
+
+    def __init__(
+        self,
+        kind,
+        estimators,
+        *,
+        names=None,
+        name_details=None,
+        name_caption=None,
+        doc_link_label=None,
+        dash_wrapped=True,
+    ):
+        self.kind = kind
+        self.estimators = estimators
+        self.dash_wrapped = dash_wrapped
+        self.name_caption = name_caption
+        self.doc_link_label = doc_link_label
+
+        if self.kind in ("parallel", "serial"):
+            if names is None:
+                names = (None,) * len(estimators)
+            if name_details is None:
+                name_details = (None,) * len(estimators)
+
+        self.names = names
+        self.name_details = name_details
+
+    def _sk_visual_block_(self):
+        return self
+
+
+def _write_label_html(
+    out,
+    params,
+    name,
+    name_details,
+    name_caption=None,
+    doc_link_label=None,
+    outer_class="sk-label-container",
+    inner_class="sk-label",
+    checked=False,
+    doc_link="",
+    is_fitted_css_class="",
+    is_fitted_icon="",
+    param_prefix="",
+):
+    """Write labeled html with or without a dropdown with named details.
+
+    Parameters
+    ----------
+    out : file-like object
+        The file to write the HTML representation to.
+    params: str
+        If estimator has `get_params` method, this is the HTML representation
+        of the estimator's parameters and their values. When the estimator
+        does not have `get_params`, it is an empty string.
+    name : str
+        The label for the estimator. It corresponds either to the estimator class name
+        for a simple estimator or in the case of a `Pipeline` and `ColumnTransformer`,
+        it corresponds to the name of the step.
+    name_details : str
+        The details to show as content in the dropdown part of the toggleable label. It
+        can contain information such as non-default parameters or column information for
+        `ColumnTransformer`.
+    name_caption : str, default=None
+        The caption below the name. If `None`, no caption will be created.
+    doc_link_label : str, default=None
+        The label for the documentation link. If provided, the label would be
+        "Documentation for {doc_link_label}". Otherwise it will look for `name`.
+    outer_class : {"sk-label-container", "sk-item"}, default="sk-label-container"
+        The CSS class for the outer container.
+    inner_class : {"sk-label", "sk-estimator"}, default="sk-label"
+        The CSS class for the inner container.
+    checked : bool, default=False
+        Whether the dropdown is folded or not. With a single estimator, we intend to
+        unfold the content.
+    doc_link : str, default=""
+        The link to the documentation for the estimator. If an empty string, no link is
+        added to the diagram. This can be generated for an estimator if it uses the
+        `_HTMLDocumentationLinkMixin`.
+    is_fitted_css_class : {"", "fitted"}
+        The CSS class to indicate whether or not the estimator is fitted. The
+        empty string means that the estimator is not fitted and "fitted" means that the
+        estimator is fitted.
+    is_fitted_icon : str, default=""
+        The HTML representation to show the fitted information in the diagram. An empty
+        string means that no information is shown.
+    param_prefix : str, default=""
+        The prefix to prepend to parameter names for nested estimators.
+    """
+    out.write(
+        f'<div class="{outer_class}"><div'
+        f' class="{inner_class} {is_fitted_css_class} sk-toggleable">'
+    )
+    name = html.escape(name)
+    if name_details is not None:
+        name_details = html.escape(str(name_details))
+        checked_str = "checked" if checked else ""
+        est_id = _ESTIMATOR_ID_COUNTER.get_id()
+
+        if doc_link:
+            doc_label = "<span>Online documentation</span>"
+            if doc_link_label is not None:
+                doc_label = f"<span>Documentation for {doc_link_label}</span>"
+            elif name is not None:
+                doc_label = f"<span>Documentation for {name}</span>"
+            doc_link = (
+                f'<a class="sk-estimator-doc-link {is_fitted_css_class}"'
+                f' rel="noreferrer" target="_blank" href="{doc_link}">?{doc_label}</a>'
+            )
+
+        name_caption_div = (
+            ""
+            if name_caption is None
+            else f'<div class="caption">{html.escape(name_caption)}</div>'
+        )
+        name_caption_div = f"<div><div>{name}</div>{name_caption_div}</div>"
+        links_div = (
+            f"<div>{doc_link}{is_fitted_icon}</div>"
+            if doc_link or is_fitted_icon
+            else ""
+        )
+
+        label_html = (
+            f'<label for="{est_id}" class="sk-toggleable__label {is_fitted_css_class} '
+            f'sk-toggleable__label-arrow">{name_caption_div}{links_div}</label>'
+        )
+
+        fmt_str = (
+            f'<input class="sk-toggleable__control sk-hidden--visually" id="{est_id}" '
+            f'type="checkbox" {checked_str}>{label_html}<div '
+            f'class="sk-toggleable__content {is_fitted_css_class}" '
+            f'data-param-prefix="{html.escape(param_prefix)}">'
+        )
+
+        if params:
+            fmt_str = "".join([fmt_str, f"{params}</div>"])
+        elif name_details and ("Pipeline" not in name):
+            fmt_str = "".join([fmt_str, f"<pre>{name_details}</pre></div>"])
+
+        out.write(fmt_str)
+    else:
+        out.write(f"<label>{name}</label>")
+    out.write("</div></div>")  # outer_class inner_class
+
+
+def _get_visual_block(estimator):
+    """Generate information about how to display an estimator."""
+    if hasattr(estimator, "_sk_visual_block_"):
+        try:
+            return estimator._sk_visual_block_()
+        except Exception:
+            return _VisualBlock(
+                "single",
+                estimator,
+                names=estimator.__class__.__name__,
+                name_details=str(estimator),
+            )
+
+    if isinstance(estimator, str):
+        return _VisualBlock(
+            "single", estimator, names=estimator, name_details=estimator
+        )
+    elif estimator is None:
+        return _VisualBlock("single", estimator, names="None", name_details="None")
+
+    # check if estimator looks like a meta estimator (wraps estimators)
+    if hasattr(estimator, "get_params") and not isclass(estimator):
+        estimators = [
+            (key, est)
+            for key, est in estimator.get_params(deep=False).items()
+            if hasattr(est, "get_params") and hasattr(est, "fit") and not isclass(est)
+        ]
+        if estimators:
+            return _VisualBlock(
+                "parallel",
+                [est for _, est in estimators],
+                names=[f"{key}: {est.__class__.__name__}" for key, est in estimators],
+                name_details=[str(est) for _, est in estimators],
+            )
+
+    return _VisualBlock(
+        "single",
+        estimator,
+        names=estimator.__class__.__name__,
+        name_details=str(estimator),
+    )
+
+
+def _write_estimator_html(
+    out,
+    estimator,
+    estimator_label,
+    estimator_label_details,
+    is_fitted_css_class,
+    is_fitted_icon="",
+    first_call=False,
+    param_prefix="",
+):
+    """Write estimator to html in serial, parallel, or by itself (single).
+
+    For multiple estimators, this function is called recursively.
+
+    Parameters
+    ----------
+    out : file-like object
+        The file to write the HTML representation to.
+    estimator : estimator object
+        The estimator to visualize.
+    estimator_label : str
+        The label for the estimator. It corresponds either to the estimator class name
+        for simple estimator or in the case of `Pipeline` and `ColumnTransformer`, it
+        corresponds to the name of the step.
+    estimator_label_details : str
+        The details to show as content in the dropdown part of the toggleable label.
+        It can contain information as non-default parameters or column information for
+        `ColumnTransformer`.
+    is_fitted_css_class : {"", "fitted"}
+        The CSS class to indicate whether or not the estimator is fitted or not. The
+        empty string means that the estimator is not fitted and "fitted" means that the
+        estimator is fitted.
+    is_fitted_icon : str, default=""
+        The HTML representation to show the fitted information in the diagram. An empty
+        string means that no information is shown. If the estimator to be shown is not
+        the first estimator (i.e. `first_call=False`), `is_fitted_icon` is always an
+        empty string.
+    first_call : bool, default=False
+        Whether this is the first time this function is called.
+    param_prefix : str, default=""
+        The prefix to prepend to parameter names for nested estimators.
+        For example, in a pipeline this might be "pipeline__stepname__".
+    """
+    if first_call:
+        est_block = _get_visual_block(estimator)
+    else:
+        is_fitted_icon = ""
+        with config_context(print_changed_only=True):
+            est_block = _get_visual_block(estimator)
+    # `estimator` can also be an instance of `_VisualBlock`
+    if hasattr(estimator, "_get_doc_link"):
+        doc_link = estimator._get_doc_link()
+    else:
+        doc_link = ""
+    if est_block.kind in ("serial", "parallel"):
+        dashed_wrapped = first_call or est_block.dash_wrapped
+        dash_cls = " sk-dashed-wrapped" if dashed_wrapped else ""
+        out.write(f'<div class="sk-item{dash_cls}">')
+
+        if estimator_label:
+            if hasattr(estimator, "get_params") and hasattr(
+                estimator, "_get_params_html"
+            ):
+                params = estimator._get_params_html(deep=False)._repr_html_inner()
+            else:
+                params = ""
+
+            _write_label_html(
+                out,
+                params,
+                estimator_label,
+                estimator_label_details,
+                doc_link=doc_link,
+                is_fitted_css_class=is_fitted_css_class,
+                is_fitted_icon=is_fitted_icon,
+                param_prefix=param_prefix,
+            )
+
+        kind = est_block.kind
+        out.write(f'<div class="sk-{kind}">')
+        est_infos = zip(est_block.estimators, est_block.names, est_block.name_details)
+
+        for est, name, name_details in est_infos:
+            # Build the parameter prefix for nested estimators
+
+            if param_prefix and hasattr(name, "split"):
+                # If we already have a prefix, append the new component
+                new_prefix = f"{param_prefix}{name.split(':')[0]}__"
+            elif hasattr(name, "split"):
+                # If this is the first level, start the prefix
+                new_prefix = f"{name.split(':')[0]}__" if name else ""
+            else:
+                new_prefix = param_prefix
+
+            if kind == "serial":
+                _write_estimator_html(
+                    out,
+                    est,
+                    name,
+                    name_details,
+                    is_fitted_css_class=is_fitted_css_class,
+                    param_prefix=new_prefix,
+                )
+            else:  # parallel
+                out.write('<div class="sk-parallel-item">')
+                # wrap element in a serial visualblock
+                serial_block = _VisualBlock("serial", [est], dash_wrapped=False)
+                _write_estimator_html(
+                    out,
+                    serial_block,
+                    name,
+                    name_details,
+                    is_fitted_css_class=is_fitted_css_class,
+                    param_prefix=new_prefix,
+                )
+                out.write("</div>")  # sk-parallel-item
+
+        out.write("</div></div>")
+    elif est_block.kind == "single":
+        if hasattr(estimator, "_get_params_html"):
+            params = estimator._get_params_html()._repr_html_inner()
+        else:
+            params = ""
+
+        _write_label_html(
+            out,
+            params,
+            est_block.names,
+            est_block.name_details,
+            est_block.name_caption,
+            est_block.doc_link_label,
+            outer_class="sk-item",
+            inner_class="sk-estimator",
+            checked=first_call,
+            doc_link=doc_link,
+            is_fitted_css_class=is_fitted_css_class,
+            is_fitted_icon=is_fitted_icon,
+            param_prefix=param_prefix,
+        )
+
+
+def estimator_html_repr(estimator):
+    """Build a HTML representation of an estimator.
+
+    Read more in the :ref:`User Guide <visualizing_composite_estimators>`.
+
+    Parameters
+    ----------
+    estimator : estimator object
+        The estimator to visualize.
+
+    Returns
+    -------
+    html: str
+        HTML representation of estimator.
+
+    Examples
+    --------
+    >>> from sklearn.utils._repr_html.estimator import estimator_html_repr
+    >>> from sklearn.linear_model import LogisticRegression
+    >>> estimator_html_repr(LogisticRegression())
+    '<style>#sk-container-id...'
+    """
+    from sklearn.exceptions import NotFittedError
+    from sklearn.utils.validation import check_is_fitted
+
+    if not hasattr(estimator, "fit"):
+        status_label = "<span>Not fitted</span>"
+        is_fitted_css_class = ""
+    else:
+        try:
+            check_is_fitted(estimator)
+            status_label = "<span>Fitted</span>"
+            is_fitted_css_class = "fitted"
+        except NotFittedError:
+            status_label = "<span>Not fitted</span>"
+            is_fitted_css_class = ""
+
+    is_fitted_icon = (
+        f'<span class="sk-estimator-doc-link {is_fitted_css_class}">'
+        f"i{status_label}</span>"
+    )
+    with closing(StringIO()) as out:
+        container_id = _CONTAINER_ID_COUNTER.get_id()
+        style_template = Template(_CSS_STYLE)
+        style_with_id = style_template.substitute(id=container_id)
+        estimator_str = str(estimator)
+
+        # The fallback message is shown by default and loading the CSS sets
+        # div.sk-text-repr-fallback to display: none to hide the fallback message.
+        #
+        # If the notebook is trusted, the CSS is loaded which hides the fallback
+        # message. If the notebook is not trusted, then the CSS is not loaded and the
+        # fallback message is shown by default.
+        #
+        # The reverse logic applies to HTML repr div.sk-container.
+        # div.sk-container is hidden by default and the loading the CSS displays it.
+        fallback_msg = (
+            "In a Jupyter environment, please rerun this cell to show the HTML"
+            " representation or trust the notebook. <br />On GitHub, the"
+            " HTML representation is unable to render, please try loading this page"
+            " with nbviewer.org."
+        )
+        html_template = (
+            f"<style>{style_with_id}</style>"
+            f"<body>"
+            f'<div id="{container_id}" class="sk-top-container">'
+            '<div class="sk-text-repr-fallback">'
+            f"<pre>{html.escape(estimator_str)}</pre><b>{fallback_msg}</b>"
+            "</div>"
+            '<div class="sk-container" hidden>'
+        )
+
+        out.write(html_template)
+        _write_estimator_html(
+            out,
+            estimator,
+            estimator.__class__.__name__,
+            estimator_str,
+            first_call=True,
+            is_fitted_css_class=is_fitted_css_class,
+            is_fitted_icon=is_fitted_icon,
+        )
+        with open(str(Path(__file__).parent / "estimator.js"), "r") as f:
+            script = f.read()
+
+        html_end = f"</div></div><script>{script}</script></body>"
+
+        out.write(html_end)
+
+        html_output = out.getvalue()
+        return html_output
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.css b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.css
new file mode 100644
index 0000000000000000000000000000000000000000..df815f966ffcfe3544b5c73a9c87c0f7f2d256f5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.css
@@ -0,0 +1,63 @@
+.estimator-table summary {
+    padding: .5rem;
+    font-family: monospace;
+    cursor: pointer;
+}
+
+.estimator-table details[open] {
+    padding-left: 0.1rem;
+    padding-right: 0.1rem;
+    padding-bottom: 0.3rem;
+}
+
+.estimator-table .parameters-table {
+    margin-left: auto !important;
+    margin-right: auto !important;
+}
+
+.estimator-table .parameters-table tr:nth-child(odd) {
+    background-color: #fff;
+}
+
+.estimator-table .parameters-table tr:nth-child(even) {
+    background-color: #f6f6f6;
+}
+
+.estimator-table .parameters-table tr:hover {
+    background-color: #e0e0e0;
+}
+
+.estimator-table table td {
+    border: 1px solid rgba(106, 105, 104, 0.232);
+}
+
+.user-set td {
+    color:rgb(255, 94, 0);
+    text-align: left;
+}
+
+.user-set td.value pre {
+    color:rgb(255, 94, 0) !important;
+    background-color: transparent !important;
+}
+
+.default td {
+    color: black;
+    text-align: left;
+}
+
+.user-set td i,
+.default td i {
+    color: black;
+}
+
+.copy-paste-icon {
+    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);
+    background-repeat: no-repeat;
+    background-size: 14px 14px;
+    background-position: 0;
+    display: inline-block;
+    width: 14px;
+    height: 14px;
+    cursor: pointer;
+}
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.py
new file mode 100644
index 0000000000000000000000000000000000000000..d85bf1280a8fcb16bd61895a96d9959d735fc5e0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/params.py
@@ -0,0 +1,83 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import html
+import reprlib
+from collections import UserDict
+
+from sklearn.utils._repr_html.base import ReprHTMLMixin
+
+
+def _read_params(name, value, non_default_params):
+    """Categorizes parameters as 'default' or 'user-set' and formats their values.
+    Escapes or truncates parameter values for display safety and readability.
+    """
+    r = reprlib.Repr()
+    r.maxlist = 2  # Show only first 2 items of lists
+    r.maxtuple = 1  # Show only first item of tuples
+    r.maxstring = 50  # Limit string length
+    cleaned_value = html.escape(r.repr(value))
+
+    param_type = "user-set" if name in non_default_params else "default"
+
+    return {"param_type": param_type, "param_name": name, "param_value": cleaned_value}
+
+
+def _params_html_repr(params):
+    """Generate HTML representation of estimator parameters.
+
+    Creates an HTML table with parameter names and values, wrapped in a
+    collapsible details element. Parameters are styled differently based
+    on whether they are default or user-set values.
+    """
+    HTML_TEMPLATE = """
+        <div class="estimator-table">
+            <details>
+                <summary>Parameters</summary>
+                <table class="parameters-table">
+                  <tbody>
+                    {rows}
+                  </tbody>
+                </table>
+            </details>
+        </div>
+    """
+    ROW_TEMPLATE = """
+        <tr class="{param_type}">
+            <td><i class="copy-paste-icon"
+                 onclick="copyToClipboard('{param_name}',
+                          this.parentElement.nextElementSibling)"
+            ></i></td>
+            <td class="param">{param_name}&nbsp;</td>
+            <td class="value">{param_value}</td>
+        </tr>
+    """
+
+    rows = [
+        ROW_TEMPLATE.format(**_read_params(name, value, params.non_default))
+        for name, value in params.items()
+    ]
+
+    return HTML_TEMPLATE.format(rows="\n".join(rows))
+
+
+class ParamsDict(ReprHTMLMixin, UserDict):
+    """Dictionary-like class to store and provide an HTML representation.
+
+    It builds an HTML structure to be used with Jupyter notebooks or similar
+    environments. It allows storing metadata to track non-default parameters.
+
+    Parameters
+    ----------
+    params : dict, default=None
+        The original dictionary of parameters and their values.
+
+    non_default : tuple
+        The list of non-default parameters.
+    """
+
+    _html_repr = _params_html_repr
+
+    def __init__(self, params=None, non_default=tuple()):
+        super().__init__(params or {})
+        self.non_default = non_default
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_estimator.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_estimator.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc975d854ed8f416d3f48e16dfd0fbaa10a9352a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_estimator.py
@@ -0,0 +1,616 @@
+import html
+import locale
+import re
+import types
+from contextlib import closing
+from functools import partial
+from io import StringIO
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+
+from sklearn import config_context
+from sklearn.base import BaseEstimator
+from sklearn.cluster import AgglomerativeClustering, Birch
+from sklearn.compose import ColumnTransformer, make_column_transformer
+from sklearn.datasets import load_iris
+from sklearn.decomposition import PCA, TruncatedSVD
+from sklearn.ensemble import StackingClassifier, StackingRegressor, VotingClassifier
+from sklearn.feature_selection import SelectPercentile
+from sklearn.gaussian_process.kernels import ExpSineSquared
+from sklearn.impute import SimpleImputer
+from sklearn.kernel_ridge import KernelRidge
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import RandomizedSearchCV
+from sklearn.multiclass import OneVsOneClassifier
+from sklearn.neural_network import MLPClassifier
+from sklearn.pipeline import FeatureUnion, Pipeline, make_pipeline
+from sklearn.preprocessing import FunctionTransformer, OneHotEncoder, StandardScaler
+from sklearn.svm import LinearSVC, LinearSVR
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.utils._repr_html.base import _HTMLDocumentationLinkMixin
+from sklearn.utils._repr_html.estimator import (
+    _get_css_style,
+    _get_visual_block,
+    _write_label_html,
+    estimator_html_repr,
+)
+from sklearn.utils.fixes import parse_version
+
+
+def dummy_function(x, y):
+    return x + y  # pragma: nocover
+
+
+@pytest.mark.parametrize("checked", [True, False])
+def test_write_label_html(checked):
+    # Test checking logic and labeling
+    name = "LogisticRegression"
+    params = ""
+    tool_tip = "hello-world"
+
+    with closing(StringIO()) as out:
+        _write_label_html(out, params, name, tool_tip, checked=checked)
+        html_label = out.getvalue()
+
+        p = (
+            r'<label for="sk-estimator-id-[0-9]*"'
+            r' class="sk-toggleable__label (fitted)? sk-toggleable__label-arrow">'
+            r"<div><div>LogisticRegression</div></div>"
+        )
+        re_compiled = re.compile(p)
+        assert re_compiled.search(html_label)
+        assert html_label.startswith('<div class="sk-label-container">')
+        assert "<pre>hello-world</pre>" in html_label
+
+        if checked:
+            assert "checked>" in html_label
+
+
+@pytest.mark.parametrize("est", ["passthrough", "drop", None])
+def test_get_visual_block_single_str_none(est):
+    # Test estimators that are represented by strings
+    est_html_info = _get_visual_block(est)
+    assert est_html_info.kind == "single"
+    assert est_html_info.estimators == est
+    assert est_html_info.names == str(est)
+    assert est_html_info.name_details == str(est)
+
+
+def test_get_visual_block_single_estimator():
+    est = LogisticRegression(C=10.0)
+    est_html_info = _get_visual_block(est)
+    assert est_html_info.kind == "single"
+    assert est_html_info.estimators == est
+    assert est_html_info.names == est.__class__.__name__
+    assert est_html_info.name_details == str(est)
+
+
+def test_get_visual_block_pipeline():
+    pipe = Pipeline(
+        [
+            ("imputer", SimpleImputer()),
+            ("do_nothing", "passthrough"),
+            ("do_nothing_more", None),
+            ("classifier", LogisticRegression()),
+        ]
+    )
+    est_html_info = _get_visual_block(pipe)
+    assert est_html_info.kind == "serial"
+    assert est_html_info.estimators == tuple(step[1] for step in pipe.steps)
+    assert est_html_info.names == [
+        "imputer: SimpleImputer",
+        "do_nothing: passthrough",
+        "do_nothing_more: passthrough",
+        "classifier: LogisticRegression",
+    ]
+    assert est_html_info.name_details == [str(est) for _, est in pipe.steps]
+
+
+def test_get_visual_block_feature_union():
+    f_union = FeatureUnion([("pca", PCA()), ("svd", TruncatedSVD())])
+    est_html_info = _get_visual_block(f_union)
+    assert est_html_info.kind == "parallel"
+    assert est_html_info.names == ("pca", "svd")
+    assert est_html_info.estimators == tuple(
+        trans[1] for trans in f_union.transformer_list
+    )
+    assert est_html_info.name_details == (None, None)
+
+
+def test_get_visual_block_voting():
+    clf = VotingClassifier(
+        [("log_reg", LogisticRegression()), ("mlp", MLPClassifier())]
+    )
+    est_html_info = _get_visual_block(clf)
+    assert est_html_info.kind == "parallel"
+    assert est_html_info.estimators == tuple(trans[1] for trans in clf.estimators)
+    assert est_html_info.names == ("log_reg", "mlp")
+    assert est_html_info.name_details == (None, None)
+
+
+def test_get_visual_block_column_transformer():
+    ct = ColumnTransformer(
+        [("pca", PCA(), ["num1", "num2"]), ("svd", TruncatedSVD, [0, 3])]
+    )
+    est_html_info = _get_visual_block(ct)
+    assert est_html_info.kind == "parallel"
+    assert est_html_info.estimators == tuple(trans[1] for trans in ct.transformers)
+    assert est_html_info.names == ("pca", "svd")
+    assert est_html_info.name_details == (["num1", "num2"], [0, 3])
+
+
+def test_estimator_html_repr_an_empty_pipeline():
+    """Check that the representation of an empty Pipeline does not fail.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/30197
+    """
+    empty_pipeline = Pipeline([])
+    estimator_html_repr(empty_pipeline)
+
+
+def test_estimator_html_repr_pipeline():
+    num_trans = Pipeline(
+        steps=[("pass", "passthrough"), ("imputer", SimpleImputer(strategy="median"))]
+    )
+
+    cat_trans = Pipeline(
+        steps=[
+            ("imputer", SimpleImputer(strategy="constant", missing_values="empty")),
+            ("one-hot", OneHotEncoder(drop="first")),
+        ]
+    )
+
+    preprocess = ColumnTransformer(
+        [
+            ("num", num_trans, ["a", "b", "c", "d", "e"]),
+            ("cat", cat_trans, [0, 1, 2, 3]),
+        ]
+    )
+
+    feat_u = FeatureUnion(
+        [
+            ("pca", PCA(n_components=1)),
+            (
+                "tsvd",
+                Pipeline(
+                    [
+                        ("first", TruncatedSVD(n_components=3)),
+                        ("select", SelectPercentile()),
+                    ]
+                ),
+            ),
+        ]
+    )
+
+    clf = VotingClassifier(
+        [
+            ("lr", LogisticRegression(solver="lbfgs", random_state=1)),
+            ("mlp", MLPClassifier(alpha=0.001)),
+        ]
+    )
+
+    pipe = Pipeline(
+        [("preprocessor", preprocess), ("feat_u", feat_u), ("classifier", clf)]
+    )
+    html_output = estimator_html_repr(pipe)
+
+    # top level estimators show estimator with changes
+    assert html.escape(str(pipe)) in html_output
+    for _, est in pipe.steps:
+        assert html.escape(str(est))[:44] in html_output
+
+    # low level estimators do not show changes
+    with config_context(print_changed_only=True):
+        assert html.escape(str(num_trans["pass"])) in html_output
+        assert "<div><div>passthrough</div></div></label>" in html_output
+        assert html.escape(str(num_trans["imputer"])) in html_output
+
+        for _, _, cols in preprocess.transformers:
+            assert f"<pre>{html.escape(str(cols))}</pre>" in html_output
+
+        # feature union
+        for name, _ in feat_u.transformer_list:
+            assert f"<label>{html.escape(name)}</label>" in html_output
+
+        pca = feat_u.transformer_list[0][1]
+
+        assert html.escape(str(pca)) in html_output
+
+        tsvd = feat_u.transformer_list[1][1]
+        first = tsvd["first"]
+        select = tsvd["select"]
+        assert html.escape(str(first)) in html_output
+        assert html.escape(str(select)) in html_output
+
+        # voting classifier
+        for name, est in clf.estimators:
+            assert html.escape(name) in html_output
+            assert html.escape(str(est)) in html_output
+
+    # verify that prefers-color-scheme is implemented
+    assert "prefers-color-scheme" in html_output
+
+
+@pytest.mark.parametrize("final_estimator", [None, LinearSVC()])
+def test_stacking_classifier(final_estimator):
+    estimators = [
+        ("mlp", MLPClassifier(alpha=0.001)),
+        ("tree", DecisionTreeClassifier()),
+    ]
+    clf = StackingClassifier(estimators=estimators, final_estimator=final_estimator)
+
+    html_output = estimator_html_repr(clf)
+
+    assert html.escape(str(clf)) in html_output
+    # If final_estimator's default changes from LogisticRegression
+    # this should be updated
+    if final_estimator is None:
+        assert "LogisticRegression" in html_output
+    else:
+        assert final_estimator.__class__.__name__ in html_output
+
+
+@pytest.mark.parametrize("final_estimator", [None, LinearSVR()])
+def test_stacking_regressor(final_estimator):
+    reg = StackingRegressor(
+        estimators=[("svr", LinearSVR())], final_estimator=final_estimator
+    )
+    html_output = estimator_html_repr(reg)
+
+    assert html.escape(str(reg.estimators[0][0])) in html_output
+    p = (
+        r'<label for="sk-estimator-id-[0-9]*"'
+        r' class="sk-toggleable__label (fitted)? sk-toggleable__label-arrow">'
+        r"<div><div>LinearSVR</div></div>"
+    )
+    re_compiled = re.compile(p)
+    assert re_compiled.search(html_output)
+
+    if final_estimator is None:
+        p = (
+            r'<label for="sk-estimator-id-[0-9]*"'
+            r' class="sk-toggleable__label (fitted)? sk-toggleable__label-arrow">'
+            r"<div><div>RidgeCV</div></div>"
+        )
+        re_compiled = re.compile(p)
+        assert re_compiled.search(html_output)
+    else:
+        assert html.escape(final_estimator.__class__.__name__) in html_output
+
+
+def test_birch_duck_typing_meta():
+    # Test duck typing meta estimators with Birch
+    birch = Birch(n_clusters=AgglomerativeClustering(n_clusters=3))
+    html_output = estimator_html_repr(birch)
+
+    # inner estimators do not show changes
+    with config_context(print_changed_only=True):
+        assert f"<pre>{html.escape(str(birch.n_clusters))}" in html_output
+
+        p = r"<div><div>AgglomerativeClustering</div></div><div>.+</div></label>"
+        re_compiled = re.compile(p)
+        assert re_compiled.search(html_output)
+
+    # outer estimator contains all changes
+    assert f"<pre>{html.escape(str(birch))}" in html_output
+
+
+def test_ovo_classifier_duck_typing_meta():
+    # Test duck typing metaestimators with OVO
+    ovo = OneVsOneClassifier(LinearSVC(penalty="l1"))
+    html_output = estimator_html_repr(ovo)
+
+    # inner estimators do not show changes
+    with config_context(print_changed_only=True):
+        assert f"<pre>{html.escape(str(ovo.estimator))}" in html_output
+        # regex to match the start of the tag
+        p = (
+            r'<label for="sk-estimator-id-[0-9]*" '
+            r'class="sk-toggleable__label  sk-toggleable__label-arrow">'
+            r"<div><div>LinearSVC</div></div>"
+        )
+        re_compiled = re.compile(p)
+        assert re_compiled.search(html_output)
+
+    # outer estimator
+    assert f"<pre>{html.escape(str(ovo))}" in html_output
+
+
+def test_duck_typing_nested_estimator():
+    # Test duck typing metaestimators with random search
+    kernel_ridge = KernelRidge(kernel=ExpSineSquared())
+    param_distributions = {"alpha": [1, 2]}
+
+    kernel_ridge_tuned = RandomizedSearchCV(
+        kernel_ridge,
+        param_distributions=param_distributions,
+    )
+    html_output = estimator_html_repr(kernel_ridge_tuned)
+    assert "<div><div>estimator: KernelRidge</div></div></label>" in html_output
+
+
+@pytest.mark.parametrize("print_changed_only", [True, False])
+def test_one_estimator_print_change_only(print_changed_only):
+    pca = PCA(n_components=10)
+
+    with config_context(print_changed_only=print_changed_only):
+        pca_repr = html.escape(str(pca))
+        html_output = estimator_html_repr(pca)
+        assert pca_repr in html_output
+
+
+def test_fallback_exists():
+    """Check that repr fallback is in the HTML."""
+    pca = PCA(n_components=10)
+    html_output = estimator_html_repr(pca)
+
+    assert (
+        f'<div class="sk-text-repr-fallback"><pre>{html.escape(str(pca))}'
+        in html_output
+    )
+
+
+def test_show_arrow_pipeline():
+    """Show arrow in pipeline for top level in pipeline"""
+    pipe = Pipeline([("scale", StandardScaler()), ("log_Reg", LogisticRegression())])
+
+    html_output = estimator_html_repr(pipe)
+    assert (
+        'class="sk-toggleable__label  sk-toggleable__label-arrow">'
+        "<div><div>Pipeline</div></div>" in html_output
+    )
+
+
+def test_invalid_parameters_in_stacking():
+    """Invalidate stacking configuration uses default repr.
+
+    Non-regression test for #24009.
+    """
+    stacker = StackingClassifier(estimators=[])
+
+    html_output = estimator_html_repr(stacker)
+    assert html.escape(str(stacker)) in html_output
+
+
+def test_estimator_get_params_return_cls():
+    """Check HTML repr works where a value in get_params is a class."""
+
+    class MyEstimator:
+        def get_params(self, deep=False):
+            return {"inner_cls": LogisticRegression}
+
+    est = MyEstimator()
+    assert "MyEstimator" in estimator_html_repr(est)
+
+
+def test_estimator_html_repr_unfitted_vs_fitted():
+    """Check that we have the information that the estimator is fitted or not in the
+    HTML representation.
+    """
+
+    class MyEstimator(BaseEstimator):
+        def fit(self, X, y):
+            self.fitted_ = True
+            return self
+
+    X, y = load_iris(return_X_y=True)
+    estimator = MyEstimator()
+    assert "<span>Not fitted</span>" in estimator_html_repr(estimator)
+    estimator.fit(X, y)
+    assert "<span>Fitted</span>" in estimator_html_repr(estimator)
+
+
+@pytest.mark.parametrize(
+    "estimator",
+    [
+        LogisticRegression(),
+        make_pipeline(StandardScaler(), LogisticRegression()),
+        make_pipeline(
+            make_column_transformer((StandardScaler(), slice(0, 3))),
+            LogisticRegression(),
+        ),
+    ],
+)
+def test_estimator_html_repr_fitted_icon(estimator):
+    """Check that we are showing the fitted status icon only once."""
+    pattern = '<span class="sk-estimator-doc-link ">i<span>Not fitted</span></span>'
+    assert estimator_html_repr(estimator).count(pattern) == 1
+    X, y = load_iris(return_X_y=True)
+    estimator.fit(X, y)
+    pattern = '<span class="sk-estimator-doc-link fitted">i<span>Fitted</span></span>'
+    assert estimator_html_repr(estimator).count(pattern) == 1
+
+
+@pytest.mark.parametrize("mock_version", ["1.3.0.dev0", "1.3.0"])
+def test_html_documentation_link_mixin_sklearn(mock_version):
+    """Check the behaviour of the `_HTMLDocumentationLinkMixin` class for scikit-learn
+    default.
+    """
+
+    # mock the `__version__` where the mixin is located
+    with patch("sklearn.utils._repr_html.base.__version__", mock_version):
+        mixin = _HTMLDocumentationLinkMixin()
+
+        assert mixin._doc_link_module == "sklearn"
+        sklearn_version = parse_version(mock_version)
+        # we need to parse the version manually to be sure that this test is passing in
+        # other branches than `main` (that is "dev").
+        if sklearn_version.dev is None:
+            version = f"{sklearn_version.major}.{sklearn_version.minor}"
+        else:
+            version = "dev"
+        assert (
+            mixin._doc_link_template
+            == f"https://scikit-learn.org/{version}/modules/generated/"
+            "{estimator_module}.{estimator_name}.html"
+        )
+        assert (
+            mixin._get_doc_link()
+            == f"https://scikit-learn.org/{version}/modules/generated/"
+            "sklearn.utils._HTMLDocumentationLinkMixin.html"
+        )
+
+
+@pytest.mark.parametrize(
+    "module_path,expected_module",
+    [
+        ("prefix.mymodule", "prefix.mymodule"),
+        ("prefix._mymodule", "prefix"),
+        ("prefix.mypackage._mymodule", "prefix.mypackage"),
+        ("prefix.mypackage._mymodule.submodule", "prefix.mypackage"),
+        ("prefix.mypackage.mymodule.submodule", "prefix.mypackage.mymodule.submodule"),
+    ],
+)
+def test_html_documentation_link_mixin_get_doc_link_instance(
+    module_path, expected_module
+):
+    """Check the behaviour of the `_get_doc_link` with various parameter."""
+
+    class FooBar(_HTMLDocumentationLinkMixin):
+        pass
+
+    FooBar.__module__ = module_path
+    est = FooBar()
+    # if we set `_doc_link`, then we expect to infer a module and name for the estimator
+    est._doc_link_module = "prefix"
+    est._doc_link_template = (
+        "https://website.com/{estimator_module}.{estimator_name}.html"
+    )
+    assert est._get_doc_link() == f"https://website.com/{expected_module}.FooBar.html"
+
+
+@pytest.mark.parametrize(
+    "module_path,expected_module",
+    [
+        ("prefix.mymodule", "prefix.mymodule"),
+        ("prefix._mymodule", "prefix"),
+        ("prefix.mypackage._mymodule", "prefix.mypackage"),
+        ("prefix.mypackage._mymodule.submodule", "prefix.mypackage"),
+        ("prefix.mypackage.mymodule.submodule", "prefix.mypackage.mymodule.submodule"),
+    ],
+)
+def test_html_documentation_link_mixin_get_doc_link_class(module_path, expected_module):
+    """Check the behaviour of the `_get_doc_link` when `_doc_link_module` and
+    `_doc_link_template` are defined at the class level and not at the instance
+    level."""
+
+    class FooBar(_HTMLDocumentationLinkMixin):
+        _doc_link_module = "prefix"
+        _doc_link_template = (
+            "https://website.com/{estimator_module}.{estimator_name}.html"
+        )
+
+    FooBar.__module__ = module_path
+    est = FooBar()
+    assert est._get_doc_link() == f"https://website.com/{expected_module}.FooBar.html"
+
+
+def test_html_documentation_link_mixin_get_doc_link_out_of_library():
+    """Check the behaviour of the `_get_doc_link` with various parameter."""
+    mixin = _HTMLDocumentationLinkMixin()
+
+    # if the `_doc_link_module` does not refer to the root module of the estimator
+    # (here the mixin), then we should return an empty string.
+    mixin._doc_link_module = "xxx"
+    assert mixin._get_doc_link() == ""
+
+
+def test_html_documentation_link_mixin_doc_link_url_param_generator_instance():
+    mixin = _HTMLDocumentationLinkMixin()
+    # we can bypass the generation by providing our own callable
+    mixin._doc_link_template = (
+        "https://website.com/{my_own_variable}.{another_variable}.html"
+    )
+
+    def url_param_generator(estimator):
+        return {
+            "my_own_variable": "value_1",
+            "another_variable": "value_2",
+        }
+
+    mixin._doc_link_url_param_generator = types.MethodType(url_param_generator, mixin)
+
+    assert mixin._get_doc_link() == "https://website.com/value_1.value_2.html"
+
+
+def test_html_documentation_link_mixin_doc_link_url_param_generator_class():
+    # we can bypass the generation by providing our own callable
+
+    def url_param_generator(estimator):
+        return {
+            "my_own_variable": "value_1",
+            "another_variable": "value_2",
+        }
+
+    class FooBar(_HTMLDocumentationLinkMixin):
+        _doc_link_template = (
+            "https://website.com/{my_own_variable}.{another_variable}.html"
+        )
+        _doc_link_url_param_generator = url_param_generator
+
+    estimator = FooBar()
+    assert estimator._get_doc_link() == "https://website.com/value_1.value_2.html"
+
+
+@pytest.fixture
+def set_non_utf8_locale():
+    """Pytest fixture to set non utf-8 locale during the test.
+
+    The locale is set to the original one after the test has run.
+    """
+    try:
+        locale.setlocale(locale.LC_CTYPE, "C")
+    except locale.Error:
+        pytest.skip("'C' locale is not available on this OS")
+
+    yield
+
+    # Resets the locale to the original one. Python calls setlocale(LC_TYPE, "")
+    # at startup according to
+    # https://docs.python.org/3/library/locale.html#background-details-hints-tips-and-caveats.
+    # This assumes that no other locale changes have been made. For some reason,
+    # on some platforms, trying to restore locale with something like
+    # locale.setlocale(locale.LC_CTYPE, locale.getlocale()) raises a
+    # locale.Error: unsupported locale setting
+    locale.setlocale(locale.LC_CTYPE, "")
+
+
+def test_non_utf8_locale(set_non_utf8_locale):
+    """Checks that utf8 encoding is used when reading the CSS file.
+
+    Non-regression test for https://github.com/scikit-learn/scikit-learn/issues/27725
+    """
+    _get_css_style()
+
+
+@pytest.mark.parametrize(
+    "func, expected_name",
+    [
+        (lambda x: x + 1, html.escape("<lambda>")),
+        (dummy_function, "dummy_function"),
+        (partial(dummy_function, y=1), "dummy_function"),
+        (np.vectorize(partial(dummy_function, y=1)), re.escape("vectorize(...)")),
+    ],
+)
+def test_function_transformer_show_caption(func, expected_name):
+    # Test that function name is shown as the name and "FunctionTransformer" is shown
+    # in the caption
+    ft = FunctionTransformer(func)
+    html_output = estimator_html_repr(ft)
+
+    p = (
+        r'<label for="sk-estimator-id-[0-9]*" class="sk-toggleable__label fitted '
+        rf'sk-toggleable__label-arrow"><div><div>{expected_name}</div>'
+        r'<div class="caption">FunctionTransformer</div></div>'
+    )
+    re_compiled = re.compile(p)
+    assert re_compiled.search(html_output)
+
+
+def test_estimator_html_repr_table():
+    """Check that we add the table of parameters in the HTML representation."""
+    est = LogisticRegression(C=10.0, fit_intercept=False)
+    assert "parameters-table" in estimator_html_repr(est)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_params.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_params.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd1c7dfb9aff79ea980bf224c2ab136647cebe9f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_repr_html/tests/test_params.py
@@ -0,0 +1,74 @@
+import pytest
+
+from sklearn import config_context
+from sklearn.utils._repr_html.params import ParamsDict, _params_html_repr, _read_params
+
+
+def test_params_dict_content():
+    """Check the behavior of the ParamsDict class."""
+    params = ParamsDict({"a": 1, "b": 2})
+    assert params["a"] == 1
+    assert params["b"] == 2
+    assert params.non_default == ()
+
+    params = ParamsDict({"a": 1, "b": 2}, non_default=("a",))
+    assert params["a"] == 1
+    assert params["b"] == 2
+    assert params.non_default == ("a",)
+
+
+def test_params_dict_repr_html_():
+    params = ParamsDict({"a": 1, "b": 2}, non_default=("a",))
+    out = params._repr_html_()
+    assert "<summary>Parameters</summary>" in out
+
+    with config_context(display="text"):
+        msg = "_repr_html_ is only defined when"
+        with pytest.raises(AttributeError, match=msg):
+            params._repr_html_()
+
+
+def test_params_dict_repr_mimebundle():
+    params = ParamsDict({"a": 1, "b": 2}, non_default=("a",))
+    out = params._repr_mimebundle_()
+
+    assert "text/plain" in out
+    assert "text/html" in out
+    assert "<summary>Parameters</summary>" in out["text/html"]
+    assert out["text/plain"] == "{'a': 1, 'b': 2}"
+
+    with config_context(display="text"):
+        out = params._repr_mimebundle_()
+        assert "text/plain" in out
+        assert "text/html" not in out
+
+
+def test_read_params():
+    """Check the behavior of the `_read_params` function."""
+    out = _read_params("a", 1, tuple())
+    assert out["param_type"] == "default"
+    assert out["param_name"] == "a"
+    assert out["param_value"] == "1"
+
+    # check non-default parameters
+    out = _read_params("a", 1, ("a",))
+    assert out["param_type"] == "user-set"
+    assert out["param_name"] == "a"
+    assert out["param_value"] == "1"
+
+    # check that we escape html tags
+    tag_injection = "<script>alert('xss')</script>"
+    out = _read_params("a", tag_injection, tuple())
+    assert (
+        out["param_value"]
+        == "&quot;&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;&quot;"
+    )
+    assert out["param_name"] == "a"
+    assert out["param_type"] == "default"
+
+
+def test_params_html_repr():
+    """Check returned HTML template"""
+    params = ParamsDict({"a": 1, "b": 2})
+    assert "parameters-table" in _params_html_repr(params)
+    assert "estimator-table" in _params_html_repr(params)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..67dd18fb94b593f0a3125c1f5833f3b9597614ba
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/__init__.py
@@ -0,0 +1,2 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/instance_generator.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/instance_generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d88ad23eb5e954c92e5b87dd8a8d25449856a63
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/_test_common/instance_generator.py
@@ -0,0 +1,1293 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+
+import re
+import warnings
+from contextlib import suppress
+from functools import partial
+from inspect import isfunction
+
+from sklearn import clone, config_context
+from sklearn.calibration import CalibratedClassifierCV
+from sklearn.cluster import (
+    HDBSCAN,
+    AffinityPropagation,
+    AgglomerativeClustering,
+    Birch,
+    BisectingKMeans,
+    FeatureAgglomeration,
+    KMeans,
+    MeanShift,
+    MiniBatchKMeans,
+    SpectralBiclustering,
+    SpectralClustering,
+    SpectralCoclustering,
+)
+from sklearn.compose import ColumnTransformer
+from sklearn.covariance import GraphicalLasso, GraphicalLassoCV
+from sklearn.cross_decomposition import CCA, PLSSVD, PLSCanonical, PLSRegression
+from sklearn.decomposition import (
+    NMF,
+    PCA,
+    DictionaryLearning,
+    FactorAnalysis,
+    FastICA,
+    IncrementalPCA,
+    KernelPCA,
+    LatentDirichletAllocation,
+    MiniBatchDictionaryLearning,
+    MiniBatchNMF,
+    MiniBatchSparsePCA,
+    SparseCoder,
+    SparsePCA,
+    TruncatedSVD,
+)
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.dummy import DummyClassifier
+from sklearn.ensemble import (
+    AdaBoostClassifier,
+    AdaBoostRegressor,
+    BaggingClassifier,
+    BaggingRegressor,
+    ExtraTreesClassifier,
+    ExtraTreesRegressor,
+    GradientBoostingClassifier,
+    GradientBoostingRegressor,
+    HistGradientBoostingClassifier,
+    HistGradientBoostingRegressor,
+    IsolationForest,
+    RandomForestClassifier,
+    RandomForestRegressor,
+    RandomTreesEmbedding,
+    StackingClassifier,
+    StackingRegressor,
+    VotingClassifier,
+    VotingRegressor,
+)
+from sklearn.exceptions import SkipTestWarning
+from sklearn.experimental import enable_halving_search_cv  # noqa: F401
+from sklearn.feature_selection import (
+    RFE,
+    RFECV,
+    SelectFdr,
+    SelectFromModel,
+    SelectKBest,
+    SequentialFeatureSelector,
+)
+from sklearn.frozen import FrozenEstimator
+from sklearn.kernel_approximation import (
+    Nystroem,
+    PolynomialCountSketch,
+    RBFSampler,
+    SkewedChi2Sampler,
+)
+from sklearn.linear_model import (
+    ARDRegression,
+    BayesianRidge,
+    ElasticNet,
+    ElasticNetCV,
+    GammaRegressor,
+    HuberRegressor,
+    LarsCV,
+    Lasso,
+    LassoCV,
+    LassoLars,
+    LassoLarsCV,
+    LassoLarsIC,
+    LinearRegression,
+    LogisticRegression,
+    LogisticRegressionCV,
+    MultiTaskElasticNet,
+    MultiTaskElasticNetCV,
+    MultiTaskLasso,
+    MultiTaskLassoCV,
+    OrthogonalMatchingPursuitCV,
+    PassiveAggressiveClassifier,
+    PassiveAggressiveRegressor,
+    Perceptron,
+    PoissonRegressor,
+    QuantileRegressor,
+    RANSACRegressor,
+    Ridge,
+    RidgeClassifier,
+    SGDClassifier,
+    SGDOneClassSVM,
+    SGDRegressor,
+    TheilSenRegressor,
+    TweedieRegressor,
+)
+from sklearn.manifold import (
+    MDS,
+    TSNE,
+    Isomap,
+    LocallyLinearEmbedding,
+    SpectralEmbedding,
+)
+from sklearn.mixture import BayesianGaussianMixture, GaussianMixture
+from sklearn.model_selection import (
+    FixedThresholdClassifier,
+    GridSearchCV,
+    HalvingGridSearchCV,
+    HalvingRandomSearchCV,
+    RandomizedSearchCV,
+    TunedThresholdClassifierCV,
+)
+from sklearn.multiclass import (
+    OneVsOneClassifier,
+    OneVsRestClassifier,
+    OutputCodeClassifier,
+)
+from sklearn.multioutput import (
+    ClassifierChain,
+    MultiOutputClassifier,
+    MultiOutputRegressor,
+    RegressorChain,
+)
+from sklearn.neighbors import (
+    KernelDensity,
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    KNeighborsTransformer,
+    NeighborhoodComponentsAnalysis,
+    RadiusNeighborsTransformer,
+)
+from sklearn.neural_network import BernoulliRBM, MLPClassifier, MLPRegressor
+from sklearn.pipeline import FeatureUnion, Pipeline
+from sklearn.preprocessing import (
+    KBinsDiscretizer,
+    OneHotEncoder,
+    SplineTransformer,
+    StandardScaler,
+    TargetEncoder,
+)
+from sklearn.random_projection import (
+    GaussianRandomProjection,
+    SparseRandomProjection,
+)
+from sklearn.semi_supervised import (
+    LabelPropagation,
+    LabelSpreading,
+    SelfTrainingClassifier,
+)
+from sklearn.svm import SVC, SVR, LinearSVC, LinearSVR, NuSVC, NuSVR, OneClassSVM
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.utils import all_estimators
+from sklearn.utils._tags import get_tags
+from sklearn.utils._testing import SkipTest
+from sklearn.utils.fixes import _IS_32BIT, parse_version, sp_base_version
+
+CROSS_DECOMPOSITION = ["PLSCanonical", "PLSRegression", "CCA", "PLSSVD"]
+
+# The following dictionary is to indicate constructor arguments suitable for the test
+# suite, which uses very small datasets, and is intended to run rather quickly.
+INIT_PARAMS = {
+    AdaBoostClassifier: dict(n_estimators=5),
+    AdaBoostRegressor: dict(n_estimators=5),
+    AffinityPropagation: dict(max_iter=5),
+    AgglomerativeClustering: dict(n_clusters=2),
+    ARDRegression: dict(max_iter=5),
+    BaggingClassifier: dict(n_estimators=5),
+    BaggingRegressor: dict(n_estimators=5),
+    BayesianGaussianMixture: dict(n_init=2, max_iter=5),
+    BayesianRidge: dict(max_iter=5),
+    BernoulliRBM: dict(n_iter=5, batch_size=10),
+    Birch: dict(n_clusters=2),
+    BisectingKMeans: dict(n_init=2, n_clusters=2, max_iter=5),
+    CalibratedClassifierCV: dict(estimator=LogisticRegression(C=1), cv=3),
+    CCA: dict(n_components=1, max_iter=5),
+    ClassifierChain: dict(estimator=LogisticRegression(C=1), cv=3),
+    ColumnTransformer: dict(transformers=[("trans1", StandardScaler(), [0, 1])]),
+    DictionaryLearning: dict(max_iter=20, transform_algorithm="lasso_lars"),
+    # the default strategy prior would output constant predictions and fail
+    # for check_classifiers_predictions
+    DummyClassifier: [dict(strategy="stratified"), dict(strategy="most_frequent")],
+    ElasticNetCV: dict(max_iter=5, cv=3),
+    ElasticNet: dict(max_iter=5),
+    ExtraTreesClassifier: dict(n_estimators=5),
+    ExtraTreesRegressor: dict(n_estimators=5),
+    FactorAnalysis: dict(max_iter=5),
+    FastICA: dict(max_iter=5),
+    FeatureAgglomeration: dict(n_clusters=2),
+    FeatureUnion: dict(transformer_list=[("trans1", StandardScaler())]),
+    FixedThresholdClassifier: dict(estimator=LogisticRegression(C=1)),
+    GammaRegressor: dict(max_iter=5),
+    GaussianMixture: dict(n_init=2, max_iter=5),
+    # Due to the jl lemma and often very few samples, the number
+    # of components of the random matrix projection will be probably
+    # greater than the number of features.
+    # So we impose a smaller number (avoid "auto" mode)
+    GaussianRandomProjection: dict(n_components=2),
+    GradientBoostingClassifier: dict(n_estimators=5),
+    GradientBoostingRegressor: dict(n_estimators=5),
+    GraphicalLassoCV: dict(max_iter=5, cv=3),
+    GraphicalLasso: dict(max_iter=5),
+    GridSearchCV: [
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Ridge(),
+            param_grid={"alpha": [0.1, 1.0]},
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=LogisticRegression(),
+            param_grid={"C": [0.1, 1.0]},
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(steps=[("pca", PCA()), ("ridge", Ridge())]),
+            param_grid={"ridge__alpha": [0.1, 1.0]},
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(
+                steps=[("pca", PCA()), ("logisticregression", LogisticRegression())]
+            ),
+            param_grid={"logisticregression__C": [0.1, 1.0]},
+        ),
+    ],
+    HalvingGridSearchCV: [
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Ridge(),
+            min_resources="smallest",
+            param_grid={"alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=LogisticRegression(),
+            min_resources="smallest",
+            param_grid={"C": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(steps=[("pca", PCA()), ("ridge", Ridge())]),
+            min_resources="smallest",
+            param_grid={"ridge__alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(
+                steps=[("pca", PCA()), ("logisticregression", LogisticRegression())]
+            ),
+            min_resources="smallest",
+            param_grid={"logisticregression__C": [0.1, 1.0]},
+            random_state=0,
+        ),
+    ],
+    HalvingRandomSearchCV: [
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Ridge(),
+            param_distributions={"alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=LogisticRegression(),
+            param_distributions={"C": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(steps=[("pca", PCA()), ("ridge", Ridge())]),
+            param_distributions={"ridge__alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(
+                steps=[("pca", PCA()), ("logisticregression", LogisticRegression())]
+            ),
+            param_distributions={"logisticregression__C": [0.1, 1.0]},
+            random_state=0,
+        ),
+    ],
+    HDBSCAN: dict(min_samples=1),
+    # The default min_samples_leaf (20) isn't appropriate for small
+    # datasets (only very shallow trees are built) that the checks use.
+    HistGradientBoostingClassifier: dict(max_iter=5, min_samples_leaf=5),
+    HistGradientBoostingRegressor: dict(max_iter=5, min_samples_leaf=5),
+    HuberRegressor: dict(max_iter=5),
+    IncrementalPCA: dict(batch_size=10),
+    IsolationForest: dict(n_estimators=5),
+    KMeans: dict(n_init=2, n_clusters=2, max_iter=5),
+    KNeighborsClassifier: [dict(n_neighbors=2), dict(metric="precomputed")],
+    KNeighborsRegressor: [dict(n_neighbors=2), dict(metric="precomputed")],
+    LabelPropagation: dict(max_iter=5),
+    LabelSpreading: dict(max_iter=5),
+    LarsCV: dict(max_iter=5, cv=3),
+    LassoCV: dict(max_iter=5, cv=3),
+    Lasso: dict(max_iter=5),
+    LassoLarsCV: dict(max_iter=5, cv=3),
+    LassoLars: dict(max_iter=5),
+    # Noise variance estimation does not work when `n_samples < n_features`.
+    # We need to provide the noise variance explicitly.
+    LassoLarsIC: dict(max_iter=5, noise_variance=1.0),
+    LatentDirichletAllocation: dict(max_iter=5, batch_size=10),
+    LinearSVC: dict(max_iter=20),
+    LinearSVR: dict(max_iter=20),
+    LocallyLinearEmbedding: dict(max_iter=5),
+    LogisticRegressionCV: dict(max_iter=5, cv=3),
+    LogisticRegression: dict(max_iter=5),
+    MDS: dict(n_init=2, max_iter=5),
+    # In the case of check_fit2d_1sample, bandwidth is set to None and
+    # is thus estimated. De facto it is 0.0 as a single sample is provided
+    # and this makes the test fails. Hence we give it a placeholder value.
+    MeanShift: dict(max_iter=5, bandwidth=1.0),
+    MiniBatchDictionaryLearning: dict(batch_size=10, max_iter=5),
+    MiniBatchKMeans: dict(n_init=2, n_clusters=2, max_iter=5, batch_size=10),
+    MiniBatchNMF: dict(batch_size=10, max_iter=20, fresh_restarts=True),
+    MiniBatchSparsePCA: dict(max_iter=5, batch_size=10),
+    MLPClassifier: dict(max_iter=100),
+    MLPRegressor: dict(max_iter=100),
+    MultiOutputClassifier: dict(estimator=LogisticRegression(C=1)),
+    MultiOutputRegressor: dict(estimator=Ridge()),
+    MultiTaskElasticNetCV: dict(max_iter=5, cv=3),
+    MultiTaskElasticNet: dict(max_iter=5),
+    MultiTaskLassoCV: dict(max_iter=5, cv=3),
+    MultiTaskLasso: dict(max_iter=5),
+    NeighborhoodComponentsAnalysis: dict(max_iter=5),
+    NMF: dict(max_iter=500),
+    NuSVC: dict(max_iter=-1),
+    NuSVR: dict(max_iter=-1),
+    OneClassSVM: dict(max_iter=-1),
+    OneHotEncoder: dict(handle_unknown="ignore"),
+    OneVsOneClassifier: dict(estimator=LogisticRegression(C=1)),
+    OneVsRestClassifier: dict(estimator=LogisticRegression(C=1)),
+    OrthogonalMatchingPursuitCV: dict(cv=3),
+    OutputCodeClassifier: dict(estimator=LogisticRegression(C=1)),
+    PassiveAggressiveClassifier: dict(max_iter=5),
+    PassiveAggressiveRegressor: dict(max_iter=5),
+    Perceptron: dict(max_iter=5),
+    Pipeline: [
+        {"steps": [("scaler", StandardScaler()), ("final_estimator", Ridge())]},
+        {
+            "steps": [
+                ("scaler", StandardScaler()),
+                ("final_estimator", LogisticRegression()),
+            ]
+        },
+    ],
+    PLSCanonical: dict(n_components=1, max_iter=5),
+    PLSRegression: dict(n_components=1, max_iter=5),
+    PLSSVD: dict(n_components=1),
+    PoissonRegressor: dict(max_iter=5),
+    RandomForestClassifier: dict(n_estimators=5),
+    RandomForestRegressor: dict(n_estimators=5),
+    RandomizedSearchCV: [
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Ridge(),
+            param_distributions={"alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=LogisticRegression(),
+            param_distributions={"C": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(steps=[("pca", PCA()), ("ridge", Ridge())]),
+            param_distributions={"ridge__alpha": [0.1, 1.0]},
+            random_state=0,
+        ),
+        dict(
+            cv=2,
+            error_score="raise",
+            estimator=Pipeline(
+                steps=[("pca", PCA()), ("logisticregression", LogisticRegression())]
+            ),
+            param_distributions={"logisticregression__C": [0.1, 1.0]},
+            random_state=0,
+        ),
+    ],
+    RandomTreesEmbedding: dict(n_estimators=5),
+    # `RANSACRegressor` will raise an error with any model other
+    # than `LinearRegression` if we don't fix the `min_samples` parameter.
+    # For common tests, we can enforce using `LinearRegression` that
+    # is the default estimator in `RANSACRegressor` instead of `Ridge`.
+    RANSACRegressor: dict(estimator=LinearRegression(), max_trials=10),
+    RegressorChain: dict(estimator=Ridge(), cv=3),
+    RFECV: dict(estimator=LogisticRegression(C=1), cv=3),
+    RFE: dict(estimator=LogisticRegression(C=1)),
+    # be tolerant of noisy datasets (not actually speed)
+    SelectFdr: dict(alpha=0.5),
+    # Increases coverage because SGDRegressor has partial_fit
+    SelectFromModel: dict(estimator=SGDRegressor(random_state=0)),
+    # SelectKBest has a default of k=10
+    # which is more feature than we have in most case.
+    SelectKBest: dict(k=1),
+    SelfTrainingClassifier: dict(estimator=LogisticRegression(C=1), max_iter=5),
+    SequentialFeatureSelector: dict(estimator=LogisticRegression(C=1), cv=3),
+    SGDClassifier: dict(max_iter=5),
+    SGDOneClassSVM: dict(max_iter=5),
+    SGDRegressor: dict(max_iter=5),
+    SparsePCA: dict(max_iter=5),
+    # Due to the jl lemma and often very few samples, the number
+    # of components of the random matrix projection will be probably
+    # greater than the number of features.
+    # So we impose a smaller number (avoid "auto" mode)
+    SparseRandomProjection: dict(n_components=2),
+    SpectralBiclustering: dict(n_init=2, n_best=1, n_clusters=2),
+    SpectralClustering: dict(n_init=2, n_clusters=2),
+    SpectralCoclustering: dict(n_init=2, n_clusters=2),
+    # Default "auto" parameter can lead to different ordering of eigenvalues on
+    # windows: #24105
+    SpectralEmbedding: dict(eigen_tol=1e-05),
+    StackingClassifier: dict(
+        estimators=[
+            ("est1", DecisionTreeClassifier(max_depth=3, random_state=0)),
+            ("est2", DecisionTreeClassifier(max_depth=3, random_state=1)),
+        ],
+        cv=3,
+    ),
+    StackingRegressor: dict(
+        estimators=[
+            ("est1", DecisionTreeRegressor(max_depth=3, random_state=0)),
+            ("est2", DecisionTreeRegressor(max_depth=3, random_state=1)),
+        ],
+        cv=3,
+    ),
+    SVC: [dict(max_iter=-1), dict(kernel="precomputed")],
+    SVR: [dict(max_iter=-1), dict(kernel="precomputed")],
+    TargetEncoder: dict(cv=3),
+    TheilSenRegressor: dict(max_iter=5, max_subpopulation=100),
+    # TruncatedSVD doesn't run with n_components = n_features
+    TruncatedSVD: dict(n_iter=5, n_components=1),
+    TSNE: dict(perplexity=2),
+    TunedThresholdClassifierCV: dict(estimator=LogisticRegression(C=1), cv=3),
+    TweedieRegressor: dict(max_iter=5),
+    VotingClassifier: dict(
+        estimators=[
+            ("est1", DecisionTreeClassifier(max_depth=3, random_state=0)),
+            ("est2", DecisionTreeClassifier(max_depth=3, random_state=1)),
+        ]
+    ),
+    VotingRegressor: dict(
+        estimators=[
+            ("est1", DecisionTreeRegressor(max_depth=3, random_state=0)),
+            ("est2", DecisionTreeRegressor(max_depth=3, random_state=1)),
+        ]
+    ),
+}
+
+# This dictionary stores parameters for specific checks. It also enables running the
+# same check with multiple instances of the same estimator with different parameters.
+# The special key "*" allows to apply the parameters to all checks.
+# TODO(devtools): allow third-party developers to pass test specific params to checks
+PER_ESTIMATOR_CHECK_PARAMS: dict = {
+    # TODO(devtools): check that function names here exist in checks for the estimator
+    AgglomerativeClustering: {"check_dict_unchanged": dict(n_clusters=1)},
+    BayesianGaussianMixture: {"check_dict_unchanged": dict(max_iter=5, n_init=2)},
+    BernoulliRBM: {"check_dict_unchanged": dict(n_components=1, n_iter=5)},
+    Birch: {"check_dict_unchanged": dict(n_clusters=1)},
+    BisectingKMeans: {"check_dict_unchanged": dict(max_iter=5, n_clusters=1, n_init=2)},
+    CCA: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    DecisionTreeRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(criterion="squared_error"),
+            dict(criterion="absolute_error"),
+            dict(criterion="friedman_mse"),
+            dict(criterion="poisson"),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(criterion="squared_error"),
+            dict(criterion="absolute_error"),
+            dict(criterion="friedman_mse"),
+            dict(criterion="poisson"),
+        ],
+    },
+    DecisionTreeClassifier: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(criterion="gini"),
+            dict(criterion="log_loss"),
+            dict(criterion="entropy"),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(criterion="gini"),
+            dict(criterion="log_loss"),
+            dict(criterion="entropy"),
+        ],
+    },
+    DictionaryLearning: {
+        "check_dict_unchanged": dict(
+            max_iter=20, n_components=1, transform_algorithm="lasso_lars"
+        )
+    },
+    FactorAnalysis: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    FastICA: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    FeatureAgglomeration: {"check_dict_unchanged": dict(n_clusters=1)},
+    FeatureUnion: {
+        "check_estimator_sparse_tag": [
+            dict(transformer_list=[("trans1", StandardScaler())]),
+            dict(
+                transformer_list=[
+                    ("trans1", StandardScaler(with_mean=False)),
+                    ("trans2", "drop"),
+                    ("trans3", "passthrough"),
+                ]
+            ),
+        ]
+    },
+    GammaRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="newton-cholesky"),
+            dict(solver="lbfgs"),
+        ],
+    },
+    GaussianMixture: {"check_dict_unchanged": dict(max_iter=5, n_init=2)},
+    GaussianRandomProjection: {"check_dict_unchanged": dict(n_components=1)},
+    IncrementalPCA: {"check_dict_unchanged": dict(batch_size=10, n_components=1)},
+    Isomap: {"check_dict_unchanged": dict(n_components=1)},
+    KMeans: {"check_dict_unchanged": dict(max_iter=5, n_clusters=1, n_init=2)},
+    # TODO(1.9) simplify when averaged_inverted_cdf is the default
+    KBinsDiscretizer: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            # Using subsample != None leads to a stochastic fit that is not
+            # handled by the check_sample_weight_equivalence_on_dense_data test.
+            dict(strategy="quantile", subsample=None, quantile_method="inverted_cdf"),
+            dict(
+                strategy="quantile",
+                subsample=None,
+                quantile_method="averaged_inverted_cdf",
+            ),
+            dict(strategy="uniform", subsample=None),
+            # The "kmeans" strategy leads to a stochastic fit that is not
+            # handled by the check_sample_weight_equivalence test.
+        ],
+        "check_sample_weights_list": dict(
+            strategy="quantile", quantile_method="averaged_inverted_cdf"
+        ),
+        "check_sample_weights_pandas_series": dict(
+            strategy="quantile", quantile_method="averaged_inverted_cdf"
+        ),
+        "check_sample_weights_shape": dict(
+            strategy="quantile", quantile_method="averaged_inverted_cdf"
+        ),
+        "check_sample_weights_not_an_array": dict(
+            strategy="quantile", quantile_method="averaged_inverted_cdf"
+        ),
+        "check_sample_weights_not_overwritten": dict(
+            strategy="quantile", quantile_method="averaged_inverted_cdf"
+        ),
+    },
+    KernelPCA: {"check_dict_unchanged": dict(n_components=1)},
+    LassoLars: {"check_non_transformer_estimators_n_iter": dict(alpha=0.0)},
+    LatentDirichletAllocation: {
+        "check_dict_unchanged": dict(batch_size=10, max_iter=5, n_components=1)
+    },
+    LinearDiscriminantAnalysis: {"check_dict_unchanged": dict(n_components=1)},
+    LinearSVC: {
+        "check_sample_weight_equivalence": [
+            # TODO: dual=True is a stochastic solver: we cannot rely on
+            # check_sample_weight_equivalence to check the correct handling of
+            # sample_weight and we would need a statistical test instead, see
+            # meta-issue #162298.
+            # dict(max_iter=20, dual=True, tol=1e-12),
+            dict(dual=False, tol=1e-12),
+            dict(dual=False, tol=1e-12, class_weight="balanced"),
+        ]
+    },
+    LinearRegression: {
+        "check_estimator_sparse_tag": [dict(positive=False), dict(positive=True)],
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(positive=False),
+            dict(positive=True),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [dict(tol=1e-12)],
+    },
+    LocallyLinearEmbedding: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    LogisticRegression: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="lbfgs"),
+            dict(solver="liblinear"),
+            dict(solver="newton-cg"),
+            dict(solver="newton-cholesky"),
+            dict(solver="newton-cholesky", class_weight="balanced"),
+        ]
+    },
+    LogisticRegressionCV: {
+        "check_sample_weight_equivalence": [
+            dict(solver="lbfgs"),
+            dict(solver="newton-cholesky"),
+            dict(solver="newton-cholesky", class_weight="balanced"),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(solver="liblinear"),
+        ],
+    },
+    MDS: {"check_dict_unchanged": dict(max_iter=5, n_components=1, n_init=2)},
+    MLPClassifier: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="lbfgs"),
+        ]
+    },
+    MLPRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="sgd", tol=1e-2, random_state=42),
+        ]
+    },
+    MiniBatchDictionaryLearning: {
+        "check_dict_unchanged": dict(batch_size=10, max_iter=5, n_components=1)
+    },
+    MiniBatchKMeans: {
+        "check_dict_unchanged": dict(batch_size=10, max_iter=5, n_clusters=1, n_init=2)
+    },
+    MiniBatchNMF: {
+        "check_dict_unchanged": dict(
+            batch_size=10, fresh_restarts=True, max_iter=20, n_components=1
+        )
+    },
+    MiniBatchSparsePCA: {
+        "check_dict_unchanged": dict(batch_size=10, max_iter=5, n_components=1)
+    },
+    NMF: {"check_dict_unchanged": dict(max_iter=500, n_components=1)},
+    NeighborhoodComponentsAnalysis: {
+        "check_dict_unchanged": dict(max_iter=5, n_components=1)
+    },
+    Nystroem: {"check_dict_unchanged": dict(n_components=1)},
+    PCA: {"check_dict_unchanged": dict(n_components=1)},
+    PLSCanonical: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    PLSRegression: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    PLSSVD: {"check_dict_unchanged": dict(n_components=1)},
+    PoissonRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="newton-cholesky"),
+            dict(solver="lbfgs"),
+        ],
+    },
+    PolynomialCountSketch: {"check_dict_unchanged": dict(n_components=1)},
+    QuantileRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(quantile=0.5),
+            dict(quantile=0.75),
+            dict(solver="highs-ds"),
+            dict(solver="highs-ipm"),
+        ],
+    },
+    RBFSampler: {"check_dict_unchanged": dict(n_components=1)},
+    Ridge: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="svd"),
+            dict(solver="cholesky"),
+            dict(solver="sparse_cg"),
+            dict(solver="lsqr"),
+            dict(solver="lbfgs", positive=True),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(solver="sparse_cg"),
+            dict(solver="lsqr"),
+        ],
+    },
+    RidgeClassifier: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="svd"),
+            dict(solver="cholesky"),
+            dict(solver="sparse_cg"),
+            dict(solver="lsqr"),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(solver="sparse_cg"),
+            dict(solver="lsqr"),
+        ],
+    },
+    SkewedChi2Sampler: {"check_dict_unchanged": dict(n_components=1)},
+    SparsePCA: {"check_dict_unchanged": dict(max_iter=5, n_components=1)},
+    SparseRandomProjection: {"check_dict_unchanged": dict(n_components=1)},
+    SpectralBiclustering: {
+        "check_dict_unchanged": dict(n_best=1, n_clusters=1, n_components=1, n_init=2)
+    },
+    SpectralClustering: {
+        "check_dict_unchanged": dict(n_clusters=1, n_components=1, n_init=2)
+    },
+    SpectralCoclustering: {"check_dict_unchanged": dict(n_clusters=1, n_init=2)},
+    SpectralEmbedding: {"check_dict_unchanged": dict(eigen_tol=1e-05, n_components=1)},
+    StandardScaler: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(with_mean=True),
+            dict(with_mean=False),
+        ],
+        "check_sample_weight_equivalence_on_sparse_data": [
+            dict(with_mean=False),
+        ],
+    },
+    TSNE: {"check_dict_unchanged": dict(n_components=1, perplexity=2)},
+    TruncatedSVD: {"check_dict_unchanged": dict(n_components=1)},
+    TweedieRegressor: {
+        "check_sample_weight_equivalence_on_dense_data": [
+            dict(solver="newton-cholesky"),
+            dict(solver="lbfgs"),
+        ],
+    },
+}
+
+
+def _tested_estimators(type_filter=None):
+    for _, Estimator in all_estimators(type_filter=type_filter):
+        with suppress(SkipTest):
+            for estimator in _construct_instances(Estimator):
+                yield estimator
+
+
+SKIPPED_ESTIMATORS = [SparseCoder, FrozenEstimator]
+
+
+def _construct_instances(Estimator):
+    """Construct Estimator instances if possible.
+
+    If parameter sets in INIT_PARAMS are provided, use them. If there are a list
+    of parameter sets, return one instance for each set.
+    """
+    if Estimator in SKIPPED_ESTIMATORS:
+        msg = f"Can't instantiate estimator {Estimator.__name__}"
+        # raise additional warning to be shown by pytest
+        warnings.warn(msg, SkipTestWarning)
+        raise SkipTest(msg)
+
+    if Estimator in INIT_PARAMS:
+        param_sets = INIT_PARAMS[Estimator]
+        if not isinstance(param_sets, list):
+            param_sets = [param_sets]
+        for params in param_sets:
+            est = Estimator(**params)
+            yield est
+    else:
+        yield Estimator()
+
+
+def _get_check_estimator_ids(obj):
+    """Create pytest ids for checks.
+
+    When `obj` is an estimator, this returns the pprint version of the
+    estimator (with `print_changed_only=True`). When `obj` is a function, the
+    name of the function is returned with its keyword arguments.
+
+    `_get_check_estimator_ids` is designed to be used as the `id` in
+    `pytest.mark.parametrize` where `check_estimator(..., generate_only=True)`
+    is yielding estimators and checks.
+
+    Parameters
+    ----------
+    obj : estimator or function
+        Items generated by `check_estimator`.
+
+    Returns
+    -------
+    id : str or None
+
+    See Also
+    --------
+    check_estimator
+    """
+    if isfunction(obj):
+        return obj.__name__
+    if isinstance(obj, partial):
+        if not obj.keywords:
+            return obj.func.__name__
+        kwstring = ",".join(["{}={}".format(k, v) for k, v in obj.keywords.items()])
+        return "{}({})".format(obj.func.__name__, kwstring)
+    if hasattr(obj, "get_params"):
+        with config_context(print_changed_only=True):
+            return re.sub(r"\s", "", str(obj))
+
+
+def _yield_instances_for_check(check, estimator_orig):
+    """Yield instances for a check.
+
+    For most estimators, this is a no-op.
+
+    For estimators which have an entry in PER_ESTIMATOR_CHECK_PARAMS, this will yield
+    an estimator for each parameter set in PER_ESTIMATOR_CHECK_PARAMS[estimator].
+    """
+    # TODO(devtools): enable this behavior for third party estimators as well
+    if type(estimator_orig) not in PER_ESTIMATOR_CHECK_PARAMS:
+        yield estimator_orig
+        return
+
+    check_params = PER_ESTIMATOR_CHECK_PARAMS[type(estimator_orig)]
+
+    try:
+        check_name = check.__name__
+    except AttributeError:
+        # partial tests
+        check_name = check.func.__name__
+
+    if check_name not in check_params:
+        yield estimator_orig
+        return
+
+    param_set = check_params[check_name]
+    if isinstance(param_set, dict):
+        param_set = [param_set]
+
+    for params in param_set:
+        estimator = clone(estimator_orig)
+        estimator.set_params(**params)
+        yield estimator
+
+
+PER_ESTIMATOR_XFAIL_CHECKS = {
+    AdaBoostClassifier: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    AdaBoostRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    BaggingClassifier: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    BaggingRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    BernoulliRBM: {
+        "check_methods_subset_invariance": ("fails for the decision_function method"),
+        "check_methods_sample_order_invariance": ("fails for the score_samples method"),
+    },
+    BisectingKMeans: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    ColumnTransformer: {
+        "check_estimators_empty_data_messages": "FIXME",
+        "check_estimators_nan_inf": "FIXME",
+        "check_estimator_sparse_array": "FIXME",
+        "check_estimator_sparse_matrix": "FIXME",
+        "check_fit1d": "FIXME",
+        "check_fit2d_predict1d": "FIXME",
+        "check_complex_data": "FIXME",
+        "check_fit2d_1feature": "FIXME",
+    },
+    DummyClassifier: {
+        "check_methods_subset_invariance": "fails for the predict method",
+        "check_methods_sample_order_invariance": "fails for the predict method",
+    },
+    FeatureUnion: {
+        "check_estimators_overwrite_params": "FIXME",
+        "check_estimators_nan_inf": "FIXME",
+        "check_dont_overwrite_parameters": "FIXME",
+    },
+    FixedThresholdClassifier: {
+        "check_classifiers_train": "Threshold at probability 0.5 does not hold",
+        "check_sample_weight_equivalence_on_dense_data": (
+            "Due to the cross-validation and sample ordering, removing a sample"
+            " is not strictly equal to putting is weight to zero. Specific unit"
+            " tests are added for TunedThresholdClassifierCV specifically."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    GradientBoostingClassifier: {
+        # TODO: investigate failure see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    GradientBoostingRegressor: {
+        # TODO: investigate failure see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    GridSearchCV: {
+        "check_supervised_y_2d": "DataConversionWarning not caught",
+        "check_requires_y_none": "Doesn't fail gracefully",
+    },
+    HalvingGridSearchCV: {
+        "check_fit2d_1sample": (
+            "Fail during parameter check since min/max resources requires more samples"
+        ),
+        "check_estimators_nan_inf": "FIXME",
+        "check_classifiers_one_label_sample_weights": "FIXME",
+        "check_fit2d_1feature": "FIXME",
+        "check_supervised_y_2d": "DataConversionWarning not caught",
+        "check_requires_y_none": "Doesn't fail gracefully",
+    },
+    HalvingRandomSearchCV: {
+        "check_fit2d_1sample": (
+            "Fail during parameter check since min/max resources requires more samples"
+        ),
+        "check_estimators_nan_inf": "FIXME",
+        "check_classifiers_one_label_sample_weights": "FIXME",
+        "check_fit2d_1feature": "FIXME",
+        "check_supervised_y_2d": "DataConversionWarning not caught",
+        "check_requires_y_none": "Doesn't fail gracefully",
+    },
+    HistGradientBoostingClassifier: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    HistGradientBoostingRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    IsolationForest: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    KernelDensity: {
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight must have positive values"
+        ),
+    },
+    KMeans: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    KNeighborsTransformer: {
+        "check_methods_sample_order_invariance": "check is not applicable."
+    },
+    LinearSVC: {
+        # TODO: replace by a statistical test when _dual=True, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_non_transformer_estimators_n_iter": (
+            "n_iter_ cannot be easily accessed."
+        ),
+    },
+    LinearSVR: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    LogisticRegression: {
+        # TODO: fix sample_weight handling of this estimator, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    MiniBatchKMeans: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    NuSVC: {
+        "check_class_weight_classifiers": "class_weight is ignored.",
+        # TODO: fix sample_weight handling of this estimator when probability=False
+        # TODO: replace by a statistical test when probability=True
+        # see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_classifiers_one_label_sample_weights": (
+            "specified nu is infeasible for the fit."
+        ),
+    },
+    NuSVR: {
+        # TODO: fix sample_weight handling of this estimator, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    Nystroem: {
+        "check_transformer_preserves_dtypes": (
+            "dtypes are preserved but not at a close enough precision"
+        )
+    },
+    OneClassSVM: {
+        # TODO: fix sample_weight handling of this estimator, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    Perceptron: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    Pipeline: {
+        "check_dont_overwrite_parameters": (
+            "Pipeline changes the `steps` parameter, which it shouldn't."
+            "Therefore this test is x-fail until we fix this."
+        ),
+        "check_estimators_overwrite_params": (
+            "Pipeline changes the `steps` parameter, which it shouldn't."
+            "Therefore this test is x-fail until we fix this."
+        ),
+    },
+    RadiusNeighborsTransformer: {
+        "check_methods_sample_order_invariance": "check is not applicable."
+    },
+    RandomForestClassifier: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    RandomForestRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    RandomizedSearchCV: {
+        "check_supervised_y_2d": "DataConversionWarning not caught",
+        "check_requires_y_none": "Doesn't fail gracefully",
+    },
+    RandomTreesEmbedding: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    RANSACRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    Ridge: {
+        "check_non_transformer_estimators_n_iter": (
+            "n_iter_ cannot be easily accessed."
+        )
+    },
+    RidgeClassifier: {
+        "check_non_transformer_estimators_n_iter": (
+            "n_iter_ cannot be easily accessed."
+        )
+    },
+    SelfTrainingClassifier: {
+        "check_non_transformer_estimators_n_iter": "n_iter_ can be 0."
+    },
+    SGDClassifier: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    SGDOneClassSVM: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    SGDRegressor: {
+        # TODO: replace by a statistical test, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    SpectralCoclustering: {
+        "check_estimators_dtypes": "raises nan error",
+        "check_fit2d_1sample": "_scale_normalize fails",
+        "check_fit2d_1feature": "raises apply_along_axis error",
+        "check_estimator_sparse_matrix": "does not fail gracefully",
+        "check_estimator_sparse_array": "does not fail gracefully",
+        "check_methods_subset_invariance": "empty array passed inside",
+        "check_dont_overwrite_parameters": "empty array passed inside",
+        "check_fit2d_predict1d": "empty array passed inside",
+        # ValueError: Found array with 0 feature(s) (shape=(23, 0))
+        # while a minimum of 1 is required.
+        "check_dict_unchanged": "FIXME",
+    },
+    SpectralBiclustering: {
+        "check_estimators_dtypes": "raises nan error",
+        "check_fit2d_1sample": "_scale_normalize fails",
+        "check_fit2d_1feature": "raises apply_along_axis error",
+        "check_estimator_sparse_matrix": "does not fail gracefully",
+        "check_estimator_sparse_array": "does not fail gracefully",
+        "check_methods_subset_invariance": "empty array passed inside",
+        "check_dont_overwrite_parameters": "empty array passed inside",
+        "check_fit2d_predict1d": "empty array passed inside",
+    },
+    SVC: {
+        # TODO: fix sample_weight handling of this estimator when probability=False
+        # TODO: replace by a statistical test when probability=True
+        # see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    SVR: {
+        # TODO: fix sample_weight handling of this estimator, see meta-issue #16298
+        "check_sample_weight_equivalence_on_dense_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+        "check_sample_weight_equivalence_on_sparse_data": (
+            "sample_weight is not equivalent to removing/repeating samples."
+        ),
+    },
+    TunedThresholdClassifierCV: {
+        "check_classifiers_train": "Threshold at probability 0.5 does not hold",
+        "check_sample_weight_equivalence_on_dense_data": (
+            "Due to the cross-validation and sample ordering, removing a sample"
+            " is not strictly equal to putting is weight to zero. Specific unit"
+            " tests are added for TunedThresholdClassifierCV specifically."
+        ),
+    },
+}
+
+# TODO: remove when scipy min version >= 1.11
+if sp_base_version < parse_version("1.11"):
+    PER_ESTIMATOR_XFAIL_CHECKS[SplineTransformer] = {
+        "check_estimators_pickle": (
+            "scipy < 1.11 implementation of _bsplines does not"
+            "support const memory views."
+        ),
+    }
+
+
+def _get_expected_failed_checks(estimator):
+    """Get the expected failed checks for all estimators in scikit-learn."""
+    failed_checks = PER_ESTIMATOR_XFAIL_CHECKS.get(type(estimator), {})
+
+    tags = get_tags(estimator)
+
+    # all xfail marks that depend on the instance, come here. As of now, we have only
+    # these two cases.
+    if type(estimator) in [KNeighborsClassifier, KNeighborsRegressor]:
+        if tags.input_tags.pairwise:
+            failed_checks.update(
+                {
+                    "check_n_features_in_after_fitting": "FIXME",
+                    "check_dataframe_column_names_consistency": "FIXME",
+                }
+            )
+    if type(estimator) == LinearRegression:
+        # TODO: remove when scipy min version >= 1.16
+        # Regression introduced in scipy 1.15 and fixed in 1.16, see
+        # https://github.com/scipy/scipy/issues/22791
+        if (
+            parse_version("1.15.0") <= sp_base_version < parse_version("1.16")
+            and _IS_32BIT
+        ):
+            failed_checks.update(
+                {
+                    "check_sample_weight_equivalence_on_dense_data": (
+                        "Issue #31098. Fails on 32-bit platforms with recent scipy."
+                    ),
+                    "check_sample_weight_equivalence_on_sparse_data": (
+                        "Issue #31098. Fails on 32-bit platforms with recent scipy."
+                    ),
+                }
+            )
+
+    return failed_checks
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/optimize.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/optimize.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0d21b179658223e9c687de7004491a131696f38
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/optimize.py
@@ -0,0 +1,389 @@
+"""
+Our own implementation of the Newton algorithm
+
+Unlike the scipy.optimize version, this version of the Newton conjugate
+gradient solver uses only one function call to retrieve the
+func value, the gradient value and a callable for the Hessian matvec
+product. If the function call is very expensive (e.g. for logistic
+regression with large design matrix), this approach gives very
+significant speedups.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+# This is a modified file from scipy.optimize
+# Original authors: Travis Oliphant, Eric Jones
+
+import warnings
+
+import numpy as np
+import scipy
+from scipy.optimize._linesearch import line_search_wolfe1, line_search_wolfe2
+
+from ..exceptions import ConvergenceWarning
+
+
+class _LineSearchError(RuntimeError):
+    pass
+
+
+def _line_search_wolfe12(
+    f, fprime, xk, pk, gfk, old_fval, old_old_fval, verbose=0, **kwargs
+):
+    """
+    Same as line_search_wolfe1, but fall back to line_search_wolfe2 if
+    suitable step length is not found, and raise an exception if a
+    suitable step length is not found.
+
+    Raises
+    ------
+    _LineSearchError
+        If no suitable step size is found.
+
+    """
+    is_verbose = verbose >= 2
+    eps = 16 * np.finfo(np.asarray(old_fval).dtype).eps
+    if is_verbose:
+        print("  Line Search")
+        print(f"    eps=16 * finfo.eps={eps}")
+        print("    try line search wolfe1")
+
+    ret = line_search_wolfe1(f, fprime, xk, pk, gfk, old_fval, old_old_fval, **kwargs)
+
+    if is_verbose:
+        _not_ = "not " if ret[0] is None else ""
+        print("    wolfe1 line search was " + _not_ + "successful")
+
+    if ret[0] is None:
+        # Have a look at the line_search method of our NewtonSolver class. We borrow
+        # the logic from there
+        # Deal with relative loss differences around machine precision.
+        args = kwargs.get("args", tuple())
+        fval = f(xk + pk, *args)
+        tiny_loss = np.abs(old_fval * eps)
+        loss_improvement = fval - old_fval
+        check = np.abs(loss_improvement) <= tiny_loss
+        if is_verbose:
+            print(
+                "    check loss |improvement| <= eps * |loss_old|:"
+                f" {np.abs(loss_improvement)} <= {tiny_loss} {check}"
+            )
+        if check:
+            # 2.1 Check sum of absolute gradients as alternative condition.
+            sum_abs_grad_old = scipy.linalg.norm(gfk, ord=1)
+            grad = fprime(xk + pk, *args)
+            sum_abs_grad = scipy.linalg.norm(grad, ord=1)
+            check = sum_abs_grad < sum_abs_grad_old
+            if is_verbose:
+                print(
+                    "    check sum(|gradient|) < sum(|gradient_old|): "
+                    f"{sum_abs_grad} < {sum_abs_grad_old} {check}"
+                )
+            if check:
+                ret = (
+                    1.0,  # step size
+                    ret[1] + 1,  # number of function evaluations
+                    ret[2] + 1,  # number of gradient evaluations
+                    fval,
+                    old_fval,
+                    grad,
+                )
+
+    if ret[0] is None:
+        # line search failed: try different one.
+        # TODO: It seems that the new check for the sum of absolute gradients above
+        # catches all cases that, earlier, ended up here. In fact, our tests never
+        # trigger this "if branch" here and we can consider to remove it.
+        if is_verbose:
+            print("    last resort: try line search wolfe2")
+        ret = line_search_wolfe2(
+            f, fprime, xk, pk, gfk, old_fval, old_old_fval, **kwargs
+        )
+        if is_verbose:
+            _not_ = "not " if ret[0] is None else ""
+            print("    wolfe2 line search was " + _not_ + "successful")
+
+    if ret[0] is None:
+        raise _LineSearchError()
+
+    return ret
+
+
+def _cg(fhess_p, fgrad, maxiter, tol, verbose=0):
+    """
+    Solve iteratively the linear system 'fhess_p . xsupi = fgrad'
+    with a conjugate gradient descent.
+
+    Parameters
+    ----------
+    fhess_p : callable
+        Function that takes the gradient as a parameter and returns the
+        matrix product of the Hessian and gradient.
+
+    fgrad : ndarray of shape (n_features,) or (n_features + 1,)
+        Gradient vector.
+
+    maxiter : int
+        Number of CG iterations.
+
+    tol : float
+        Stopping criterion.
+
+    Returns
+    -------
+    xsupi : ndarray of shape (n_features,) or (n_features + 1,)
+        Estimated solution.
+    """
+    eps = 16 * np.finfo(np.float64).eps
+    xsupi = np.zeros(len(fgrad), dtype=fgrad.dtype)
+    ri = np.copy(fgrad)  # residual = fgrad - fhess_p @ xsupi
+    psupi = -ri
+    i = 0
+    dri0 = np.dot(ri, ri)
+    # We also keep track of |p_i|^2.
+    psupi_norm2 = dri0
+    is_verbose = verbose >= 2
+
+    while i <= maxiter:
+        if np.sum(np.abs(ri)) <= tol:
+            if is_verbose:
+                print(
+                    f"  Inner CG solver iteration {i} stopped with\n"
+                    f"    sum(|residuals|) <= tol: {np.sum(np.abs(ri))} <= {tol}"
+                )
+            break
+
+        Ap = fhess_p(psupi)
+        # check curvature
+        curv = np.dot(psupi, Ap)
+        if 0 <= curv <= eps * psupi_norm2:
+            # See https://arxiv.org/abs/1803.02924, Algo 1 Capped Conjugate Gradient.
+            if is_verbose:
+                print(
+                    f"  Inner CG solver iteration {i} stopped with\n"
+                    f"    tiny_|p| = eps * ||p||^2, eps = {eps}, "
+                    f"squared L2 norm ||p||^2 = {psupi_norm2}\n"
+                    f"    curvature <= tiny_|p|: {curv} <= {eps * psupi_norm2}"
+                )
+            break
+        elif curv < 0:
+            if i > 0:
+                if is_verbose:
+                    print(
+                        f"  Inner CG solver iteration {i} stopped with negative "
+                        f"curvature, curvature = {curv}"
+                    )
+                break
+            else:
+                # fall back to steepest descent direction
+                xsupi += dri0 / curv * psupi
+                if is_verbose:
+                    print("  Inner CG solver iteration 0 fell back to steepest descent")
+                break
+        alphai = dri0 / curv
+        xsupi += alphai * psupi
+        ri += alphai * Ap
+        dri1 = np.dot(ri, ri)
+        betai = dri1 / dri0
+        psupi = -ri + betai * psupi
+        # We use  |p_i|^2 = |r_i|^2 + beta_i^2 |p_{i-1}|^2
+        psupi_norm2 = dri1 + betai**2 * psupi_norm2
+        i = i + 1
+        dri0 = dri1  # update np.dot(ri,ri) for next time.
+    if is_verbose and i > maxiter:
+        print(
+            f"  Inner CG solver stopped reaching maxiter={i - 1} with "
+            f"sum(|residuals|) = {np.sum(np.abs(ri))}"
+        )
+    return xsupi
+
+
+def _newton_cg(
+    grad_hess,
+    func,
+    grad,
+    x0,
+    args=(),
+    tol=1e-4,
+    maxiter=100,
+    maxinner=200,
+    line_search=True,
+    warn=True,
+    verbose=0,
+):
+    """
+    Minimization of scalar function of one or more variables using the
+    Newton-CG algorithm.
+
+    Parameters
+    ----------
+    grad_hess : callable
+        Should return the gradient and a callable returning the matvec product
+        of the Hessian.
+
+    func : callable
+        Should return the value of the function.
+
+    grad : callable
+        Should return the function value and the gradient. This is used
+        by the linesearch functions.
+
+    x0 : array of float
+        Initial guess.
+
+    args : tuple, default=()
+        Arguments passed to func_grad_hess, func and grad.
+
+    tol : float, default=1e-4
+        Stopping criterion. The iteration will stop when
+        ``max{|g_i | i = 1, ..., n} <= tol``
+        where ``g_i`` is the i-th component of the gradient.
+
+    maxiter : int, default=100
+        Number of Newton iterations.
+
+    maxinner : int, default=200
+        Number of CG iterations.
+
+    line_search : bool, default=True
+        Whether to use a line search or not.
+
+    warn : bool, default=True
+        Whether to warn when didn't converge.
+
+    Returns
+    -------
+    xk : ndarray of float
+        Estimated minimum.
+    """
+    x0 = np.asarray(x0).flatten()
+    xk = np.copy(x0)
+    k = 0
+
+    if line_search:
+        old_fval = func(x0, *args)
+        old_old_fval = None
+    else:
+        old_fval = 0
+
+    is_verbose = verbose > 0
+
+    # Outer loop: our Newton iteration
+    while k < maxiter:
+        # Compute a search direction pk by applying the CG method to
+        #  del2 f(xk) p = - fgrad f(xk) starting from 0.
+        fgrad, fhess_p = grad_hess(xk, *args)
+
+        absgrad = np.abs(fgrad)
+        max_absgrad = np.max(absgrad)
+        check = max_absgrad <= tol
+        if is_verbose:
+            print(f"Newton-CG iter = {k}")
+            print("  Check Convergence")
+            print(f"    max |gradient| <= tol: {max_absgrad} <= {tol} {check}")
+        if check:
+            break
+
+        maggrad = np.sum(absgrad)
+        eta = min([0.5, np.sqrt(maggrad)])
+        termcond = eta * maggrad
+
+        # Inner loop: solve the Newton update by conjugate gradient, to
+        # avoid inverting the Hessian
+        xsupi = _cg(fhess_p, fgrad, maxiter=maxinner, tol=termcond, verbose=verbose)
+
+        alphak = 1.0
+
+        if line_search:
+            try:
+                alphak, fc, gc, old_fval, old_old_fval, gfkp1 = _line_search_wolfe12(
+                    func,
+                    grad,
+                    xk,
+                    xsupi,
+                    fgrad,
+                    old_fval,
+                    old_old_fval,
+                    verbose=verbose,
+                    args=args,
+                )
+            except _LineSearchError:
+                warnings.warn("Line Search failed")
+                break
+
+        xk += alphak * xsupi  # upcast if necessary
+        k += 1
+
+    if warn and k >= maxiter:
+        warnings.warn(
+            (
+                f"newton-cg failed to converge at loss = {old_fval}. Increase the"
+                " number of iterations."
+            ),
+            ConvergenceWarning,
+        )
+    elif is_verbose:
+        print(f"  Solver did converge at loss = {old_fval}.")
+    return xk, k
+
+
+def _check_optimize_result(solver, result, max_iter=None, extra_warning_msg=None):
+    """Check the OptimizeResult for successful convergence
+
+    Parameters
+    ----------
+    solver : str
+       Solver name. Currently only `lbfgs` is supported.
+
+    result : OptimizeResult
+       Result of the scipy.optimize.minimize function.
+
+    max_iter : int, default=None
+       Expected maximum number of iterations.
+
+    extra_warning_msg : str, default=None
+        Extra warning message.
+
+    Returns
+    -------
+    n_iter : int
+       Number of iterations.
+    """
+    # handle both scipy and scikit-learn solver names
+    if solver == "lbfgs":
+        if max_iter is not None:
+            # In scipy <= 1.0.0, nit may exceed maxiter for lbfgs.
+            # See https://github.com/scipy/scipy/issues/7854
+            n_iter_i = min(result.nit, max_iter)
+        else:
+            n_iter_i = result.nit
+
+        if result.status != 0:
+            warning_msg = (
+                f"{solver} failed to converge after {n_iter_i} iteration(s) "
+                f"(status={result.status}):\n"
+                f"{result.message}\n"
+            )
+            # Append a recommendation to increase iterations only when the
+            # number of iterations reaches the maximum allowed (max_iter),
+            # as this suggests the optimization may have been prematurely
+            # terminated due to the iteration limit.
+            if max_iter is not None and n_iter_i == max_iter:
+                warning_msg += (
+                    f"\nIncrease the number of iterations to improve the "
+                    f"convergence (max_iter={max_iter})."
+                )
+            warning_msg += (
+                "\nYou might also want to scale the data as shown in:\n"
+                "    https://scikit-learn.org/stable/modules/"
+                "preprocessing.html"
+            )
+            if extra_warning_msg is not None:
+                warning_msg += "\n" + extra_warning_msg
+            warnings.warn(warning_msg, ConvergenceWarning, stacklevel=2)
+
+    else:
+        raise NotImplementedError
+
+    return n_iter_i
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/parallel.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..743162dbc478d597da48a06d600fcef2cecc6f51
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/parallel.py
@@ -0,0 +1,177 @@
+"""Customizations of :mod:`joblib` and :mod:`threadpoolctl` tools for scikit-learn
+usage.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import functools
+import warnings
+from functools import update_wrapper
+
+import joblib
+from threadpoolctl import ThreadpoolController
+
+from .._config import config_context, get_config
+
+# Global threadpool controller instance that can be used to locally limit the number of
+# threads without looping through all shared libraries every time.
+# It should not be accessed directly and _get_threadpool_controller should be used
+# instead.
+_threadpool_controller = None
+
+
+def _with_config_and_warning_filters(delayed_func, config, warning_filters):
+    """Helper function that intends to attach a config to a delayed function."""
+    if hasattr(delayed_func, "with_config_and_warning_filters"):
+        return delayed_func.with_config_and_warning_filters(config, warning_filters)
+    else:
+        warnings.warn(
+            (
+                "`sklearn.utils.parallel.Parallel` needs to be used in "
+                "conjunction with `sklearn.utils.parallel.delayed` instead of "
+                "`joblib.delayed` to correctly propagate the scikit-learn "
+                "configuration to the joblib workers."
+            ),
+            UserWarning,
+        )
+        return delayed_func
+
+
+class Parallel(joblib.Parallel):
+    """Tweak of :class:`joblib.Parallel` that propagates the scikit-learn configuration.
+
+    This subclass of :class:`joblib.Parallel` ensures that the active configuration
+    (thread-local) of scikit-learn is propagated to the parallel workers for the
+    duration of the execution of the parallel tasks.
+
+    The API does not change and you can refer to :class:`joblib.Parallel`
+    documentation for more details.
+
+    .. versionadded:: 1.3
+    """
+
+    def __call__(self, iterable):
+        """Dispatch the tasks and return the results.
+
+        Parameters
+        ----------
+        iterable : iterable
+            Iterable containing tuples of (delayed_function, args, kwargs) that should
+            be consumed.
+
+        Returns
+        -------
+        results : list
+            List of results of the tasks.
+        """
+        # Capture the thread-local scikit-learn configuration at the time
+        # Parallel.__call__ is issued since the tasks can be dispatched
+        # in a different thread depending on the backend and on the value of
+        # pre_dispatch and n_jobs.
+        config = get_config()
+        warning_filters = warnings.filters
+        iterable_with_config_and_warning_filters = (
+            (
+                _with_config_and_warning_filters(delayed_func, config, warning_filters),
+                args,
+                kwargs,
+            )
+            for delayed_func, args, kwargs in iterable
+        )
+        return super().__call__(iterable_with_config_and_warning_filters)
+
+
+# remove when https://github.com/joblib/joblib/issues/1071 is fixed
+def delayed(function):
+    """Decorator used to capture the arguments of a function.
+
+    This alternative to `joblib.delayed` is meant to be used in conjunction
+    with `sklearn.utils.parallel.Parallel`. The latter captures the scikit-
+    learn configuration by calling `sklearn.get_config()` in the current
+    thread, prior to dispatching the first task. The captured configuration is
+    then propagated and enabled for the duration of the execution of the
+    delayed function in the joblib workers.
+
+    .. versionchanged:: 1.3
+       `delayed` was moved from `sklearn.utils.fixes` to `sklearn.utils.parallel`
+       in scikit-learn 1.3.
+
+    Parameters
+    ----------
+    function : callable
+        The function to be delayed.
+
+    Returns
+    -------
+    output: tuple
+        Tuple containing the delayed function, the positional arguments, and the
+        keyword arguments.
+    """
+
+    @functools.wraps(function)
+    def delayed_function(*args, **kwargs):
+        return _FuncWrapper(function), args, kwargs
+
+    return delayed_function
+
+
+class _FuncWrapper:
+    """Load the global configuration before calling the function."""
+
+    def __init__(self, function):
+        self.function = function
+        update_wrapper(self, self.function)
+
+    def with_config_and_warning_filters(self, config, warning_filters):
+        self.config = config
+        self.warning_filters = warning_filters
+        return self
+
+    def __call__(self, *args, **kwargs):
+        config = getattr(self, "config", {})
+        warning_filters = getattr(self, "warning_filters", [])
+        if not config or not warning_filters:
+            warnings.warn(
+                (
+                    "`sklearn.utils.parallel.delayed` should be used with"
+                    " `sklearn.utils.parallel.Parallel` to make it possible to"
+                    " propagate the scikit-learn configuration of the current thread to"
+                    " the joblib workers."
+                ),
+                UserWarning,
+            )
+
+        with config_context(**config), warnings.catch_warnings():
+            warnings.filters = warning_filters
+            return self.function(*args, **kwargs)
+
+
+def _get_threadpool_controller():
+    """Return the global threadpool controller instance."""
+    global _threadpool_controller
+
+    if _threadpool_controller is None:
+        _threadpool_controller = ThreadpoolController()
+
+    return _threadpool_controller
+
+
+def _threadpool_controller_decorator(limits=1, user_api="blas"):
+    """Decorator to limit the number of threads used at the function level.
+
+    It should be preferred over `threadpoolctl.ThreadpoolController.wrap` because this
+    one only loads the shared libraries when the function is called while the latter
+    loads them at import time.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            controller = _get_threadpool_controller()
+            with controller.limit(limits=limits, user_api=user_api):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/random.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/random.py
new file mode 100644
index 0000000000000000000000000000000000000000..aad8b84828514c443cd972a8887505cac28d2555
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/random.py
@@ -0,0 +1,101 @@
+"""Utilities for random sampling."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import array
+
+import numpy as np
+import scipy.sparse as sp
+
+from . import check_random_state
+from ._random import sample_without_replacement
+
+__all__ = ["sample_without_replacement"]
+
+
+def _random_choice_csc(n_samples, classes, class_probability=None, random_state=None):
+    """Generate a sparse random matrix given column class distributions
+
+    Parameters
+    ----------
+    n_samples : int,
+        Number of samples to draw in each column.
+
+    classes : list of size n_outputs of arrays of size (n_classes,)
+        List of classes for each column.
+
+    class_probability : list of size n_outputs of arrays of \
+        shape (n_classes,), default=None
+        Class distribution of each column. If None, uniform distribution is
+        assumed.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the randomness of the sampled classes.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    random_matrix : sparse csc matrix of size (n_samples, n_outputs)
+
+    """
+    data = array.array("i")
+    indices = array.array("i")
+    indptr = array.array("i", [0])
+
+    for j in range(len(classes)):
+        classes[j] = np.asarray(classes[j])
+        if classes[j].dtype.kind != "i":
+            raise ValueError("class dtype %s is not supported" % classes[j].dtype)
+        classes[j] = classes[j].astype(np.int64, copy=False)
+
+        # use uniform distribution if no class_probability is given
+        if class_probability is None:
+            class_prob_j = np.empty(shape=classes[j].shape[0])
+            class_prob_j.fill(1 / classes[j].shape[0])
+        else:
+            class_prob_j = np.asarray(class_probability[j])
+
+        if not np.isclose(np.sum(class_prob_j), 1.0):
+            raise ValueError(
+                "Probability array at index {0} does not sum to one".format(j)
+            )
+
+        if class_prob_j.shape[0] != classes[j].shape[0]:
+            raise ValueError(
+                "classes[{0}] (length {1}) and "
+                "class_probability[{0}] (length {2}) have "
+                "different length.".format(
+                    j, classes[j].shape[0], class_prob_j.shape[0]
+                )
+            )
+
+        # If 0 is not present in the classes insert it with a probability 0.0
+        if 0 not in classes[j]:
+            classes[j] = np.insert(classes[j], 0, 0)
+            class_prob_j = np.insert(class_prob_j, 0, 0.0)
+
+        # If there are nonzero classes choose randomly using class_probability
+        rng = check_random_state(random_state)
+        if classes[j].shape[0] > 1:
+            index_class_0 = np.flatnonzero(classes[j] == 0).item()
+            p_nonzero = 1 - class_prob_j[index_class_0]
+            nnz = int(n_samples * p_nonzero)
+            ind_sample = sample_without_replacement(
+                n_population=n_samples, n_samples=nnz, random_state=random_state
+            )
+            indices.extend(ind_sample)
+
+            # Normalize probabilities for the nonzero elements
+            classes_j_nonzero = classes[j] != 0
+            class_probability_nz = class_prob_j[classes_j_nonzero]
+            class_probability_nz_norm = class_probability_nz / np.sum(
+                class_probability_nz
+            )
+            classes_ind = np.searchsorted(
+                class_probability_nz_norm.cumsum(), rng.uniform(size=nnz)
+            )
+            data.extend(classes[j][classes_j_nonzero][classes_ind])
+        indptr.append(len(indices))
+
+    return sp.csc_matrix((data, indices, indptr), (n_samples, len(classes)), dtype=int)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs.py
new file mode 100644
index 0000000000000000000000000000000000000000..00e359bf7954715f176b80e82d1b28e706121f12
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs.py
@@ -0,0 +1,742 @@
+"""A collection of utilities to work with sparse matrices and arrays."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import itertools
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import LinearOperator
+
+from ..utils.fixes import _sparse_min_max, _sparse_nan_min_max
+from ..utils.validation import _check_sample_weight
+from .sparsefuncs_fast import (
+    csc_mean_variance_axis0 as _csc_mean_var_axis0,
+)
+from .sparsefuncs_fast import (
+    csr_mean_variance_axis0 as _csr_mean_var_axis0,
+)
+from .sparsefuncs_fast import (
+    incr_mean_variance_axis0 as _incr_mean_var_axis0,
+)
+
+
+def _raise_typeerror(X):
+    """Raises a TypeError if X is not a CSR or CSC matrix"""
+    input_type = X.format if sp.issparse(X) else type(X)
+    err = "Expected a CSR or CSC sparse matrix, got %s." % input_type
+    raise TypeError(err)
+
+
+def _raise_error_wrong_axis(axis):
+    if axis not in (0, 1):
+        raise ValueError(
+            "Unknown axis value: %d. Use 0 for rows, or 1 for columns" % axis
+        )
+
+
+def inplace_csr_column_scale(X, scale):
+    """Inplace column scaling of a CSR matrix.
+
+    Scale each feature of the data matrix by multiplying with specific scale
+    provided by the caller assuming a (n_samples, n_features) shape.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix to normalize using the variance of the features.
+        It should be of CSR format.
+
+    scale : ndarray of shape (n_features,), dtype={np.float32, np.float64}
+        Array of precomputed feature-wise values to use for scaling.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 3, 4, 4, 4])
+    >>> indices = np.array([0, 1, 2, 2])
+    >>> data = np.array([8, 1, 2, 5])
+    >>> scale = np.array([2, 3, 2])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 1, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.inplace_csr_column_scale(csr, scale)
+    >>> csr.todense()
+    matrix([[16,  3,  4],
+            [ 0,  0, 10],
+            [ 0,  0,  0],
+            [ 0,  0,  0]])
+    """
+    assert scale.shape[0] == X.shape[1]
+    X.data *= scale.take(X.indices, mode="clip")
+
+
+def inplace_csr_row_scale(X, scale):
+    """Inplace row scaling of a CSR matrix.
+
+    Scale each sample of the data matrix by multiplying with specific scale
+    provided by the caller assuming a (n_samples, n_features) shape.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix to be scaled. It should be of CSR format.
+
+    scale : ndarray of float of shape (n_samples,)
+        Array of precomputed sample-wise values to use for scaling.
+    """
+    assert scale.shape[0] == X.shape[0]
+    X.data *= np.repeat(scale, np.diff(X.indptr))
+
+
+def mean_variance_axis(X, axis, weights=None, return_sum_weights=False):
+    """Compute mean and variance along an axis on a CSR or CSC matrix.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Input data. It can be of CSR or CSC format.
+
+    axis : {0, 1}
+        Axis along which the axis should be computed.
+
+    weights : ndarray of shape (n_samples,) or (n_features,), default=None
+        If axis is set to 0 shape is (n_samples,) or
+        if axis is set to 1 shape is (n_features,).
+        If it is set to None, then samples are equally weighted.
+
+        .. versionadded:: 0.24
+
+    return_sum_weights : bool, default=False
+        If True, returns the sum of weights seen for each feature
+        if `axis=0` or each sample if `axis=1`.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+
+    means : ndarray of shape (n_features,), dtype=floating
+        Feature-wise means.
+
+    variances : ndarray of shape (n_features,), dtype=floating
+        Feature-wise variances.
+
+    sum_weights : ndarray of shape (n_features,), dtype=floating
+        Returned if `return_sum_weights` is `True`.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 3, 4, 4, 4])
+    >>> indices = np.array([0, 1, 2, 2])
+    >>> data = np.array([8, 1, 2, 5])
+    >>> scale = np.array([2, 3, 2])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 1, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.mean_variance_axis(csr, axis=0)
+    (array([2.  , 0.25, 1.75]), array([12.    ,  0.1875,  4.1875]))
+    """
+    _raise_error_wrong_axis(axis)
+
+    if sp.issparse(X) and X.format == "csr":
+        if axis == 0:
+            return _csr_mean_var_axis0(
+                X, weights=weights, return_sum_weights=return_sum_weights
+            )
+        else:
+            return _csc_mean_var_axis0(
+                X.T, weights=weights, return_sum_weights=return_sum_weights
+            )
+    elif sp.issparse(X) and X.format == "csc":
+        if axis == 0:
+            return _csc_mean_var_axis0(
+                X, weights=weights, return_sum_weights=return_sum_weights
+            )
+        else:
+            return _csr_mean_var_axis0(
+                X.T, weights=weights, return_sum_weights=return_sum_weights
+            )
+    else:
+        _raise_typeerror(X)
+
+
+def incr_mean_variance_axis(X, *, axis, last_mean, last_var, last_n, weights=None):
+    """Compute incremental mean and variance along an axis on a CSR or CSC matrix.
+
+    last_mean, last_var are the statistics computed at the last step by this
+    function. Both must be initialized to 0-arrays of the proper size, i.e.
+    the number of features in X. last_n is the number of samples encountered
+    until now.
+
+    Parameters
+    ----------
+    X : CSR or CSC sparse matrix of shape (n_samples, n_features)
+        Input data.
+
+    axis : {0, 1}
+        Axis along which the axis should be computed.
+
+    last_mean : ndarray of shape (n_features,) or (n_samples,), dtype=floating
+        Array of means to update with the new data X.
+        Should be of shape (n_features,) if axis=0 or (n_samples,) if axis=1.
+
+    last_var : ndarray of shape (n_features,) or (n_samples,), dtype=floating
+        Array of variances to update with the new data X.
+        Should be of shape (n_features,) if axis=0 or (n_samples,) if axis=1.
+
+    last_n : float or ndarray of shape (n_features,) or (n_samples,), \
+            dtype=floating
+        Sum of the weights seen so far, excluding the current weights
+        If not float, it should be of shape (n_features,) if
+        axis=0 or (n_samples,) if axis=1. If float it corresponds to
+        having same weights for all samples (or features).
+
+    weights : ndarray of shape (n_samples,) or (n_features,), default=None
+        If axis is set to 0 shape is (n_samples,) or
+        if axis is set to 1 shape is (n_features,).
+        If it is set to None, then samples are equally weighted.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+    means : ndarray of shape (n_features,) or (n_samples,), dtype=floating
+        Updated feature-wise means if axis = 0 or
+        sample-wise means if axis = 1.
+
+    variances : ndarray of shape (n_features,) or (n_samples,), dtype=floating
+        Updated feature-wise variances if axis = 0 or
+        sample-wise variances if axis = 1.
+
+    n : ndarray of shape (n_features,) or (n_samples,), dtype=integral
+        Updated number of seen samples per feature if axis=0
+        or number of seen features per sample if axis=1.
+
+        If weights is not None, n is a sum of the weights of the seen
+        samples or features instead of the actual number of seen
+        samples or features.
+
+    Notes
+    -----
+    NaNs are ignored in the algorithm.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 3, 4, 4, 4])
+    >>> indices = np.array([0, 1, 2, 2])
+    >>> data = np.array([8, 1, 2, 5])
+    >>> scale = np.array([2, 3, 2])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 1, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.incr_mean_variance_axis(
+    ...     csr, axis=0, last_mean=np.zeros(3), last_var=np.zeros(3), last_n=2
+    ... )
+    (array([1.33, 0.167, 1.17]), array([8.88, 0.139, 3.47]),
+    array([6., 6., 6.]))
+    """
+    _raise_error_wrong_axis(axis)
+
+    if not (sp.issparse(X) and X.format in ("csc", "csr")):
+        _raise_typeerror(X)
+
+    if np.size(last_n) == 1:
+        last_n = np.full(last_mean.shape, last_n, dtype=last_mean.dtype)
+
+    if not (np.size(last_mean) == np.size(last_var) == np.size(last_n)):
+        raise ValueError("last_mean, last_var, last_n do not have the same shapes.")
+
+    if axis == 1:
+        if np.size(last_mean) != X.shape[0]:
+            raise ValueError(
+                "If axis=1, then last_mean, last_n, last_var should be of "
+                f"size n_samples {X.shape[0]} (Got {np.size(last_mean)})."
+            )
+    else:  # axis == 0
+        if np.size(last_mean) != X.shape[1]:
+            raise ValueError(
+                "If axis=0, then last_mean, last_n, last_var should be of "
+                f"size n_features {X.shape[1]} (Got {np.size(last_mean)})."
+            )
+
+    X = X.T if axis == 1 else X
+
+    if weights is not None:
+        weights = _check_sample_weight(weights, X, dtype=X.dtype)
+
+    return _incr_mean_var_axis0(
+        X, last_mean=last_mean, last_var=last_var, last_n=last_n, weights=weights
+    )
+
+
+def inplace_column_scale(X, scale):
+    """Inplace column scaling of a CSC/CSR matrix.
+
+    Scale each feature of the data matrix by multiplying with specific scale
+    provided by the caller assuming a (n_samples, n_features) shape.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix to normalize using the variance of the features. It should be
+        of CSC or CSR format.
+
+    scale : ndarray of shape (n_features,), dtype={np.float32, np.float64}
+        Array of precomputed feature-wise values to use for scaling.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 3, 4, 4, 4])
+    >>> indices = np.array([0, 1, 2, 2])
+    >>> data = np.array([8, 1, 2, 5])
+    >>> scale = np.array([2, 3, 2])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 1, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.inplace_column_scale(csr, scale)
+    >>> csr.todense()
+    matrix([[16,  3,  4],
+            [ 0,  0, 10],
+            [ 0,  0,  0],
+            [ 0,  0,  0]])
+    """
+    if sp.issparse(X) and X.format == "csc":
+        inplace_csr_row_scale(X.T, scale)
+    elif sp.issparse(X) and X.format == "csr":
+        inplace_csr_column_scale(X, scale)
+    else:
+        _raise_typeerror(X)
+
+
+def inplace_row_scale(X, scale):
+    """Inplace row scaling of a CSR or CSC matrix.
+
+    Scale each row of the data matrix by multiplying with specific scale
+    provided by the caller assuming a (n_samples, n_features) shape.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix to be scaled. It should be of CSR or CSC format.
+
+    scale : ndarray of shape (n_features,), dtype={np.float32, np.float64}
+        Array of precomputed sample-wise values to use for scaling.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 2, 3, 4, 5])
+    >>> indices = np.array([0, 1, 2, 3, 3])
+    >>> data = np.array([8, 1, 2, 5, 6])
+    >>> scale = np.array([2, 3, 4, 5])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 1, 0, 0],
+            [0, 0, 2, 0],
+            [0, 0, 0, 5],
+            [0, 0, 0, 6]])
+    >>> sparsefuncs.inplace_row_scale(csr, scale)
+    >>> csr.todense()
+     matrix([[16,  2,  0,  0],
+             [ 0,  0,  6,  0],
+             [ 0,  0,  0, 20],
+             [ 0,  0,  0, 30]])
+    """
+    if sp.issparse(X) and X.format == "csc":
+        inplace_csr_column_scale(X.T, scale)
+    elif sp.issparse(X) and X.format == "csr":
+        inplace_csr_row_scale(X, scale)
+    else:
+        _raise_typeerror(X)
+
+
+def inplace_swap_row_csc(X, m, n):
+    """Swap two rows of a CSC matrix in-place.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix whose two rows are to be swapped. It should be of
+        CSC format.
+
+    m : int
+        Index of the row of X to be swapped.
+
+    n : int
+        Index of the row of X to be swapped.
+    """
+    for t in [m, n]:
+        if isinstance(t, np.ndarray):
+            raise TypeError("m and n should be valid integers")
+
+    if m < 0:
+        m += X.shape[0]
+    if n < 0:
+        n += X.shape[0]
+
+    m_mask = X.indices == m
+    X.indices[X.indices == n] = m
+    X.indices[m_mask] = n
+
+
+def inplace_swap_row_csr(X, m, n):
+    """Swap two rows of a CSR matrix in-place.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix whose two rows are to be swapped. It should be of
+        CSR format.
+
+    m : int
+        Index of the row of X to be swapped.
+
+    n : int
+        Index of the row of X to be swapped.
+    """
+    for t in [m, n]:
+        if isinstance(t, np.ndarray):
+            raise TypeError("m and n should be valid integers")
+
+    if m < 0:
+        m += X.shape[0]
+    if n < 0:
+        n += X.shape[0]
+
+    # The following swapping makes life easier since m is assumed to be the
+    # smaller integer below.
+    if m > n:
+        m, n = n, m
+
+    indptr = X.indptr
+    m_start = indptr[m]
+    m_stop = indptr[m + 1]
+    n_start = indptr[n]
+    n_stop = indptr[n + 1]
+    nz_m = m_stop - m_start
+    nz_n = n_stop - n_start
+
+    if nz_m != nz_n:
+        # Modify indptr first
+        X.indptr[m + 2 : n] += nz_n - nz_m
+        X.indptr[m + 1] = m_start + nz_n
+        X.indptr[n] = n_stop - nz_m
+
+    X.indices = np.concatenate(
+        [
+            X.indices[:m_start],
+            X.indices[n_start:n_stop],
+            X.indices[m_stop:n_start],
+            X.indices[m_start:m_stop],
+            X.indices[n_stop:],
+        ]
+    )
+    X.data = np.concatenate(
+        [
+            X.data[:m_start],
+            X.data[n_start:n_stop],
+            X.data[m_stop:n_start],
+            X.data[m_start:m_stop],
+            X.data[n_stop:],
+        ]
+    )
+
+
+def inplace_swap_row(X, m, n):
+    """
+    Swap two rows of a CSC/CSR matrix in-place.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix whose two rows are to be swapped. It should be of CSR or
+        CSC format.
+
+    m : int
+        Index of the row of X to be swapped.
+
+    n : int
+        Index of the row of X to be swapped.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 2, 3, 3, 3])
+    >>> indices = np.array([0, 2, 2])
+    >>> data = np.array([8, 2, 5])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 0, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.inplace_swap_row(csr, 0, 1)
+    >>> csr.todense()
+    matrix([[0, 0, 5],
+            [8, 0, 2],
+            [0, 0, 0],
+            [0, 0, 0]])
+    """
+    if sp.issparse(X) and X.format == "csc":
+        inplace_swap_row_csc(X, m, n)
+    elif sp.issparse(X) and X.format == "csr":
+        inplace_swap_row_csr(X, m, n)
+    else:
+        _raise_typeerror(X)
+
+
+def inplace_swap_column(X, m, n):
+    """
+    Swap two columns of a CSC/CSR matrix in-place.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Matrix whose two columns are to be swapped. It should be of
+        CSR or CSC format.
+
+    m : int
+        Index of the column of X to be swapped.
+
+    n : int
+        Index of the column of X to be swapped.
+
+    Examples
+    --------
+    >>> from sklearn.utils import sparsefuncs
+    >>> from scipy import sparse
+    >>> import numpy as np
+    >>> indptr = np.array([0, 2, 3, 3, 3])
+    >>> indices = np.array([0, 2, 2])
+    >>> data = np.array([8, 2, 5])
+    >>> csr = sparse.csr_matrix((data, indices, indptr))
+    >>> csr.todense()
+    matrix([[8, 0, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    >>> sparsefuncs.inplace_swap_column(csr, 0, 1)
+    >>> csr.todense()
+    matrix([[0, 8, 2],
+            [0, 0, 5],
+            [0, 0, 0],
+            [0, 0, 0]])
+    """
+    if m < 0:
+        m += X.shape[1]
+    if n < 0:
+        n += X.shape[1]
+    if sp.issparse(X) and X.format == "csc":
+        inplace_swap_row_csr(X, m, n)
+    elif sp.issparse(X) and X.format == "csr":
+        inplace_swap_row_csc(X, m, n)
+    else:
+        _raise_typeerror(X)
+
+
+def min_max_axis(X, axis, ignore_nan=False):
+    """Compute minimum and maximum along an axis on a CSR or CSC matrix.
+
+     Optionally ignore NaN values.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Input data. It should be of CSR or CSC format.
+
+    axis : {0, 1}
+        Axis along which the axis should be computed.
+
+    ignore_nan : bool, default=False
+        Ignore or passing through NaN values.
+
+        .. versionadded:: 0.20
+
+    Returns
+    -------
+
+    mins : ndarray of shape (n_features,), dtype={np.float32, np.float64}
+        Feature-wise minima.
+
+    maxs : ndarray of shape (n_features,), dtype={np.float32, np.float64}
+        Feature-wise maxima.
+    """
+    if sp.issparse(X) and X.format in ("csr", "csc"):
+        if ignore_nan:
+            return _sparse_nan_min_max(X, axis=axis)
+        else:
+            return _sparse_min_max(X, axis=axis)
+    else:
+        _raise_typeerror(X)
+
+
+def count_nonzero(X, axis=None, sample_weight=None):
+    """A variant of X.getnnz() with extension to weighting on axis 0.
+
+    Useful in efficiently calculating multilabel metrics.
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_labels)
+        Input data. It should be of CSR format.
+
+    axis : {0, 1}, default=None
+        The axis on which the data is aggregated.
+
+    sample_weight : array-like of shape (n_samples,), default=None
+        Weight for each row of X.
+
+    Returns
+    -------
+    nnz : int, float, ndarray of shape (n_samples,) or ndarray of shape (n_features,)
+        Number of non-zero values in the array along a given axis. Otherwise,
+        the total number of non-zero values in the array is returned.
+    """
+    if axis == -1:
+        axis = 1
+    elif axis == -2:
+        axis = 0
+    elif X.format != "csr":
+        raise TypeError("Expected CSR sparse format, got {0}".format(X.format))
+
+    # We rely here on the fact that np.diff(Y.indptr) for a CSR
+    # will return the number of nonzero entries in each row.
+    # A bincount over Y.indices will return the number of nonzeros
+    # in each column. See ``csr_matrix.getnnz`` in scipy >= 0.14.
+    if axis is None:
+        if sample_weight is None:
+            return X.nnz
+        else:
+            return np.dot(np.diff(X.indptr), sample_weight)
+    elif axis == 1:
+        out = np.diff(X.indptr)
+        if sample_weight is None:
+            # astype here is for consistency with axis=0 dtype
+            return out.astype("intp")
+        return out * sample_weight
+    elif axis == 0:
+        if sample_weight is None:
+            return np.bincount(X.indices, minlength=X.shape[1])
+        else:
+            weights = np.repeat(sample_weight, np.diff(X.indptr))
+            return np.bincount(X.indices, minlength=X.shape[1], weights=weights)
+    else:
+        raise ValueError("Unsupported axis: {0}".format(axis))
+
+
+def _get_median(data, n_zeros):
+    """Compute the median of data with n_zeros additional zeros.
+
+    This function is used to support sparse matrices; it modifies data
+    in-place.
+    """
+    n_elems = len(data) + n_zeros
+    if not n_elems:
+        return np.nan
+    n_negative = np.count_nonzero(data < 0)
+    middle, is_odd = divmod(n_elems, 2)
+    data.sort()
+
+    if is_odd:
+        return _get_elem_at_rank(middle, data, n_negative, n_zeros)
+
+    return (
+        _get_elem_at_rank(middle - 1, data, n_negative, n_zeros)
+        + _get_elem_at_rank(middle, data, n_negative, n_zeros)
+    ) / 2.0
+
+
+def _get_elem_at_rank(rank, data, n_negative, n_zeros):
+    """Find the value in data augmented with n_zeros for the given rank"""
+    if rank < n_negative:
+        return data[rank]
+    if rank - n_negative < n_zeros:
+        return 0
+    return data[rank - n_zeros]
+
+
+def csc_median_axis_0(X):
+    """Find the median across axis 0 of a CSC matrix.
+
+    It is equivalent to doing np.median(X, axis=0).
+
+    Parameters
+    ----------
+    X : sparse matrix of shape (n_samples, n_features)
+        Input data. It should be of CSC format.
+
+    Returns
+    -------
+    median : ndarray of shape (n_features,)
+        Median.
+    """
+    if not (sp.issparse(X) and X.format == "csc"):
+        raise TypeError("Expected matrix of CSC format, got %s" % X.format)
+
+    indptr = X.indptr
+    n_samples, n_features = X.shape
+    median = np.zeros(n_features)
+
+    for f_ind, (start, end) in enumerate(itertools.pairwise(indptr)):
+        # Prevent modifying X in place
+        data = np.copy(X.data[start:end])
+        nz = n_samples - data.size
+        median[f_ind] = _get_median(data, nz)
+
+    return median
+
+
+def _implicit_column_offset(X, offset):
+    """Create an implicitly offset linear operator.
+
+    This is used by PCA on sparse data to avoid densifying the whole data
+    matrix.
+
+    Params
+    ------
+        X : sparse matrix of shape (n_samples, n_features)
+        offset : ndarray of shape (n_features,)
+
+    Returns
+    -------
+    centered : LinearOperator
+    """
+    offset = offset[None, :]
+    XT = X.T
+    return LinearOperator(
+        matvec=lambda x: X @ x - offset @ x,
+        matmat=lambda x: X @ x - offset @ x,
+        rmatvec=lambda x: XT @ x - (offset * x.sum()),
+        rmatmat=lambda x: XT @ x - offset.T @ x.sum(axis=0)[None, :],
+        dtype=X.dtype,
+        shape=X.shape,
+    )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs_fast.pyx b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs_fast.pyx
new file mode 100644
index 0000000000000000000000000000000000000000..23261c59de3204ad4155a8e87ca2d316da598c57
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/sparsefuncs_fast.pyx
@@ -0,0 +1,640 @@
+"""Utilities to work with sparse matrices and arrays written in Cython."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from libc.math cimport fabs, sqrt, isnan
+from libc.stdint cimport intptr_t
+
+import numpy as np
+from cython cimport floating
+from ..utils._typedefs cimport float64_t, int32_t, int64_t, intp_t, uint64_t
+
+
+ctypedef fused integral:
+    int32_t
+    int64_t
+
+
+def csr_row_norms(X):
+    """Squared L2 norm of each row in CSR matrix X."""
+    if X.dtype not in [np.float32, np.float64]:
+        X = X.astype(np.float64)
+    return _sqeuclidean_row_norms_sparse(X.data, X.indptr)
+
+
+def _sqeuclidean_row_norms_sparse(
+    const floating[::1] X_data,
+    const integral[::1] X_indptr,
+):
+    cdef:
+        integral n_samples = X_indptr.shape[0] - 1
+        integral i, j
+
+    dtype = np.float32 if floating is float else np.float64
+
+    cdef floating[::1] squared_row_norms = np.zeros(n_samples, dtype=dtype)
+
+    with nogil:
+        for i in range(n_samples):
+            for j in range(X_indptr[i], X_indptr[i + 1]):
+                squared_row_norms[i] += X_data[j] * X_data[j]
+
+    return np.asarray(squared_row_norms)
+
+
+def csr_mean_variance_axis0(X, weights=None, return_sum_weights=False):
+    """Compute mean and variance along axis 0 on a CSR matrix
+
+    Uses a np.float64 accumulator.
+
+    Parameters
+    ----------
+    X : CSR sparse matrix, shape (n_samples, n_features)
+        Input data.
+
+    weights : ndarray of shape (n_samples,), dtype=floating, default=None
+        If it is set to None samples will be equally weighted.
+
+        .. versionadded:: 0.24
+
+    return_sum_weights : bool, default=False
+        If True, returns the sum of weights seen for each feature.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+    means : float array with shape (n_features,)
+        Feature-wise means
+
+    variances : float array with shape (n_features,)
+        Feature-wise variances
+
+    sum_weights : ndarray of shape (n_features,), dtype=floating
+        Returned if return_sum_weights is True.
+    """
+    if X.dtype not in [np.float32, np.float64]:
+        X = X.astype(np.float64)
+
+    if weights is None:
+        weights = np.ones(X.shape[0], dtype=X.dtype)
+
+    means, variances, sum_weights = _csr_mean_variance_axis0(
+        X.data, X.shape[0], X.shape[1], X.indices, X.indptr, weights)
+
+    if return_sum_weights:
+        return means, variances, sum_weights
+    return means, variances
+
+
+def _csr_mean_variance_axis0(
+    const floating[::1] X_data,
+    uint64_t n_samples,
+    uint64_t n_features,
+    const integral[:] X_indices,
+    const integral[:] X_indptr,
+    const floating[:] weights,
+):
+    # Implement the function here since variables using fused types
+    # cannot be declared directly and can only be passed as function arguments
+    cdef:
+        intp_t row_ind
+        uint64_t feature_idx
+        integral i, col_ind
+        float64_t diff
+        # means[j] contains the mean of feature j
+        float64_t[::1] means = np.zeros(n_features)
+        # variances[j] contains the variance of feature j
+        float64_t[::1] variances = np.zeros(n_features)
+
+        float64_t[::1] sum_weights = np.full(
+            fill_value=np.sum(weights, dtype=np.float64), shape=n_features
+        )
+        float64_t[::1] sum_weights_nz = np.zeros(shape=n_features)
+        float64_t[::1] correction = np.zeros(shape=n_features)
+
+        uint64_t[::1] counts = np.full(
+            fill_value=weights.shape[0], shape=n_features, dtype=np.uint64
+        )
+        uint64_t[::1] counts_nz = np.zeros(shape=n_features, dtype=np.uint64)
+
+    for row_ind in range(len(X_indptr) - 1):
+        for i in range(X_indptr[row_ind], X_indptr[row_ind + 1]):
+            col_ind = X_indices[i]
+            if not isnan(X_data[i]):
+                means[col_ind] += <float64_t>(X_data[i]) * weights[row_ind]
+                # sum of weights where X[:, col_ind] is non-zero
+                sum_weights_nz[col_ind] += weights[row_ind]
+                # number of non-zero elements of X[:, col_ind]
+                counts_nz[col_ind] += 1
+            else:
+                # sum of weights where X[:, col_ind] is not nan
+                sum_weights[col_ind] -= weights[row_ind]
+                # number of non nan elements of X[:, col_ind]
+                counts[col_ind] -= 1
+
+    for feature_idx in range(n_features):
+        means[feature_idx] /= sum_weights[feature_idx]
+
+    for row_ind in range(len(X_indptr) - 1):
+        for i in range(X_indptr[row_ind], X_indptr[row_ind + 1]):
+            col_ind = X_indices[i]
+            if not isnan(X_data[i]):
+                diff = X_data[i] - means[col_ind]
+                # correction term of the corrected 2 pass algorithm.
+                # See "Algorithms for computing the sample variance: analysis
+                # and recommendations", by Chan, Golub, and LeVeque.
+                correction[col_ind] += diff * weights[row_ind]
+                variances[col_ind] += diff * diff * weights[row_ind]
+
+    for feature_idx in range(n_features):
+        if counts[feature_idx] != counts_nz[feature_idx]:
+            correction[feature_idx] -= (
+                sum_weights[feature_idx] - sum_weights_nz[feature_idx]
+            ) * means[feature_idx]
+        correction[feature_idx] = correction[feature_idx]**2 / sum_weights[feature_idx]
+        if counts[feature_idx] != counts_nz[feature_idx]:
+            # only compute it when it's guaranteed to be non-zero to avoid
+            # catastrophic cancellation.
+            variances[feature_idx] += (
+                sum_weights[feature_idx] - sum_weights_nz[feature_idx]
+            ) * means[feature_idx]**2
+        variances[feature_idx] = (
+            (variances[feature_idx] - correction[feature_idx]) /
+            sum_weights[feature_idx]
+        )
+
+    if floating is float:
+        return (
+            np.array(means, dtype=np.float32),
+            np.array(variances, dtype=np.float32),
+            np.array(sum_weights, dtype=np.float32),
+        )
+    else:
+        return (
+            np.asarray(means), np.asarray(variances), np.asarray(sum_weights)
+        )
+
+
+def csc_mean_variance_axis0(X, weights=None, return_sum_weights=False):
+    """Compute mean and variance along axis 0 on a CSC matrix
+
+    Uses a np.float64 accumulator.
+
+    Parameters
+    ----------
+    X : CSC sparse matrix, shape (n_samples, n_features)
+        Input data.
+
+    weights : ndarray of shape (n_samples,), dtype=floating, default=None
+        If it is set to None samples will be equally weighted.
+
+        .. versionadded:: 0.24
+
+    return_sum_weights : bool, default=False
+        If True, returns the sum of weights seen for each feature.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+    means : float array with shape (n_features,)
+        Feature-wise means
+
+    variances : float array with shape (n_features,)
+        Feature-wise variances
+
+    sum_weights : ndarray of shape (n_features,), dtype=floating
+        Returned if return_sum_weights is True.
+    """
+    if X.dtype not in [np.float32, np.float64]:
+        X = X.astype(np.float64)
+
+    if weights is None:
+        weights = np.ones(X.shape[0], dtype=X.dtype)
+
+    means, variances, sum_weights = _csc_mean_variance_axis0(
+        X.data, X.shape[0], X.shape[1], X.indices, X.indptr, weights)
+
+    if return_sum_weights:
+        return means, variances, sum_weights
+    return means, variances
+
+
+def _csc_mean_variance_axis0(
+    const floating[::1] X_data,
+    uint64_t n_samples,
+    uint64_t n_features,
+    const integral[:] X_indices,
+    const integral[:] X_indptr,
+    const floating[:] weights,
+):
+    # Implement the function here since variables using fused types
+    # cannot be declared directly and can only be passed as function arguments
+    cdef:
+        integral i, row_ind
+        uint64_t feature_idx, col_ind
+        float64_t diff
+        # means[j] contains the mean of feature j
+        float64_t[::1] means = np.zeros(n_features)
+        # variances[j] contains the variance of feature j
+        float64_t[::1] variances = np.zeros(n_features)
+
+        float64_t[::1] sum_weights = np.full(
+            fill_value=np.sum(weights, dtype=np.float64), shape=n_features
+        )
+        float64_t[::1] sum_weights_nz = np.zeros(shape=n_features)
+        float64_t[::1] correction = np.zeros(shape=n_features)
+
+        uint64_t[::1] counts = np.full(
+            fill_value=weights.shape[0], shape=n_features, dtype=np.uint64
+        )
+        uint64_t[::1] counts_nz = np.zeros(shape=n_features, dtype=np.uint64)
+
+    for col_ind in range(n_features):
+        for i in range(X_indptr[col_ind], X_indptr[col_ind + 1]):
+            row_ind = X_indices[i]
+            if not isnan(X_data[i]):
+                means[col_ind] += <float64_t>(X_data[i]) * weights[row_ind]
+                # sum of weights where X[:, col_ind] is non-zero
+                sum_weights_nz[col_ind] += weights[row_ind]
+                # number of non-zero elements of X[:, col_ind]
+                counts_nz[col_ind] += 1
+            else:
+                # sum of weights where X[:, col_ind] is not nan
+                sum_weights[col_ind] -= weights[row_ind]
+                # number of non nan elements of X[:, col_ind]
+                counts[col_ind] -= 1
+
+    for feature_idx in range(n_features):
+        means[feature_idx] /= sum_weights[feature_idx]
+
+    for col_ind in range(n_features):
+        for i in range(X_indptr[col_ind], X_indptr[col_ind + 1]):
+            row_ind = X_indices[i]
+            if not isnan(X_data[i]):
+                diff = X_data[i] - means[col_ind]
+                # correction term of the corrected 2 pass algorithm.
+                # See "Algorithms for computing the sample variance: analysis
+                # and recommendations", by Chan, Golub, and LeVeque.
+                correction[col_ind] += diff * weights[row_ind]
+                variances[col_ind] += diff * diff * weights[row_ind]
+
+    for feature_idx in range(n_features):
+        if counts[feature_idx] != counts_nz[feature_idx]:
+            correction[feature_idx] -= (
+                sum_weights[feature_idx] - sum_weights_nz[feature_idx]
+            ) * means[feature_idx]
+        correction[feature_idx] = correction[feature_idx]**2 / sum_weights[feature_idx]
+        if counts[feature_idx] != counts_nz[feature_idx]:
+            # only compute it when it's guaranteed to be non-zero to avoid
+            # catastrophic cancellation.
+            variances[feature_idx] += (
+                sum_weights[feature_idx] - sum_weights_nz[feature_idx]
+            ) * means[feature_idx]**2
+        variances[feature_idx] = (
+            (variances[feature_idx] - correction[feature_idx])
+        ) / sum_weights[feature_idx]
+
+    if floating is float:
+        return (np.array(means, dtype=np.float32),
+                np.array(variances, dtype=np.float32),
+                np.array(sum_weights, dtype=np.float32))
+    else:
+        return (
+            np.asarray(means), np.asarray(variances), np.asarray(sum_weights)
+        )
+
+
+def incr_mean_variance_axis0(X, last_mean, last_var, last_n, weights=None):
+    """Compute mean and variance along axis 0 on a CSR or CSC matrix.
+
+    last_mean, last_var are the statistics computed at the last step by this
+    function. Both must be initialized to 0.0. last_n is the
+    number of samples encountered until now and is initialized at 0.
+
+    Parameters
+    ----------
+    X : CSR or CSC sparse matrix, shape (n_samples, n_features)
+      Input data.
+
+    last_mean : float array with shape (n_features,)
+      Array of feature-wise means to update with the new data X.
+
+    last_var : float array with shape (n_features,)
+      Array of feature-wise var to update with the new data X.
+
+    last_n : float array with shape (n_features,)
+      Sum of the weights seen so far (if weights are all set to 1
+      this will be the same as number of samples seen so far, before X).
+
+    weights : float array with shape (n_samples,) or None. If it is set
+      to None samples will be equally weighted.
+
+    Returns
+    -------
+    updated_mean : float array with shape (n_features,)
+      Feature-wise means
+
+    updated_variance : float array with shape (n_features,)
+      Feature-wise variances
+
+    updated_n : int array with shape (n_features,)
+      Updated number of samples seen
+
+    Notes
+    -----
+    NaNs are ignored during the computation.
+
+    References
+    ----------
+    T. Chan, G. Golub, R. LeVeque. Algorithms for computing the sample
+      variance: recommendations, The American Statistician, Vol. 37, No. 3,
+      pp. 242-247
+
+    Also, see the non-sparse implementation of this in
+    `utils.extmath._batch_mean_variance_update`.
+
+    """
+    if X.dtype not in [np.float32, np.float64]:
+        X = X.astype(np.float64)
+    X_dtype = X.dtype
+    if weights is None:
+        weights = np.ones(X.shape[0], dtype=X_dtype)
+    elif weights.dtype not in [np.float32, np.float64]:
+        weights = weights.astype(np.float64, copy=False)
+    if last_n.dtype not in [np.float32, np.float64]:
+        last_n = last_n.astype(np.float64, copy=False)
+
+    return _incr_mean_variance_axis0(X.data,
+                                     np.sum(weights),
+                                     X.shape[1],
+                                     X.indices,
+                                     X.indptr,
+                                     X.format,
+                                     last_mean.astype(X_dtype, copy=False),
+                                     last_var.astype(X_dtype, copy=False),
+                                     last_n.astype(X_dtype, copy=False),
+                                     weights.astype(X_dtype, copy=False))
+
+
+def _incr_mean_variance_axis0(
+    const floating[:] X_data,
+    floating n_samples,
+    uint64_t n_features,
+    const int[:] X_indices,
+    # X_indptr might be either int32 or int64
+    const integral[:] X_indptr,
+    str X_format,
+    floating[:] last_mean,
+    floating[:] last_var,
+    floating[:] last_n,
+    # previous sum of the weights (ie float)
+    const floating[:] weights,
+):
+    # Implement the function here since variables using fused types
+    # cannot be declared directly and can only be passed as function arguments
+    cdef:
+        uint64_t i
+
+        # last = stats until now
+        # new = the current increment
+        # updated = the aggregated stats
+        # when arrays, they are indexed by i per-feature
+        floating[::1] new_mean
+        floating[::1] new_var
+        floating[::1] updated_mean
+        floating[::1] updated_var
+
+    if floating is float:
+        dtype = np.float32
+    else:
+        dtype = np.float64
+
+    new_mean = np.zeros(n_features, dtype=dtype)
+    new_var = np.zeros_like(new_mean, dtype=dtype)
+    updated_mean = np.zeros_like(new_mean, dtype=dtype)
+    updated_var = np.zeros_like(new_mean, dtype=dtype)
+
+    cdef:
+        floating[::1] new_n
+        floating[::1] updated_n
+        floating[::1] last_over_new_n
+
+    # Obtain new stats first
+    updated_n = np.zeros(shape=n_features, dtype=dtype)
+    last_over_new_n = np.zeros_like(updated_n, dtype=dtype)
+
+    # X can be a CSR or CSC matrix
+    if X_format == 'csr':
+        new_mean, new_var, new_n = _csr_mean_variance_axis0(
+            X_data, n_samples, n_features, X_indices, X_indptr, weights)
+    else:  # X_format == 'csc'
+        new_mean, new_var, new_n = _csc_mean_variance_axis0(
+            X_data, n_samples, n_features, X_indices, X_indptr, weights)
+
+    # First pass
+    cdef bint is_first_pass = True
+    for i in range(n_features):
+        if last_n[i] > 0:
+            is_first_pass = False
+            break
+
+    if is_first_pass:
+        return np.asarray(new_mean), np.asarray(new_var), np.asarray(new_n)
+
+    for i in range(n_features):
+        updated_n[i] = last_n[i] + new_n[i]
+
+    # Next passes
+    for i in range(n_features):
+        if new_n[i] > 0:
+            last_over_new_n[i] = dtype(last_n[i]) / dtype(new_n[i])
+            # Unnormalized stats
+            last_mean[i] *= last_n[i]
+            last_var[i] *= last_n[i]
+            new_mean[i] *= new_n[i]
+            new_var[i] *= new_n[i]
+            # Update stats
+            updated_var[i] = (
+                last_var[i] + new_var[i] +
+                last_over_new_n[i] / updated_n[i] *
+                (last_mean[i] / last_over_new_n[i] - new_mean[i])**2
+            )
+            updated_mean[i] = (last_mean[i] + new_mean[i]) / updated_n[i]
+            updated_var[i] /= updated_n[i]
+        else:
+            updated_var[i] = last_var[i]
+            updated_mean[i] = last_mean[i]
+            updated_n[i] = last_n[i]
+
+    return (
+        np.asarray(updated_mean),
+        np.asarray(updated_var),
+        np.asarray(updated_n),
+    )
+
+
+def inplace_csr_row_normalize_l1(X):
+    """Normalize inplace the rows of a CSR matrix or array by their L1 norm.
+
+    Parameters
+    ----------
+    X : scipy.sparse.csr_matrix and scipy.sparse.csr_array, \
+            shape=(n_samples, n_features)
+        The input matrix or array to be modified inplace.
+
+    Examples
+    --------
+    >>> from scipy.sparse import csr_matrix
+    >>> from sklearn.utils.sparsefuncs_fast import inplace_csr_row_normalize_l1
+    >>> import numpy as np
+    >>> indptr = np.array([0, 2, 3, 4])
+    >>> indices = np.array([0, 1, 2, 3])
+    >>> data = np.array([1.0, 2.0, 3.0, 4.0])
+    >>> X = csr_matrix((data, indices, indptr), shape=(3, 4))
+    >>> X.toarray()
+    array([[1., 2., 0., 0.],
+           [0., 0., 3., 0.],
+           [0., 0., 0., 4.]])
+    >>> inplace_csr_row_normalize_l1(X)
+    >>> X.toarray()
+    array([[0.33...   , 0.66...   , 0.        , 0.        ],
+           [0.        , 0.        , 1.        , 0.        ],
+           [0.        , 0.        , 0.        , 1.        ]])
+    """
+    _inplace_csr_row_normalize_l1(X.data, X.shape, X.indices, X.indptr)
+
+
+def _inplace_csr_row_normalize_l1(
+    floating[:] X_data,
+    shape,
+    const integral[:] X_indices,
+    const integral[:] X_indptr,
+):
+    cdef:
+        uint64_t n_samples = shape[0]
+
+        # the column indices for row i are stored in:
+        #    indices[indptr[i]:indices[i+1]]
+        # and their corresponding values are stored in:
+        #    data[indptr[i]:indptr[i+1]]
+        uint64_t i
+        integral j
+        double sum_
+
+    for i in range(n_samples):
+        sum_ = 0.0
+
+        for j in range(X_indptr[i], X_indptr[i + 1]):
+            sum_ += fabs(X_data[j])
+
+        if sum_ == 0.0:
+            # do not normalize empty rows (can happen if CSR is not pruned
+            # correctly)
+            continue
+
+        for j in range(X_indptr[i], X_indptr[i + 1]):
+            X_data[j] /= sum_
+
+
+def inplace_csr_row_normalize_l2(X):
+    """Normalize inplace the rows of a CSR matrix or array by their L2 norm.
+
+    Parameters
+    ----------
+    X : scipy.sparse.csr_matrix, shape=(n_samples, n_features)
+        The input matrix or array to be modified inplace.
+
+    Examples
+    --------
+    >>> from scipy.sparse import csr_matrix
+    >>> from sklearn.utils.sparsefuncs_fast import inplace_csr_row_normalize_l2
+    >>> import numpy as np
+    >>> indptr = np.array([0, 2, 3, 4])
+    >>> indices = np.array([0, 1, 2, 3])
+    >>> data = np.array([1.0, 2.0, 3.0, 4.0])
+    >>> X = csr_matrix((data, indices, indptr), shape=(3, 4))
+    >>> X.toarray()
+    array([[1., 2., 0., 0.],
+           [0., 0., 3., 0.],
+           [0., 0., 0., 4.]])
+    >>> inplace_csr_row_normalize_l2(X)
+    >>> X.toarray()
+    array([[0.44...   , 0.89...   , 0.        , 0.        ],
+           [0.        , 0.        , 1.        , 0.        ],
+           [0.        , 0.        , 0.        , 1.        ]])
+    """
+    _inplace_csr_row_normalize_l2(X.data, X.shape, X.indices, X.indptr)
+
+
+def _inplace_csr_row_normalize_l2(
+    floating[:] X_data,
+    shape,
+    const integral[:] X_indices,
+    const integral[:] X_indptr,
+):
+    cdef:
+        uint64_t n_samples = shape[0]
+        uint64_t i
+        integral j
+        double sum_
+
+    for i in range(n_samples):
+        sum_ = 0.0
+
+        for j in range(X_indptr[i], X_indptr[i + 1]):
+            sum_ += (X_data[j] * X_data[j])
+
+        if sum_ == 0.0:
+            # do not normalize empty rows (can happen if CSR is not pruned
+            # correctly)
+            continue
+
+        sum_ = sqrt(sum_)
+
+        for j in range(X_indptr[i], X_indptr[i + 1]):
+            X_data[j] /= sum_
+
+
+def assign_rows_csr(
+    X,
+    const intptr_t[:] X_rows,
+    const intptr_t[:] out_rows,
+    floating[:, ::1] out,
+):
+    """Densify selected rows of a CSR matrix into a preallocated array.
+
+    Like out[out_rows] = X[X_rows].toarray() but without copying.
+    No-copy supported for both dtype=np.float32 and dtype=np.float64.
+
+    Parameters
+    ----------
+    X : scipy.sparse.csr_matrix, shape=(n_samples, n_features)
+    X_rows : array, dtype=np.intp, shape=n_rows
+    out_rows : array, dtype=np.intp, shape=n_rows
+    out : array, shape=(arbitrary, n_features)
+    """
+    cdef:
+        # intptr_t (npy_intp, np.intp in Python) is what np.where returns,
+        # but int is what scipy.sparse uses.
+        intp_t i, ind, j, k
+        intptr_t rX
+        const floating[:] data = X.data
+        const int32_t[:] indices = X.indices
+        const int32_t[:] indptr = X.indptr
+
+    if X_rows.shape[0] != out_rows.shape[0]:
+        raise ValueError("cannot assign %d rows to %d"
+                         % (X_rows.shape[0], out_rows.shape[0]))
+
+    with nogil:
+        for k in range(out_rows.shape[0]):
+            out[out_rows[k]] = 0.0
+
+        for i in range(X_rows.shape[0]):
+            rX = X_rows[i]
+            for ind in range(indptr[rX], indptr[rX + 1]):
+                j = indices[ind]
+                out[out_rows[i], j] = data[ind]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.cpp b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c42316121e246acc676563969c74db2f103fa5b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.cpp
@@ -0,0 +1,345 @@
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+// Note - The x86 and x64 versions do _not_ produce the same results, as the
+// algorithms are optimized for their respective platforms. You can still
+// compile and run any of them on any platform, but your performance with the
+// non-native version will be less than optimal.
+
+#include "MurmurHash3.h"
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+
+#define FORCE_INLINE	__forceinline
+
+#include <stdlib.h>
+
+#define ROTL32(x,y)	_rotl(x,y)
+#define ROTL64(x,y)	_rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x)
+
+// Other compilers
+
+#else	// defined(_MSC_VER)
+
+#if defined(GNUC) && ((GNUC > 4) || (GNUC == 4 && GNUC_MINOR >= 4))
+
+/* gcc version >= 4.4 4.1 = RHEL 5, 4.4 = RHEL 6.
+ * Don't inline for RHEL 5 gcc which is 4.1 */
+#define FORCE_INLINE attribute((always_inline))
+
+#else
+
+#define FORCE_INLINE
+
+#endif
+
+
+inline uint32_t rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+
+inline uint64_t rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+#define	ROTL32(x,y)	rotl32(x,y)
+#define ROTL64(x,y)	rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+#endif // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+// Block read - if your platform needs to do endian-swapping or can only
+// handle aligned reads, do the conversion here
+
+FORCE_INLINE uint32_t getblock ( const uint32_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint64_t getblock ( const uint64_t * p, int i )
+{
+  return p[i];
+}
+
+//-----------------------------------------------------------------------------
+// Finalization mix - force all bits of a hash block to avalanche
+
+FORCE_INLINE uint32_t fmix ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+//----------
+
+FORCE_INLINE uint64_t fmix ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_32 ( const void * key, int len,
+                          uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 4;
+
+  uint32_t h1 = seed;
+
+  uint32_t c1 = 0xcc9e2d51;
+  uint32_t c2 = 0x1b873593;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(int i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock(blocks,i);
+
+    k1 *= c1;
+    k1 = ROTL32(k1,15);
+    k1 *= c2;
+
+    h1 ^= k1;
+    h1 = ROTL32(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  }
+
+  //----------
+  // finalization
+
+  h1 ^= len;
+
+  h1 = fmix(h1);
+
+  *(uint32_t*)out = h1;
+}
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_128 ( const void * key, const int len,
+                           uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+
+  uint32_t h1 = seed;
+  uint32_t h2 = seed;
+  uint32_t h3 = seed;
+  uint32_t h4 = seed;
+
+  uint32_t c1 = 0x239b961b;
+  uint32_t c2 = 0xab0e9789;
+  uint32_t c3 = 0x38b34ae5;
+  uint32_t c4 = 0xa1e38b93;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*16);
+
+  for(int i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock(blocks,i*4+0);
+    uint32_t k2 = getblock(blocks,i*4+1);
+    uint32_t k3 = getblock(blocks,i*4+2);
+    uint32_t k4 = getblock(blocks,i*4+3);
+
+    k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b;
+
+    k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+    h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747;
+
+    k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+    h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35;
+
+    k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+    h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint32_t k1 = 0;
+  uint32_t k2 = 0;
+  uint32_t k3 = 0;
+  uint32_t k4 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k4 ^= tail[14] << 16;
+  case 14: k4 ^= tail[13] << 8;
+  case 13: k4 ^= tail[12] << 0;
+           k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+  case 12: k3 ^= tail[11] << 24;
+  case 11: k3 ^= tail[10] << 16;
+  case 10: k3 ^= tail[ 9] << 8;
+  case  9: k3 ^= tail[ 8] << 0;
+           k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+  case  8: k2 ^= tail[ 7] << 24;
+  case  7: k2 ^= tail[ 6] << 16;
+  case  6: k2 ^= tail[ 5] << 8;
+  case  5: k2 ^= tail[ 4] << 0;
+           k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+  case  4: k1 ^= tail[ 3] << 24;
+  case  3: k1 ^= tail[ 2] << 16;
+  case  2: k1 ^= tail[ 1] << 8;
+  case  1: k1 ^= tail[ 0] << 0;
+           k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  }
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  h1 = fmix(h1);
+  h2 = fmix(h2);
+  h3 = fmix(h3);
+  h4 = fmix(h4);
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  ((uint32_t*)out)[0] = h1;
+  ((uint32_t*)out)[1] = h2;
+  ((uint32_t*)out)[2] = h3;
+  ((uint32_t*)out)[3] = h4;
+}
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x64_128 ( const void * key, const int len,
+                           const uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+
+  uint64_t h1 = seed;
+  uint64_t h2 = seed;
+
+  uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+  uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const uint64_t * blocks = (const uint64_t *)(data);
+
+  for(int i = 0; i < nblocks; i++)
+  {
+    uint64_t k1 = getblock(blocks,i*2+0);
+    uint64_t k2 = getblock(blocks,i*2+1);
+
+    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+
+    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint64_t k1 = 0;
+  uint64_t k2 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k2 ^= uint64_t(tail[14]) << 48;
+  case 14: k2 ^= uint64_t(tail[13]) << 40;
+  case 13: k2 ^= uint64_t(tail[12]) << 32;
+  case 12: k2 ^= uint64_t(tail[11]) << 24;
+  case 11: k2 ^= uint64_t(tail[10]) << 16;
+  case 10: k2 ^= uint64_t(tail[ 9]) << 8;
+  case  9: k2 ^= uint64_t(tail[ 8]) << 0;
+           k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+  case  8: k1 ^= uint64_t(tail[ 7]) << 56;
+  case  7: k1 ^= uint64_t(tail[ 6]) << 48;
+  case  6: k1 ^= uint64_t(tail[ 5]) << 40;
+  case  5: k1 ^= uint64_t(tail[ 4]) << 32;
+  case  4: k1 ^= uint64_t(tail[ 3]) << 24;
+  case  3: k1 ^= uint64_t(tail[ 2]) << 16;
+  case  2: k1 ^= uint64_t(tail[ 1]) << 8;
+  case  1: k1 ^= uint64_t(tail[ 0]) << 0;
+           k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+  }
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix(h1);
+  h2 = fmix(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  ((uint64_t*)out)[0] = h1;
+  ((uint64_t*)out)[1] = h2;
+}
+
+//-----------------------------------------------------------------------------
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.h b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bfaca6ba52b962b820270fb1722fdc25b0de8fb
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/src/MurmurHash3.h
@@ -0,0 +1,45 @@
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#ifndef _MURMURHASH3_H_
+#define _MURMURHASH3_H_
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+
+typedef unsigned char uint8_t;
+typedef unsigned long uint32_t;
+typedef unsigned __int64 uint64_t;
+
+// Other compilers
+
+#else	// defined(_MSC_VER)
+
+#include <stdint.h>
+
+#endif // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+void MurmurHash3_x86_32  ( const void * key, int len, uint32_t seed, void * out );
+
+void MurmurHash3_x86_128 ( const void * key, int len, uint32_t seed, void * out );
+
+void MurmurHash3_x64_128 ( const void * key, int len, uint32_t seed, void * out );
+
+#ifdef __cplusplus
+}
+#endif
+
+//-----------------------------------------------------------------------------
+
+#endif // _MURMURHASH3_H_
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/stats.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/stats.py
new file mode 100644
index 0000000000000000000000000000000000000000..66179e5ea3aba3940ce445a82baa4c0fc77e0134
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/stats.py
@@ -0,0 +1,122 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from ..utils._array_api import (
+    _find_matching_floating_dtype,
+    get_namespace_and_device,
+)
+
+
+def _weighted_percentile(array, sample_weight, percentile_rank=50, xp=None):
+    """Compute the weighted percentile with method 'inverted_cdf'.
+
+    When the percentile lies between two data points of `array`, the function returns
+    the lower value.
+
+    If `array` is a 2D array, the `values` are selected along axis 0.
+
+    `NaN` values are ignored by setting their weights to 0. If `array` is 2D, this
+    is done in a column-isolated manner: a `NaN` in the second column, does not impact
+    the percentile computed for the first column even if `sample_weight` is 1D.
+
+        .. versionchanged:: 0.24
+            Accepts 2D `array`.
+
+        .. versionchanged:: 1.7
+            Supports handling of `NaN` values.
+
+    Parameters
+    ----------
+    array : 1D or 2D array
+        Values to take the weighted percentile of.
+
+    sample_weight: 1D or 2D array
+        Weights for each value in `array`. Must be same shape as `array` or of shape
+        `(array.shape[0],)`.
+
+    percentile_rank: int or float, default=50
+        The probability level of the percentile to compute, in percent. Must be between
+        0 and 100.
+
+    xp : array_namespace, default=None
+        The standard-compatible namespace for `array`. Default: infer.
+
+    Returns
+    -------
+    percentile : scalar or 0D array if `array` 1D (or 0D), array if `array` 2D
+        Weighted percentile at the requested probability level.
+    """
+    xp, _, device = get_namespace_and_device(array)
+    # `sample_weight` should follow `array` for dtypes
+    floating_dtype = _find_matching_floating_dtype(array, xp=xp)
+    array = xp.asarray(array, dtype=floating_dtype, device=device)
+    sample_weight = xp.asarray(sample_weight, dtype=floating_dtype, device=device)
+
+    n_dim = array.ndim
+    if n_dim == 0:
+        return array
+    if array.ndim == 1:
+        array = xp.reshape(array, (-1, 1))
+    # When sample_weight 1D, repeat for each array.shape[1]
+    if array.shape != sample_weight.shape and array.shape[0] == sample_weight.shape[0]:
+        sample_weight = xp.tile(sample_weight, (array.shape[1], 1)).T
+    # Sort `array` and `sample_weight` along axis=0:
+    sorted_idx = xp.argsort(array, axis=0)
+    sorted_weights = xp.take_along_axis(sample_weight, sorted_idx, axis=0)
+
+    # Set NaN values in `sample_weight` to 0. Only perform this operation if NaN
+    # values present to avoid temporary allocations of size `(n_samples, n_features)`.
+    n_features = array.shape[1]
+    largest_value_per_column = array[
+        sorted_idx[-1, ...], xp.arange(n_features, device=device)
+    ]
+    # NaN values get sorted to end (largest value)
+    if xp.any(xp.isnan(largest_value_per_column)):
+        sorted_nan_mask = xp.take_along_axis(xp.isnan(array), sorted_idx, axis=0)
+        sorted_weights[sorted_nan_mask] = 0
+
+    # Compute the weighted cumulative distribution function (CDF) based on
+    # `sample_weight` and scale `percentile_rank` along it.
+    #
+    # Note: we call `xp.cumulative_sum` on the transposed `sorted_weights` to
+    # ensure that the result is of shape `(n_features, n_samples)` so
+    # `xp.searchsorted` calls take contiguous inputs as a result (for
+    # performance reasons).
+    weight_cdf = xp.cumulative_sum(sorted_weights.T, axis=1)
+    adjusted_percentile_rank = percentile_rank / 100 * weight_cdf[..., -1]
+
+    # Ignore leading `sample_weight=0` observations when `percentile_rank=0` (#20528)
+    mask = adjusted_percentile_rank == 0
+    adjusted_percentile_rank[mask] = xp.nextafter(
+        adjusted_percentile_rank[mask], adjusted_percentile_rank[mask] + 1
+    )
+    # For each feature with index j, find sample index i of the scalar value
+    # `adjusted_percentile_rank[j]` in 1D array `weight_cdf[j]`, such that:
+    # weight_cdf[j, i-1] < adjusted_percentile_rank[j] <= weight_cdf[j, i].
+    percentile_indices = xp.stack(
+        [
+            xp.searchsorted(
+                weight_cdf[feature_idx, ...], adjusted_percentile_rank[feature_idx]
+            )
+            for feature_idx in range(weight_cdf.shape[0])
+        ],
+    )
+    # In rare cases, `percentile_indices` equals to `sorted_idx.shape[0]`
+    max_idx = sorted_idx.shape[0] - 1
+    percentile_indices = xp.clip(percentile_indices, 0, max_idx)
+
+    col_indices = xp.arange(array.shape[1], device=device)
+    percentile_in_sorted = sorted_idx[percentile_indices, col_indices]
+
+    result = array[percentile_in_sorted, col_indices]
+
+    return result[0] if n_dim == 1 else result
+
+
+# TODO: refactor to do the symmetrisation inside _weighted_percentile to avoid
+# sorting the input array twice.
+def _averaged_weighted_percentile(array, sample_weight, percentile_rank=50, xp=None):
+    return (
+        _weighted_percentile(array, sample_weight, percentile_rank, xp=xp)
+        - _weighted_percentile(-array, sample_weight, 100 - percentile_rank, xp=xp)
+    ) / 2
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arpack.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arpack.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab1d622d51a08eca5ecf526b77d1bbeab17737f6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arpack.py
@@ -0,0 +1,16 @@
+import pytest
+from numpy.testing import assert_allclose
+
+from sklearn.utils import check_random_state
+from sklearn.utils._arpack import _init_arpack_v0
+
+
+@pytest.mark.parametrize("seed", range(100))
+def test_init_arpack_v0(seed):
+    # check that the initialization a sampling from an uniform distribution
+    # where we can fix the random state
+    size = 1000
+    v0 = _init_arpack_v0(size, seed)
+
+    rng = check_random_state(seed)
+    assert_allclose(v0, rng.uniform(-1, 1, size=size))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_array_api.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_array_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dfbfd4d62ea1f2f0022213799af92171fca19ae
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_array_api.py
@@ -0,0 +1,605 @@
+import os
+from functools import partial
+
+import numpy
+import pytest
+from numpy.testing import assert_allclose
+
+from sklearn._config import config_context
+from sklearn.base import BaseEstimator
+from sklearn.utils._array_api import (
+    _asarray_with_order,
+    _atol_for_type,
+    _average,
+    _convert_to_numpy,
+    _count_nonzero,
+    _estimator_with_converted_arrays,
+    _fill_or_add_to_diagonal,
+    _get_namespace_device_dtype_ids,
+    _is_numpy_namespace,
+    _isin,
+    _max_precision_float_dtype,
+    _nanmax,
+    _nanmean,
+    _nanmin,
+    _ravel,
+    device,
+    get_namespace,
+    get_namespace_and_device,
+    indexing_dtype,
+    np_compat,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._testing import (
+    SkipTest,
+    _array_api_for_tests,
+    assert_array_equal,
+    skip_if_array_api_compat_not_configured,
+)
+from sklearn.utils.fixes import _IS_32BIT, CSR_CONTAINERS, np_version, parse_version
+
+
+@pytest.mark.parametrize("X", [numpy.asarray([1, 2, 3]), [1, 2, 3]])
+def test_get_namespace_ndarray_default(X):
+    """Check that get_namespace returns NumPy wrapper"""
+    xp_out, is_array_api_compliant = get_namespace(X)
+    assert xp_out is np_compat
+    assert not is_array_api_compliant
+
+
+def test_get_namespace_ndarray_creation_device():
+    """Check expected behavior with device and creation functions."""
+    X = numpy.asarray([1, 2, 3])
+    xp_out, _ = get_namespace(X)
+
+    full_array = xp_out.full(10, fill_value=2.0, device="cpu")
+    assert_allclose(full_array, [2.0] * 10)
+
+    with pytest.raises(ValueError, match="Unsupported device"):
+        xp_out.zeros(10, device="cuda")
+
+
+@skip_if_array_api_compat_not_configured
+def test_get_namespace_ndarray_with_dispatch():
+    """Test get_namespace on NumPy ndarrays."""
+
+    X_np = numpy.asarray([[1, 2, 3]])
+
+    with config_context(array_api_dispatch=True):
+        xp_out, is_array_api_compliant = get_namespace(X_np)
+        assert is_array_api_compliant
+
+        # In the future, NumPy should become API compliant library and we should have
+        # assert xp_out is numpy
+        assert xp_out is np_compat
+
+
+@skip_if_array_api_compat_not_configured
+def test_get_namespace_array_api(monkeypatch):
+    """Test get_namespace for ArrayAPI arrays."""
+    xp = pytest.importorskip("array_api_strict")
+
+    X_np = numpy.asarray([[1, 2, 3]])
+    X_xp = xp.asarray(X_np)
+    with config_context(array_api_dispatch=True):
+        xp_out, is_array_api_compliant = get_namespace(X_xp)
+        assert is_array_api_compliant
+
+        with pytest.raises(TypeError):
+            xp_out, is_array_api_compliant = get_namespace(X_xp, X_np)
+
+        def mock_getenv(key):
+            if key == "SCIPY_ARRAY_API":
+                return "0"
+
+        monkeypatch.setattr("os.environ.get", mock_getenv)
+        assert os.environ.get("SCIPY_ARRAY_API") != "1"
+        with pytest.raises(
+            RuntimeError,
+            match="scipy's own support is not enabled.",
+        ):
+            get_namespace(X_xp)
+
+
+@pytest.mark.parametrize("array_api", ["numpy", "array_api_strict"])
+def test_asarray_with_order(array_api):
+    """Test _asarray_with_order passes along order for NumPy arrays."""
+    xp = pytest.importorskip(array_api)
+
+    X = xp.asarray([1.2, 3.4, 5.1])
+    X_new = _asarray_with_order(X, order="F", xp=xp)
+
+    X_new_np = numpy.asarray(X_new)
+    assert X_new_np.flags["F_CONTIGUOUS"]
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device_, dtype_name",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+@pytest.mark.parametrize(
+    "weights, axis, normalize, expected",
+    [
+        # normalize = True
+        (None, None, True, 3.5),
+        (None, 0, True, [2.5, 3.5, 4.5]),
+        (None, 1, True, [2, 5]),
+        ([True, False], 0, True, [1, 2, 3]),  # boolean weights
+        ([True, True, False], 1, True, [1.5, 4.5]),  # boolean weights
+        ([0.4, 0.1], 0, True, [1.6, 2.6, 3.6]),
+        ([0.4, 0.2, 0.2], 1, True, [1.75, 4.75]),
+        ([1, 2], 0, True, [3, 4, 5]),
+        ([1, 1, 2], 1, True, [2.25, 5.25]),
+        ([[1, 2, 3], [1, 2, 3]], 0, True, [2.5, 3.5, 4.5]),
+        ([[1, 2, 1], [2, 2, 2]], 1, True, [2, 5]),
+        # normalize = False
+        (None, None, False, 21),
+        (None, 0, False, [5, 7, 9]),
+        (None, 1, False, [6, 15]),
+        ([True, False], 0, False, [1, 2, 3]),  # boolean weights
+        ([True, True, False], 1, False, [3, 9]),  # boolean weights
+        ([0.4, 0.1], 0, False, [0.8, 1.3, 1.8]),
+        ([0.4, 0.2, 0.2], 1, False, [1.4, 3.8]),
+        ([1, 2], 0, False, [9, 12, 15]),
+        ([1, 1, 2], 1, False, [9, 21]),
+        ([[1, 2, 3], [1, 2, 3]], 0, False, [5, 14, 27]),
+        ([[1, 2, 1], [2, 2, 2]], 1, False, [8, 30]),
+    ],
+)
+def test_average(
+    array_namespace, device_, dtype_name, weights, axis, normalize, expected
+):
+    xp = _array_api_for_tests(array_namespace, device_)
+    array_in = numpy.asarray([[1, 2, 3], [4, 5, 6]], dtype=dtype_name)
+    array_in = xp.asarray(array_in, device=device_)
+    if weights is not None:
+        weights = numpy.asarray(weights, dtype=dtype_name)
+        weights = xp.asarray(weights, device=device_)
+
+    with config_context(array_api_dispatch=True):
+        result = _average(array_in, axis=axis, weights=weights, normalize=normalize)
+
+    if np_version < parse_version("2.0.0") or np_version >= parse_version("2.1.0"):
+        # NumPy 2.0 has a problem with the device attribute of scalar arrays:
+        # https://github.com/numpy/numpy/issues/26850
+        assert device(array_in) == device(result)
+
+    result = _convert_to_numpy(result, xp)
+    assert_allclose(result, expected, atol=_atol_for_type(dtype_name))
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name",
+    yield_namespace_device_dtype_combinations(include_numpy_namespaces=False),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_average_raises_with_wrong_dtype(array_namespace, device, dtype_name):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    array_in = numpy.asarray([2, 0], dtype=dtype_name) + 1j * numpy.asarray(
+        [4, 3], dtype=dtype_name
+    )
+    complex_type_name = array_in.dtype.name
+    if not hasattr(xp, complex_type_name):
+        # This is the case for cupy as of March 2024 for instance.
+        pytest.skip(f"{array_namespace} does not support {complex_type_name}")
+
+    array_in = xp.asarray(array_in, device=device)
+
+    err_msg = "Complex floating point values are not supported by average."
+    with (
+        config_context(array_api_dispatch=True),
+        pytest.raises(NotImplementedError, match=err_msg),
+    ):
+        _average(array_in)
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name",
+    yield_namespace_device_dtype_combinations(include_numpy_namespaces=True),
+    ids=_get_namespace_device_dtype_ids,
+)
+@pytest.mark.parametrize(
+    "axis, weights, error, error_msg",
+    (
+        (
+            None,
+            [1, 2],
+            TypeError,
+            "Axis must be specified",
+        ),
+        (
+            0,
+            [[1, 2]],
+            # NumPy 2 raises ValueError, NumPy 1 raises TypeError
+            (ValueError, TypeError),
+            "weights",  # the message is different for NumPy 1 and 2...
+        ),
+        (
+            0,
+            [1, 2, 3, 4],
+            ValueError,
+            "weights",
+        ),
+        (0, [-1, 1], ZeroDivisionError, "Weights sum to zero, can't be normalized"),
+    ),
+)
+def test_average_raises_with_invalid_parameters(
+    array_namespace, device, dtype_name, axis, weights, error, error_msg
+):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    array_in = numpy.asarray([[1, 2, 3], [4, 5, 6]], dtype=dtype_name)
+    array_in = xp.asarray(array_in, device=device)
+
+    weights = numpy.asarray(weights, dtype=dtype_name)
+    weights = xp.asarray(weights, device=device)
+
+    with config_context(array_api_dispatch=True), pytest.raises(error, match=error_msg):
+        _average(array_in, axis=axis, weights=weights)
+
+
+def test_device_none_if_no_input():
+    assert device() is None
+
+    assert device(None, "name") is None
+
+
+@skip_if_array_api_compat_not_configured
+def test_device_inspection():
+    class Device:
+        def __init__(self, name):
+            self.name = name
+
+        def __eq__(self, device):
+            return self.name == device.name
+
+        def __hash__(self):
+            raise TypeError("Device object is not hashable")
+
+        def __str__(self):
+            return self.name
+
+    class Array:
+        def __init__(self, device_name):
+            self.device = Device(device_name)
+
+    # Sanity check: ensure our Device mock class is non hashable, to
+    # accurately account for non-hashable device objects in some array
+    # libraries, because of which the `device` inspection function shouldn't
+    # make use of hash lookup tables (in particular, not use `set`)
+    with pytest.raises(TypeError):
+        hash(Array("device").device)
+
+    # If array API dispatch is disabled the device should be ignored. Erroring
+    # early for different devices would prevent the np.asarray conversion to
+    # happen. For example, `r2_score(np.ones(5), torch.ones(5))` should work
+    # fine with array API disabled.
+    assert device(Array("cpu"), Array("mygpu")) is None
+
+    # Test that ValueError is raised if on different devices and array API dispatch is
+    # enabled.
+    err_msg = "Input arrays use different devices: cpu, mygpu"
+    with config_context(array_api_dispatch=True):
+        with pytest.raises(ValueError, match=err_msg):
+            device(Array("cpu"), Array("mygpu"))
+
+        # Test expected value is returned otherwise
+        array1 = Array("device")
+        array2 = Array("device")
+
+        assert array1.device == device(array1)
+        assert array1.device == device(array1, array2)
+        assert array1.device == device(array1, array1, array2)
+
+
+# TODO: add cupy to the list of libraries once the following upstream issue
+# has been fixed:
+# https://github.com/cupy/cupy/issues/8180
+@skip_if_array_api_compat_not_configured
+@pytest.mark.parametrize("library", ["numpy", "array_api_strict", "torch"])
+@pytest.mark.parametrize(
+    "X,reduction,expected",
+    [
+        ([1, 2, numpy.nan], _nanmin, 1),
+        ([1, -2, -numpy.nan], _nanmin, -2),
+        ([numpy.inf, numpy.inf], _nanmin, numpy.inf),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmin, axis=0),
+            [1.0, 2.0, 3.0],
+        ),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmin, axis=1),
+            [1.0, numpy.nan, 4.0],
+        ),
+        ([1, 2, numpy.nan], _nanmax, 2),
+        ([1, 2, numpy.nan], _nanmax, 2),
+        ([-numpy.inf, -numpy.inf], _nanmax, -numpy.inf),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmax, axis=0),
+            [4.0, 5.0, 6.0],
+        ),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmax, axis=1),
+            [3.0, numpy.nan, 6.0],
+        ),
+        ([1, 2, numpy.nan], _nanmean, 1.5),
+        ([1, -2, -numpy.nan], _nanmean, -0.5),
+        ([-numpy.inf, -numpy.inf], _nanmean, -numpy.inf),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmean, axis=0),
+            [2.5, 3.5, 4.5],
+        ),
+        (
+            [[1, 2, 3], [numpy.nan, numpy.nan, numpy.nan], [4, 5, 6.0]],
+            partial(_nanmean, axis=1),
+            [2.0, numpy.nan, 5.0],
+        ),
+    ],
+)
+def test_nan_reductions(library, X, reduction, expected):
+    """Check NaN reductions like _nanmin and _nanmax"""
+    xp = pytest.importorskip(library)
+
+    with config_context(array_api_dispatch=True):
+        result = reduction(xp.asarray(X))
+
+    result = _convert_to_numpy(result, xp)
+    assert_allclose(result, expected)
+
+
+@pytest.mark.parametrize(
+    "namespace, _device, _dtype",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_ravel(namespace, _device, _dtype):
+    xp = _array_api_for_tests(namespace, _device)
+
+    array = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
+    array_xp = xp.asarray(array, device=_device)
+    with config_context(array_api_dispatch=True):
+        result = _ravel(array_xp)
+
+    result = _convert_to_numpy(result, xp)
+    expected = numpy.ravel(array, order="C")
+
+    assert_allclose(expected, result)
+
+    if _is_numpy_namespace(xp):
+        assert numpy.asarray(result).flags["C_CONTIGUOUS"]
+
+
+@skip_if_array_api_compat_not_configured
+@pytest.mark.parametrize("library", ["cupy", "torch"])
+def test_convert_to_numpy_gpu(library):  # pragma: nocover
+    """Check convert_to_numpy for GPU backed libraries."""
+    xp = pytest.importorskip(library)
+
+    if library == "torch":
+        if not xp.backends.cuda.is_built():
+            pytest.skip("test requires cuda")
+        X_gpu = xp.asarray([1.0, 2.0, 3.0], device="cuda")
+    else:
+        X_gpu = xp.asarray([1.0, 2.0, 3.0])
+
+    X_cpu = _convert_to_numpy(X_gpu, xp=xp)
+    expected_output = numpy.asarray([1.0, 2.0, 3.0])
+    assert_allclose(X_cpu, expected_output)
+
+
+def test_convert_to_numpy_cpu():
+    """Check convert_to_numpy for PyTorch CPU arrays."""
+    torch = pytest.importorskip("torch")
+    X_torch = torch.asarray([1.0, 2.0, 3.0], device="cpu")
+
+    X_cpu = _convert_to_numpy(X_torch, xp=torch)
+    expected_output = numpy.asarray([1.0, 2.0, 3.0])
+    assert_allclose(X_cpu, expected_output)
+
+
+class SimpleEstimator(BaseEstimator):
+    def fit(self, X, y=None):
+        self.X_ = X
+        self.n_features_ = X.shape[0]
+        return self
+
+
+@skip_if_array_api_compat_not_configured
+@pytest.mark.parametrize(
+    "array_namespace, converter",
+    [
+        ("torch", lambda array: array.cpu().numpy()),
+        ("array_api_strict", lambda array: numpy.asarray(array)),
+        ("cupy", lambda array: array.get()),
+    ],
+)
+def test_convert_estimator_to_ndarray(array_namespace, converter):
+    """Convert estimator attributes to ndarray."""
+    xp = pytest.importorskip(array_namespace)
+
+    X = xp.asarray([[1.3, 4.5]])
+    est = SimpleEstimator().fit(X)
+
+    new_est = _estimator_with_converted_arrays(est, converter)
+    assert isinstance(new_est.X_, numpy.ndarray)
+
+
+@skip_if_array_api_compat_not_configured
+def test_convert_estimator_to_array_api():
+    """Convert estimator attributes to ArrayAPI arrays."""
+    xp = pytest.importorskip("array_api_strict")
+
+    X_np = numpy.asarray([[1.3, 4.5]])
+    est = SimpleEstimator().fit(X_np)
+
+    new_est = _estimator_with_converted_arrays(est, lambda array: xp.asarray(array))
+    assert hasattr(new_est.X_, "__array_namespace__")
+
+
+@pytest.mark.parametrize(
+    "namespace, _device, _dtype",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_indexing_dtype(namespace, _device, _dtype):
+    xp = _array_api_for_tests(namespace, _device)
+
+    if _IS_32BIT:
+        assert indexing_dtype(xp) == xp.int32
+    else:
+        assert indexing_dtype(xp) == xp.int64
+
+
+@pytest.mark.parametrize(
+    "namespace, _device, _dtype",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_max_precision_float_dtype(namespace, _device, _dtype):
+    xp = _array_api_for_tests(namespace, _device)
+    expected_dtype = xp.float32 if _device == "mps" else xp.float64
+    assert _max_precision_float_dtype(xp, _device) == expected_dtype
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, _",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+@pytest.mark.parametrize("invert", [True, False])
+@pytest.mark.parametrize("assume_unique", [True, False])
+@pytest.mark.parametrize("element_size", [6, 10, 14])
+@pytest.mark.parametrize("int_dtype", ["int16", "int32", "int64", "uint8"])
+def test_isin(
+    array_namespace, device, _, invert, assume_unique, element_size, int_dtype
+):
+    xp = _array_api_for_tests(array_namespace, device)
+    r = element_size // 2
+    element = 2 * numpy.arange(element_size).reshape((r, 2)).astype(int_dtype)
+    test_elements = numpy.array(numpy.arange(14), dtype=int_dtype)
+    element_xp = xp.asarray(element, device=device)
+    test_elements_xp = xp.asarray(test_elements, device=device)
+    expected = numpy.isin(
+        element=element,
+        test_elements=test_elements,
+        assume_unique=assume_unique,
+        invert=invert,
+    )
+    with config_context(array_api_dispatch=True):
+        result = _isin(
+            element=element_xp,
+            test_elements=test_elements_xp,
+            xp=xp,
+            assume_unique=assume_unique,
+            invert=invert,
+        )
+
+    assert_array_equal(_convert_to_numpy(result, xp=xp), expected)
+
+
+@pytest.mark.skipif(
+    os.environ.get("SCIPY_ARRAY_API") != "1", reason="SCIPY_ARRAY_API not set to 1."
+)
+def test_get_namespace_and_device():
+    # Use torch as a library with custom Device objects:
+    torch = pytest.importorskip("torch")
+
+    from sklearn.externals.array_api_compat import torch as torch_compat
+
+    some_torch_tensor = torch.arange(3, device="cpu")
+    some_numpy_array = numpy.arange(3)
+
+    # When dispatch is disabled, get_namespace_and_device should return the
+    # default NumPy wrapper namespace and "cpu" device. Our code will handle such
+    # inputs via the usual __array__ interface without attempting to dispatch
+    # via the array API.
+    namespace, is_array_api, device = get_namespace_and_device(some_torch_tensor)
+    assert namespace is get_namespace(some_numpy_array)[0]
+    assert not is_array_api
+    assert device is None
+
+    # Otherwise, expose the torch namespace and device via array API compat
+    # wrapper.
+    with config_context(array_api_dispatch=True):
+        namespace, is_array_api, device = get_namespace_and_device(some_torch_tensor)
+        assert namespace is torch_compat
+        assert is_array_api
+        assert device == some_torch_tensor.device
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device_, dtype_name",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("axis", [0, 1, None, -1, -2])
+@pytest.mark.parametrize("sample_weight_type", [None, "int", "float"])
+def test_count_nonzero(
+    array_namespace, device_, dtype_name, csr_container, axis, sample_weight_type
+):
+    from sklearn.utils.sparsefuncs import count_nonzero as sparse_count_nonzero
+
+    xp = _array_api_for_tests(array_namespace, device_)
+    array = numpy.array([[0, 3, 0], [2, -1, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]])
+    if sample_weight_type == "int":
+        sample_weight = numpy.asarray([1, 2, 2, 3, 1])
+    elif sample_weight_type == "float":
+        sample_weight = numpy.asarray([0.5, 1.5, 0.8, 3.2, 2.4], dtype=dtype_name)
+    else:
+        sample_weight = None
+    expected = sparse_count_nonzero(
+        csr_container(array), axis=axis, sample_weight=sample_weight
+    )
+    array_xp = xp.asarray(array, device=device_)
+
+    with config_context(array_api_dispatch=True):
+        result = _count_nonzero(
+            array_xp, axis=axis, sample_weight=sample_weight, xp=xp, device=device_
+        )
+
+    assert_allclose(_convert_to_numpy(result, xp=xp), expected)
+
+    if np_version < parse_version("2.0.0") or np_version >= parse_version("2.1.0"):
+        # NumPy 2.0 has a problem with the device attribute of scalar arrays:
+        # https://github.com/numpy/numpy/issues/26850
+        assert device(array_xp) == device(result)
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device_, dtype_name",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+@pytest.mark.parametrize("wrap", [True, False])
+def test_fill_or_add_to_diagonal(array_namespace, device_, dtype_name, wrap):
+    xp = _array_api_for_tests(array_namespace, device_)
+
+    array_np = numpy.zeros((5, 4), dtype=dtype_name)
+    array_xp = xp.asarray(array_np.copy(), device=device_)
+
+    numpy.fill_diagonal(array_np, val=1, wrap=wrap)
+    with config_context(array_api_dispatch=True):
+        _fill_or_add_to_diagonal(array_xp, value=1, xp=xp, add_value=False, wrap=wrap)
+
+    assert_array_equal(_convert_to_numpy(array_xp, xp=xp), array_np)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("dispatch", [True, False])
+def test_sparse_device(csr_container, dispatch):
+    a, b = csr_container(numpy.array([[1]])), csr_container(numpy.array([[2]]))
+    if dispatch and os.environ.get("SCIPY_ARRAY_API") is None:
+        raise SkipTest("SCIPY_ARRAY_API is not set: not checking array_api input")
+    with config_context(array_api_dispatch=dispatch):
+        assert device(a, b) is None
+        assert device(a, numpy.array([1])) is None
+        assert get_namespace_and_device(a, b)[2] is None
+        assert get_namespace_and_device(a, numpy.array([1]))[2] is None
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arrayfuncs.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arrayfuncs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5c99427cbd003eebe0eb4228667be056a0ab642
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_arrayfuncs.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from sklearn.utils._testing import assert_allclose
+from sklearn.utils.arrayfuncs import _all_with_any_reduction_axis_1, min_pos
+
+
+def test_min_pos():
+    # Check that min_pos returns a positive value and that it's consistent
+    # between float and double
+    X = np.random.RandomState(0).randn(100)
+
+    min_double = min_pos(X)
+    min_float = min_pos(X.astype(np.float32))
+
+    assert_allclose(min_double, min_float)
+    assert min_double >= 0
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_min_pos_no_positive(dtype):
+    # Check that the return value of min_pos is the maximum representable
+    # value of the input dtype when all input elements are <= 0 (#19328)
+    X = np.full(100, -1.0).astype(dtype, copy=False)
+
+    assert min_pos(X) == np.finfo(dtype).max
+
+
+@pytest.mark.parametrize(
+    "dtype", [np.int16, np.int32, np.int64, np.float32, np.float64]
+)
+@pytest.mark.parametrize("value", [0, 1.5, -1])
+def test_all_with_any_reduction_axis_1(dtype, value):
+    # Check that return value is False when there is no row equal to `value`
+    X = np.arange(12, dtype=dtype).reshape(3, 4)
+    assert not _all_with_any_reduction_axis_1(X, value=value)
+
+    # Make a row equal to `value`
+    X[1, :] = value
+    assert _all_with_any_reduction_axis_1(X, value=value)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_bunch.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_bunch.py
new file mode 100644
index 0000000000000000000000000000000000000000..15463475747f4229ed7ab320d8f5be8005f9cf0a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_bunch.py
@@ -0,0 +1,32 @@
+import warnings
+
+import numpy as np
+import pytest
+
+from sklearn.utils import Bunch
+
+
+def test_bunch_attribute_deprecation():
+    """Check that bunch raises deprecation message with `__getattr__`."""
+    bunch = Bunch()
+    values = np.asarray([1, 2, 3])
+    msg = (
+        "Key: 'values', is deprecated in 1.3 and will be "
+        "removed in 1.5. Please use 'grid_values' instead"
+    )
+    bunch._set_deprecated(
+        values, new_key="grid_values", deprecated_key="values", warning_message=msg
+    )
+
+    with warnings.catch_warnings():
+        # Does not warn for "grid_values"
+        warnings.simplefilter("error")
+        v = bunch["grid_values"]
+
+    assert v is values
+
+    with pytest.warns(FutureWarning, match=msg):
+        # Warns for "values"
+        v = bunch["values"]
+
+    assert v is values
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_chunking.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_chunking.py
new file mode 100644
index 0000000000000000000000000000000000000000..10c7ed17a0c2da4365f7b4a326368d432b3131bf
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_chunking.py
@@ -0,0 +1,73 @@
+import warnings
+from itertools import chain
+
+import pytest
+
+from sklearn import config_context
+from sklearn.utils._chunking import gen_even_slices, get_chunk_n_rows
+from sklearn.utils._testing import assert_array_equal
+
+
+def test_gen_even_slices():
+    # check that gen_even_slices contains all samples
+    some_range = range(10)
+    joined_range = list(chain(*[some_range[slice] for slice in gen_even_slices(10, 3)]))
+    assert_array_equal(some_range, joined_range)
+
+
+@pytest.mark.parametrize(
+    ("row_bytes", "max_n_rows", "working_memory", "expected"),
+    [
+        (1024, None, 1, 1024),
+        (1024, None, 0.99999999, 1023),
+        (1023, None, 1, 1025),
+        (1025, None, 1, 1023),
+        (1024, None, 2, 2048),
+        (1024, 7, 1, 7),
+        (1024 * 1024, None, 1, 1),
+    ],
+)
+def test_get_chunk_n_rows(row_bytes, max_n_rows, working_memory, expected):
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        actual = get_chunk_n_rows(
+            row_bytes=row_bytes,
+            max_n_rows=max_n_rows,
+            working_memory=working_memory,
+        )
+
+    assert actual == expected
+    assert type(actual) is type(expected)
+    with config_context(working_memory=working_memory):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", UserWarning)
+            actual = get_chunk_n_rows(row_bytes=row_bytes, max_n_rows=max_n_rows)
+        assert actual == expected
+        assert type(actual) is type(expected)
+
+
+def test_get_chunk_n_rows_warns():
+    """Check that warning is raised when working_memory is too low."""
+    row_bytes = 1024 * 1024 + 1
+    max_n_rows = None
+    working_memory = 1
+    expected = 1
+
+    warn_msg = (
+        "Could not adhere to working_memory config. Currently 1MiB, 2MiB required."
+    )
+    with pytest.warns(UserWarning, match=warn_msg):
+        actual = get_chunk_n_rows(
+            row_bytes=row_bytes,
+            max_n_rows=max_n_rows,
+            working_memory=working_memory,
+        )
+
+    assert actual == expected
+    assert type(actual) is type(expected)
+
+    with config_context(working_memory=working_memory):
+        with pytest.warns(UserWarning, match=warn_msg):
+            actual = get_chunk_n_rows(row_bytes=row_bytes, max_n_rows=max_n_rows)
+        assert actual == expected
+        assert type(actual) is type(expected)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_class_weight.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_class_weight.py
new file mode 100644
index 0000000000000000000000000000000000000000..3efee050c3b9021ea2ce8a61bd25e2c71848c13f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_class_weight.py
@@ -0,0 +1,334 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from sklearn.datasets import make_blobs
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.utils._testing import assert_almost_equal, assert_array_almost_equal
+from sklearn.utils.class_weight import compute_class_weight, compute_sample_weight
+from sklearn.utils.fixes import CSC_CONTAINERS
+
+
+def test_compute_class_weight():
+    # Test (and demo) compute_class_weight.
+    y = np.asarray([2, 2, 2, 3, 3, 4])
+    classes = np.unique(y)
+
+    cw = compute_class_weight("balanced", classes=classes, y=y)
+    # total effect of samples is preserved
+    class_counts = np.bincount(y)[2:]
+    assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
+    assert cw[0] < cw[1] < cw[2]
+
+
+@pytest.mark.parametrize(
+    "y_type, class_weight, classes, err_msg",
+    [
+        (
+            "numeric",
+            "balanced",
+            np.arange(4),
+            "classes should have valid labels that are in y",
+        ),
+        # Non-regression for https://github.com/scikit-learn/scikit-learn/issues/8312
+        (
+            "numeric",
+            {"label_not_present": 1.0},
+            np.arange(4),
+            r"The classes, \[0, 1, 2, 3\], are not in class_weight",
+        ),
+        (
+            "numeric",
+            "balanced",
+            np.arange(2),
+            "classes should include all valid labels",
+        ),
+        (
+            "numeric",
+            {0: 1.0, 1: 2.0},
+            np.arange(2),
+            "classes should include all valid labels",
+        ),
+        (
+            "string",
+            {"dogs": 3, "cat": 2},
+            np.array(["dog", "cat"]),
+            r"The classes, \['dog'\], are not in class_weight",
+        ),
+    ],
+)
+def test_compute_class_weight_not_present(y_type, class_weight, classes, err_msg):
+    # Raise error when y does not contain all class labels
+    y = (
+        np.asarray([0, 0, 0, 1, 1, 2])
+        if y_type == "numeric"
+        else np.asarray(["dog", "cat", "dog"])
+    )
+
+    print(y)
+    with pytest.raises(ValueError, match=err_msg):
+        compute_class_weight(class_weight, classes=classes, y=y)
+
+
+def test_compute_class_weight_dict():
+    classes = np.arange(3)
+    class_weights = {0: 1.0, 1: 2.0, 2: 3.0}
+    y = np.asarray([0, 0, 1, 2])
+    cw = compute_class_weight(class_weights, classes=classes, y=y)
+
+    # When the user specifies class weights, compute_class_weights should just
+    # return them.
+    assert_array_almost_equal(np.asarray([1.0, 2.0, 3.0]), cw)
+
+    # When a class weight is specified that isn't in classes, the weight is ignored
+    class_weights = {0: 1.0, 1: 2.0, 2: 3.0, 4: 1.5}
+    cw = compute_class_weight(class_weights, classes=classes, y=y)
+    assert_allclose([1.0, 2.0, 3.0], cw)
+
+    class_weights = {-1: 5.0, 0: 4.0, 1: 2.0, 2: 3.0}
+    cw = compute_class_weight(class_weights, classes=classes, y=y)
+    assert_allclose([4.0, 2.0, 3.0], cw)
+
+
+def test_compute_class_weight_invariance():
+    # Test that results with class_weight="balanced" is invariant wrt
+    # class imbalance if the number of samples is identical.
+    # The test uses a balanced two class dataset with 100 datapoints.
+    # It creates three versions, one where class 1 is duplicated
+    # resulting in 150 points of class 1 and 50 of class 0,
+    # one where there are 50 points in class 1 and 150 in class 0,
+    # and one where there are 100 points of each class (this one is balanced
+    # again).
+    # With balancing class weights, all three should give the same model.
+    X, y = make_blobs(centers=2, random_state=0)
+    # create dataset where class 1 is duplicated twice
+    X_1 = np.vstack([X] + [X[y == 1]] * 2)
+    y_1 = np.hstack([y] + [y[y == 1]] * 2)
+    # create dataset where class 0 is duplicated twice
+    X_0 = np.vstack([X] + [X[y == 0]] * 2)
+    y_0 = np.hstack([y] + [y[y == 0]] * 2)
+    # duplicate everything
+    X_ = np.vstack([X] * 2)
+    y_ = np.hstack([y] * 2)
+    # results should be identical
+    logreg1 = LogisticRegression(class_weight="balanced").fit(X_1, y_1)
+    logreg0 = LogisticRegression(class_weight="balanced").fit(X_0, y_0)
+    logreg = LogisticRegression(class_weight="balanced").fit(X_, y_)
+    assert_array_almost_equal(logreg1.coef_, logreg0.coef_)
+    assert_array_almost_equal(logreg.coef_, logreg0.coef_)
+
+
+def test_compute_class_weight_balanced_negative():
+    # Test compute_class_weight when labels are negative
+    # Test with balanced class labels.
+    classes = np.array([-2, -1, 0])
+    y = np.asarray([-1, -1, 0, 0, -2, -2])
+
+    cw = compute_class_weight("balanced", classes=classes, y=y)
+    assert len(cw) == len(classes)
+    assert_array_almost_equal(cw, np.array([1.0, 1.0, 1.0]))
+
+
+def test_compute_class_weight_balanced_sample_weight_equivalence():
+    # Test with unbalanced and negative class labels for
+    # equivalence between repeated and weighted samples
+
+    classes = np.array([-2, -1, 0])
+    y = np.asarray([-1, -1, 0, 0, -2, -2])
+    sw = np.asarray([1, 0, 1, 1, 1, 2])
+
+    y_rep = np.repeat(y, sw, axis=0)
+
+    class_weights_weighted = compute_class_weight(
+        "balanced", classes=classes, y=y, sample_weight=sw
+    )
+    class_weights_repeated = compute_class_weight("balanced", classes=classes, y=y_rep)
+    assert len(class_weights_weighted) == len(classes)
+    assert len(class_weights_repeated) == len(classes)
+
+    class_counts_weighted = np.bincount(y + 2, weights=sw)
+    class_counts_repeated = np.bincount(y_rep + 2)
+
+    assert np.dot(class_weights_weighted, class_counts_weighted) == pytest.approx(
+        np.dot(class_weights_repeated, class_counts_repeated)
+    )
+
+    assert_allclose(class_weights_weighted, class_weights_repeated)
+
+
+def test_compute_class_weight_balanced_unordered():
+    # Test compute_class_weight when classes are unordered
+    classes = np.array([1, 0, 3])
+    y = np.asarray([1, 0, 0, 3, 3, 3])
+
+    cw = compute_class_weight("balanced", classes=classes, y=y)
+    class_counts = np.bincount(y)[classes]
+    assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
+    assert_array_almost_equal(cw, [2.0, 1.0, 2.0 / 3])
+
+
+def test_compute_class_weight_default():
+    # Test for the case where no weight is given for a present class.
+    # Current behaviour is to assign the unweighted classes a weight of 1.
+    y = np.asarray([2, 2, 2, 3, 3, 4])
+    classes = np.unique(y)
+    classes_len = len(classes)
+
+    # Test for non specified weights
+    cw = compute_class_weight(None, classes=classes, y=y)
+    assert len(cw) == classes_len
+    assert_array_almost_equal(cw, np.ones(3))
+
+    # Tests for partly specified weights
+    cw = compute_class_weight({2: 1.5}, classes=classes, y=y)
+    assert len(cw) == classes_len
+    assert_array_almost_equal(cw, [1.5, 1.0, 1.0])
+
+    cw = compute_class_weight({2: 1.5, 4: 0.5}, classes=classes, y=y)
+    assert len(cw) == classes_len
+    assert_array_almost_equal(cw, [1.5, 1.0, 0.5])
+
+
+def test_compute_sample_weight():
+    # Test (and demo) compute_sample_weight.
+    # Test with balanced classes
+    y = np.asarray([1, 1, 1, 2, 2, 2])
+    sample_weight = compute_sample_weight("balanced", y)
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with user-defined weights
+    sample_weight = compute_sample_weight({1: 2, 2: 1}, y)
+    assert_array_almost_equal(sample_weight, [2.0, 2.0, 2.0, 1.0, 1.0, 1.0])
+
+    # Test with column vector of balanced classes
+    y = np.asarray([[1], [1], [1], [2], [2], [2]])
+    sample_weight = compute_sample_weight("balanced", y)
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with unbalanced classes
+    y = np.asarray([1, 1, 1, 2, 2, 2, 3])
+    sample_weight = compute_sample_weight("balanced", y)
+    expected_balanced = np.array(
+        [0.7777, 0.7777, 0.7777, 0.7777, 0.7777, 0.7777, 2.3333]
+    )
+    assert_array_almost_equal(sample_weight, expected_balanced, decimal=4)
+
+    # Test with `None` weights
+    sample_weight = compute_sample_weight(None, y)
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with multi-output of balanced classes
+    y = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1]])
+    sample_weight = compute_sample_weight("balanced", y)
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with multi-output with user-defined weights
+    y = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1]])
+    sample_weight = compute_sample_weight([{1: 2, 2: 1}, {0: 1, 1: 2}], y)
+    assert_array_almost_equal(sample_weight, [2.0, 2.0, 2.0, 2.0, 2.0, 2.0])
+
+    # Test with multi-output of unbalanced classes
+    y = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1], [3, -1]])
+    sample_weight = compute_sample_weight("balanced", y)
+    assert_array_almost_equal(sample_weight, expected_balanced**2, decimal=3)
+
+
+def test_compute_sample_weight_with_subsample():
+    # Test compute_sample_weight with subsamples specified.
+    # Test with balanced classes and all samples present
+    y = np.asarray([1, 1, 1, 2, 2, 2])
+    sample_weight = compute_sample_weight("balanced", y, indices=range(6))
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with column vector of balanced classes and all samples present
+    y = np.asarray([[1], [1], [1], [2], [2], [2]])
+    sample_weight = compute_sample_weight("balanced", y, indices=range(6))
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+    # Test with a subsample
+    y = np.asarray([1, 1, 1, 2, 2, 2])
+    sample_weight = compute_sample_weight("balanced", y, indices=range(4))
+    assert_array_almost_equal(sample_weight, [2.0 / 3, 2.0 / 3, 2.0 / 3, 2.0, 2.0, 2.0])
+
+    # Test with a bootstrap subsample
+    y = np.asarray([1, 1, 1, 2, 2, 2])
+    sample_weight = compute_sample_weight("balanced", y, indices=[0, 1, 1, 2, 2, 3])
+    expected_balanced = np.asarray([0.6, 0.6, 0.6, 3.0, 3.0, 3.0])
+    assert_array_almost_equal(sample_weight, expected_balanced)
+
+    # Test with a bootstrap subsample for multi-output
+    y = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1]])
+    sample_weight = compute_sample_weight("balanced", y, indices=[0, 1, 1, 2, 2, 3])
+    assert_array_almost_equal(sample_weight, expected_balanced**2)
+
+    # Test with a missing class
+    y = np.asarray([1, 1, 1, 2, 2, 2, 3])
+    sample_weight = compute_sample_weight("balanced", y, indices=range(6))
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0])
+
+    # Test with a missing class for multi-output
+    y = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1], [2, 2]])
+    sample_weight = compute_sample_weight("balanced", y, indices=range(6))
+    assert_array_almost_equal(sample_weight, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0])
+
+
+@pytest.mark.parametrize(
+    "y_type, class_weight, indices, err_msg",
+    [
+        (
+            "single-output",
+            {1: 2, 2: 1},
+            range(4),
+            "The only valid class_weight for subsampling is 'balanced'.",
+        ),
+        (
+            "multi-output",
+            {1: 2, 2: 1},
+            None,
+            "For multi-output, class_weight should be a list of dicts, or the string",
+        ),
+        (
+            "multi-output",
+            [{1: 2, 2: 1}],
+            None,
+            r"Got 1 element\(s\) while having 2 outputs",
+        ),
+    ],
+)
+def test_compute_sample_weight_errors(y_type, class_weight, indices, err_msg):
+    # Test compute_sample_weight raises errors expected.
+    # Invalid preset string
+    y_single_output = np.asarray([1, 1, 1, 2, 2, 2])
+    y_multi_output = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1]])
+
+    y = y_single_output if y_type == "single-output" else y_multi_output
+    with pytest.raises(ValueError, match=err_msg):
+        compute_sample_weight(class_weight, y, indices=indices)
+
+
+def test_compute_sample_weight_more_than_32():
+    # Non-regression smoke test for #12146
+    y = np.arange(50)  # more than 32 distinct classes
+    indices = np.arange(50)  # use subsampling
+    weight = compute_sample_weight("balanced", y, indices=indices)
+    assert_array_almost_equal(weight, np.ones(y.shape[0]))
+
+
+def test_class_weight_does_not_contains_more_classes():
+    """Check that class_weight can contain more labels than in y.
+
+    Non-regression test for #22413
+    """
+    tree = DecisionTreeClassifier(class_weight={0: 1, 1: 10, 2: 20})
+
+    # Does not raise
+    tree.fit([[0, 0, 1], [1, 0, 1], [1, 2, 0]], [0, 0, 1])
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+def test_compute_sample_weight_sparse(csc_container):
+    """Check that we can compute weight for sparse `y`."""
+    y = csc_container(np.asarray([[0], [1], [1]]))
+    sample_weight = compute_sample_weight("balanced", y)
+    assert_allclose(sample_weight, [1.5, 0.75, 0.75])
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_cython_blas.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_cython_blas.py
new file mode 100644
index 0000000000000000000000000000000000000000..e221c3fea4e02fc66cb206e856415a963b66026f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_cython_blas.py
@@ -0,0 +1,250 @@
+import numpy as np
+import pytest
+
+from sklearn.utils._cython_blas import (
+    BLAS_Order,
+    BLAS_Trans,
+    _asum_memview,
+    _axpy_memview,
+    _copy_memview,
+    _dot_memview,
+    _gemm_memview,
+    _gemv_memview,
+    _ger_memview,
+    _nrm2_memview,
+    _rot_memview,
+    _rotg_memview,
+    _scal_memview,
+)
+from sklearn.utils._testing import assert_allclose
+
+
+def _numpy_to_cython(dtype):
+    cython = pytest.importorskip("cython")
+    if dtype == np.float32:
+        return cython.float
+    elif dtype == np.float64:
+        return cython.double
+
+
+RTOL = {np.float32: 1e-6, np.float64: 1e-12}
+ORDER = {BLAS_Order.RowMajor: "C", BLAS_Order.ColMajor: "F"}
+
+
+def _no_op(x):
+    return x
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dot(dtype):
+    dot = _dot_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = rng.random_sample(10).astype(dtype, copy=False)
+
+    expected = x.dot(y)
+    actual = dot(x, y)
+
+    assert_allclose(actual, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_asum(dtype):
+    asum = _asum_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+
+    expected = np.abs(x).sum()
+    actual = asum(x)
+
+    assert_allclose(actual, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_axpy(dtype):
+    axpy = _axpy_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = rng.random_sample(10).astype(dtype, copy=False)
+    alpha = 2.5
+
+    expected = alpha * x + y
+    axpy(alpha, x, y)
+
+    assert_allclose(y, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_nrm2(dtype):
+    nrm2 = _nrm2_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+
+    expected = np.linalg.norm(x)
+    actual = nrm2(x)
+
+    assert_allclose(actual, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_copy(dtype):
+    copy = _copy_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = np.empty_like(x)
+
+    expected = x.copy()
+    copy(x, y)
+
+    assert_allclose(y, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_scal(dtype):
+    scal = _scal_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    alpha = 2.5
+
+    expected = alpha * x
+    scal(alpha, x)
+
+    assert_allclose(x, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_rotg(dtype):
+    rotg = _rotg_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    a = dtype(rng.randn())
+    b = dtype(rng.randn())
+    c, s = 0.0, 0.0
+
+    def expected_rotg(a, b):
+        roe = a if abs(a) > abs(b) else b
+        if a == 0 and b == 0:
+            c, s, r, z = (1, 0, 0, 0)
+        else:
+            r = np.sqrt(a**2 + b**2) * (1 if roe >= 0 else -1)
+            c, s = a / r, b / r
+            z = s if roe == a else (1 if c == 0 else 1 / c)
+        return r, z, c, s
+
+    expected = expected_rotg(a, b)
+    actual = rotg(a, b, c, s)
+
+    assert_allclose(actual, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_rot(dtype):
+    rot = _rot_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = rng.random_sample(10).astype(dtype, copy=False)
+    c = dtype(rng.randn())
+    s = dtype(rng.randn())
+
+    expected_x = c * x + s * y
+    expected_y = c * y - s * x
+
+    rot(x, y, c, s)
+
+    assert_allclose(x, expected_x)
+    assert_allclose(y, expected_y)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "opA, transA",
+    [(_no_op, BLAS_Trans.NoTrans), (np.transpose, BLAS_Trans.Trans)],
+    ids=["NoTrans", "Trans"],
+)
+@pytest.mark.parametrize(
+    "order",
+    [BLAS_Order.RowMajor, BLAS_Order.ColMajor],
+    ids=["RowMajor", "ColMajor"],
+)
+def test_gemv(dtype, opA, transA, order):
+    gemv = _gemv_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    A = np.asarray(
+        opA(rng.random_sample((20, 10)).astype(dtype, copy=False)), order=ORDER[order]
+    )
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = rng.random_sample(20).astype(dtype, copy=False)
+    alpha, beta = 2.5, -0.5
+
+    expected = alpha * opA(A).dot(x) + beta * y
+    gemv(transA, alpha, A, x, beta, y)
+
+    assert_allclose(y, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "order",
+    [BLAS_Order.RowMajor, BLAS_Order.ColMajor],
+    ids=["BLAS_Order.RowMajor", "BLAS_Order.ColMajor"],
+)
+def test_ger(dtype, order):
+    ger = _ger_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    x = rng.random_sample(10).astype(dtype, copy=False)
+    y = rng.random_sample(20).astype(dtype, copy=False)
+    A = np.asarray(
+        rng.random_sample((10, 20)).astype(dtype, copy=False), order=ORDER[order]
+    )
+    alpha = 2.5
+
+    expected = alpha * np.outer(x, y) + A
+    ger(alpha, x, y, A)
+
+    assert_allclose(A, expected, rtol=RTOL[dtype])
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "opB, transB",
+    [(_no_op, BLAS_Trans.NoTrans), (np.transpose, BLAS_Trans.Trans)],
+    ids=["NoTrans", "Trans"],
+)
+@pytest.mark.parametrize(
+    "opA, transA",
+    [(_no_op, BLAS_Trans.NoTrans), (np.transpose, BLAS_Trans.Trans)],
+    ids=["NoTrans", "Trans"],
+)
+@pytest.mark.parametrize(
+    "order",
+    [BLAS_Order.RowMajor, BLAS_Order.ColMajor],
+    ids=["BLAS_Order.RowMajor", "BLAS_Order.ColMajor"],
+)
+def test_gemm(dtype, opA, transA, opB, transB, order):
+    gemm = _gemm_memview[_numpy_to_cython(dtype)]
+
+    rng = np.random.RandomState(0)
+    A = np.asarray(
+        opA(rng.random_sample((30, 10)).astype(dtype, copy=False)), order=ORDER[order]
+    )
+    B = np.asarray(
+        opB(rng.random_sample((10, 20)).astype(dtype, copy=False)), order=ORDER[order]
+    )
+    C = np.asarray(
+        rng.random_sample((30, 20)).astype(dtype, copy=False), order=ORDER[order]
+    )
+    alpha, beta = 2.5, -0.5
+
+    expected = alpha * opA(A).dot(opB(B)) + beta * C
+    gemm(transA, transB, alpha, A, B, beta, C)
+
+    assert_allclose(C, expected, rtol=RTOL[dtype])
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_deprecation.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..eec83182bf5769ac0d5af21cbd58eafade4ade35
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_deprecation.py
@@ -0,0 +1,98 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+
+import pickle
+from inspect import signature
+
+import pytest
+
+from sklearn.utils.deprecation import _is_deprecated, deprecated
+
+
+@deprecated("qwerty")
+class MockClass1:
+    pass
+
+
+class MockClass2:
+    @deprecated("mockclass2_method")
+    def method(self):
+        pass
+
+    @deprecated("n_features_ is deprecated")  # type: ignore[prop-decorator]
+    @property
+    def n_features_(self):
+        """Number of input features."""
+        return 10
+
+
+class MockClass3:
+    @deprecated()
+    def __init__(self):
+        pass
+
+
+class MockClass4:
+    pass
+
+
+class MockClass5(MockClass1):
+    """Inherit from deprecated class but does not call super().__init__."""
+
+    def __init__(self, a):
+        self.a = a
+
+
+@deprecated("a message")
+class MockClass6:
+    """A deprecated class that overrides __new__."""
+
+    def __new__(cls, *args, **kwargs):
+        assert len(args) > 0
+        return super().__new__(cls)
+
+
+@deprecated()
+def mock_function():
+    return 10
+
+
+def test_deprecated():
+    with pytest.warns(FutureWarning, match="qwerty"):
+        MockClass1()
+    with pytest.warns(FutureWarning, match="mockclass2_method"):
+        MockClass2().method()
+    with pytest.warns(FutureWarning, match="deprecated"):
+        MockClass3()
+    with pytest.warns(FutureWarning, match="qwerty"):
+        MockClass5(42)
+    with pytest.warns(FutureWarning, match="a message"):
+        MockClass6(42)
+    with pytest.warns(FutureWarning, match="deprecated"):
+        val = mock_function()
+    assert val == 10
+
+
+def test_is_deprecated():
+    # Test if _is_deprecated helper identifies wrapping via deprecated
+    # NOTE it works only for class methods and functions
+    assert _is_deprecated(MockClass1.__new__)
+    assert _is_deprecated(MockClass2().method)
+    assert _is_deprecated(MockClass3.__init__)
+    assert not _is_deprecated(MockClass4.__init__)
+    assert _is_deprecated(MockClass5.__new__)
+    assert _is_deprecated(mock_function)
+
+
+def test_pickle():
+    pickle.loads(pickle.dumps(mock_function))
+
+
+def test_deprecated_class_signature():
+    @deprecated()
+    class MockClass:
+        def __init__(self, a, b=1, c=2):
+            pass
+
+    assert list(signature(MockClass).parameters.keys()) == ["a", "b", "c"]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_encode.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_encode.py
new file mode 100644
index 0000000000000000000000000000000000000000..9118eb56f0ba4bbc5227b6c57450af891876acfa
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_encode.py
@@ -0,0 +1,274 @@
+import pickle
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn.utils._encode import _check_unknown, _encode, _get_counts, _unique
+
+
+@pytest.mark.parametrize(
+    "values, expected",
+    [
+        (np.array([2, 1, 3, 1, 3], dtype="int64"), np.array([1, 2, 3], dtype="int64")),
+        (
+            np.array([2, 1, np.nan, 1, np.nan], dtype="float32"),
+            np.array([1, 2, np.nan], dtype="float32"),
+        ),
+        (
+            np.array(["b", "a", "c", "a", "c"], dtype=object),
+            np.array(["a", "b", "c"], dtype=object),
+        ),
+        (
+            np.array(["b", "a", None, "a", None], dtype=object),
+            np.array(["a", "b", None], dtype=object),
+        ),
+        (np.array(["b", "a", "c", "a", "c"]), np.array(["a", "b", "c"])),
+    ],
+    ids=["int64", "float32-nan", "object", "object-None", "str"],
+)
+def test_encode_util(values, expected):
+    uniques = _unique(values)
+    assert_array_equal(uniques, expected)
+
+    result, encoded = _unique(values, return_inverse=True)
+    assert_array_equal(result, expected)
+    assert_array_equal(encoded, np.array([1, 0, 2, 0, 2]))
+
+    encoded = _encode(values, uniques=uniques)
+    assert_array_equal(encoded, np.array([1, 0, 2, 0, 2]))
+
+    result, counts = _unique(values, return_counts=True)
+    assert_array_equal(result, expected)
+    assert_array_equal(counts, np.array([2, 1, 2]))
+
+    result, encoded, counts = _unique(values, return_inverse=True, return_counts=True)
+    assert_array_equal(result, expected)
+    assert_array_equal(encoded, np.array([1, 0, 2, 0, 2]))
+    assert_array_equal(counts, np.array([2, 1, 2]))
+
+
+def test_encode_with_check_unknown():
+    # test for the check_unknown parameter of _encode()
+    uniques = np.array([1, 2, 3])
+    values = np.array([1, 2, 3, 4])
+
+    # Default is True, raise error
+    with pytest.raises(ValueError, match="y contains previously unseen labels"):
+        _encode(values, uniques=uniques, check_unknown=True)
+
+    # dont raise error if False
+    _encode(values, uniques=uniques, check_unknown=False)
+
+    # parameter is ignored for object dtype
+    uniques = np.array(["a", "b", "c"], dtype=object)
+    values = np.array(["a", "b", "c", "d"], dtype=object)
+    with pytest.raises(ValueError, match="y contains previously unseen labels"):
+        _encode(values, uniques=uniques, check_unknown=False)
+
+
+def _assert_check_unknown(values, uniques, expected_diff, expected_mask):
+    diff = _check_unknown(values, uniques)
+    assert_array_equal(diff, expected_diff)
+
+    diff, valid_mask = _check_unknown(values, uniques, return_mask=True)
+    assert_array_equal(diff, expected_diff)
+    assert_array_equal(valid_mask, expected_mask)
+
+
+@pytest.mark.parametrize(
+    "values, uniques, expected_diff, expected_mask",
+    [
+        (np.array([1, 2, 3, 4]), np.array([1, 2, 3]), [4], [True, True, True, False]),
+        (np.array([2, 1, 4, 5]), np.array([2, 5, 1]), [4], [True, True, False, True]),
+        (np.array([2, 1, np.nan]), np.array([2, 5, 1]), [np.nan], [True, True, False]),
+        (
+            np.array([2, 1, 4, np.nan]),
+            np.array([2, 5, 1, np.nan]),
+            [4],
+            [True, True, False, True],
+        ),
+        (
+            np.array([2, 1, 4, np.nan]),
+            np.array([2, 5, 1]),
+            [4, np.nan],
+            [True, True, False, False],
+        ),
+        (
+            np.array([2, 1, 4, 5]),
+            np.array([2, 5, 1, np.nan]),
+            [4],
+            [True, True, False, True],
+        ),
+        (
+            np.array(["a", "b", "c", "d"], dtype=object),
+            np.array(["a", "b", "c"], dtype=object),
+            np.array(["d"], dtype=object),
+            [True, True, True, False],
+        ),
+        (
+            np.array(["d", "c", "a", "b"], dtype=object),
+            np.array(["a", "c", "b"], dtype=object),
+            np.array(["d"], dtype=object),
+            [False, True, True, True],
+        ),
+        (
+            np.array(["a", "b", "c", "d"]),
+            np.array(["a", "b", "c"]),
+            np.array(["d"]),
+            [True, True, True, False],
+        ),
+        (
+            np.array(["d", "c", "a", "b"]),
+            np.array(["a", "c", "b"]),
+            np.array(["d"]),
+            [False, True, True, True],
+        ),
+    ],
+)
+def test_check_unknown(values, uniques, expected_diff, expected_mask):
+    _assert_check_unknown(values, uniques, expected_diff, expected_mask)
+
+
+@pytest.mark.parametrize("missing_value", [None, np.nan, float("nan")])
+@pytest.mark.parametrize("pickle_uniques", [True, False])
+def test_check_unknown_missing_values(missing_value, pickle_uniques):
+    # check for check_unknown with missing values with object dtypes
+    values = np.array(["d", "c", "a", "b", missing_value], dtype=object)
+    uniques = np.array(["c", "a", "b", missing_value], dtype=object)
+    if pickle_uniques:
+        uniques = pickle.loads(pickle.dumps(uniques))
+
+    expected_diff = ["d"]
+    expected_mask = [False, True, True, True, True]
+    _assert_check_unknown(values, uniques, expected_diff, expected_mask)
+
+    values = np.array(["d", "c", "a", "b", missing_value], dtype=object)
+    uniques = np.array(["c", "a", "b"], dtype=object)
+    if pickle_uniques:
+        uniques = pickle.loads(pickle.dumps(uniques))
+
+    expected_diff = ["d", missing_value]
+
+    expected_mask = [False, True, True, True, False]
+    _assert_check_unknown(values, uniques, expected_diff, expected_mask)
+
+    values = np.array(["a", missing_value], dtype=object)
+    uniques = np.array(["a", "b", "z"], dtype=object)
+    if pickle_uniques:
+        uniques = pickle.loads(pickle.dumps(uniques))
+
+    expected_diff = [missing_value]
+    expected_mask = [True, False]
+    _assert_check_unknown(values, uniques, expected_diff, expected_mask)
+
+
+@pytest.mark.parametrize("missing_value", [np.nan, None, float("nan")])
+@pytest.mark.parametrize("pickle_uniques", [True, False])
+def test_unique_util_missing_values_objects(missing_value, pickle_uniques):
+    # check for _unique and _encode with missing values with object dtypes
+    values = np.array(["a", "c", "c", missing_value, "b"], dtype=object)
+    expected_uniques = np.array(["a", "b", "c", missing_value], dtype=object)
+
+    uniques = _unique(values)
+
+    if missing_value is None:
+        assert_array_equal(uniques, expected_uniques)
+    else:  # missing_value == np.nan
+        assert_array_equal(uniques[:-1], expected_uniques[:-1])
+        assert np.isnan(uniques[-1])
+
+    if pickle_uniques:
+        uniques = pickle.loads(pickle.dumps(uniques))
+
+    encoded = _encode(values, uniques=uniques)
+    assert_array_equal(encoded, np.array([0, 2, 2, 3, 1]))
+
+
+def test_unique_util_missing_values_numeric():
+    # Check missing values in numerical values
+    values = np.array([3, 1, np.nan, 5, 3, np.nan], dtype=float)
+    expected_uniques = np.array([1, 3, 5, np.nan], dtype=float)
+    expected_inverse = np.array([1, 0, 3, 2, 1, 3])
+
+    uniques = _unique(values)
+    assert_array_equal(uniques, expected_uniques)
+
+    uniques, inverse = _unique(values, return_inverse=True)
+    assert_array_equal(uniques, expected_uniques)
+    assert_array_equal(inverse, expected_inverse)
+
+    encoded = _encode(values, uniques=uniques)
+    assert_array_equal(encoded, expected_inverse)
+
+
+def test_unique_util_with_all_missing_values():
+    # test for all types of missing values for object dtype
+    values = np.array([np.nan, "a", "c", "c", None, float("nan"), None], dtype=object)
+
+    uniques = _unique(values)
+    assert_array_equal(uniques[:-1], ["a", "c", None])
+    # last value is nan
+    assert np.isnan(uniques[-1])
+
+    expected_inverse = [3, 0, 1, 1, 2, 3, 2]
+    _, inverse = _unique(values, return_inverse=True)
+    assert_array_equal(inverse, expected_inverse)
+
+
+def test_check_unknown_with_both_missing_values():
+    # test for both types of missing values for object dtype
+    values = np.array([np.nan, "a", "c", "c", None, np.nan, None], dtype=object)
+
+    diff = _check_unknown(values, known_values=np.array(["a", "c"], dtype=object))
+    assert diff[0] is None
+    assert np.isnan(diff[1])
+
+    diff, valid_mask = _check_unknown(
+        values, known_values=np.array(["a", "c"], dtype=object), return_mask=True
+    )
+
+    assert diff[0] is None
+    assert np.isnan(diff[1])
+    assert_array_equal(valid_mask, [False, True, True, True, False, False, False])
+
+
+@pytest.mark.parametrize(
+    "values, uniques, expected_counts",
+    [
+        (np.array([1] * 10 + [2] * 4 + [3] * 15), np.array([1, 2, 3]), [10, 4, 15]),
+        (
+            np.array([1] * 10 + [2] * 4 + [3] * 15),
+            np.array([1, 2, 3, 5]),
+            [10, 4, 15, 0],
+        ),
+        (
+            np.array([np.nan] * 10 + [2] * 4 + [3] * 15),
+            np.array([2, 3, np.nan]),
+            [4, 15, 10],
+        ),
+        (
+            np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object),
+            ["a", "b", "c"],
+            [16, 4, 20],
+        ),
+        (
+            np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object),
+            ["c", "b", "a"],
+            [20, 4, 16],
+        ),
+        (
+            np.array([np.nan] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object),
+            ["c", np.nan, "a"],
+            [20, 4, 16],
+        ),
+        (
+            np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object),
+            ["a", "b", "c", "e"],
+            [16, 4, 20, 0],
+        ),
+    ],
+)
+def test_get_counts(values, uniques, expected_counts):
+    counts = _get_counts(values, uniques)
+    assert_array_equal(counts, expected_counts)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_checks.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_checks.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd313d2397a0f467d46cf9cdbae63777c17c99df
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_checks.py
@@ -0,0 +1,1665 @@
+# We can not use pytest here, because we run
+# build_tools/azure/test_pytest_soft_dependency.sh on these
+# tests to make sure estimator_checks works without pytest.
+
+import importlib
+import re
+import sys
+import unittest
+import warnings
+from inspect import isgenerator
+from numbers import Integral, Real
+
+import joblib
+import numpy as np
+import scipy.sparse as sp
+
+from sklearn import config_context, get_config
+from sklearn.base import BaseEstimator, ClassifierMixin, OutlierMixin, TransformerMixin
+from sklearn.cluster import MiniBatchKMeans
+from sklearn.datasets import (
+    load_iris,
+    make_multilabel_classification,
+)
+from sklearn.decomposition import PCA
+from sklearn.exceptions import (
+    ConvergenceWarning,
+    EstimatorCheckFailedWarning,
+    SkipTestWarning,
+)
+from sklearn.linear_model import (
+    LinearRegression,
+    LogisticRegression,
+    MultiTaskElasticNet,
+    SGDClassifier,
+)
+from sklearn.mixture import GaussianMixture
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVC, NuSVC
+from sklearn.utils import _array_api, all_estimators, deprecated
+from sklearn.utils._param_validation import Interval, StrOptions
+from sklearn.utils._test_common.instance_generator import (
+    _construct_instances,
+    _get_expected_failed_checks,
+)
+from sklearn.utils._testing import (
+    MinimalClassifier,
+    MinimalRegressor,
+    MinimalTransformer,
+    SkipTest,
+    ignore_warnings,
+    raises,
+)
+from sklearn.utils.estimator_checks import (
+    _check_name,
+    _NotAnArray,
+    _yield_all_checks,
+    check_array_api_input,
+    check_class_weight_balanced_linear_classifier,
+    check_classifier_data_not_an_array,
+    check_classifier_not_supporting_multiclass,
+    check_classifiers_multilabel_output_format_decision_function,
+    check_classifiers_multilabel_output_format_predict,
+    check_classifiers_multilabel_output_format_predict_proba,
+    check_classifiers_one_label_sample_weights,
+    check_dataframe_column_names_consistency,
+    check_decision_proba_consistency,
+    check_dict_unchanged,
+    check_dont_overwrite_parameters,
+    check_estimator,
+    check_estimator_cloneable,
+    check_estimator_repr,
+    check_estimator_sparse_array,
+    check_estimator_sparse_matrix,
+    check_estimator_sparse_tag,
+    check_estimator_tags_renamed,
+    check_estimators_nan_inf,
+    check_estimators_overwrite_params,
+    check_estimators_unfitted,
+    check_fit_check_is_fitted,
+    check_fit_score_takes_y,
+    check_methods_sample_order_invariance,
+    check_methods_subset_invariance,
+    check_mixin_order,
+    check_no_attributes_set_in_init,
+    check_outlier_contamination,
+    check_outlier_corruption,
+    check_parameters_default_constructible,
+    check_positive_only_tag_during_fit,
+    check_regressor_data_not_an_array,
+    check_requires_y_none,
+    check_sample_weights_pandas_series,
+    check_set_params,
+    estimator_checks_generator,
+    set_random_state,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS, SPARRAY_PRESENT
+from sklearn.utils.metaestimators import available_if
+from sklearn.utils.multiclass import type_of_target
+from sklearn.utils.validation import (
+    check_array,
+    check_is_fitted,
+    check_X_y,
+    validate_data,
+)
+
+
+class CorrectNotFittedError(ValueError):
+    """Exception class to raise if estimator is used before fitting.
+
+    Like NotFittedError, it inherits from ValueError, but not from
+    AttributeError. Used for testing only.
+    """
+
+
+class BaseBadClassifier(ClassifierMixin, BaseEstimator):
+    def fit(self, X, y):
+        return self
+
+    def predict(self, X):
+        return np.ones(X.shape[0])
+
+
+class ChangesDict(BaseEstimator):
+    def __init__(self, key=0):
+        self.key = key
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+    def predict(self, X):
+        X = check_array(X)
+        self.key = 1000
+        return np.ones(X.shape[0])
+
+
+class SetsWrongAttribute(BaseEstimator):
+    def __init__(self, acceptable_key=0):
+        self.acceptable_key = acceptable_key
+
+    def fit(self, X, y=None):
+        self.wrong_attribute = 0
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class ChangesWrongAttribute(BaseEstimator):
+    def __init__(self, wrong_attribute=0):
+        self.wrong_attribute = wrong_attribute
+
+    def fit(self, X, y=None):
+        self.wrong_attribute = 1
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class ChangesUnderscoreAttribute(BaseEstimator):
+    def fit(self, X, y=None):
+        self._good_attribute = 1
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class RaisesErrorInSetParams(BaseEstimator):
+    def __init__(self, p=0):
+        self.p = p
+
+    def set_params(self, **kwargs):
+        if "p" in kwargs:
+            p = kwargs.pop("p")
+            if p < 0:
+                raise ValueError("p can't be less than 0")
+            self.p = p
+        return super().set_params(**kwargs)
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class HasMutableParameters(BaseEstimator):
+    def __init__(self, p=object()):
+        self.p = p
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class HasImmutableParameters(BaseEstimator):
+    # Note that object is an uninitialized class, thus immutable.
+    def __init__(self, p=42, q=np.int32(42), r=object):
+        self.p = p
+        self.q = q
+        self.r = r
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class ModifiesValueInsteadOfRaisingError(BaseEstimator):
+    def __init__(self, p=0):
+        self.p = p
+
+    def set_params(self, **kwargs):
+        if "p" in kwargs:
+            p = kwargs.pop("p")
+            if p < 0:
+                p = 0
+            self.p = p
+        return super().set_params(**kwargs)
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class ModifiesAnotherValue(BaseEstimator):
+    def __init__(self, a=0, b="method1"):
+        self.a = a
+        self.b = b
+
+    def set_params(self, **kwargs):
+        if "a" in kwargs:
+            a = kwargs.pop("a")
+            self.a = a
+            if a is None:
+                kwargs.pop("b")
+                self.b = "method2"
+        return super().set_params(**kwargs)
+
+    def fit(self, X, y=None):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class NoCheckinPredict(BaseBadClassifier):
+    def fit(self, X, y):
+        X, y = validate_data(self, X, y)
+        return self
+
+
+class NoSparseClassifier(BaseBadClassifier):
+    def __init__(self, raise_for_type=None):
+        # raise_for_type : str, expects "sparse_array" or "sparse_matrix"
+        self.raise_for_type = raise_for_type
+
+    def fit(self, X, y):
+        X, y = validate_data(self, X, y, accept_sparse=["csr", "csc"])
+        if self.raise_for_type == "sparse_array":
+            correct_type = isinstance(X, sp.sparray)
+        elif self.raise_for_type == "sparse_matrix":
+            correct_type = isinstance(X, sp.spmatrix)
+        if correct_type:
+            raise ValueError("Nonsensical Error")
+        return self
+
+    def predict(self, X):
+        X = check_array(X)
+        return np.ones(X.shape[0])
+
+
+class CorrectNotFittedErrorClassifier(BaseBadClassifier):
+    def fit(self, X, y):
+        X, y = validate_data(self, X, y)
+        self.coef_ = np.ones(X.shape[1])
+        return self
+
+    def predict(self, X):
+        check_is_fitted(self)
+        X = check_array(X)
+        return np.ones(X.shape[0])
+
+
+class NoSampleWeightPandasSeriesType(BaseEstimator):
+    def fit(self, X, y, sample_weight=None):
+        # Convert data
+        X, y = validate_data(
+            self, X, y, accept_sparse=("csr", "csc"), multi_output=True, y_numeric=True
+        )
+        # Function is only called after we verify that pandas is installed
+        from pandas import Series
+
+        if isinstance(sample_weight, Series):
+            raise ValueError(
+                "Estimator does not accept 'sample_weight'of type pandas.Series"
+            )
+        return self
+
+    def predict(self, X):
+        X = check_array(X)
+        return np.ones(X.shape[0])
+
+
+class BadBalancedWeightsClassifier(BaseBadClassifier):
+    def __init__(self, class_weight=None):
+        self.class_weight = class_weight
+
+    def fit(self, X, y):
+        from sklearn.preprocessing import LabelEncoder
+        from sklearn.utils import compute_class_weight
+
+        label_encoder = LabelEncoder().fit(y)
+        classes = label_encoder.classes_
+        class_weight = compute_class_weight(self.class_weight, classes=classes, y=y)
+
+        # Intentionally modify the balanced class_weight
+        # to simulate a bug and raise an exception
+        if self.class_weight == "balanced":
+            class_weight += 1.0
+
+        # Simply assigning coef_ to the class_weight
+        self.coef_ = class_weight
+        return self
+
+
+class BadTransformerWithoutMixin(BaseEstimator):
+    def fit(self, X, y=None):
+        X = validate_data(self, X)
+        return self
+
+    def transform(self, X):
+        check_is_fitted(self)
+        X = validate_data(self, X, reset=False)
+        return X
+
+
+class NotInvariantPredict(BaseEstimator):
+    def fit(self, X, y):
+        # Convert data
+        X, y = validate_data(
+            self, X, y, accept_sparse=("csr", "csc"), multi_output=True, y_numeric=True
+        )
+        return self
+
+    def predict(self, X):
+        # return 1 if X has more than one element else return 0
+        X = check_array(X)
+        if X.shape[0] > 1:
+            return np.ones(X.shape[0])
+        return np.zeros(X.shape[0])
+
+
+class NotInvariantSampleOrder(BaseEstimator):
+    def fit(self, X, y):
+        X, y = validate_data(
+            self, X, y, accept_sparse=("csr", "csc"), multi_output=True, y_numeric=True
+        )
+        # store the original X to check for sample order later
+        self._X = X
+        return self
+
+    def predict(self, X):
+        X = check_array(X)
+        # if the input contains the same elements but different sample order,
+        # then just return zeros.
+        if (
+            np.array_equiv(np.sort(X, axis=0), np.sort(self._X, axis=0))
+            and (X != self._X).any()
+        ):
+            return np.zeros(X.shape[0])
+        return X[:, 0]
+
+
+class OneClassSampleErrorClassifier(BaseBadClassifier):
+    """Classifier allowing to trigger different behaviors when `sample_weight` reduces
+    the number of classes to 1."""
+
+    def __init__(self, raise_when_single_class=False):
+        self.raise_when_single_class = raise_when_single_class
+
+    def fit(self, X, y, sample_weight=None):
+        X, y = check_X_y(
+            X, y, accept_sparse=("csr", "csc"), multi_output=True, y_numeric=True
+        )
+
+        self.has_single_class_ = False
+        self.classes_, y = np.unique(y, return_inverse=True)
+        n_classes_ = self.classes_.shape[0]
+        if n_classes_ < 2 and self.raise_when_single_class:
+            self.has_single_class_ = True
+            raise ValueError("normal class error")
+
+        # find the number of class after trimming
+        if sample_weight is not None:
+            if isinstance(sample_weight, np.ndarray) and len(sample_weight) > 0:
+                n_classes_ = np.count_nonzero(np.bincount(y, sample_weight))
+            if n_classes_ < 2:
+                self.has_single_class_ = True
+                raise ValueError("Nonsensical Error")
+
+        return self
+
+    def predict(self, X):
+        check_is_fitted(self)
+        X = check_array(X)
+        if self.has_single_class_:
+            return np.zeros(X.shape[0])
+        return np.ones(X.shape[0])
+
+
+class LargeSparseNotSupportedClassifier(BaseEstimator):
+    """Estimator that claims to support large sparse data
+    (accept_large_sparse=True), but doesn't"""
+
+    def __init__(self, raise_for_type=None):
+        # raise_for_type : str, expects "sparse_array" or "sparse_matrix"
+        self.raise_for_type = raise_for_type
+
+    def fit(self, X, y):
+        X, y = validate_data(
+            self,
+            X,
+            y,
+            accept_sparse=("csr", "csc", "coo"),
+            accept_large_sparse=True,
+            multi_output=True,
+            y_numeric=True,
+        )
+        if self.raise_for_type == "sparse_array":
+            correct_type = isinstance(X, sp.sparray)
+        elif self.raise_for_type == "sparse_matrix":
+            correct_type = isinstance(X, sp.spmatrix)
+        if correct_type:
+            if X.format == "coo":
+                if X.row.dtype == "int64" or X.col.dtype == "int64":
+                    raise ValueError("Estimator doesn't support 64-bit indices")
+            elif X.format in ["csc", "csr"]:
+                assert "int64" not in (
+                    X.indices.dtype,
+                    X.indptr.dtype,
+                ), "Estimator doesn't support 64-bit indices"
+
+        return self
+
+
+class SparseTransformer(TransformerMixin, BaseEstimator):
+    def __init__(self, sparse_container=None):
+        self.sparse_container = sparse_container
+
+    def fit(self, X, y=None):
+        validate_data(self, X)
+        return self
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y).transform(X)
+
+    def transform(self, X):
+        check_is_fitted(self)
+        X = validate_data(self, X, accept_sparse=True, reset=False)
+        return self.sparse_container(X)
+
+
+class EstimatorInconsistentForPandas(BaseEstimator):
+    def fit(self, X, y):
+        try:
+            from pandas import DataFrame
+
+            if isinstance(X, DataFrame):
+                self.value_ = X.iloc[0, 0]
+            else:
+                X = check_array(X)
+                self.value_ = X[1, 0]
+            return self
+
+        except ImportError:
+            X = check_array(X)
+            self.value_ = X[1, 0]
+            return self
+
+    def predict(self, X):
+        X = check_array(X)
+        return np.array([self.value_] * X.shape[0])
+
+
+class UntaggedBinaryClassifier(SGDClassifier):
+    # Toy classifier that only supports binary classification, will fail tests.
+    def fit(self, X, y, coef_init=None, intercept_init=None, sample_weight=None):
+        super().fit(X, y, coef_init, intercept_init, sample_weight)
+        if len(self.classes_) > 2:
+            raise ValueError("Only 2 classes are supported")
+        return self
+
+    def partial_fit(self, X, y, classes=None, sample_weight=None):
+        super().partial_fit(X=X, y=y, classes=classes, sample_weight=sample_weight)
+        if len(self.classes_) > 2:
+            raise ValueError("Only 2 classes are supported")
+        return self
+
+
+class TaggedBinaryClassifier(UntaggedBinaryClassifier):
+    def fit(self, X, y):
+        y_type = type_of_target(y, input_name="y", raise_unknown=True)
+        if y_type != "binary":
+            raise ValueError(
+                "Only binary classification is supported. The type of the target "
+                f"is {y_type}."
+            )
+        return super().fit(X, y)
+
+    # Toy classifier that only supports binary classification.
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.multi_class = False
+        return tags
+
+
+class RequiresPositiveXRegressor(LinearRegression):
+    def fit(self, X, y):
+        # reject sparse X to be able to call (X < 0).any()
+        X, y = validate_data(self, X, y, accept_sparse=False, multi_output=True)
+        if (X < 0).any():
+            raise ValueError("Negative values in data passed to X.")
+        return super().fit(X, y)
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.input_tags.positive_only = True
+        # reject sparse X to be able to call (X < 0).any()
+        tags.input_tags.sparse = False
+        return tags
+
+
+class RequiresPositiveYRegressor(LinearRegression):
+    def fit(self, X, y):
+        X, y = validate_data(self, X, y, accept_sparse=True, multi_output=True)
+        if (y <= 0).any():
+            raise ValueError("negative y values not supported!")
+        return super().fit(X, y)
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.target_tags.positive_only = True
+        return tags
+
+
+class PoorScoreLogisticRegression(LogisticRegression):
+    def decision_function(self, X):
+        return super().decision_function(X) + 1
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.poor_score = True
+        return tags
+
+
+class PartialFitChecksName(BaseEstimator):
+    def fit(self, X, y):
+        validate_data(self, X, y)
+        return self
+
+    def partial_fit(self, X, y):
+        reset = not hasattr(self, "_fitted")
+        validate_data(self, X, y, reset=reset)
+        self._fitted = True
+        return self
+
+
+class BrokenArrayAPI(BaseEstimator):
+    """Make different predictions when using Numpy and the Array API"""
+
+    def fit(self, X, y):
+        return self
+
+    def predict(self, X):
+        enabled = get_config()["array_api_dispatch"]
+        xp, _ = _array_api.get_namespace(X)
+        if enabled:
+            return xp.asarray([1, 2, 3])
+        else:
+            return np.array([3, 2, 1])
+
+
+def test_check_array_api_input():
+    try:
+        importlib.import_module("array_api_strict")
+    except ModuleNotFoundError:  # pragma: nocover
+        raise SkipTest("array-api-strict is required to run this test")
+
+    with raises(AssertionError, match="Not equal to tolerance"):
+        check_array_api_input(
+            "BrokenArrayAPI",
+            BrokenArrayAPI(),
+            array_namespace="array_api_strict",
+            check_values=True,
+        )
+
+
+def test_not_an_array_array_function():
+    not_array = _NotAnArray(np.ones(10))
+    msg = "Don't want to call array_function sum!"
+    with raises(TypeError, match=msg):
+        np.sum(not_array)
+    # always returns True
+    assert np.may_share_memory(not_array, None)
+
+
+def test_check_fit_score_takes_y_works_on_deprecated_fit():
+    # Tests that check_fit_score_takes_y works on a class with
+    # a deprecated fit method
+
+    class TestEstimatorWithDeprecatedFitMethod(BaseEstimator):
+        @deprecated("Deprecated for the purpose of testing check_fit_score_takes_y")
+        def fit(self, X, y):
+            return self
+
+    check_fit_score_takes_y("test", TestEstimatorWithDeprecatedFitMethod())
+
+
+def test_check_estimator_with_class_removed():
+    """Test that passing a class instead of an instance fails."""
+    msg = "Passing a class was deprecated"
+    with raises(TypeError, match=msg):
+        check_estimator(LogisticRegression)
+
+
+def test_mutable_default_params():
+    """Test that constructor cannot have mutable default parameters."""
+    msg = (
+        "Parameter 'p' of estimator 'HasMutableParameters' is of type "
+        "object which is not allowed"
+    )
+    # check that the "default_constructible" test checks for mutable parameters
+    check_parameters_default_constructible(
+        "Immutable", HasImmutableParameters()
+    )  # should pass
+    with raises(AssertionError, match=msg):
+        check_parameters_default_constructible("Mutable", HasMutableParameters())
+
+
+def test_check_set_params():
+    """Check set_params doesn't fail and sets the right values."""
+    # check that values returned by get_params match set_params
+    msg = "get_params result does not match what was passed to set_params"
+    with raises(AssertionError, match=msg):
+        check_set_params("test", ModifiesValueInsteadOfRaisingError())
+
+    with warnings.catch_warnings(record=True) as records:
+        check_set_params("test", RaisesErrorInSetParams())
+    assert UserWarning in [rec.category for rec in records]
+
+    with raises(AssertionError, match=msg):
+        check_set_params("test", ModifiesAnotherValue())
+
+
+def test_check_estimators_nan_inf():
+    # check that predict does input validation (doesn't accept dicts in input)
+    msg = "Estimator NoCheckinPredict doesn't check for NaN and inf in predict"
+    with raises(AssertionError, match=msg):
+        check_estimators_nan_inf("NoCheckinPredict", NoCheckinPredict())
+
+
+def test_check_dict_unchanged():
+    # check that estimator state does not change
+    # at transform/predict/predict_proba time
+    msg = "Estimator changes __dict__ during predict"
+    with raises(AssertionError, match=msg):
+        check_dict_unchanged("test", ChangesDict())
+
+
+def test_check_sample_weights_pandas_series():
+    # check that sample_weights in fit accepts pandas.Series type
+    try:
+        from pandas import Series  # noqa: F401
+
+        msg = (
+            "Estimator NoSampleWeightPandasSeriesType raises error if "
+            "'sample_weight' parameter is of type pandas.Series"
+        )
+        with raises(ValueError, match=msg):
+            check_sample_weights_pandas_series(
+                "NoSampleWeightPandasSeriesType", NoSampleWeightPandasSeriesType()
+            )
+    except ImportError:
+        pass
+
+
+def test_check_estimators_overwrite_params():
+    # check that `fit` only changes attributes that
+    # are private (start with an _ or end with a _).
+    msg = (
+        "Estimator ChangesWrongAttribute should not change or mutate  "
+        "the parameter wrong_attribute from 0 to 1 during fit."
+    )
+    with raises(AssertionError, match=msg):
+        check_estimators_overwrite_params(
+            "ChangesWrongAttribute", ChangesWrongAttribute()
+        )
+    check_estimators_overwrite_params("test", ChangesUnderscoreAttribute())
+
+
+def test_check_dont_overwrite_parameters():
+    # check that `fit` doesn't add any public attribute
+    msg = (
+        r"Estimator adds public attribute\(s\) during the fit method."
+        " Estimators are only allowed to add private attributes"
+        " either started with _ or ended"
+        " with _ but wrong_attribute added"
+    )
+    with raises(AssertionError, match=msg):
+        check_dont_overwrite_parameters("test", SetsWrongAttribute())
+
+
+def test_check_methods_sample_order_invariance():
+    # check for sample order invariance
+    name = NotInvariantSampleOrder.__name__
+    method = "predict"
+    msg = (
+        "{method} of {name} is not invariant when applied to a dataset"
+        "with different sample order."
+    ).format(method=method, name=name)
+    with raises(AssertionError, match=msg):
+        check_methods_sample_order_invariance(
+            "NotInvariantSampleOrder", NotInvariantSampleOrder()
+        )
+
+
+def test_check_methods_subset_invariance():
+    # check for invariant method
+    name = NotInvariantPredict.__name__
+    method = "predict"
+    msg = ("{method} of {name} is not invariant when applied to a subset.").format(
+        method=method, name=name
+    )
+    with raises(AssertionError, match=msg):
+        check_methods_subset_invariance("NotInvariantPredict", NotInvariantPredict())
+
+
+def test_check_estimator_sparse_data():
+    # check for sparse data input handling
+    name = NoSparseClassifier.__name__
+    msg = "Estimator %s doesn't seem to fail gracefully on sparse data" % name
+    with raises(AssertionError, match=msg):
+        check_estimator_sparse_matrix(name, NoSparseClassifier("sparse_matrix"))
+
+    if SPARRAY_PRESENT:
+        with raises(AssertionError, match=msg):
+            check_estimator_sparse_array(name, NoSparseClassifier("sparse_array"))
+
+    # Large indices test on bad estimator
+    msg = (
+        "Estimator LargeSparseNotSupportedClassifier doesn't seem to "
+        r"support \S{3}_64 matrix, and is not failing gracefully.*"
+    )
+    with raises(AssertionError, match=msg):
+        check_estimator_sparse_matrix(
+            "LargeSparseNotSupportedClassifier",
+            LargeSparseNotSupportedClassifier("sparse_matrix"),
+        )
+
+    if SPARRAY_PRESENT:
+        with raises(AssertionError, match=msg):
+            check_estimator_sparse_array(
+                "LargeSparseNotSupportedClassifier",
+                LargeSparseNotSupportedClassifier("sparse_array"),
+            )
+
+
+def test_check_classifiers_one_label_sample_weights():
+    # check for classifiers reducing to less than two classes via sample weights
+    name = OneClassSampleErrorClassifier.__name__
+    msg = (
+        f"{name} failed when fitted on one label after sample_weight "
+        "trimming. Error message is not explicit, it should have "
+        "'class'."
+    )
+    with raises(AssertionError, match=msg):
+        check_classifiers_one_label_sample_weights(
+            "OneClassSampleErrorClassifier", OneClassSampleErrorClassifier()
+        )
+
+
+def test_check_estimator_not_fail_fast():
+    """Check the contents of the results returned with on_fail!="raise".
+
+    This results should contain details about the observed failures, expected
+    or not.
+    """
+    check_results = check_estimator(BaseEstimator(), on_fail=None)
+    assert isinstance(check_results, list)
+    assert len(check_results) > 0
+    assert all(
+        isinstance(item, dict)
+        and set(item.keys())
+        == {
+            "estimator",
+            "check_name",
+            "exception",
+            "status",
+            "expected_to_fail",
+            "expected_to_fail_reason",
+        }
+        for item in check_results
+    )
+    # Some tests are expected to fail, some are expected to pass.
+    assert any(item["status"] == "failed" for item in check_results)
+    assert any(item["status"] == "passed" for item in check_results)
+
+
+def test_check_estimator():
+    # tests that the estimator actually fails on "bad" estimators.
+    # not a complete test of all checks, which are very extensive.
+
+    # check that we have a fit method
+    msg = "object has no attribute 'fit'"
+    with raises(AttributeError, match=msg):
+        check_estimator(BaseEstimator())
+
+    # does error on binary_only untagged estimator
+    msg = "Only 2 classes are supported"
+    with raises(ValueError, match=msg):
+        check_estimator(UntaggedBinaryClassifier())
+
+    for csr_container in CSR_CONTAINERS:
+        # non-regression test for estimators transforming to sparse data
+        check_estimator(SparseTransformer(sparse_container=csr_container))
+
+    # doesn't error on actual estimator
+    check_estimator(LogisticRegression())
+    check_estimator(LogisticRegression(C=0.01))
+    check_estimator(MultiTaskElasticNet())
+
+    # doesn't error on binary_only tagged estimator
+    check_estimator(TaggedBinaryClassifier())
+    check_estimator(RequiresPositiveXRegressor())
+
+    # Check regressor with requires_positive_y estimator tag
+    msg = "negative y values not supported!"
+    with raises(ValueError, match=msg):
+        check_estimator(RequiresPositiveYRegressor())
+
+    # Does not raise error on classifier with poor_score tag
+    check_estimator(PoorScoreLogisticRegression())
+
+
+def test_check_outlier_corruption():
+    # should raise AssertionError
+    decision = np.array([0.0, 1.0, 1.5, 2.0])
+    with raises(AssertionError):
+        check_outlier_corruption(1, 2, decision)
+    # should pass
+    decision = np.array([0.0, 1.0, 1.0, 2.0])
+    check_outlier_corruption(1, 2, decision)
+
+
+def test_check_estimator_sparse_tag():
+    """Test that check_estimator_sparse_tag raises error when sparse tag is
+    misaligned."""
+
+    class EstimatorWithSparseConfig(BaseEstimator):
+        def __init__(self, tag_sparse, accept_sparse, fit_error=None):
+            self.tag_sparse = tag_sparse
+            self.accept_sparse = accept_sparse
+            self.fit_error = fit_error
+
+        def fit(self, X, y=None):
+            if self.fit_error:
+                raise self.fit_error
+            validate_data(self, X, y, accept_sparse=self.accept_sparse)
+            return self
+
+        def __sklearn_tags__(self):
+            tags = super().__sklearn_tags__()
+            tags.input_tags.sparse = self.tag_sparse
+            return tags
+
+    test_cases = [
+        {"tag_sparse": True, "accept_sparse": True, "error_type": None},
+        {"tag_sparse": False, "accept_sparse": False, "error_type": None},
+        {"tag_sparse": False, "accept_sparse": True, "error_type": AssertionError},
+        {"tag_sparse": True, "accept_sparse": False, "error_type": AssertionError},
+    ]
+
+    for test_case in test_cases:
+        estimator = EstimatorWithSparseConfig(
+            test_case["tag_sparse"],
+            test_case["accept_sparse"],
+        )
+        if test_case["error_type"] is None:
+            check_estimator_sparse_tag(estimator.__class__.__name__, estimator)
+        else:
+            with raises(test_case["error_type"]):
+                check_estimator_sparse_tag(estimator.__class__.__name__, estimator)
+
+    # estimator `tag_sparse=accept_sparse=False` fails on sparse data
+    # but does not raise the appropriate error
+    for fit_error in [TypeError("unexpected error"), KeyError("other error")]:
+        estimator = EstimatorWithSparseConfig(False, False, fit_error)
+        with raises(AssertionError):
+            check_estimator_sparse_tag(estimator.__class__.__name__, estimator)
+
+
+def test_check_estimator_transformer_no_mixin():
+    # check that TransformerMixin is not required for transformer tests to run
+    # but it fails since the tag is not set
+    with raises(RuntimeError, "the `transformer_tags` tag is not set"):
+        check_estimator(BadTransformerWithoutMixin())
+
+
+def test_check_estimator_clones():
+    # check that check_estimator doesn't modify the estimator it receives
+
+    iris = load_iris()
+
+    for Estimator in [
+        GaussianMixture,
+        LinearRegression,
+        SGDClassifier,
+        PCA,
+        MiniBatchKMeans,
+    ]:
+        # without fitting
+        with ignore_warnings(category=ConvergenceWarning):
+            est = Estimator()
+            set_random_state(est)
+            old_hash = joblib.hash(est)
+            check_estimator(
+                est, expected_failed_checks=_get_expected_failed_checks(est)
+            )
+        assert old_hash == joblib.hash(est)
+
+        # with fitting
+        with ignore_warnings(category=ConvergenceWarning):
+            est = Estimator()
+            set_random_state(est)
+            est.fit(iris.data, iris.target)
+            old_hash = joblib.hash(est)
+            check_estimator(
+                est, expected_failed_checks=_get_expected_failed_checks(est)
+            )
+        assert old_hash == joblib.hash(est)
+
+
+def test_check_estimators_unfitted():
+    # check that a ValueError/AttributeError is raised when calling predict
+    # on an unfitted estimator
+    msg = "Estimator should raise a NotFittedError when calling"
+    with raises(AssertionError, match=msg):
+        check_estimators_unfitted("estimator", NoSparseClassifier())
+
+    # check that CorrectNotFittedError inherit from either ValueError
+    # or AttributeError
+    check_estimators_unfitted("estimator", CorrectNotFittedErrorClassifier())
+
+
+def test_check_no_attributes_set_in_init():
+    class NonConformantEstimatorPrivateSet(BaseEstimator):
+        def __init__(self):
+            self.you_should_not_set_this_ = None
+
+    class NonConformantEstimatorNoParamSet(BaseEstimator):
+        def __init__(self, you_should_set_this_=None):
+            pass
+
+    class ConformantEstimatorClassAttribute(BaseEstimator):
+        # making sure our __metadata_request__* class attributes are okay!
+        __metadata_request__fit = {"foo": True}
+
+    msg = (
+        "Estimator estimator_name should not set any"
+        " attribute apart from parameters during init."
+        r" Found attributes \['you_should_not_set_this_'\]."
+    )
+    with raises(AssertionError, match=msg):
+        check_no_attributes_set_in_init(
+            "estimator_name", NonConformantEstimatorPrivateSet()
+        )
+
+    msg = (
+        "Estimator estimator_name should store all parameters as an attribute"
+        " during init"
+    )
+    with raises(AttributeError, match=msg):
+        check_no_attributes_set_in_init(
+            "estimator_name", NonConformantEstimatorNoParamSet()
+        )
+
+    # a private class attribute is okay!
+    check_no_attributes_set_in_init(
+        "estimator_name", ConformantEstimatorClassAttribute()
+    )
+    # also check if cloning an estimator which has non-default set requests is
+    # fine. Setting a non-default value via `set_{method}_request` sets the
+    # private _metadata_request instance attribute which is copied in `clone`.
+    with config_context(enable_metadata_routing=True):
+        check_no_attributes_set_in_init(
+            "estimator_name",
+            ConformantEstimatorClassAttribute().set_fit_request(foo=True),
+        )
+
+
+def test_check_estimator_pairwise():
+    # check that check_estimator() works on estimator with _pairwise
+    # kernel or metric
+
+    # test precomputed kernel
+    est = SVC(kernel="precomputed")
+    check_estimator(est)
+
+    # test precomputed metric
+    est = KNeighborsRegressor(metric="precomputed")
+    check_estimator(est, expected_failed_checks=_get_expected_failed_checks(est))
+
+
+def test_check_classifier_data_not_an_array():
+    with raises(AssertionError, match="Not equal to tolerance"):
+        check_classifier_data_not_an_array(
+            "estimator_name", EstimatorInconsistentForPandas()
+        )
+
+
+def test_check_regressor_data_not_an_array():
+    with raises(AssertionError, match="Not equal to tolerance"):
+        check_regressor_data_not_an_array(
+            "estimator_name", EstimatorInconsistentForPandas()
+        )
+
+
+def test_check_dataframe_column_names_consistency():
+    err_msg = "Estimator does not have a feature_names_in_"
+    with raises(ValueError, match=err_msg):
+        check_dataframe_column_names_consistency("estimator_name", BaseBadClassifier())
+    check_dataframe_column_names_consistency("estimator_name", PartialFitChecksName())
+
+    lr = LogisticRegression()
+    check_dataframe_column_names_consistency(lr.__class__.__name__, lr)
+    lr.__doc__ = "Docstring that does not document the estimator's attributes"
+    err_msg = (
+        "Estimator LogisticRegression does not document its feature_names_in_ attribute"
+    )
+    with raises(ValueError, match=err_msg):
+        check_dataframe_column_names_consistency(lr.__class__.__name__, lr)
+
+
+class _BaseMultiLabelClassifierMock(ClassifierMixin, BaseEstimator):
+    def __init__(self, response_output):
+        self.response_output = response_output
+
+    def fit(self, X, y):
+        return self
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.multi_label = True
+        return tags
+
+
+def test_check_classifiers_multilabel_output_format_predict():
+    n_samples, test_size, n_outputs = 100, 25, 5
+    _, y = make_multilabel_classification(
+        n_samples=n_samples,
+        n_features=2,
+        n_classes=n_outputs,
+        n_labels=3,
+        length=50,
+        allow_unlabeled=True,
+        random_state=0,
+    )
+    y_test = y[-test_size:]
+
+    class MultiLabelClassifierPredict(_BaseMultiLabelClassifierMock):
+        def predict(self, X):
+            return self.response_output
+
+    # 1. inconsistent array type
+    clf = MultiLabelClassifierPredict(response_output=y_test.tolist())
+    err_msg = (
+        r"MultiLabelClassifierPredict.predict is expected to output a "
+        r"NumPy array. Got <class 'list'> instead."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict(clf.__class__.__name__, clf)
+    # 2. inconsistent shape
+    clf = MultiLabelClassifierPredict(response_output=y_test[:, :-1])
+    err_msg = (
+        r"MultiLabelClassifierPredict.predict outputs a NumPy array of "
+        r"shape \(25, 4\) instead of \(25, 5\)."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict(clf.__class__.__name__, clf)
+    # 3. inconsistent dtype
+    clf = MultiLabelClassifierPredict(response_output=y_test.astype(np.float64))
+    err_msg = (
+        r"MultiLabelClassifierPredict.predict does not output the same "
+        r"dtype than the targets."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict(clf.__class__.__name__, clf)
+
+
+def test_check_classifiers_multilabel_output_format_predict_proba():
+    n_samples, test_size, n_outputs = 100, 25, 5
+    _, y = make_multilabel_classification(
+        n_samples=n_samples,
+        n_features=2,
+        n_classes=n_outputs,
+        n_labels=3,
+        length=50,
+        allow_unlabeled=True,
+        random_state=0,
+    )
+    y_test = y[-test_size:]
+
+    class MultiLabelClassifierPredictProba(_BaseMultiLabelClassifierMock):
+        def predict_proba(self, X):
+            return self.response_output
+
+    for csr_container in CSR_CONTAINERS:
+        # 1. unknown output type
+        clf = MultiLabelClassifierPredictProba(response_output=csr_container(y_test))
+        err_msg = (
+            f"Unknown returned type .*{csr_container.__name__}.* by "
+            r"MultiLabelClassifierPredictProba.predict_proba. A list or a Numpy "
+            r"array is expected."
+        )
+        with raises(ValueError, match=err_msg):
+            check_classifiers_multilabel_output_format_predict_proba(
+                clf.__class__.__name__,
+                clf,
+            )
+    # 2. for list output
+    # 2.1. inconsistent length
+    clf = MultiLabelClassifierPredictProba(response_output=y_test.tolist())
+    err_msg = (
+        "When MultiLabelClassifierPredictProba.predict_proba returns a list, "
+        "the list should be of length n_outputs and contain NumPy arrays. Got "
+        f"length of {test_size} instead of {n_outputs}."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 2.2. array of inconsistent shape
+    response_output = [np.ones_like(y_test) for _ in range(n_outputs)]
+    clf = MultiLabelClassifierPredictProba(response_output=response_output)
+    err_msg = (
+        r"When MultiLabelClassifierPredictProba.predict_proba returns a list, "
+        r"this list should contain NumPy arrays of shape \(n_samples, 2\). Got "
+        r"NumPy arrays of shape \(25, 5\) instead of \(25, 2\)."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 2.3. array of inconsistent dtype
+    response_output = [
+        np.ones(shape=(y_test.shape[0], 2), dtype=np.int64) for _ in range(n_outputs)
+    ]
+    clf = MultiLabelClassifierPredictProba(response_output=response_output)
+    err_msg = (
+        "When MultiLabelClassifierPredictProba.predict_proba returns a list, "
+        "it should contain NumPy arrays with floating dtype."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 2.4. array does not contain probability (each row should sum to 1)
+    response_output = [
+        np.ones(shape=(y_test.shape[0], 2), dtype=np.float64) for _ in range(n_outputs)
+    ]
+    clf = MultiLabelClassifierPredictProba(response_output=response_output)
+    err_msg = (
+        r"When MultiLabelClassifierPredictProba.predict_proba returns a list, "
+        r"each NumPy array should contain probabilities for each class and "
+        r"thus each row should sum to 1"
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 3 for array output
+    # 3.1. array of inconsistent shape
+    clf = MultiLabelClassifierPredictProba(response_output=y_test[:, :-1])
+    err_msg = (
+        r"When MultiLabelClassifierPredictProba.predict_proba returns a NumPy "
+        r"array, the expected shape is \(n_samples, n_outputs\). Got \(25, 4\)"
+        r" instead of \(25, 5\)."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 3.2. array of inconsistent dtype
+    response_output = np.zeros_like(y_test, dtype=np.int64)
+    clf = MultiLabelClassifierPredictProba(response_output=response_output)
+    err_msg = (
+        r"When MultiLabelClassifierPredictProba.predict_proba returns a NumPy "
+        r"array, the expected data type is floating."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 4. array does not contain probabilities
+    clf = MultiLabelClassifierPredictProba(response_output=y_test * 2.0)
+    err_msg = (
+        r"When MultiLabelClassifierPredictProba.predict_proba returns a NumPy "
+        r"array, this array is expected to provide probabilities of the "
+        r"positive class and should therefore contain values between 0 and 1."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_predict_proba(
+            clf.__class__.__name__,
+            clf,
+        )
+
+
+def test_check_classifiers_multilabel_output_format_decision_function():
+    n_samples, test_size, n_outputs = 100, 25, 5
+    _, y = make_multilabel_classification(
+        n_samples=n_samples,
+        n_features=2,
+        n_classes=n_outputs,
+        n_labels=3,
+        length=50,
+        allow_unlabeled=True,
+        random_state=0,
+    )
+    y_test = y[-test_size:]
+
+    class MultiLabelClassifierDecisionFunction(_BaseMultiLabelClassifierMock):
+        def decision_function(self, X):
+            return self.response_output
+
+    # 1. inconsistent array type
+    clf = MultiLabelClassifierDecisionFunction(response_output=y_test.tolist())
+    err_msg = (
+        r"MultiLabelClassifierDecisionFunction.decision_function is expected "
+        r"to output a NumPy array. Got <class 'list'> instead."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_decision_function(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 2. inconsistent shape
+    clf = MultiLabelClassifierDecisionFunction(response_output=y_test[:, :-1])
+    err_msg = (
+        r"MultiLabelClassifierDecisionFunction.decision_function is expected "
+        r"to provide a NumPy array of shape \(n_samples, n_outputs\). Got "
+        r"\(25, 4\) instead of \(25, 5\)"
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_decision_function(
+            clf.__class__.__name__,
+            clf,
+        )
+    # 3. inconsistent dtype
+    clf = MultiLabelClassifierDecisionFunction(response_output=y_test)
+    err_msg = (
+        r"MultiLabelClassifierDecisionFunction.decision_function is expected "
+        r"to output a floating dtype."
+    )
+    with raises(AssertionError, match=err_msg):
+        check_classifiers_multilabel_output_format_decision_function(
+            clf.__class__.__name__,
+            clf,
+        )
+
+
+def run_tests_without_pytest():
+    """Runs the tests in this file without using pytest."""
+    main_module = sys.modules["__main__"]
+    test_functions = [
+        getattr(main_module, name)
+        for name in dir(main_module)
+        if name.startswith("test_")
+    ]
+    test_cases = [unittest.FunctionTestCase(fn) for fn in test_functions]
+    suite = unittest.TestSuite()
+    suite.addTests(test_cases)
+    runner = unittest.TextTestRunner()
+    runner.run(suite)
+
+
+def test_check_class_weight_balanced_linear_classifier():
+    # check that ill-computed balanced weights raises an exception
+    msg = "Classifier estimator_name is not computing class_weight=balanced properly"
+    with raises(AssertionError, match=msg):
+        check_class_weight_balanced_linear_classifier(
+            "estimator_name", BadBalancedWeightsClassifier()
+        )
+
+
+def test_all_estimators_all_public():
+    # all_estimator should not fail when pytest is not installed and return
+    # only public estimators
+    with warnings.catch_warnings(record=True) as record:
+        estimators = all_estimators()
+    # no warnings are raised
+    assert not record
+    for est in estimators:
+        assert not est.__class__.__name__.startswith("_")
+
+
+if __name__ == "__main__":
+    # This module is run as a script to check that we have no dependency on
+    # pytest for estimator checks.
+    run_tests_without_pytest()
+
+
+def test_estimator_checks_generator_skipping_tests():
+    # Make sure the checks generator skips tests that are expected to fail
+    est = next(_construct_instances(NuSVC))
+    expected_to_fail = _get_expected_failed_checks(est)
+    checks = estimator_checks_generator(
+        est, legacy=True, expected_failed_checks=expected_to_fail, mark="skip"
+    )
+    # making sure we use a class that has expected failures
+    assert len(expected_to_fail) > 0
+    skipped_checks = []
+    for estimator, check in checks:
+        try:
+            check(estimator)
+        except SkipTest:
+            skipped_checks.append(_check_name(check))
+    # all checks expected to fail are skipped
+    # some others might also be skipped, if their dependencies are not installed.
+    assert set(expected_to_fail.keys()) <= set(skipped_checks)
+
+
+def test_xfail_count_with_no_fast_fail():
+    """Test that the right number of xfail warnings are raised when on_fail is "warn".
+
+    It also checks the number of raised EstimatorCheckFailedWarning, and checks the
+    output of check_estimator.
+    """
+    est = NuSVC()
+    expected_failed_checks = _get_expected_failed_checks(est)
+    # This is to make sure we test a class that has some expected failures
+    assert len(expected_failed_checks) > 0
+    with warnings.catch_warnings(record=True) as records:
+        logs = check_estimator(
+            est,
+            expected_failed_checks=expected_failed_checks,
+            on_fail="warn",
+        )
+    xfail_warns = [w for w in records if w.category != SkipTestWarning]
+    assert all([rec.category == EstimatorCheckFailedWarning for rec in xfail_warns])
+    assert len(xfail_warns) == len(expected_failed_checks)
+
+    xfailed = [log for log in logs if log["status"] == "xfail"]
+    assert len(xfailed) == len(expected_failed_checks)
+
+
+def test_check_estimator_callback():
+    """Test that the callback is called with the right arguments."""
+    call_count = {"xfail": 0, "skipped": 0, "passed": 0, "failed": 0}
+
+    def callback(
+        *,
+        estimator,
+        check_name,
+        exception,
+        status,
+        expected_to_fail,
+        expected_to_fail_reason,
+    ):
+        assert status in ("xfail", "skipped", "passed", "failed")
+        nonlocal call_count
+        call_count[status] += 1
+
+    est = NuSVC()
+    expected_failed_checks = _get_expected_failed_checks(est)
+    # This is to make sure we test a class that has some expected failures
+    assert len(expected_failed_checks) > 0
+    with warnings.catch_warnings(record=True):
+        check_estimator(
+            est,
+            expected_failed_checks=expected_failed_checks,
+            on_fail=None,
+            callback=callback,
+        )
+    all_checks_count = len(list(estimator_checks_generator(est, legacy=True)))
+    assert call_count["xfail"] == len(expected_failed_checks)
+    assert call_count["passed"] > 0
+    assert call_count["failed"] == 0
+    assert call_count["skipped"] == (
+        all_checks_count - call_count["xfail"] - call_count["passed"]
+    )
+
+
+# FIXME: this test should be uncommented when the checks will be granular
+# enough. In 0.24, these tests fail due to low estimator performance.
+def test_minimal_class_implementation_checks():
+    # Check that third-party library can run tests without inheriting from
+    # BaseEstimator.
+    # FIXME
+    raise SkipTest
+    minimal_estimators = [MinimalTransformer(), MinimalRegressor(), MinimalClassifier()]
+    for estimator in minimal_estimators:
+        check_estimator(estimator)
+
+
+def test_check_fit_check_is_fitted():
+    class Estimator(BaseEstimator):
+        def __init__(self, behavior="attribute"):
+            self.behavior = behavior
+
+        def fit(self, X, y, **kwargs):
+            if self.behavior == "attribute":
+                self.is_fitted_ = True
+            elif self.behavior == "method":
+                self._is_fitted = True
+            return self
+
+        @available_if(lambda self: self.behavior in {"method", "always-true"})
+        def __sklearn_is_fitted__(self):
+            if self.behavior == "always-true":
+                return True
+            return hasattr(self, "_is_fitted")
+
+    with raises(Exception, match="passes check_is_fitted before being fit"):
+        check_fit_check_is_fitted("estimator", Estimator(behavior="always-true"))
+
+    check_fit_check_is_fitted("estimator", Estimator(behavior="method"))
+    check_fit_check_is_fitted("estimator", Estimator(behavior="attribute"))
+
+
+def test_check_requires_y_none():
+    class Estimator(BaseEstimator):
+        def fit(self, X, y):
+            X, y = check_X_y(X, y)
+
+    with warnings.catch_warnings(record=True) as record:
+        check_requires_y_none("estimator", Estimator())
+
+    # no warnings are raised
+    assert not [r.message for r in record]
+
+
+def test_non_deterministic_estimator_skip_tests():
+    # check estimators with non_deterministic tag set to True
+    # will skip certain tests, refer to issue #22313 for details
+    for Estimator in [MinimalTransformer, MinimalRegressor, MinimalClassifier]:
+        all_tests = list(_yield_all_checks(Estimator(), legacy=True))
+        assert check_methods_sample_order_invariance in all_tests
+        assert check_methods_subset_invariance in all_tests
+
+        class MyEstimator(Estimator):
+            def __sklearn_tags__(self):
+                tags = super().__sklearn_tags__()
+                tags.non_deterministic = True
+                return tags
+
+        all_tests = list(_yield_all_checks(MyEstimator(), legacy=True))
+        assert check_methods_sample_order_invariance not in all_tests
+        assert check_methods_subset_invariance not in all_tests
+
+
+def test_check_outlier_contamination():
+    """Check the test for the contamination parameter in the outlier detectors."""
+
+    # Without any parameter constraints, the estimator will early exit the test by
+    # returning None.
+    class OutlierDetectorWithoutConstraint(OutlierMixin, BaseEstimator):
+        """Outlier detector without parameter validation."""
+
+        def __init__(self, contamination=0.1):
+            self.contamination = contamination
+
+        def fit(self, X, y=None, sample_weight=None):
+            return self  # pragma: no cover
+
+        def predict(self, X, y=None):
+            return np.ones(X.shape[0])
+
+    detector = OutlierDetectorWithoutConstraint()
+    assert check_outlier_contamination(detector.__class__.__name__, detector) is None
+
+    # Now, we check that with the parameter constraints, the test should only be valid
+    # if an Interval constraint with bound in [0, 1] is provided.
+    class OutlierDetectorWithConstraint(OutlierDetectorWithoutConstraint):
+        _parameter_constraints = {"contamination": [StrOptions({"auto"})]}
+
+    detector = OutlierDetectorWithConstraint()
+    err_msg = "contamination constraints should contain a Real Interval constraint."
+    with raises(AssertionError, match=err_msg):
+        check_outlier_contamination(detector.__class__.__name__, detector)
+
+    # Add a correct interval constraint and check that the test passes.
+    OutlierDetectorWithConstraint._parameter_constraints["contamination"] = [
+        Interval(Real, 0, 0.5, closed="right")
+    ]
+    detector = OutlierDetectorWithConstraint()
+    check_outlier_contamination(detector.__class__.__name__, detector)
+
+    incorrect_intervals = [
+        Interval(Integral, 0, 1, closed="right"),  # not an integral interval
+        Interval(Real, -1, 1, closed="right"),  # lower bound is negative
+        Interval(Real, 0, 2, closed="right"),  # upper bound is greater than 1
+        Interval(Real, 0, 0.5, closed="left"),  # lower bound include 0
+    ]
+
+    err_msg = r"contamination constraint should be an interval in \(0, 0.5\]"
+    for interval in incorrect_intervals:
+        OutlierDetectorWithConstraint._parameter_constraints["contamination"] = [
+            interval
+        ]
+        detector = OutlierDetectorWithConstraint()
+        with raises(AssertionError, match=err_msg):
+            check_outlier_contamination(detector.__class__.__name__, detector)
+
+
+def test_decision_proba_tie_ranking():
+    """Check that in case with some probabilities ties, we relax the
+    ranking comparison with the decision function.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/24025
+    """
+    estimator = SGDClassifier(loss="log_loss")
+    check_decision_proba_consistency("SGDClassifier", estimator)
+
+
+def test_yield_all_checks_legacy():
+    # Test that _yield_all_checks with legacy=True returns more checks.
+    estimator = MinimalClassifier()
+
+    legacy_checks = list(_yield_all_checks(estimator, legacy=True))
+    non_legacy_checks = list(_yield_all_checks(estimator, legacy=False))
+
+    assert len(legacy_checks) > len(non_legacy_checks)
+
+    def get_check_name(check):
+        try:
+            return check.__name__
+        except AttributeError:
+            return check.func.__name__
+
+    # Check that all non-legacy checks are included in legacy checks
+    non_legacy_check_names = {get_check_name(check) for check in non_legacy_checks}
+    legacy_check_names = {get_check_name(check) for check in legacy_checks}
+    assert non_legacy_check_names.issubset(legacy_check_names)
+
+
+def test_check_estimator_cloneable_error():
+    """Check that the right error is raised when the estimator is not cloneable."""
+
+    class NotCloneable(BaseEstimator):
+        def __sklearn_clone__(self):
+            raise NotImplementedError("This estimator is not cloneable.")
+
+    estimator = NotCloneable()
+    msg = "Cloning of .* failed with error"
+    with raises(AssertionError, match=msg):
+        check_estimator_cloneable("NotCloneable", estimator)
+
+
+def test_estimator_repr_error():
+    """Check that the right error is raised when the estimator does not have a repr."""
+
+    class NotRepr(BaseEstimator):
+        def __repr__(self):
+            raise NotImplementedError("This estimator does not have a repr.")
+
+    estimator = NotRepr()
+    msg = "Repr of .* failed with error"
+    with raises(AssertionError, match=msg):
+        check_estimator_repr("NotRepr", estimator)
+
+
+def test_check_estimator_tags_renamed():
+    class BadEstimator1:
+        def _more_tags(self):
+            return None  # pragma: no cover
+
+    class BadEstimator2:
+        def _get_tags(self):
+            return None  # pragma: no cover
+
+    class OkayEstimator:
+        def __sklearn_tags__(self):
+            return None  # pragma: no cover
+
+        def _more_tags(self):
+            return None  # pragma: no cover
+
+    msg = "has defined either `_more_tags` or `_get_tags`"
+    with raises(TypeError, match=msg):
+        check_estimator_tags_renamed("BadEstimator1", BadEstimator1())
+    with raises(TypeError, match=msg):
+        check_estimator_tags_renamed("BadEstimator2", BadEstimator2())
+
+    # This shouldn't fail since we allow both __sklearn_tags__ and _more_tags
+    # to exist so that third party estimators can easily support multiple sklearn
+    # versions.
+    check_estimator_tags_renamed("OkayEstimator", OkayEstimator())
+
+
+def test_check_classifier_not_supporting_multiclass():
+    """Check that when the estimator has the wrong tags.classifier_tags.multi_class
+    set, the test fails."""
+
+    class BadEstimator(BaseEstimator):
+        # we don't actually need to define the tag here since we're running the test
+        # manually, and BaseEstimator defaults to multi_output=False.
+        def fit(self, X, y):
+            return self
+
+    msg = "The estimator tag `tags.classifier_tags.multi_class` is False"
+    with raises(AssertionError, match=msg):
+        check_classifier_not_supporting_multiclass("BadEstimator", BadEstimator())
+
+
+# Test that set_output doesn't make the tests to fail.
+def test_estimator_with_set_output():
+    # Doing this since pytest is not available for this file.
+    for lib in ["pandas", "polars"]:
+        try:
+            importlib.__import__(lib)
+        except ImportError:
+            raise SkipTest(f"Library {lib} is not installed")
+
+        estimator = StandardScaler().set_output(transform=lib)
+        check_estimator(estimator)
+
+
+def test_estimator_checks_generator():
+    """Check that checks_generator returns a generator."""
+    all_instance_gen_checks = estimator_checks_generator(LogisticRegression())
+    assert isgenerator(all_instance_gen_checks)
+
+
+def test_check_estimator_callback_with_fast_fail_error():
+    """Check that check_estimator fails correctly with on_fail='raise' and callback."""
+    with raises(
+        ValueError, match="callback cannot be provided together with on_fail='raise'"
+    ):
+        check_estimator(LogisticRegression(), on_fail="raise", callback=lambda: None)
+
+
+def test_check_mixin_order():
+    """Test that the check raises an error when the mixin order is incorrect."""
+
+    class BadEstimator(BaseEstimator, TransformerMixin):
+        def fit(self, X, y=None):
+            return self
+
+    msg = "TransformerMixin comes before/left side of BaseEstimator"
+    with raises(AssertionError, match=re.escape(msg)):
+        check_mixin_order("BadEstimator", BadEstimator())
+
+
+def test_check_positive_only_tag_during_fit():
+    class RequiresPositiveXBadTag(RequiresPositiveXRegressor):
+        def __sklearn_tags__(self):
+            tags = super().__sklearn_tags__()
+            tags.input_tags.positive_only = False
+            return tags
+
+    with raises(
+        AssertionError, match="This happens when passing negative input values as X."
+    ):
+        check_positive_only_tag_during_fit(
+            "RequiresPositiveXBadTag", RequiresPositiveXBadTag()
+        )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_html_repr.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_html_repr.py
new file mode 100644
index 0000000000000000000000000000000000000000..d24e357b74426bc787d688ac8004ade5d2ff9333
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_estimator_html_repr.py
@@ -0,0 +1,21 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import importlib
+import sys
+
+import pytest
+
+
+# TODO(1.8): Remove the entire file
+def test_estimator_html_repr_warning():
+    with pytest.warns(FutureWarning):
+        # Make sure that we check for the warning when loading the module (reloading it
+        # if needed).
+        module_name = "sklearn.utils._estimator_html_repr"
+        if module_name in sys.modules:
+            importlib.reload(sys.modules[module_name])
+        else:
+            importlib.import_module(module_name)
+
+    assert sys.modules[module_name] is not None
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_extmath.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_extmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..907de11702af286650d9c1894df140f096fda799
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_extmath.py
@@ -0,0 +1,1121 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import itertools
+
+import numpy as np
+import pytest
+from scipy import linalg, sparse
+from scipy.linalg import eigh
+from scipy.sparse.linalg import eigsh
+
+from sklearn import config_context
+from sklearn.datasets import make_low_rank_matrix, make_sparse_spd_matrix
+from sklearn.utils import gen_batches
+from sklearn.utils._arpack import _init_arpack_v0
+from sklearn.utils._array_api import (
+    _convert_to_numpy,
+    _get_namespace_device_dtype_ids,
+    get_namespace,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._testing import (
+    _array_api_for_tests,
+    assert_allclose,
+    assert_allclose_dense_sparse,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+    skip_if_32bit,
+)
+from sklearn.utils.extmath import (
+    _approximate_mode,
+    _deterministic_vector_sign_flip,
+    _incremental_mean_and_var,
+    _randomized_eigsh,
+    _safe_accumulator_op,
+    cartesian,
+    density,
+    randomized_range_finder,
+    randomized_svd,
+    row_norms,
+    safe_sparse_dot,
+    softmax,
+    stable_cumsum,
+    svd_flip,
+    weighted_mode,
+)
+from sklearn.utils.fixes import (
+    COO_CONTAINERS,
+    CSC_CONTAINERS,
+    CSR_CONTAINERS,
+    DOK_CONTAINERS,
+    LIL_CONTAINERS,
+    _mode,
+)
+
+
+@pytest.mark.parametrize(
+    "sparse_container",
+    COO_CONTAINERS + CSC_CONTAINERS + CSR_CONTAINERS + LIL_CONTAINERS,
+)
+def test_density(sparse_container):
+    rng = np.random.RandomState(0)
+    X = rng.randint(10, size=(10, 5))
+    X[1, 2] = 0
+    X[5, 3] = 0
+
+    assert density(sparse_container(X)) == density(X)
+
+
+def test_uniform_weights():
+    # with uniform weights, results should be identical to stats.mode
+    rng = np.random.RandomState(0)
+    x = rng.randint(10, size=(10, 5))
+    weights = np.ones(x.shape)
+
+    for axis in (None, 0, 1):
+        mode, score = _mode(x, axis)
+        mode2, score2 = weighted_mode(x, weights, axis=axis)
+
+        assert_array_equal(mode, mode2)
+        assert_array_equal(score, score2)
+
+
+def test_random_weights():
+    # set this up so that each row should have a weighted mode of 6,
+    # with a score that is easily reproduced
+    mode_result = 6
+
+    rng = np.random.RandomState(0)
+    x = rng.randint(mode_result, size=(100, 10))
+    w = rng.random_sample(x.shape)
+
+    x[:, :5] = mode_result
+    w[:, :5] += 1
+
+    mode, score = weighted_mode(x, w, axis=1)
+
+    assert_array_equal(mode, mode_result)
+    assert_array_almost_equal(score.ravel(), w[:, :5].sum(1))
+
+
+@pytest.mark.parametrize("dtype", (np.int32, np.int64, np.float32, np.float64))
+def test_randomized_svd_low_rank_all_dtypes(dtype):
+    # Check that extmath.randomized_svd is consistent with linalg.svd
+    n_samples = 100
+    n_features = 500
+    rank = 5
+    k = 10
+    decimal = 5 if dtype == np.float32 else 7
+    dtype = np.dtype(dtype)
+
+    # generate a matrix X of approximate effective rank `rank` and no noise
+    # component (very structured signal):
+    X = make_low_rank_matrix(
+        n_samples=n_samples,
+        n_features=n_features,
+        effective_rank=rank,
+        tail_strength=0.0,
+        random_state=0,
+    ).astype(dtype, copy=False)
+    assert X.shape == (n_samples, n_features)
+
+    # compute the singular values of X using the slow exact method
+    U, s, Vt = linalg.svd(X, full_matrices=False)
+
+    # Convert the singular values to the specific dtype
+    U = U.astype(dtype, copy=False)
+    s = s.astype(dtype, copy=False)
+    Vt = Vt.astype(dtype, copy=False)
+
+    for normalizer in ["auto", "LU", "QR"]:  # 'none' would not be stable
+        # compute the singular values of X using the fast approximate method
+        Ua, sa, Va = randomized_svd(
+            X, k, power_iteration_normalizer=normalizer, random_state=0
+        )
+
+        # If the input dtype is float, then the output dtype is float of the
+        # same bit size (f32 is not upcast to f64)
+        # But if the input dtype is int, the output dtype is float64
+        if dtype.kind == "f":
+            assert Ua.dtype == dtype
+            assert sa.dtype == dtype
+            assert Va.dtype == dtype
+        else:
+            assert Ua.dtype == np.float64
+            assert sa.dtype == np.float64
+            assert Va.dtype == np.float64
+
+        assert Ua.shape == (n_samples, k)
+        assert sa.shape == (k,)
+        assert Va.shape == (k, n_features)
+
+        # ensure that the singular values of both methods are equal up to the
+        # real rank of the matrix
+        assert_almost_equal(s[:k], sa, decimal=decimal)
+
+        # check the singular vectors too (while not checking the sign)
+        assert_almost_equal(
+            np.dot(U[:, :k], Vt[:k, :]), np.dot(Ua, Va), decimal=decimal
+        )
+
+        # check the sparse matrix representation
+        for csr_container in CSR_CONTAINERS:
+            X = csr_container(X)
+
+            # compute the singular values of X using the fast approximate method
+            Ua, sa, Va = randomized_svd(
+                X, k, power_iteration_normalizer=normalizer, random_state=0
+            )
+            if dtype.kind == "f":
+                assert Ua.dtype == dtype
+                assert sa.dtype == dtype
+                assert Va.dtype == dtype
+            else:
+                assert Ua.dtype.kind == "f"
+                assert sa.dtype.kind == "f"
+                assert Va.dtype.kind == "f"
+
+            assert_almost_equal(s[:rank], sa[:rank], decimal=decimal)
+
+
+@pytest.mark.parametrize("dtype", (np.int32, np.int64, np.float32, np.float64))
+def test_randomized_eigsh(dtype):
+    """Test that `_randomized_eigsh` returns the appropriate components"""
+
+    rng = np.random.RandomState(42)
+    X = np.diag(np.array([1.0, -2.0, 0.0, 3.0], dtype=dtype))
+    # random rotation that preserves the eigenvalues of X
+    rand_rot = np.linalg.qr(rng.normal(size=X.shape))[0]
+    X = rand_rot @ X @ rand_rot.T
+
+    # with 'module' selection method, the negative eigenvalue shows up
+    eigvals, eigvecs = _randomized_eigsh(X, n_components=2, selection="module")
+    # eigenvalues
+    assert eigvals.shape == (2,)
+    assert_array_almost_equal(eigvals, [3.0, -2.0])  # negative eigenvalue here
+    # eigenvectors
+    assert eigvecs.shape == (4, 2)
+
+    # with 'value' selection method, the negative eigenvalue does not show up
+    with pytest.raises(NotImplementedError):
+        _randomized_eigsh(X, n_components=2, selection="value")
+
+
+@pytest.mark.parametrize("k", (10, 50, 100, 199, 200))
+def test_randomized_eigsh_compared_to_others(k):
+    """Check that `_randomized_eigsh` is similar to other `eigsh`
+
+    Tests that for a random PSD matrix, `_randomized_eigsh` provides results
+    comparable to LAPACK (scipy.linalg.eigh) and ARPACK
+    (scipy.sparse.linalg.eigsh).
+
+    Note: some versions of ARPACK do not support k=n_features.
+    """
+
+    # make a random PSD matrix
+    n_features = 200
+    X = make_sparse_spd_matrix(n_features, random_state=0)
+
+    # compare two versions of randomized
+    # rough and fast
+    eigvals, eigvecs = _randomized_eigsh(
+        X, n_components=k, selection="module", n_iter=25, random_state=0
+    )
+    # more accurate but slow (TODO find realistic settings here)
+    eigvals_qr, eigvecs_qr = _randomized_eigsh(
+        X,
+        n_components=k,
+        n_iter=25,
+        n_oversamples=20,
+        random_state=0,
+        power_iteration_normalizer="QR",
+        selection="module",
+    )
+
+    # with LAPACK
+    eigvals_lapack, eigvecs_lapack = eigh(
+        X, subset_by_index=(n_features - k, n_features - 1)
+    )
+    indices = eigvals_lapack.argsort()[::-1]
+    eigvals_lapack = eigvals_lapack[indices]
+    eigvecs_lapack = eigvecs_lapack[:, indices]
+
+    # -- eigenvalues comparison
+    assert eigvals_lapack.shape == (k,)
+    # comparison precision
+    assert_array_almost_equal(eigvals, eigvals_lapack, decimal=6)
+    assert_array_almost_equal(eigvals_qr, eigvals_lapack, decimal=6)
+
+    # -- eigenvectors comparison
+    assert eigvecs_lapack.shape == (n_features, k)
+    # flip eigenvectors' sign to enforce deterministic output
+    dummy_vecs = np.zeros_like(eigvecs).T
+    eigvecs, _ = svd_flip(eigvecs, dummy_vecs)
+    eigvecs_qr, _ = svd_flip(eigvecs_qr, dummy_vecs)
+    eigvecs_lapack, _ = svd_flip(eigvecs_lapack, dummy_vecs)
+    assert_array_almost_equal(eigvecs, eigvecs_lapack, decimal=4)
+    assert_array_almost_equal(eigvecs_qr, eigvecs_lapack, decimal=6)
+
+    # comparison ARPACK ~ LAPACK (some ARPACK implems do not support k=n)
+    if k < n_features:
+        v0 = _init_arpack_v0(n_features, random_state=0)
+        # "LA" largest algebraic <=> selection="value" in randomized_eigsh
+        eigvals_arpack, eigvecs_arpack = eigsh(
+            X, k, which="LA", tol=0, maxiter=None, v0=v0
+        )
+        indices = eigvals_arpack.argsort()[::-1]
+        # eigenvalues
+        eigvals_arpack = eigvals_arpack[indices]
+        assert_array_almost_equal(eigvals_lapack, eigvals_arpack, decimal=10)
+        # eigenvectors
+        eigvecs_arpack = eigvecs_arpack[:, indices]
+        eigvecs_arpack, _ = svd_flip(eigvecs_arpack, dummy_vecs)
+        assert_array_almost_equal(eigvecs_arpack, eigvecs_lapack, decimal=8)
+
+
+@pytest.mark.parametrize(
+    "n,rank",
+    [
+        (10, 7),
+        (100, 10),
+        (100, 80),
+        (500, 10),
+        (500, 250),
+        (500, 400),
+    ],
+)
+def test_randomized_eigsh_reconst_low_rank(n, rank):
+    """Check that randomized_eigsh is able to reconstruct a low rank psd matrix
+
+    Tests that the decomposition provided by `_randomized_eigsh` leads to
+    orthonormal eigenvectors, and that a low rank PSD matrix can be effectively
+    reconstructed with good accuracy using it.
+    """
+    assert rank < n
+
+    # create a low rank PSD
+    rng = np.random.RandomState(69)
+    X = rng.randn(n, rank)
+    A = X @ X.T
+
+    # approximate A with the "right" number of components
+    S, V = _randomized_eigsh(A, n_components=rank, random_state=rng)
+    # orthonormality checks
+    assert_array_almost_equal(np.linalg.norm(V, axis=0), np.ones(S.shape))
+    assert_array_almost_equal(V.T @ V, np.diag(np.ones(S.shape)))
+    # reconstruction
+    A_reconstruct = V @ np.diag(S) @ V.T
+
+    # test that the approximation is good
+    assert_array_almost_equal(A_reconstruct, A, decimal=6)
+
+
+@pytest.mark.parametrize("dtype", (np.float32, np.float64))
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_row_norms(dtype, csr_container):
+    X = np.random.RandomState(42).randn(100, 100)
+    if dtype is np.float32:
+        precision = 4
+    else:
+        precision = 5
+
+    X = X.astype(dtype, copy=False)
+    sq_norm = (X**2).sum(axis=1)
+
+    assert_array_almost_equal(sq_norm, row_norms(X, squared=True), precision)
+    assert_array_almost_equal(np.sqrt(sq_norm), row_norms(X), precision)
+
+    for csr_index_dtype in [np.int32, np.int64]:
+        Xcsr = csr_container(X, dtype=dtype)
+        # csr_matrix will use int32 indices by default,
+        # up-casting those to int64 when necessary
+        if csr_index_dtype is np.int64:
+            Xcsr.indptr = Xcsr.indptr.astype(csr_index_dtype, copy=False)
+            Xcsr.indices = Xcsr.indices.astype(csr_index_dtype, copy=False)
+        assert Xcsr.indices.dtype == csr_index_dtype
+        assert Xcsr.indptr.dtype == csr_index_dtype
+        assert_array_almost_equal(sq_norm, row_norms(Xcsr, squared=True), precision)
+        assert_array_almost_equal(np.sqrt(sq_norm), row_norms(Xcsr), precision)
+
+
+def test_randomized_svd_low_rank_with_noise():
+    # Check that extmath.randomized_svd can handle noisy matrices
+    n_samples = 100
+    n_features = 500
+    rank = 5
+    k = 10
+
+    # generate a matrix X wity structure approximate rank `rank` and an
+    # important noisy component
+    X = make_low_rank_matrix(
+        n_samples=n_samples,
+        n_features=n_features,
+        effective_rank=rank,
+        tail_strength=0.1,
+        random_state=0,
+    )
+    assert X.shape == (n_samples, n_features)
+
+    # compute the singular values of X using the slow exact method
+    _, s, _ = linalg.svd(X, full_matrices=False)
+
+    for normalizer in ["auto", "none", "LU", "QR"]:
+        # compute the singular values of X using the fast approximate
+        # method without the iterated power method
+        _, sa, _ = randomized_svd(
+            X, k, n_iter=0, power_iteration_normalizer=normalizer, random_state=0
+        )
+
+        # the approximation does not tolerate the noise:
+        assert np.abs(s[:k] - sa).max() > 0.01
+
+        # compute the singular values of X using the fast approximate
+        # method with iterated power method
+        _, sap, _ = randomized_svd(
+            X, k, power_iteration_normalizer=normalizer, random_state=0
+        )
+
+        # the iterated power method is helping getting rid of the noise:
+        assert_almost_equal(s[:k], sap, decimal=3)
+
+
+def test_randomized_svd_infinite_rank():
+    # Check that extmath.randomized_svd can handle noisy matrices
+    n_samples = 100
+    n_features = 500
+    rank = 5
+    k = 10
+
+    # let us try again without 'low_rank component': just regularly but slowly
+    # decreasing singular values: the rank of the data matrix is infinite
+    X = make_low_rank_matrix(
+        n_samples=n_samples,
+        n_features=n_features,
+        effective_rank=rank,
+        tail_strength=1.0,
+        random_state=0,
+    )
+    assert X.shape == (n_samples, n_features)
+
+    # compute the singular values of X using the slow exact method
+    _, s, _ = linalg.svd(X, full_matrices=False)
+    for normalizer in ["auto", "none", "LU", "QR"]:
+        # compute the singular values of X using the fast approximate method
+        # without the iterated power method
+        _, sa, _ = randomized_svd(
+            X, k, n_iter=0, power_iteration_normalizer=normalizer, random_state=0
+        )
+
+        # the approximation does not tolerate the noise:
+        assert np.abs(s[:k] - sa).max() > 0.1
+
+        # compute the singular values of X using the fast approximate method
+        # with iterated power method
+        _, sap, _ = randomized_svd(
+            X, k, n_iter=5, power_iteration_normalizer=normalizer, random_state=0
+        )
+
+        # the iterated power method is still managing to get most of the
+        # structure at the requested rank
+        assert_almost_equal(s[:k], sap, decimal=3)
+
+
+def test_randomized_svd_transpose_consistency():
+    # Check that transposing the design matrix has limited impact
+    n_samples = 100
+    n_features = 500
+    rank = 4
+    k = 10
+
+    X = make_low_rank_matrix(
+        n_samples=n_samples,
+        n_features=n_features,
+        effective_rank=rank,
+        tail_strength=0.5,
+        random_state=0,
+    )
+    assert X.shape == (n_samples, n_features)
+
+    U1, s1, V1 = randomized_svd(X, k, n_iter=3, transpose=False, random_state=0)
+    U2, s2, V2 = randomized_svd(X, k, n_iter=3, transpose=True, random_state=0)
+    U3, s3, V3 = randomized_svd(X, k, n_iter=3, transpose="auto", random_state=0)
+    U4, s4, V4 = linalg.svd(X, full_matrices=False)
+
+    assert_almost_equal(s1, s4[:k], decimal=3)
+    assert_almost_equal(s2, s4[:k], decimal=3)
+    assert_almost_equal(s3, s4[:k], decimal=3)
+
+    assert_almost_equal(np.dot(U1, V1), np.dot(U4[:, :k], V4[:k, :]), decimal=2)
+    assert_almost_equal(np.dot(U2, V2), np.dot(U4[:, :k], V4[:k, :]), decimal=2)
+
+    # in this case 'auto' is equivalent to transpose
+    assert_almost_equal(s2, s3)
+
+
+def test_randomized_svd_power_iteration_normalizer():
+    # randomized_svd with power_iteration_normalized='none' diverges for
+    # large number of power iterations on this dataset
+    rng = np.random.RandomState(42)
+    X = make_low_rank_matrix(100, 500, effective_rank=50, random_state=rng)
+    X += 3 * rng.randint(0, 2, size=X.shape)
+    n_components = 50
+
+    # Check that it diverges with many (non-normalized) power iterations
+    U, s, Vt = randomized_svd(
+        X, n_components, n_iter=2, power_iteration_normalizer="none", random_state=0
+    )
+    A = X - U.dot(np.diag(s).dot(Vt))
+    error_2 = linalg.norm(A, ord="fro")
+    U, s, Vt = randomized_svd(
+        X, n_components, n_iter=20, power_iteration_normalizer="none", random_state=0
+    )
+    A = X - U.dot(np.diag(s).dot(Vt))
+    error_20 = linalg.norm(A, ord="fro")
+    assert np.abs(error_2 - error_20) > 100
+
+    for normalizer in ["LU", "QR", "auto"]:
+        U, s, Vt = randomized_svd(
+            X,
+            n_components,
+            n_iter=2,
+            power_iteration_normalizer=normalizer,
+            random_state=0,
+        )
+        A = X - U.dot(np.diag(s).dot(Vt))
+        error_2 = linalg.norm(A, ord="fro")
+
+        for i in [5, 10, 50]:
+            U, s, Vt = randomized_svd(
+                X,
+                n_components,
+                n_iter=i,
+                power_iteration_normalizer=normalizer,
+                random_state=0,
+            )
+            A = X - U.dot(np.diag(s).dot(Vt))
+            error = linalg.norm(A, ord="fro")
+            assert 15 > np.abs(error_2 - error)
+
+
+@pytest.mark.parametrize("sparse_container", DOK_CONTAINERS + LIL_CONTAINERS)
+def test_randomized_svd_sparse_warnings(sparse_container):
+    # randomized_svd throws a warning for lil and dok matrix
+    rng = np.random.RandomState(42)
+    X = make_low_rank_matrix(50, 20, effective_rank=10, random_state=rng)
+    n_components = 5
+
+    X = sparse_container(X)
+    warn_msg = (
+        "Calculating SVD of a {} is expensive. csr_matrix is more efficient.".format(
+            sparse_container.__name__
+        )
+    )
+    with pytest.warns(sparse.SparseEfficiencyWarning, match=warn_msg):
+        randomized_svd(X, n_components, n_iter=1, power_iteration_normalizer="none")
+
+
+def test_svd_flip():
+    # Check that svd_flip works in both situations, and reconstructs input.
+    rs = np.random.RandomState(1999)
+    n_samples = 20
+    n_features = 10
+    X = rs.randn(n_samples, n_features)
+
+    # Check matrix reconstruction
+    U, S, Vt = linalg.svd(X, full_matrices=False)
+    U1, V1 = svd_flip(U, Vt, u_based_decision=False)
+    assert_almost_equal(np.dot(U1 * S, V1), X, decimal=6)
+
+    # Check transposed matrix reconstruction
+    XT = X.T
+    U, S, Vt = linalg.svd(XT, full_matrices=False)
+    U2, V2 = svd_flip(U, Vt, u_based_decision=True)
+    assert_almost_equal(np.dot(U2 * S, V2), XT, decimal=6)
+
+    # Check that different flip methods are equivalent under reconstruction
+    U_flip1, V_flip1 = svd_flip(U, Vt, u_based_decision=True)
+    assert_almost_equal(np.dot(U_flip1 * S, V_flip1), XT, decimal=6)
+    U_flip2, V_flip2 = svd_flip(U, Vt, u_based_decision=False)
+    assert_almost_equal(np.dot(U_flip2 * S, V_flip2), XT, decimal=6)
+
+
+@pytest.mark.parametrize("n_samples, n_features", [(3, 4), (4, 3)])
+def test_svd_flip_max_abs_cols(n_samples, n_features, global_random_seed):
+    rs = np.random.RandomState(global_random_seed)
+    X = rs.randn(n_samples, n_features)
+    U, _, Vt = linalg.svd(X, full_matrices=False)
+
+    U1, _ = svd_flip(U, Vt, u_based_decision=True)
+    max_abs_U1_row_idx_for_col = np.argmax(np.abs(U1), axis=0)
+    assert (U1[max_abs_U1_row_idx_for_col, np.arange(U1.shape[1])] >= 0).all()
+
+    _, V2 = svd_flip(U, Vt, u_based_decision=False)
+    max_abs_V2_col_idx_for_row = np.argmax(np.abs(V2), axis=1)
+    assert (V2[np.arange(V2.shape[0]), max_abs_V2_col_idx_for_row] >= 0).all()
+
+
+def test_randomized_svd_sign_flip():
+    a = np.array([[2.0, 0.0], [0.0, 1.0]])
+    u1, s1, v1 = randomized_svd(a, 2, flip_sign=True, random_state=41)
+    for seed in range(10):
+        u2, s2, v2 = randomized_svd(a, 2, flip_sign=True, random_state=seed)
+        assert_almost_equal(u1, u2)
+        assert_almost_equal(v1, v2)
+        assert_almost_equal(np.dot(u2 * s2, v2), a)
+        assert_almost_equal(np.dot(u2.T, u2), np.eye(2))
+        assert_almost_equal(np.dot(v2.T, v2), np.eye(2))
+
+
+def test_randomized_svd_sign_flip_with_transpose():
+    # Check if the randomized_svd sign flipping is always done based on u
+    # irrespective of transpose.
+    # See https://github.com/scikit-learn/scikit-learn/issues/5608
+    # for more details.
+    def max_loading_is_positive(u, v):
+        """
+        returns bool tuple indicating if the values maximising np.abs
+        are positive across all rows for u and across all columns for v.
+        """
+        u_based = (np.abs(u).max(axis=0) == u.max(axis=0)).all()
+        v_based = (np.abs(v).max(axis=1) == v.max(axis=1)).all()
+        return u_based, v_based
+
+    mat = np.arange(10 * 8).reshape(10, -1)
+
+    # Without transpose
+    u_flipped, _, v_flipped = randomized_svd(mat, 3, flip_sign=True, random_state=0)
+    u_based, v_based = max_loading_is_positive(u_flipped, v_flipped)
+    assert u_based
+    assert not v_based
+
+    # With transpose
+    u_flipped_with_transpose, _, v_flipped_with_transpose = randomized_svd(
+        mat, 3, flip_sign=True, transpose=True, random_state=0
+    )
+    u_based, v_based = max_loading_is_positive(
+        u_flipped_with_transpose, v_flipped_with_transpose
+    )
+    assert u_based
+    assert not v_based
+
+
+@pytest.mark.parametrize("n", [50, 100, 300])
+@pytest.mark.parametrize("m", [50, 100, 300])
+@pytest.mark.parametrize("k", [10, 20, 50])
+@pytest.mark.parametrize("seed", range(5))
+def test_randomized_svd_lapack_driver(n, m, k, seed):
+    # Check that different SVD drivers provide consistent results
+
+    # Matrix being compressed
+    rng = np.random.RandomState(seed)
+    X = rng.rand(n, m)
+
+    # Number of components
+    u1, s1, vt1 = randomized_svd(X, k, svd_lapack_driver="gesdd", random_state=0)
+    u2, s2, vt2 = randomized_svd(X, k, svd_lapack_driver="gesvd", random_state=0)
+
+    # Check shape and contents
+    assert u1.shape == u2.shape
+    assert_allclose(u1, u2, atol=0, rtol=1e-3)
+
+    assert s1.shape == s2.shape
+    assert_allclose(s1, s2, atol=0, rtol=1e-3)
+
+    assert vt1.shape == vt2.shape
+    assert_allclose(vt1, vt2, atol=0, rtol=1e-3)
+
+
+def test_cartesian():
+    # Check if cartesian product delivers the right results
+
+    axes = (np.array([1, 2, 3]), np.array([4, 5]), np.array([6, 7]))
+
+    true_out = np.array(
+        [
+            [1, 4, 6],
+            [1, 4, 7],
+            [1, 5, 6],
+            [1, 5, 7],
+            [2, 4, 6],
+            [2, 4, 7],
+            [2, 5, 6],
+            [2, 5, 7],
+            [3, 4, 6],
+            [3, 4, 7],
+            [3, 5, 6],
+            [3, 5, 7],
+        ]
+    )
+
+    out = cartesian(axes)
+    assert_array_equal(true_out, out)
+
+    # check single axis
+    x = np.arange(3)
+    assert_array_equal(x[:, np.newaxis], cartesian((x,)))
+
+
+@pytest.mark.parametrize(
+    "arrays, output_dtype",
+    [
+        (
+            [np.array([1, 2, 3], dtype=np.int32), np.array([4, 5], dtype=np.int64)],
+            np.dtype(np.int64),
+        ),
+        (
+            [np.array([1, 2, 3], dtype=np.int32), np.array([4, 5], dtype=np.float64)],
+            np.dtype(np.float64),
+        ),
+        (
+            [np.array([1, 2, 3], dtype=np.int32), np.array(["x", "y"], dtype=object)],
+            np.dtype(object),
+        ),
+    ],
+)
+def test_cartesian_mix_types(arrays, output_dtype):
+    """Check that the cartesian product works with mixed types."""
+    output = cartesian(arrays)
+
+    assert output.dtype == output_dtype
+
+
+@pytest.fixture()
+def rng():
+    return np.random.RandomState(42)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_weighted_mean_and_variance_simple(rng, dtype):
+    mult = 10
+    X = rng.rand(1000, 20).astype(dtype) * mult
+    sample_weight = rng.rand(X.shape[0]) * mult
+    mean, var, _ = _incremental_mean_and_var(X, 0, 0, 0, sample_weight=sample_weight)
+
+    expected_mean = np.average(X, weights=sample_weight, axis=0)
+    expected_var = np.average(X**2, weights=sample_weight, axis=0) - expected_mean**2
+    assert_almost_equal(mean, expected_mean)
+    assert_almost_equal(var, expected_var)
+
+
+@pytest.mark.parametrize("mean", [0, 1e7, -1e7])
+@pytest.mark.parametrize("var", [1, 1e-8, 1e5])
+@pytest.mark.parametrize(
+    "weight_loc, weight_scale", [(0, 1), (0, 1e-8), (1, 1e-8), (10, 1), (1e7, 1)]
+)
+def test_incremental_weighted_mean_and_variance(
+    mean, var, weight_loc, weight_scale, rng
+):
+    # Testing of correctness and numerical stability
+    def _assert(X, sample_weight, expected_mean, expected_var):
+        n = X.shape[0]
+        for chunk_size in [1, n // 10 + 1, n // 4 + 1, n // 2 + 1, n]:
+            last_mean, last_weight_sum, last_var = 0, 0, 0
+            for batch in gen_batches(n, chunk_size):
+                last_mean, last_var, last_weight_sum = _incremental_mean_and_var(
+                    X[batch],
+                    last_mean,
+                    last_var,
+                    last_weight_sum,
+                    sample_weight=sample_weight[batch],
+                )
+            assert_allclose(last_mean, expected_mean)
+            assert_allclose(last_var, expected_var, atol=1e-6)
+
+    size = (100, 20)
+    weight = rng.normal(loc=weight_loc, scale=weight_scale, size=size[0])
+
+    # Compare to weighted average: np.average
+    X = rng.normal(loc=mean, scale=var, size=size)
+    expected_mean = _safe_accumulator_op(np.average, X, weights=weight, axis=0)
+    expected_var = _safe_accumulator_op(
+        np.average, (X - expected_mean) ** 2, weights=weight, axis=0
+    )
+    _assert(X, weight, expected_mean, expected_var)
+
+    # Compare to unweighted mean: np.mean
+    X = rng.normal(loc=mean, scale=var, size=size)
+    ones_weight = np.ones(size[0])
+    expected_mean = _safe_accumulator_op(np.mean, X, axis=0)
+    expected_var = _safe_accumulator_op(np.var, X, axis=0)
+    _assert(X, ones_weight, expected_mean, expected_var)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_weighted_mean_and_variance_ignore_nan(dtype):
+    old_means = np.array([535.0, 535.0, 535.0, 535.0])
+    old_variances = np.array([4225.0, 4225.0, 4225.0, 4225.0])
+    old_weight_sum = np.array([2, 2, 2, 2], dtype=np.int32)
+    sample_weights_X = np.ones(3)
+    sample_weights_X_nan = np.ones(4)
+
+    X = np.array(
+        [[170, 170, 170, 170], [430, 430, 430, 430], [300, 300, 300, 300]]
+    ).astype(dtype)
+
+    X_nan = np.array(
+        [
+            [170, np.nan, 170, 170],
+            [np.nan, 170, 430, 430],
+            [430, 430, np.nan, 300],
+            [300, 300, 300, np.nan],
+        ]
+    ).astype(dtype)
+
+    X_means, X_variances, X_count = _incremental_mean_and_var(
+        X, old_means, old_variances, old_weight_sum, sample_weight=sample_weights_X
+    )
+    X_nan_means, X_nan_variances, X_nan_count = _incremental_mean_and_var(
+        X_nan,
+        old_means,
+        old_variances,
+        old_weight_sum,
+        sample_weight=sample_weights_X_nan,
+    )
+
+    assert_allclose(X_nan_means, X_means)
+    assert_allclose(X_nan_variances, X_variances)
+    assert_allclose(X_nan_count, X_count)
+
+
+def test_incremental_variance_update_formulas():
+    # Test Youngs and Cramer incremental variance formulas.
+    # Doggie data from https://www.mathsisfun.com/data/standard-deviation.html
+    A = np.array(
+        [
+            [600, 470, 170, 430, 300],
+            [600, 470, 170, 430, 300],
+            [600, 470, 170, 430, 300],
+            [600, 470, 170, 430, 300],
+        ]
+    ).T
+    idx = 2
+    X1 = A[:idx, :]
+    X2 = A[idx:, :]
+
+    old_means = X1.mean(axis=0)
+    old_variances = X1.var(axis=0)
+    old_sample_count = np.full(X1.shape[1], X1.shape[0], dtype=np.int32)
+    final_means, final_variances, final_count = _incremental_mean_and_var(
+        X2, old_means, old_variances, old_sample_count
+    )
+    assert_almost_equal(final_means, A.mean(axis=0), 6)
+    assert_almost_equal(final_variances, A.var(axis=0), 6)
+    assert_almost_equal(final_count, A.shape[0])
+
+
+def test_incremental_mean_and_variance_ignore_nan():
+    old_means = np.array([535.0, 535.0, 535.0, 535.0])
+    old_variances = np.array([4225.0, 4225.0, 4225.0, 4225.0])
+    old_sample_count = np.array([2, 2, 2, 2], dtype=np.int32)
+
+    X = np.array([[170, 170, 170, 170], [430, 430, 430, 430], [300, 300, 300, 300]])
+
+    X_nan = np.array(
+        [
+            [170, np.nan, 170, 170],
+            [np.nan, 170, 430, 430],
+            [430, 430, np.nan, 300],
+            [300, 300, 300, np.nan],
+        ]
+    )
+
+    X_means, X_variances, X_count = _incremental_mean_and_var(
+        X, old_means, old_variances, old_sample_count
+    )
+    X_nan_means, X_nan_variances, X_nan_count = _incremental_mean_and_var(
+        X_nan, old_means, old_variances, old_sample_count
+    )
+
+    assert_allclose(X_nan_means, X_means)
+    assert_allclose(X_nan_variances, X_variances)
+    assert_allclose(X_nan_count, X_count)
+
+
+@skip_if_32bit
+def test_incremental_variance_numerical_stability():
+    # Test Youngs and Cramer incremental variance formulas.
+
+    def np_var(A):
+        return A.var(axis=0)
+
+    # Naive one pass variance computation - not numerically stable
+    # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+    def one_pass_var(X):
+        n = X.shape[0]
+        exp_x2 = (X**2).sum(axis=0) / n
+        expx_2 = (X.sum(axis=0) / n) ** 2
+        return exp_x2 - expx_2
+
+    # Two-pass algorithm, stable.
+    # We use it as a benchmark. It is not an online algorithm
+    # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm
+    def two_pass_var(X):
+        mean = X.mean(axis=0)
+        Y = X.copy()
+        return np.mean((Y - mean) ** 2, axis=0)
+
+    # Naive online implementation
+    # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
+    # This works only for chunks for size 1
+    def naive_mean_variance_update(x, last_mean, last_variance, last_sample_count):
+        updated_sample_count = last_sample_count + 1
+        samples_ratio = last_sample_count / float(updated_sample_count)
+        updated_mean = x / updated_sample_count + last_mean * samples_ratio
+        updated_variance = (
+            last_variance * samples_ratio
+            + (x - last_mean) * (x - updated_mean) / updated_sample_count
+        )
+        return updated_mean, updated_variance, updated_sample_count
+
+    # We want to show a case when one_pass_var has error > 1e-3 while
+    # _batch_mean_variance_update has less.
+    tol = 200
+    n_features = 2
+    n_samples = 10000
+    x1 = np.array(1e8, dtype=np.float64)
+    x2 = np.log(1e-5, dtype=np.float64)
+    A0 = np.full((n_samples // 2, n_features), x1, dtype=np.float64)
+    A1 = np.full((n_samples // 2, n_features), x2, dtype=np.float64)
+    A = np.vstack((A0, A1))
+
+    # Naive one pass var: >tol (=1063)
+    assert np.abs(np_var(A) - one_pass_var(A)).max() > tol
+
+    # Starting point for online algorithms: after A0
+
+    # Naive implementation: >tol (436)
+    mean, var, n = A0[0, :], np.zeros(n_features), n_samples // 2
+    for i in range(A1.shape[0]):
+        mean, var, n = naive_mean_variance_update(A1[i, :], mean, var, n)
+    assert n == A.shape[0]
+    # the mean is also slightly unstable
+    assert np.abs(A.mean(axis=0) - mean).max() > 1e-6
+    assert np.abs(np_var(A) - var).max() > tol
+
+    # Robust implementation: <tol (177)
+    mean, var = A0[0, :], np.zeros(n_features)
+    n = np.full(n_features, n_samples // 2, dtype=np.int32)
+    for i in range(A1.shape[0]):
+        mean, var, n = _incremental_mean_and_var(
+            A1[i, :].reshape((1, A1.shape[1])), mean, var, n
+        )
+    assert_array_equal(n, A.shape[0])
+    assert_array_almost_equal(A.mean(axis=0), mean)
+    assert tol > np.abs(np_var(A) - var).max()
+
+
+def test_incremental_variance_ddof():
+    # Test that degrees of freedom parameter for calculations are correct.
+    rng = np.random.RandomState(1999)
+    X = rng.randn(50, 10)
+    n_samples, n_features = X.shape
+    for batch_size in [11, 20, 37]:
+        steps = np.arange(0, X.shape[0], batch_size)
+        if steps[-1] != X.shape[0]:
+            steps = np.hstack([steps, n_samples])
+
+        for i, j in itertools.pairwise(steps):
+            batch = X[i:j, :]
+            if i == 0:
+                incremental_means = batch.mean(axis=0)
+                incremental_variances = batch.var(axis=0)
+                # Assign this twice so that the test logic is consistent
+                incremental_count = batch.shape[0]
+                sample_count = np.full(batch.shape[1], batch.shape[0], dtype=np.int32)
+            else:
+                result = _incremental_mean_and_var(
+                    batch, incremental_means, incremental_variances, sample_count
+                )
+                (incremental_means, incremental_variances, incremental_count) = result
+                sample_count += batch.shape[0]
+
+            calculated_means = np.mean(X[:j], axis=0)
+            calculated_variances = np.var(X[:j], axis=0)
+            assert_almost_equal(incremental_means, calculated_means, 6)
+            assert_almost_equal(incremental_variances, calculated_variances, 6)
+            assert_array_equal(incremental_count, sample_count)
+
+
+def test_vector_sign_flip():
+    # Testing that sign flip is working & largest value has positive sign
+    data = np.random.RandomState(36).randn(5, 5)
+    max_abs_rows = np.argmax(np.abs(data), axis=1)
+    data_flipped = _deterministic_vector_sign_flip(data)
+    max_rows = np.argmax(data_flipped, axis=1)
+    assert_array_equal(max_abs_rows, max_rows)
+    signs = np.sign(data[range(data.shape[0]), max_abs_rows])
+    assert_array_equal(data, data_flipped * signs[:, np.newaxis])
+
+
+def test_softmax():
+    rng = np.random.RandomState(0)
+    X = rng.randn(3, 5)
+    exp_X = np.exp(X)
+    sum_exp_X = np.sum(exp_X, axis=1).reshape((-1, 1))
+    assert_array_almost_equal(softmax(X), exp_X / sum_exp_X)
+
+
+def test_stable_cumsum():
+    assert_array_equal(stable_cumsum([1, 2, 3]), np.cumsum([1, 2, 3]))
+    r = np.random.RandomState(0).rand(100000)
+    with pytest.warns(RuntimeWarning):
+        stable_cumsum(r, rtol=0, atol=0)
+
+    # test axis parameter
+    A = np.random.RandomState(36).randint(1000, size=(5, 5, 5))
+    assert_array_equal(stable_cumsum(A, axis=0), np.cumsum(A, axis=0))
+    assert_array_equal(stable_cumsum(A, axis=1), np.cumsum(A, axis=1))
+    assert_array_equal(stable_cumsum(A, axis=2), np.cumsum(A, axis=2))
+
+
+@pytest.mark.parametrize(
+    "A_container",
+    [np.array, *CSR_CONTAINERS],
+    ids=["dense"] + [container.__name__ for container in CSR_CONTAINERS],
+)
+@pytest.mark.parametrize(
+    "B_container",
+    [np.array, *CSR_CONTAINERS],
+    ids=["dense"] + [container.__name__ for container in CSR_CONTAINERS],
+)
+def test_safe_sparse_dot_2d(A_container, B_container):
+    rng = np.random.RandomState(0)
+
+    A = rng.random_sample((30, 10))
+    B = rng.random_sample((10, 20))
+    expected = np.dot(A, B)
+
+    A = A_container(A)
+    B = B_container(B)
+    actual = safe_sparse_dot(A, B, dense_output=True)
+
+    assert_allclose(actual, expected)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_safe_sparse_dot_nd(csr_container):
+    rng = np.random.RandomState(0)
+
+    # dense ND / sparse
+    A = rng.random_sample((2, 3, 4, 5, 6))
+    B = rng.random_sample((6, 7))
+    expected = np.dot(A, B)
+    B = csr_container(B)
+    actual = safe_sparse_dot(A, B)
+    assert_allclose(actual, expected)
+
+    # sparse / dense ND
+    A = rng.random_sample((2, 3))
+    B = rng.random_sample((4, 5, 3, 6))
+    expected = np.dot(A, B)
+    A = csr_container(A)
+    actual = safe_sparse_dot(A, B)
+    assert_allclose(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "container",
+    [np.array, *CSR_CONTAINERS],
+    ids=["dense"] + [container.__name__ for container in CSR_CONTAINERS],
+)
+def test_safe_sparse_dot_2d_1d(container):
+    rng = np.random.RandomState(0)
+    B = rng.random_sample((10))
+
+    # 2D @ 1D
+    A = rng.random_sample((30, 10))
+    expected = np.dot(A, B)
+    actual = safe_sparse_dot(container(A), B)
+    assert_allclose(actual, expected)
+
+    # 1D @ 2D
+    A = rng.random_sample((10, 30))
+    expected = np.dot(B, A)
+    actual = safe_sparse_dot(B, container(A))
+    assert_allclose(actual, expected)
+
+
+@pytest.mark.parametrize("dense_output", [True, False])
+def test_safe_sparse_dot_dense_output(dense_output):
+    rng = np.random.RandomState(0)
+
+    A = sparse.random(30, 10, density=0.1, random_state=rng)
+    B = sparse.random(10, 20, density=0.1, random_state=rng)
+
+    expected = A.dot(B)
+    actual = safe_sparse_dot(A, B, dense_output=dense_output)
+
+    assert sparse.issparse(actual) == (not dense_output)
+
+    if dense_output:
+        expected = expected.toarray()
+    assert_allclose_dense_sparse(actual, expected)
+
+
+def test_approximate_mode():
+    """Make sure sklearn.utils.extmath._approximate_mode returns valid
+    results for cases where "class_counts * n_draws" is enough
+    to overflow 32-bit signed integer.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/20774
+    """
+    X = np.array([99000, 1000], dtype=np.int32)
+    ret = _approximate_mode(class_counts=X, n_draws=25000, rng=0)
+
+    # Draws 25% of the total population, so in this case a fair draw means:
+    # 25% * 99.000 = 24.750
+    # 25% *  1.000 =    250
+    assert_array_equal(ret, [24750, 250])
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_randomized_svd_array_api_compliance(array_namespace, device, dtype):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    rng = np.random.RandomState(0)
+    X = rng.normal(size=(30, 10)).astype(dtype)
+    X_xp = xp.asarray(X, device=device)
+    n_components = 5
+    atol = 1e-5 if dtype == "float32" else 0
+
+    with config_context(array_api_dispatch=True):
+        u_np, s_np, vt_np = randomized_svd(X, n_components, random_state=0)
+        u_xp, s_xp, vt_xp = randomized_svd(X_xp, n_components, random_state=0)
+
+        assert get_namespace(u_xp)[0].__name__ == xp.__name__
+        assert get_namespace(s_xp)[0].__name__ == xp.__name__
+        assert get_namespace(vt_xp)[0].__name__ == xp.__name__
+
+        assert_allclose(_convert_to_numpy(u_xp, xp), u_np, atol=atol)
+        assert_allclose(_convert_to_numpy(s_xp, xp), s_np, atol=atol)
+        assert_allclose(_convert_to_numpy(vt_xp, xp), vt_np, atol=atol)
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_randomized_range_finder_array_api_compliance(array_namespace, device, dtype):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    rng = np.random.RandomState(0)
+    X = rng.normal(size=(30, 10)).astype(dtype)
+    X_xp = xp.asarray(X, device=device)
+    size = 5
+    n_iter = 10
+    atol = 1e-5 if dtype == "float32" else 0
+
+    with config_context(array_api_dispatch=True):
+        Q_np = randomized_range_finder(X, size=size, n_iter=n_iter, random_state=0)
+        Q_xp = randomized_range_finder(X_xp, size=size, n_iter=n_iter, random_state=0)
+
+        assert get_namespace(Q_xp)[0].__name__ == xp.__name__
+        assert_allclose(_convert_to_numpy(Q_xp, xp), Q_np, atol=atol)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fast_dict.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fast_dict.py
new file mode 100644
index 0000000000000000000000000000000000000000..c44250c36daacc920b50c776d3bc013af86f8425
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fast_dict.py
@@ -0,0 +1,47 @@
+"""Test fast_dict."""
+
+import numpy as np
+from numpy.testing import assert_allclose, assert_array_equal
+
+from sklearn.utils._fast_dict import IntFloatDict, argmin
+
+
+def test_int_float_dict():
+    rng = np.random.RandomState(0)
+    keys = np.unique(rng.randint(100, size=10).astype(np.intp))
+    values = rng.rand(len(keys))
+
+    d = IntFloatDict(keys, values)
+    for key, value in zip(keys, values):
+        assert d[key] == value
+    assert len(d) == len(keys)
+
+    d.append(120, 3.0)
+    assert d[120] == 3.0
+    assert len(d) == len(keys) + 1
+    for i in range(2000):
+        d.append(i + 1000, 4.0)
+    assert d[1100] == 4.0
+
+
+def test_int_float_dict_argmin():
+    # Test the argmin implementation on the IntFloatDict
+    keys = np.arange(100, dtype=np.intp)
+    values = np.arange(100, dtype=np.float64)
+    d = IntFloatDict(keys, values)
+    assert argmin(d) == (0, 0)
+
+
+def test_to_arrays():
+    # Test that an IntFloatDict is converted into arrays
+    # of keys and values correctly
+    keys_in = np.array([1, 2, 3], dtype=np.intp)
+    values_in = np.array([4, 5, 6], dtype=np.float64)
+
+    d = IntFloatDict(keys_in, values_in)
+    keys_out, values_out = d.to_arrays()
+
+    assert keys_out.dtype == keys_in.dtype
+    assert values_in.dtype == values_out.dtype
+    assert_array_equal(keys_out, keys_in)
+    assert_allclose(values_out, values_in)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fixes.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fixes.py
new file mode 100644
index 0000000000000000000000000000000000000000..2aa370df705a31f6771a5b7cfa184ab901de5e0d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_fixes.py
@@ -0,0 +1,160 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import pytest
+
+from sklearn.utils._testing import assert_array_equal
+from sklearn.utils.fixes import _object_dtype_isnan, _smallest_admissible_index_dtype
+
+
+@pytest.mark.parametrize("dtype, val", ([object, 1], [object, "a"], [float, 1]))
+def test_object_dtype_isnan(dtype, val):
+    X = np.array([[val, np.nan], [np.nan, val]], dtype=dtype)
+
+    expected_mask = np.array([[False, True], [True, False]])
+
+    mask = _object_dtype_isnan(X)
+
+    assert_array_equal(mask, expected_mask)
+
+
+@pytest.mark.parametrize(
+    "params, expected_dtype",
+    [
+        ({}, np.int32),  # default behaviour
+        ({"maxval": np.iinfo(np.int32).max}, np.int32),
+        ({"maxval": np.iinfo(np.int32).max + 1}, np.int64),
+    ],
+)
+def test_smallest_admissible_index_dtype_max_val(params, expected_dtype):
+    """Check the behaviour of `smallest_admissible_index_dtype` depending only on the
+    `max_val` parameter.
+    """
+    assert _smallest_admissible_index_dtype(**params) == expected_dtype
+
+
+@pytest.mark.parametrize(
+    "params, expected_dtype",
+    [
+        # Arrays dtype is int64 and thus should not be downcasted to int32 without
+        # checking the content of providing maxval.
+        ({"arrays": np.array([1, 2], dtype=np.int64)}, np.int64),
+        # One of the array is int64 and should not be downcasted to int32
+        # for the same reasons.
+        (
+            {
+                "arrays": (
+                    np.array([1, 2], dtype=np.int32),
+                    np.array([1, 2], dtype=np.int64),
+                )
+            },
+            np.int64,
+        ),
+        # Both arrays are already int32: we can just keep this dtype.
+        (
+            {
+                "arrays": (
+                    np.array([1, 2], dtype=np.int32),
+                    np.array([1, 2], dtype=np.int32),
+                )
+            },
+            np.int32,
+        ),
+        # Arrays should be upcasted to at least int32 precision.
+        ({"arrays": np.array([1, 2], dtype=np.int8)}, np.int32),
+        # Check that `maxval` takes precedence over the arrays and thus upcast to
+        # int64.
+        (
+            {
+                "arrays": np.array([1, 2], dtype=np.int32),
+                "maxval": np.iinfo(np.int32).max + 1,
+            },
+            np.int64,
+        ),
+    ],
+)
+def test_smallest_admissible_index_dtype_without_checking_contents(
+    params, expected_dtype
+):
+    """Check the behaviour of `smallest_admissible_index_dtype` using the passed
+    arrays but without checking the contents of the arrays.
+    """
+    assert _smallest_admissible_index_dtype(**params) == expected_dtype
+
+
+@pytest.mark.parametrize(
+    "params, expected_dtype",
+    [
+        # empty arrays should always be converted to int32 indices
+        (
+            {
+                "arrays": (np.array([], dtype=np.int64), np.array([], dtype=np.int64)),
+                "check_contents": True,
+            },
+            np.int32,
+        ),
+        # arrays respecting np.iinfo(np.int32).min < x < np.iinfo(np.int32).max should
+        # be converted to int32,
+        (
+            {"arrays": np.array([1], dtype=np.int64), "check_contents": True},
+            np.int32,
+        ),
+        # otherwise, it should be converted to int64. We need to create a uint32
+        # arrays to accommodate a value > np.iinfo(np.int32).max
+        (
+            {
+                "arrays": np.array([np.iinfo(np.int32).max + 1], dtype=np.uint32),
+                "check_contents": True,
+            },
+            np.int64,
+        ),
+        # maxval should take precedence over the arrays contents and thus upcast to
+        # int64.
+        (
+            {
+                "arrays": np.array([1], dtype=np.int32),
+                "check_contents": True,
+                "maxval": np.iinfo(np.int32).max + 1,
+            },
+            np.int64,
+        ),
+        # when maxval is small, but check_contents is True and the contents
+        # require np.int64, we still require np.int64 indexing in the end.
+        (
+            {
+                "arrays": np.array([np.iinfo(np.int32).max + 1], dtype=np.uint32),
+                "check_contents": True,
+                "maxval": 1,
+            },
+            np.int64,
+        ),
+    ],
+)
+def test_smallest_admissible_index_dtype_by_checking_contents(params, expected_dtype):
+    """Check the behaviour of `smallest_admissible_index_dtype` using the dtype of the
+    arrays but as well the contents.
+    """
+    assert _smallest_admissible_index_dtype(**params) == expected_dtype
+
+
+@pytest.mark.parametrize(
+    "params, err_type, err_msg",
+    [
+        (
+            {"maxval": np.iinfo(np.int64).max + 1},
+            ValueError,
+            "is to large to be represented as np.int64",
+        ),
+        (
+            {"arrays": np.array([1, 2], dtype=np.float64)},
+            ValueError,
+            "Array dtype float64 is not supported",
+        ),
+        ({"arrays": [1, 2]}, TypeError, "Arrays should be of type np.ndarray"),
+    ],
+)
+def test_smallest_admissible_index_dtype_error(params, err_type, err_msg):
+    """Check that we raise the proper error message."""
+    with pytest.raises(err_type, match=err_msg):
+        _smallest_admissible_index_dtype(**params)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_graph.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_graph.py
new file mode 100644
index 0000000000000000000000000000000000000000..d64108a40d8ab4a919b5f0e8b86749232fc4b79e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_graph.py
@@ -0,0 +1,80 @@
+import numpy as np
+import pytest
+from scipy.sparse.csgraph import connected_components
+
+from sklearn.metrics.pairwise import pairwise_distances
+from sklearn.neighbors import kneighbors_graph
+from sklearn.utils.graph import _fix_connected_components
+
+
+def test_fix_connected_components():
+    # Test that _fix_connected_components reduces the number of component to 1.
+    X = np.array([0, 1, 2, 5, 6, 7])[:, None]
+    graph = kneighbors_graph(X, n_neighbors=2, mode="distance")
+
+    n_connected_components, labels = connected_components(graph)
+    assert n_connected_components > 1
+
+    graph = _fix_connected_components(X, graph, n_connected_components, labels)
+
+    n_connected_components, labels = connected_components(graph)
+    assert n_connected_components == 1
+
+
+def test_fix_connected_components_precomputed():
+    # Test that _fix_connected_components accepts precomputed distance matrix.
+    X = np.array([0, 1, 2, 5, 6, 7])[:, None]
+    graph = kneighbors_graph(X, n_neighbors=2, mode="distance")
+
+    n_connected_components, labels = connected_components(graph)
+    assert n_connected_components > 1
+
+    distances = pairwise_distances(X)
+    graph = _fix_connected_components(
+        distances, graph, n_connected_components, labels, metric="precomputed"
+    )
+
+    n_connected_components, labels = connected_components(graph)
+    assert n_connected_components == 1
+
+    # but it does not work with precomputed neighbors graph
+    with pytest.raises(RuntimeError, match="does not work with a sparse"):
+        _fix_connected_components(
+            graph, graph, n_connected_components, labels, metric="precomputed"
+        )
+
+
+def test_fix_connected_components_wrong_mode():
+    # Test that the an error is raised if the mode string is incorrect.
+    X = np.array([0, 1, 2, 5, 6, 7])[:, None]
+    graph = kneighbors_graph(X, n_neighbors=2, mode="distance")
+    n_connected_components, labels = connected_components(graph)
+
+    with pytest.raises(ValueError, match="Unknown mode"):
+        graph = _fix_connected_components(
+            X, graph, n_connected_components, labels, mode="foo"
+        )
+
+
+def test_fix_connected_components_connectivity_mode():
+    # Test that the connectivity mode fill new connections with ones.
+    X = np.array([0, 1, 6, 7])[:, None]
+    graph = kneighbors_graph(X, n_neighbors=1, mode="connectivity")
+    n_connected_components, labels = connected_components(graph)
+    graph = _fix_connected_components(
+        X, graph, n_connected_components, labels, mode="connectivity"
+    )
+    assert np.all(graph.data == 1)
+
+
+def test_fix_connected_components_distance_mode():
+    # Test that the distance mode does not fill new connections with ones.
+    X = np.array([0, 1, 6, 7])[:, None]
+    graph = kneighbors_graph(X, n_neighbors=1, mode="distance")
+    assert np.all(graph.data == 1)
+
+    n_connected_components, labels = connected_components(graph)
+    graph = _fix_connected_components(
+        X, graph, n_connected_components, labels, mode="distance"
+    )
+    assert not np.all(graph.data == 1)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_indexing.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7127638d6abb74f7c29f40de27079e3bff41f16
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_indexing.py
@@ -0,0 +1,663 @@
+import warnings
+from copy import copy
+from unittest import SkipTest
+
+import numpy as np
+import pytest
+from scipy.stats import kstest
+
+import sklearn
+from sklearn.externals._packaging.version import parse as parse_version
+from sklearn.utils import _safe_indexing, resample, shuffle
+from sklearn.utils._array_api import (
+    _get_namespace_device_dtype_ids,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._indexing import (
+    _determine_key_type,
+    _get_column_indices,
+    _safe_assign,
+)
+from sklearn.utils._mocking import MockDataFrame
+from sklearn.utils._testing import (
+    _array_api_for_tests,
+    _convert_container,
+    assert_allclose_dense_sparse,
+    assert_array_equal,
+    skip_if_array_api_compat_not_configured,
+)
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS
+
+# toy array
+X_toy = np.arange(9).reshape((3, 3))
+
+
+def test_polars_indexing():
+    """Check _safe_indexing for polars as expected."""
+    pl = pytest.importorskip("polars", minversion="0.18.2")
+    df = pl.DataFrame(
+        {"a": [1, 2, 3, 4], "b": [4, 5, 6, 8], "c": [1, 4, 1, 10]}, orient="row"
+    )
+
+    from polars.testing import assert_frame_equal
+
+    str_keys = [["b"], ["a", "b"], ["b", "a", "c"], ["c"], ["a"]]
+
+    for key in str_keys:
+        out = _safe_indexing(df, key, axis=1)
+        assert_frame_equal(df[key], out)
+
+    bool_keys = [([True, False, True], ["a", "c"]), ([False, False, True], ["c"])]
+
+    for bool_key, str_key in bool_keys:
+        out = _safe_indexing(df, bool_key, axis=1)
+        assert_frame_equal(df[:, str_key], out)
+
+    int_keys = [([0, 1], ["a", "b"]), ([2], ["c"])]
+
+    for int_key, str_key in int_keys:
+        out = _safe_indexing(df, int_key, axis=1)
+        assert_frame_equal(df[:, str_key], out)
+
+    axis_0_keys = [[0, 1], [1, 3], [3, 2]]
+    for key in axis_0_keys:
+        out = _safe_indexing(df, key, axis=0)
+        assert_frame_equal(df[key], out)
+
+
+@pytest.mark.parametrize(
+    "key, dtype",
+    [
+        (0, "int"),
+        ("0", "str"),
+        (True, "bool"),
+        (np.bool_(True), "bool"),
+        ([0, 1, 2], "int"),
+        (["0", "1", "2"], "str"),
+        ((0, 1, 2), "int"),
+        (("0", "1", "2"), "str"),
+        (slice(None, None), None),
+        (slice(0, 2), "int"),
+        (np.array([0, 1, 2], dtype=np.int32), "int"),
+        (np.array([0, 1, 2], dtype=np.int64), "int"),
+        (np.array([0, 1, 2], dtype=np.uint8), "int"),
+        ([True, False], "bool"),
+        ((True, False), "bool"),
+        (np.array([True, False]), "bool"),
+        ("col_0", "str"),
+        (["col_0", "col_1", "col_2"], "str"),
+        (("col_0", "col_1", "col_2"), "str"),
+        (slice("begin", "end"), "str"),
+        (np.array(["col_0", "col_1", "col_2"]), "str"),
+        (np.array(["col_0", "col_1", "col_2"], dtype=object), "str"),
+    ],
+)
+def test_determine_key_type(key, dtype):
+    assert _determine_key_type(key) == dtype
+
+
+def test_determine_key_type_error():
+    with pytest.raises(ValueError, match="No valid specification of the"):
+        _determine_key_type(1.0)
+
+
+def test_determine_key_type_slice_error():
+    with pytest.raises(TypeError, match="Only array-like or scalar are"):
+        _determine_key_type(slice(0, 2, 1), accept_slice=False)
+
+
+@skip_if_array_api_compat_not_configured
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_determine_key_type_array_api(array_namespace, device, dtype_name):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    with sklearn.config_context(array_api_dispatch=True):
+        int_array_key = xp.asarray([1, 2, 3])
+        assert _determine_key_type(int_array_key) == "int"
+
+        bool_array_key = xp.asarray([True, False, True])
+        assert _determine_key_type(bool_array_key) == "bool"
+
+        try:
+            complex_array_key = xp.asarray([1 + 1j, 2 + 2j, 3 + 3j])
+        except TypeError:
+            # Complex numbers are not supported by all Array API libraries.
+            complex_array_key = None
+
+        if complex_array_key is not None:
+            with pytest.raises(ValueError, match="No valid specification of the"):
+                _determine_key_type(complex_array_key)
+
+
+@pytest.mark.parametrize(
+    "array_type", ["list", "array", "sparse", "dataframe", "polars", "pyarrow"]
+)
+@pytest.mark.parametrize("indices_type", ["list", "tuple", "array", "series", "slice"])
+def test_safe_indexing_2d_container_axis_0(array_type, indices_type):
+    indices = [1, 2]
+    if indices_type == "slice" and isinstance(indices[1], int):
+        indices[1] += 1
+    array = _convert_container([[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type)
+    indices = _convert_container(indices, indices_type)
+    subset = _safe_indexing(array, indices, axis=0)
+    assert_allclose_dense_sparse(
+        subset, _convert_container([[4, 5, 6], [7, 8, 9]], array_type)
+    )
+
+
+@pytest.mark.parametrize(
+    "array_type", ["list", "array", "series", "polars_series", "pyarrow_array"]
+)
+@pytest.mark.parametrize("indices_type", ["list", "tuple", "array", "series", "slice"])
+def test_safe_indexing_1d_container(array_type, indices_type):
+    indices = [1, 2]
+    if indices_type == "slice" and isinstance(indices[1], int):
+        indices[1] += 1
+    array = _convert_container([1, 2, 3, 4, 5, 6, 7, 8, 9], array_type)
+    indices = _convert_container(indices, indices_type)
+    subset = _safe_indexing(array, indices, axis=0)
+    assert_allclose_dense_sparse(subset, _convert_container([2, 3], array_type))
+
+
+@pytest.mark.parametrize(
+    "array_type", ["array", "sparse", "dataframe", "polars", "pyarrow"]
+)
+@pytest.mark.parametrize("indices_type", ["list", "tuple", "array", "series", "slice"])
+@pytest.mark.parametrize("indices", [[1, 2], ["col_1", "col_2"]])
+def test_safe_indexing_2d_container_axis_1(array_type, indices_type, indices):
+    # validation of the indices
+    # we make a copy because indices is mutable and shared between tests
+    indices_converted = copy(indices)
+    if indices_type == "slice" and isinstance(indices[1], int):
+        indices_converted[1] += 1
+
+    columns_name = ["col_0", "col_1", "col_2"]
+    array = _convert_container(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+    )
+    indices_converted = _convert_container(indices_converted, indices_type)
+
+    if isinstance(indices[0], str) and array_type in ("array", "sparse"):
+        err_msg = (
+            "Specifying the columns using strings is only supported for dataframes"
+        )
+        with pytest.raises(ValueError, match=err_msg):
+            _safe_indexing(array, indices_converted, axis=1)
+    else:
+        subset = _safe_indexing(array, indices_converted, axis=1)
+        assert_allclose_dense_sparse(
+            subset, _convert_container([[2, 3], [5, 6], [8, 9]], array_type)
+        )
+
+
+@pytest.mark.parametrize("array_read_only", [True, False])
+@pytest.mark.parametrize("indices_read_only", [True, False])
+@pytest.mark.parametrize(
+    "array_type", ["array", "sparse", "dataframe", "polars", "pyarrow"]
+)
+@pytest.mark.parametrize("indices_type", ["array", "series"])
+@pytest.mark.parametrize(
+    "axis, expected_array", [(0, [[4, 5, 6], [7, 8, 9]]), (1, [[2, 3], [5, 6], [8, 9]])]
+)
+def test_safe_indexing_2d_read_only_axis_1(
+    array_read_only, indices_read_only, array_type, indices_type, axis, expected_array
+):
+    array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    if array_read_only:
+        array.setflags(write=False)
+    array = _convert_container(array, array_type)
+    indices = np.array([1, 2])
+    if indices_read_only:
+        indices.setflags(write=False)
+    indices = _convert_container(indices, indices_type)
+    subset = _safe_indexing(array, indices, axis=axis)
+    assert_allclose_dense_sparse(subset, _convert_container(expected_array, array_type))
+
+
+@pytest.mark.parametrize(
+    "array_type", ["list", "array", "series", "polars_series", "pyarrow_array"]
+)
+@pytest.mark.parametrize("indices_type", ["list", "tuple", "array", "series"])
+def test_safe_indexing_1d_container_mask(array_type, indices_type):
+    indices = [False] + [True] * 2 + [False] * 6
+    array = _convert_container([1, 2, 3, 4, 5, 6, 7, 8, 9], array_type)
+    indices = _convert_container(indices, indices_type)
+    subset = _safe_indexing(array, indices, axis=0)
+    assert_allclose_dense_sparse(subset, _convert_container([2, 3], array_type))
+
+
+@pytest.mark.parametrize(
+    "array_type", ["array", "sparse", "dataframe", "polars", "pyarrow"]
+)
+@pytest.mark.parametrize("indices_type", ["list", "tuple", "array", "series"])
+@pytest.mark.parametrize(
+    "axis, expected_subset",
+    [(0, [[4, 5, 6], [7, 8, 9]]), (1, [[2, 3], [5, 6], [8, 9]])],
+)
+def test_safe_indexing_2d_mask(array_type, indices_type, axis, expected_subset):
+    columns_name = ["col_0", "col_1", "col_2"]
+    array = _convert_container(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+    )
+    indices = [False, True, True]
+    indices = _convert_container(indices, indices_type)
+
+    subset = _safe_indexing(array, indices, axis=axis)
+    assert_allclose_dense_sparse(
+        subset, _convert_container(expected_subset, array_type)
+    )
+
+
+@pytest.mark.parametrize(
+    "array_type, expected_output_type",
+    [
+        ("list", "list"),
+        ("array", "array"),
+        ("sparse", "sparse"),
+        ("dataframe", "series"),
+        ("polars", "polars_series"),
+        ("pyarrow", "pyarrow_array"),
+    ],
+)
+def test_safe_indexing_2d_scalar_axis_0(array_type, expected_output_type):
+    array = _convert_container([[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type)
+    indices = 2
+    subset = _safe_indexing(array, indices, axis=0)
+    expected_array = _convert_container([7, 8, 9], expected_output_type)
+    assert_allclose_dense_sparse(subset, expected_array)
+
+
+@pytest.mark.parametrize(
+    "array_type", ["list", "array", "series", "polars_series", "pyarrow_array"]
+)
+def test_safe_indexing_1d_scalar(array_type):
+    array = _convert_container([1, 2, 3, 4, 5, 6, 7, 8, 9], array_type)
+    indices = 2
+    subset = _safe_indexing(array, indices, axis=0)
+    assert subset == 3
+
+
+@pytest.mark.parametrize(
+    "array_type, expected_output_type",
+    [
+        ("array", "array"),
+        ("sparse", "sparse"),
+        ("dataframe", "series"),
+        ("polars", "polars_series"),
+        ("pyarrow", "pyarrow_array"),
+    ],
+)
+@pytest.mark.parametrize("indices", [2, "col_2"])
+def test_safe_indexing_2d_scalar_axis_1(array_type, expected_output_type, indices):
+    columns_name = ["col_0", "col_1", "col_2"]
+    array = _convert_container(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+    )
+
+    if isinstance(indices, str) and array_type in ("array", "sparse"):
+        err_msg = (
+            "Specifying the columns using strings is only supported for dataframes"
+        )
+        with pytest.raises(ValueError, match=err_msg):
+            _safe_indexing(array, indices, axis=1)
+    else:
+        subset = _safe_indexing(array, indices, axis=1)
+        expected_output = [3, 6, 9]
+        if expected_output_type == "sparse":
+            # sparse matrix are keeping the 2D shape
+            expected_output = [[3], [6], [9]]
+        expected_array = _convert_container(expected_output, expected_output_type)
+        assert_allclose_dense_sparse(subset, expected_array)
+
+
+@pytest.mark.parametrize("array_type", ["list", "array", "sparse"])
+def test_safe_indexing_None_axis_0(array_type):
+    X = _convert_container([[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type)
+    X_subset = _safe_indexing(X, None, axis=0)
+    assert_allclose_dense_sparse(X_subset, X)
+
+
+def test_safe_indexing_pandas_no_matching_cols_error():
+    pd = pytest.importorskip("pandas")
+    err_msg = "No valid specification of the columns."
+    X = pd.DataFrame(X_toy)
+    with pytest.raises(ValueError, match=err_msg):
+        _safe_indexing(X, [1.0], axis=1)
+
+
+@pytest.mark.parametrize("axis", [None, 3])
+def test_safe_indexing_error_axis(axis):
+    with pytest.raises(ValueError, match="'axis' should be either 0"):
+        _safe_indexing(X_toy, [0, 1], axis=axis)
+
+
+@pytest.mark.parametrize(
+    "X_constructor", ["array", "series", "polars_series", "pyarrow_array"]
+)
+def test_safe_indexing_1d_array_error(X_constructor):
+    # check that we are raising an error if the array-like passed is 1D and
+    # we try to index on the 2nd dimension
+    X = list(range(5))
+    if X_constructor == "array":
+        X_constructor = np.asarray(X)
+    elif X_constructor == "series":
+        pd = pytest.importorskip("pandas")
+        X_constructor = pd.Series(X)
+    elif X_constructor == "polars_series":
+        pl = pytest.importorskip("polars")
+        X_constructor = pl.Series(values=X)
+    elif X_constructor == "pyarrow_array":
+        pa = pytest.importorskip("pyarrow")
+        X_constructor = pa.array(X)
+
+    err_msg = "'X' should be a 2D NumPy array, 2D sparse matrix or dataframe"
+    with pytest.raises(ValueError, match=err_msg):
+        _safe_indexing(X_constructor, [0, 1], axis=1)
+
+
+def test_safe_indexing_container_axis_0_unsupported_type():
+    indices = ["col_1", "col_2"]
+    array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    err_msg = "String indexing is not supported with 'axis=0'"
+    with pytest.raises(ValueError, match=err_msg):
+        _safe_indexing(array, indices, axis=0)
+
+
+def test_safe_indexing_pandas_no_settingwithcopy_warning():
+    # Using safe_indexing with an array-like indexer gives a copy of the
+    # DataFrame -> ensure it doesn't raise a warning if modified
+    pd = pytest.importorskip("pandas")
+
+    pd_version = parse_version(pd.__version__)
+    pd_base_version = parse_version(pd_version.base_version)
+
+    if pd_base_version >= parse_version("3"):
+        raise SkipTest("SettingWithCopyWarning has been removed in pandas 3.0.0.dev")
+
+    X = pd.DataFrame({"a": [1, 2, 3], "b": [3, 4, 5]})
+    subset = _safe_indexing(X, [0, 1], axis=0)
+    if hasattr(pd.errors, "SettingWithCopyWarning"):
+        SettingWithCopyWarning = pd.errors.SettingWithCopyWarning
+    else:
+        # backward compatibility for pandas < 1.5
+        SettingWithCopyWarning = pd.core.common.SettingWithCopyWarning
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", SettingWithCopyWarning)
+        subset.iloc[0, 0] = 10
+    # The original dataframe is unaffected by the assignment on the subset:
+    assert X.iloc[0, 0] == 1
+
+
+@pytest.mark.parametrize("indices", [0, [0, 1], slice(0, 2), np.array([0, 1])])
+def test_safe_indexing_list_axis_1_unsupported(indices):
+    """Check that we raise a ValueError when axis=1 with input as list."""
+    X = [[1, 2], [4, 5], [7, 8]]
+    err_msg = "axis=1 is not supported for lists"
+    with pytest.raises(ValueError, match=err_msg):
+        _safe_indexing(X, indices, axis=1)
+
+
+@pytest.mark.parametrize("array_type", ["array", "sparse", "dataframe"])
+def test_safe_assign(array_type):
+    """Check that `_safe_assign` works as expected."""
+    rng = np.random.RandomState(0)
+    X_array = rng.randn(10, 5)
+
+    row_indexer = [1, 2]
+    values = rng.randn(len(row_indexer), X_array.shape[1])
+    X = _convert_container(X_array, array_type)
+    _safe_assign(X, values, row_indexer=row_indexer)
+
+    assigned_portion = _safe_indexing(X, row_indexer, axis=0)
+    assert_allclose_dense_sparse(
+        assigned_portion, _convert_container(values, array_type)
+    )
+
+    column_indexer = [1, 2]
+    values = rng.randn(X_array.shape[0], len(column_indexer))
+    X = _convert_container(X_array, array_type)
+    _safe_assign(X, values, column_indexer=column_indexer)
+
+    assigned_portion = _safe_indexing(X, column_indexer, axis=1)
+    assert_allclose_dense_sparse(
+        assigned_portion, _convert_container(values, array_type)
+    )
+
+    row_indexer, column_indexer = None, None
+    values = rng.randn(*X.shape)
+    X = _convert_container(X_array, array_type)
+    _safe_assign(X, values, column_indexer=column_indexer)
+
+    assert_allclose_dense_sparse(X, _convert_container(values, array_type))
+
+
+@pytest.mark.parametrize(
+    "key, err_msg",
+    [
+        (10, r"all features must be in \[0, 2\]"),
+        ("whatever", "A given column is not a column of the dataframe"),
+        (object(), "No valid specification of the columns"),
+    ],
+)
+def test_get_column_indices_error(key, err_msg):
+    pd = pytest.importorskip("pandas")
+    X_df = pd.DataFrame(X_toy, columns=["col_0", "col_1", "col_2"])
+
+    with pytest.raises(ValueError, match=err_msg):
+        _get_column_indices(X_df, key)
+
+
+@pytest.mark.parametrize(
+    "key", [["col1"], ["col2"], ["col1", "col2"], ["col1", "col3"], ["col2", "col3"]]
+)
+def test_get_column_indices_pandas_nonunique_columns_error(key):
+    pd = pytest.importorskip("pandas")
+    toy = np.zeros((1, 5), dtype=int)
+    columns = ["col1", "col1", "col2", "col3", "col2"]
+    X = pd.DataFrame(toy, columns=columns)
+
+    err_msg = "Selected columns, {}, are not unique in dataframe".format(key)
+    with pytest.raises(ValueError) as exc_info:
+        _get_column_indices(X, key)
+    assert str(exc_info.value) == err_msg
+
+
+def test_get_column_indices_interchange():
+    """Check _get_column_indices for edge cases with the interchange"""
+    pl = pytest.importorskip("polars")
+
+    # Polars dataframes go down the interchange path.
+    df = pl.DataFrame([[1, 2, 3], [4, 5, 6]], schema=["a", "b", "c"])
+
+    key_results = [
+        (slice(1, None), [1, 2]),
+        (slice(None, 2), [0, 1]),
+        (slice(1, 2), [1]),
+        (["b", "c"], [1, 2]),
+        (slice("a", "b"), [0, 1]),
+        (slice("a", None), [0, 1, 2]),
+        (slice(None, "a"), [0]),
+        (["c", "a"], [2, 0]),
+        ([], []),
+    ]
+    for key, result in key_results:
+        assert _get_column_indices(df, key) == result
+
+    msg = "A given column is not a column of the dataframe"
+    with pytest.raises(ValueError, match=msg):
+        _get_column_indices(df, ["not_a_column"])
+
+    msg = "key.step must be 1 or None"
+    with pytest.raises(NotImplementedError, match=msg):
+        _get_column_indices(df, slice("a", None, 2))
+
+
+def test_resample():
+    # Border case not worth mentioning in doctests
+    assert resample() is None
+
+    # Check that invalid arguments yield ValueError
+    with pytest.raises(ValueError):
+        resample([0], [0, 1])
+    with pytest.raises(ValueError):
+        resample([0, 1], [0, 1], replace=False, n_samples=3)
+
+    # Issue:6581, n_samples can be more when replace is True (default).
+    assert len(resample([1, 2], n_samples=5)) == 5
+
+
+def test_resample_weighted():
+    # Check that sampling with replacement with integer weights yields the
+    # samples from the same distribution as sampling uniformly with
+    # repeated data points.
+    data = np.array([-1, 0, 1])
+    sample_weight = np.asarray([0, 100, 1])
+
+    mean_repeated = []
+    mean_reweighted = []
+
+    for seed in range(100):
+        mean_repeated.append(
+            resample(
+                data.repeat(sample_weight),
+                replace=True,
+                random_state=seed,
+                n_samples=data.shape[0],
+            ).mean()
+        )
+        mean_reweighted.append(
+            resample(
+                data,
+                sample_weight=sample_weight,
+                replace=True,
+                random_state=seed,
+                n_samples=data.shape[0],
+            ).mean()
+        )
+
+    mean_repeated = np.asarray(mean_repeated)
+    mean_reweighted = np.asarray(mean_reweighted)
+
+    test_result = kstest(mean_repeated, mean_reweighted)
+    # Should never be negative because -1 has a 0 weight.
+    assert np.all(mean_reweighted >= 0)
+    # The null-hypothesis (the computed means are identically distributed)
+    # cannot be rejected.
+    assert test_result.pvalue > 0.05
+
+
+def test_resample_stratified():
+    # Make sure resample can stratify
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    p = 0.9
+    X = rng.normal(size=(n_samples, 1))
+    y = rng.binomial(1, p, size=n_samples)
+
+    _, y_not_stratified = resample(X, y, n_samples=10, random_state=0, stratify=None)
+    assert np.all(y_not_stratified == 1)
+
+    _, y_stratified = resample(X, y, n_samples=10, random_state=0, stratify=y)
+    assert not np.all(y_stratified == 1)
+    assert np.sum(y_stratified) == 9  # all 1s, one 0
+
+
+def test_resample_stratified_replace():
+    # Make sure stratified resampling supports the replace parameter
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    X = rng.normal(size=(n_samples, 1))
+    y = rng.randint(0, 2, size=n_samples)
+
+    X_replace, _ = resample(
+        X, y, replace=True, n_samples=50, random_state=rng, stratify=y
+    )
+    X_no_replace, _ = resample(
+        X, y, replace=False, n_samples=50, random_state=rng, stratify=y
+    )
+    assert np.unique(X_replace).shape[0] < 50
+    assert np.unique(X_no_replace).shape[0] == 50
+
+    # make sure n_samples can be greater than X.shape[0] if we sample with
+    # replacement
+    X_replace, _ = resample(
+        X, y, replace=True, n_samples=1000, random_state=rng, stratify=y
+    )
+    assert X_replace.shape[0] == 1000
+    assert np.unique(X_replace).shape[0] == 100
+
+
+def test_resample_stratify_2dy():
+    # Make sure y can be 2d when stratifying
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    X = rng.normal(size=(n_samples, 1))
+    y = rng.randint(0, 2, size=(n_samples, 2))
+    X, y = resample(X, y, n_samples=50, random_state=rng, stratify=y)
+    assert y.ndim == 2
+
+
+def test_notimplementederror():
+    with pytest.raises(
+        NotImplementedError,
+        match="Resampling with sample_weight is only implemented for replace=True.",
+    ):
+        resample([0, 1], [0, 1], sample_weight=[1, 1], replace=False)
+
+    with pytest.raises(
+        NotImplementedError,
+        match="Resampling with sample_weight is only implemented for stratify=None",
+    ):
+        resample([0, 1], [0, 1], sample_weight=[1, 1], stratify=[0, 1])
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_resample_stratify_sparse_error(csr_container):
+    # resample must be ndarray
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    X = rng.normal(size=(n_samples, 2))
+    y = rng.randint(0, 2, size=n_samples)
+    stratify = csr_container(y.reshape(-1, 1))
+    with pytest.raises(TypeError, match="Sparse data was passed"):
+        X, y = resample(X, y, n_samples=50, random_state=rng, stratify=stratify)
+
+
+def test_shuffle_on_ndim_equals_three():
+    def to_tuple(A):  # to make the inner arrays hashable
+        return tuple(tuple(tuple(C) for C in B) for B in A)
+
+    A = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # A.shape = (2,2,2)
+    S = set(to_tuple(A))
+    shuffle(A)  # shouldn't raise a ValueError for dim = 3
+    assert set(to_tuple(A)) == S
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+def test_shuffle_dont_convert_to_array(csc_container):
+    # Check that shuffle does not try to convert to numpy arrays with float
+    # dtypes can let any indexable datastructure pass-through.
+    a = ["a", "b", "c"]
+    b = np.array(["a", "b", "c"], dtype=object)
+    c = [1, 2, 3]
+    d = MockDataFrame(np.array([["a", 0], ["b", 1], ["c", 2]], dtype=object))
+    e = csc_container(np.arange(6).reshape(3, 2))
+    a_s, b_s, c_s, d_s, e_s = shuffle(a, b, c, d, e, random_state=0)
+
+    assert a_s == ["c", "b", "a"]
+    assert type(a_s) == list
+
+    assert_array_equal(b_s, ["c", "b", "a"])
+    assert b_s.dtype == object
+
+    assert c_s == [3, 2, 1]
+    assert type(c_s) == list
+
+    assert_array_equal(d_s, np.array([["c", 2], ["b", 1], ["a", 0]], dtype=object))
+    assert type(d_s) == MockDataFrame
+
+    assert_array_equal(e_s.toarray(), np.array([[4, 5], [2, 3], [0, 1]]))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mask.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mask.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eb88e71771f896b84cfaea2a27657999ab167ea
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mask.py
@@ -0,0 +1,19 @@
+import pytest
+
+from sklearn.utils._mask import safe_mask
+from sklearn.utils.fixes import CSR_CONTAINERS
+from sklearn.utils.validation import check_random_state
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_safe_mask(csr_container):
+    random_state = check_random_state(0)
+    X = random_state.rand(5, 4)
+    X_csr = csr_container(X)
+    mask = [False, False, True, True, True]
+
+    mask = safe_mask(X, mask)
+    assert X[mask].shape[0] == 3
+
+    mask = safe_mask(X_csr, mask)
+    assert X_csr[mask].shape[0] == 3
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_metaestimators.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_metaestimators.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e6d4eec35973e8d21c14af76264ca9fd88480f9
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_metaestimators.py
@@ -0,0 +1,63 @@
+import pickle
+
+import pytest
+
+from sklearn.utils.metaestimators import available_if
+
+
+class AvailableParameterEstimator:
+    """This estimator's `available` parameter toggles the presence of a method"""
+
+    def __init__(self, available=True, return_value=1):
+        self.available = available
+        self.return_value = return_value
+
+    @available_if(lambda est: est.available)
+    def available_func(self):
+        """This is a mock available_if function"""
+        return self.return_value
+
+
+def test_available_if_docstring():
+    assert "This is a mock available_if function" in str(
+        AvailableParameterEstimator.__dict__["available_func"].__doc__
+    )
+    assert "This is a mock available_if function" in str(
+        AvailableParameterEstimator.available_func.__doc__
+    )
+    assert "This is a mock available_if function" in str(
+        AvailableParameterEstimator().available_func.__doc__
+    )
+
+
+def test_available_if():
+    assert hasattr(AvailableParameterEstimator(), "available_func")
+    assert not hasattr(AvailableParameterEstimator(available=False), "available_func")
+
+
+def test_available_if_unbound_method():
+    # This is a non regression test for:
+    # https://github.com/scikit-learn/scikit-learn/issues/20614
+    # to make sure that decorated functions can be used as an unbound method,
+    # for instance when monkeypatching.
+    est = AvailableParameterEstimator()
+    AvailableParameterEstimator.available_func(est)
+
+    est = AvailableParameterEstimator(available=False)
+    with pytest.raises(
+        AttributeError,
+        match="This 'AvailableParameterEstimator' has no attribute 'available_func'",
+    ):
+        AvailableParameterEstimator.available_func(est)
+
+
+def test_available_if_methods_can_be_pickled():
+    """Check that available_if methods can be pickled.
+
+    Non-regression test for #21344.
+    """
+    return_value = 10
+    est = AvailableParameterEstimator(available=True, return_value=return_value)
+    pickled_bytes = pickle.dumps(est.available_func)
+    unpickled_func = pickle.loads(pickled_bytes)
+    assert unpickled_func() == return_value
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_missing.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_missing.py
new file mode 100644
index 0000000000000000000000000000000000000000..830e327f06a1173106662ffccf39c3ea281fb04d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_missing.py
@@ -0,0 +1,27 @@
+import numpy as np
+import pytest
+
+from sklearn.utils._missing import is_scalar_nan
+
+
+@pytest.mark.parametrize(
+    "value, result",
+    [
+        (float("nan"), True),
+        (np.nan, True),
+        (float(np.nan), True),
+        (np.float32(np.nan), True),
+        (np.float64(np.nan), True),
+        (0, False),
+        (0.0, False),
+        (None, False),
+        ("", False),
+        ("nan", False),
+        ([np.nan], False),
+        (9867966753463435747313673, False),  # Python int that overflows with C type
+    ],
+)
+def test_is_scalar_nan(value, result):
+    assert is_scalar_nan(value) is result
+    # make sure that we are returning a Python bool
+    assert isinstance(is_scalar_nan(value), bool)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mocking.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mocking.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd143855e6dcd33b691b9f702745c4d87bb3f4be
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_mocking.py
@@ -0,0 +1,205 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+from scipy import sparse
+
+from sklearn.datasets import load_iris
+from sklearn.utils import _safe_indexing, check_array
+from sklearn.utils._mocking import (
+    CheckingClassifier,
+    _MockEstimatorOnOffPrediction,
+)
+from sklearn.utils._testing import _convert_container
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+
+@pytest.fixture
+def iris():
+    return load_iris(return_X_y=True)
+
+
+def _success(x):
+    return True
+
+
+def _fail(x):
+    return False
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {},
+        {"check_X": _success},
+        {"check_y": _success},
+        {"check_X": _success, "check_y": _success},
+    ],
+)
+def test_check_on_fit_success(iris, kwargs):
+    X, y = iris
+    CheckingClassifier(**kwargs).fit(X, y)
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"check_X": _fail},
+        {"check_y": _fail},
+        {"check_X": _success, "check_y": _fail},
+        {"check_X": _fail, "check_y": _success},
+        {"check_X": _fail, "check_y": _fail},
+    ],
+)
+def test_check_on_fit_fail(iris, kwargs):
+    X, y = iris
+    clf = CheckingClassifier(**kwargs)
+    with pytest.raises(AssertionError):
+        clf.fit(X, y)
+
+
+@pytest.mark.parametrize(
+    "pred_func", ["predict", "predict_proba", "decision_function", "score"]
+)
+def test_check_X_on_predict_success(iris, pred_func):
+    X, y = iris
+    clf = CheckingClassifier(check_X=_success).fit(X, y)
+    getattr(clf, pred_func)(X)
+
+
+@pytest.mark.parametrize(
+    "pred_func", ["predict", "predict_proba", "decision_function", "score"]
+)
+def test_check_X_on_predict_fail(iris, pred_func):
+    X, y = iris
+    clf = CheckingClassifier(check_X=_success).fit(X, y)
+    clf.set_params(check_X=_fail)
+    with pytest.raises(AssertionError):
+        getattr(clf, pred_func)(X)
+
+
+@pytest.mark.parametrize("input_type", ["list", "array", "sparse", "dataframe"])
+def test_checking_classifier(iris, input_type):
+    # Check that the CheckingClassifier outputs what we expect
+    X, y = iris
+    X = _convert_container(X, input_type)
+    clf = CheckingClassifier()
+    clf.fit(X, y)
+
+    assert_array_equal(clf.classes_, np.unique(y))
+    assert len(clf.classes_) == 3
+    assert clf.n_features_in_ == 4
+
+    y_pred = clf.predict(X)
+    assert all(pred in clf.classes_ for pred in y_pred)
+
+    assert clf.score(X) == pytest.approx(0)
+    clf.set_params(foo_param=10)
+    assert clf.fit(X, y).score(X) == pytest.approx(1)
+
+    y_proba = clf.predict_proba(X)
+    assert y_proba.shape == (150, 3)
+    assert np.logical_and(y_proba >= 0, y_proba <= 1).all()
+
+    y_decision = clf.decision_function(X)
+    assert y_decision.shape == (150, 3)
+
+    # check the shape in case of binary classification
+    first_2_classes = np.logical_or(y == 0, y == 1)
+    X = _safe_indexing(X, first_2_classes)
+    y = _safe_indexing(y, first_2_classes)
+    clf.fit(X, y)
+
+    y_proba = clf.predict_proba(X)
+    assert y_proba.shape == (100, 2)
+    assert np.logical_and(y_proba >= 0, y_proba <= 1).all()
+
+    y_decision = clf.decision_function(X)
+    assert y_decision.shape == (100,)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_checking_classifier_with_params(iris, csr_container):
+    X, y = iris
+    X_sparse = csr_container(X)
+
+    clf = CheckingClassifier(check_X=sparse.issparse)
+    with pytest.raises(AssertionError):
+        clf.fit(X, y)
+    clf.fit(X_sparse, y)
+
+    clf = CheckingClassifier(
+        check_X=check_array, check_X_params={"accept_sparse": False}
+    )
+    clf.fit(X, y)
+    with pytest.raises(TypeError, match="Sparse data was passed"):
+        clf.fit(X_sparse, y)
+
+
+def test_checking_classifier_fit_params(iris):
+    # check the error raised when the number of samples is not the one expected
+    X, y = iris
+    clf = CheckingClassifier(expected_sample_weight=True)
+    sample_weight = np.ones(len(X) // 2)
+
+    msg = f"sample_weight.shape == ({len(X) // 2},), expected ({len(X)},)!"
+    with pytest.raises(ValueError) as exc:
+        clf.fit(X, y, sample_weight=sample_weight)
+    assert exc.value.args[0] == msg
+
+
+def test_checking_classifier_missing_fit_params(iris):
+    X, y = iris
+    clf = CheckingClassifier(expected_sample_weight=True)
+    err_msg = "Expected sample_weight to be passed"
+    with pytest.raises(AssertionError, match=err_msg):
+        clf.fit(X, y)
+
+
+@pytest.mark.parametrize(
+    "methods_to_check",
+    [["predict"], ["predict", "predict_proba"]],
+)
+@pytest.mark.parametrize(
+    "predict_method", ["predict", "predict_proba", "decision_function", "score"]
+)
+def test_checking_classifier_methods_to_check(iris, methods_to_check, predict_method):
+    # check that methods_to_check allows to bypass checks
+    X, y = iris
+
+    clf = CheckingClassifier(
+        check_X=sparse.issparse,
+        methods_to_check=methods_to_check,
+    )
+
+    clf.fit(X, y)
+    if predict_method in methods_to_check:
+        with pytest.raises(AssertionError):
+            getattr(clf, predict_method)(X)
+    else:
+        getattr(clf, predict_method)(X)
+
+
+@pytest.mark.parametrize(
+    "response_methods",
+    [
+        ["predict"],
+        ["predict", "predict_proba"],
+        ["predict", "decision_function"],
+        ["predict", "predict_proba", "decision_function"],
+    ],
+)
+def test_mock_estimator_on_off_prediction(iris, response_methods):
+    X, y = iris
+    estimator = _MockEstimatorOnOffPrediction(response_methods=response_methods)
+
+    estimator.fit(X, y)
+    assert hasattr(estimator, "classes_")
+    assert_array_equal(estimator.classes_, np.unique(y))
+
+    possible_responses = ["predict", "predict_proba", "decision_function"]
+    for response in possible_responses:
+        if response in response_methods:
+            assert hasattr(estimator, response)
+            assert getattr(estimator, response)(X) == response
+        else:
+            assert not hasattr(estimator, response)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_multiclass.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_multiclass.py
new file mode 100644
index 0000000000000000000000000000000000000000..a686b721f239375d7e7787681d1f73e00f43bd6a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_multiclass.py
@@ -0,0 +1,645 @@
+import warnings
+from itertools import product
+
+import numpy as np
+import pytest
+from scipy.sparse import issparse
+
+from sklearn import config_context, datasets
+from sklearn.model_selection import ShuffleSplit
+from sklearn.svm import SVC
+from sklearn.utils._array_api import (
+    _get_namespace_device_dtype_ids,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._testing import (
+    _array_api_for_tests,
+    _convert_container,
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+from sklearn.utils.estimator_checks import _NotAnArray
+from sklearn.utils.fixes import (
+    COO_CONTAINERS,
+    CSC_CONTAINERS,
+    CSR_CONTAINERS,
+    DOK_CONTAINERS,
+    LIL_CONTAINERS,
+)
+from sklearn.utils.metaestimators import _safe_split
+from sklearn.utils.multiclass import (
+    _ovr_decision_function,
+    check_classification_targets,
+    class_distribution,
+    is_multilabel,
+    type_of_target,
+    unique_labels,
+)
+
+multilabel_explicit_zero = np.array([[0, 1], [1, 0]])
+multilabel_explicit_zero[:, 0] = 0
+
+
+def _generate_sparse(
+    data,
+    sparse_containers=tuple(
+        COO_CONTAINERS
+        + CSC_CONTAINERS
+        + CSR_CONTAINERS
+        + DOK_CONTAINERS
+        + LIL_CONTAINERS
+    ),
+    dtypes=(bool, int, np.int8, np.uint8, float, np.float32),
+):
+    return [
+        sparse_container(data, dtype=dtype)
+        for sparse_container in sparse_containers
+        for dtype in dtypes
+    ]
+
+
+EXAMPLES = {
+    "multilabel-indicator": [
+        # valid when the data is formatted as sparse or dense, identified
+        # by CSR format when the testing takes place
+        *_generate_sparse(
+            np.random.RandomState(42).randint(2, size=(10, 10)),
+            sparse_containers=CSR_CONTAINERS,
+            dtypes=(int,),
+        ),
+        [[0, 1], [1, 0]],
+        [[0, 1]],
+        *_generate_sparse(
+            multilabel_explicit_zero, sparse_containers=CSC_CONTAINERS, dtypes=(int,)
+        ),
+        *_generate_sparse([[0, 1], [1, 0]]),
+        *_generate_sparse([[0, 0], [0, 0]]),
+        *_generate_sparse([[0, 1]]),
+        # Only valid when data is dense
+        [[-1, 1], [1, -1]],
+        np.array([[-1, 1], [1, -1]]),
+        np.array([[-3, 3], [3, -3]]),
+        _NotAnArray(np.array([[-3, 3], [3, -3]])),
+    ],
+    "multiclass": [
+        [1, 0, 2, 2, 1, 4, 2, 4, 4, 4],
+        np.array([1, 0, 2]),
+        np.array([1, 0, 2], dtype=np.int8),
+        np.array([1, 0, 2], dtype=np.uint8),
+        np.array([1, 0, 2], dtype=float),
+        np.array([1, 0, 2], dtype=np.float32),
+        np.array([[1], [0], [2]]),
+        _NotAnArray(np.array([1, 0, 2])),
+        [0, 1, 2],
+        ["a", "b", "c"],
+        np.array(["a", "b", "c"]),
+        np.array(["a", "b", "c"], dtype=object),
+        np.array(["a", "b", "c"], dtype=object),
+    ],
+    "multiclass-multioutput": [
+        [[1, 0, 2, 2], [1, 4, 2, 4]],
+        [["a", "b"], ["c", "d"]],
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]]),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.int8),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.uint8),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=float),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.float32),
+        *_generate_sparse(
+            [[1, 0, 2, 2], [1, 4, 2, 4]],
+            sparse_containers=CSC_CONTAINERS + CSR_CONTAINERS,
+            dtypes=(int, np.int8, np.uint8, float, np.float32),
+        ),
+        np.array([["a", "b"], ["c", "d"]]),
+        np.array([["a", "b"], ["c", "d"]]),
+        np.array([["a", "b"], ["c", "d"]], dtype=object),
+        np.array([[1, 0, 2]]),
+        _NotAnArray(np.array([[1, 0, 2]])),
+    ],
+    "binary": [
+        [0, 1],
+        [1, 1],
+        [],
+        [0],
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1]),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=bool),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.int8),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.uint8),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=float),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.float32),
+        np.array([[0], [1]]),
+        _NotAnArray(np.array([[0], [1]])),
+        [1, -1],
+        [3, 5],
+        ["a"],
+        ["a", "b"],
+        ["abc", "def"],
+        np.array(["abc", "def"]),
+        ["a", "b"],
+        np.array(["abc", "def"], dtype=object),
+    ],
+    "continuous": [
+        [1e-5],
+        [0, 0.5],
+        np.array([[0], [0.5]]),
+        np.array([[0], [0.5]], dtype=np.float32),
+    ],
+    "continuous-multioutput": [
+        np.array([[0, 0.5], [0.5, 0]]),
+        np.array([[0, 0.5], [0.5, 0]], dtype=np.float32),
+        np.array([[0, 0.5]]),
+        *_generate_sparse(
+            [[0, 0.5], [0.5, 0]],
+            sparse_containers=CSC_CONTAINERS + CSR_CONTAINERS,
+            dtypes=(float, np.float32),
+        ),
+        *_generate_sparse(
+            [[0, 0.5]],
+            sparse_containers=CSC_CONTAINERS + CSR_CONTAINERS,
+            dtypes=(float, np.float32),
+        ),
+    ],
+    "unknown": [
+        [[]],
+        np.array([[]], dtype=object),
+        [()],
+        # sequence of sequences that weren't supported even before deprecation
+        np.array([np.array([]), np.array([1, 2, 3])], dtype=object),
+        [np.array([]), np.array([1, 2, 3])],
+        [{1, 2, 3}, {1, 2}],
+        [frozenset([1, 2, 3]), frozenset([1, 2])],
+        # and also confusable as sequences of sequences
+        [{0: "a", 1: "b"}, {0: "a"}],
+        # ndim 0
+        np.array(0),
+        # empty second dimension
+        np.array([[], []]),
+        # 3d
+        np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]),
+    ],
+}
+
+ARRAY_API_EXAMPLES = {
+    "multilabel-indicator": [
+        np.random.RandomState(42).randint(2, size=(10, 10)),
+        [[0, 1], [1, 0]],
+        [[0, 1]],
+        multilabel_explicit_zero,
+        [[0, 0], [0, 0]],
+        [[-1, 1], [1, -1]],
+        np.array([[-1, 1], [1, -1]]),
+        np.array([[-3, 3], [3, -3]]),
+        _NotAnArray(np.array([[-3, 3], [3, -3]])),
+    ],
+    "multiclass": [
+        [1, 0, 2, 2, 1, 4, 2, 4, 4, 4],
+        np.array([1, 0, 2]),
+        np.array([1, 0, 2], dtype=np.int8),
+        np.array([1, 0, 2], dtype=np.uint8),
+        np.array([1, 0, 2], dtype=float),
+        np.array([1, 0, 2], dtype=np.float32),
+        np.array([[1], [0], [2]]),
+        _NotAnArray(np.array([1, 0, 2])),
+        [0, 1, 2],
+    ],
+    "multiclass-multioutput": [
+        [[1, 0, 2, 2], [1, 4, 2, 4]],
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]]),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.int8),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.uint8),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=float),
+        np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.float32),
+        np.array([[1, 0, 2]]),
+        _NotAnArray(np.array([[1, 0, 2]])),
+    ],
+    "binary": [
+        [0, 1],
+        [1, 1],
+        [],
+        [0],
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1]),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=bool),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.int8),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.uint8),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=float),
+        np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.float32),
+        np.array([[0], [1]]),
+        _NotAnArray(np.array([[0], [1]])),
+        [1, -1],
+        [3, 5],
+    ],
+    "continuous": [
+        [1e-5],
+        [0, 0.5],
+        np.array([[0], [0.5]]),
+        np.array([[0], [0.5]], dtype=np.float32),
+    ],
+    "continuous-multioutput": [
+        np.array([[0, 0.5], [0.5, 0]]),
+        np.array([[0, 0.5], [0.5, 0]], dtype=np.float32),
+        np.array([[0, 0.5]]),
+    ],
+    "unknown": [
+        [[]],
+        [()],
+        np.array(0),
+        np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]),
+    ],
+}
+
+
+NON_ARRAY_LIKE_EXAMPLES = [
+    {1, 2, 3},
+    {0: "a", 1: "b"},
+    {0: [5], 1: [5]},
+    "abc",
+    frozenset([1, 2, 3]),
+    None,
+]
+
+MULTILABEL_SEQUENCES = [
+    [[1], [2], [0, 1]],
+    [(), (2), (0, 1)],
+    np.array([[], [1, 2]], dtype="object"),
+    _NotAnArray(np.array([[], [1, 2]], dtype="object")),
+]
+
+
+def test_unique_labels():
+    # Empty iterable
+    with pytest.raises(ValueError):
+        unique_labels()
+
+    # Multiclass problem
+    assert_array_equal(unique_labels(range(10)), np.arange(10))
+    assert_array_equal(unique_labels(np.arange(10)), np.arange(10))
+    assert_array_equal(unique_labels([4, 0, 2]), np.array([0, 2, 4]))
+
+    # Multilabel indicator
+    assert_array_equal(
+        unique_labels(np.array([[0, 0, 1], [1, 0, 1], [0, 0, 0]])), np.arange(3)
+    )
+
+    assert_array_equal(unique_labels(np.array([[0, 0, 1], [0, 0, 0]])), np.arange(3))
+
+    # Several arrays passed
+    assert_array_equal(unique_labels([4, 0, 2], range(5)), np.arange(5))
+    assert_array_equal(unique_labels((0, 1, 2), (0,), (2, 1)), np.arange(3))
+
+    # Border line case with binary indicator matrix
+    with pytest.raises(ValueError):
+        unique_labels([4, 0, 2], np.ones((5, 5)))
+    with pytest.raises(ValueError):
+        unique_labels(np.ones((5, 4)), np.ones((5, 5)))
+
+    assert_array_equal(unique_labels(np.ones((4, 5)), np.ones((5, 5))), np.arange(5))
+
+
+def test_type_of_target_too_many_unique_classes():
+    """Check that we raise a warning when the number of unique classes is greater than
+    50% of the number of samples.
+
+    We need to check that we don't raise if we have less than 20 samples.
+    """
+
+    # Create array of unique labels, except '0', which appears twice.
+    # This does raise a warning.
+    # Note warning would not be raised if we passed only unique
+    # labels, which happens when `type_of_target` is passed `classes_`.
+    y = np.hstack((np.arange(20), [0]))
+    msg = r"The number of unique classes is greater than 50% of the number of samples."
+    with pytest.warns(UserWarning, match=msg):
+        type_of_target(y)
+
+    # less than 20 samples, no warning should be raised
+    y = np.arange(10)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        type_of_target(y)
+
+    # More than 20 samples but only unique classes, simulating passing
+    # `classes_` to `type_of_target` (when number of classes is large).
+    # No warning should be raised
+    y = np.arange(25)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        type_of_target(y)
+
+
+def test_unique_labels_non_specific():
+    # Test unique_labels with a variety of collected examples
+
+    # Smoke test for all supported format
+    for format in ["binary", "multiclass", "multilabel-indicator"]:
+        for y in EXAMPLES[format]:
+            unique_labels(y)
+
+    # We don't support those format at the moment
+    for example in NON_ARRAY_LIKE_EXAMPLES:
+        with pytest.raises(ValueError):
+            unique_labels(example)
+
+    for y_type in [
+        "unknown",
+        "continuous",
+        "continuous-multioutput",
+        "multiclass-multioutput",
+    ]:
+        for example in EXAMPLES[y_type]:
+            with pytest.raises(ValueError):
+                unique_labels(example)
+
+
+def test_unique_labels_mixed_types():
+    # Mix with binary or multiclass and multilabel
+    mix_clf_format = product(
+        EXAMPLES["multilabel-indicator"], EXAMPLES["multiclass"] + EXAMPLES["binary"]
+    )
+
+    for y_multilabel, y_multiclass in mix_clf_format:
+        with pytest.raises(ValueError):
+            unique_labels(y_multiclass, y_multilabel)
+        with pytest.raises(ValueError):
+            unique_labels(y_multilabel, y_multiclass)
+
+    with pytest.raises(ValueError):
+        unique_labels([[1, 2]], [["a", "d"]])
+
+    with pytest.raises(ValueError):
+        unique_labels(["1", 2])
+
+    with pytest.raises(ValueError):
+        unique_labels([["1", 2], [1, 3]])
+
+    with pytest.raises(ValueError):
+        unique_labels([["1", "2"], [2, 3]])
+
+
+def test_is_multilabel():
+    for group, group_examples in EXAMPLES.items():
+        dense_exp = group == "multilabel-indicator"
+
+        for example in group_examples:
+            # Only mark explicitly defined sparse examples as valid sparse
+            # multilabel-indicators
+            sparse_exp = dense_exp and issparse(example)
+
+            if issparse(example) or (
+                hasattr(example, "__array__")
+                and np.asarray(example).ndim == 2
+                and np.asarray(example).dtype.kind in "biuf"
+                and np.asarray(example).shape[1] > 0
+            ):
+                examples_sparse = [
+                    sparse_container(example)
+                    for sparse_container in (
+                        COO_CONTAINERS
+                        + CSC_CONTAINERS
+                        + CSR_CONTAINERS
+                        + DOK_CONTAINERS
+                        + LIL_CONTAINERS
+                    )
+                ]
+                for exmpl_sparse in examples_sparse:
+                    assert sparse_exp == is_multilabel(exmpl_sparse), (
+                        f"is_multilabel({exmpl_sparse!r}) should be {sparse_exp}"
+                    )
+
+            # Densify sparse examples before testing
+            if issparse(example):
+                example = example.toarray()
+
+            assert dense_exp == is_multilabel(example), (
+                f"is_multilabel({example!r}) should be {dense_exp}"
+            )
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_is_multilabel_array_api_compliance(array_namespace, device, dtype_name):
+    xp = _array_api_for_tests(array_namespace, device)
+
+    for group, group_examples in ARRAY_API_EXAMPLES.items():
+        dense_exp = group == "multilabel-indicator"
+        for example in group_examples:
+            if np.asarray(example).dtype.kind == "f":
+                example = np.asarray(example, dtype=dtype_name)
+            else:
+                example = np.asarray(example)
+            example = xp.asarray(example, device=device)
+
+            with config_context(array_api_dispatch=True):
+                assert dense_exp == is_multilabel(example), (
+                    f"is_multilabel({example!r}) should be {dense_exp}"
+                )
+
+
+def test_check_classification_targets():
+    for y_type in EXAMPLES.keys():
+        if y_type in ["unknown", "continuous", "continuous-multioutput"]:
+            for example in EXAMPLES[y_type]:
+                msg = "Unknown label type: "
+                with pytest.raises(ValueError, match=msg):
+                    check_classification_targets(example)
+        else:
+            for example in EXAMPLES[y_type]:
+                check_classification_targets(example)
+
+
+def test_type_of_target():
+    for group, group_examples in EXAMPLES.items():
+        for example in group_examples:
+            assert type_of_target(example) == group, (
+                "type_of_target(%r) should be %r, got %r"
+                % (
+                    example,
+                    group,
+                    type_of_target(example),
+                )
+            )
+
+    for example in NON_ARRAY_LIKE_EXAMPLES:
+        msg_regex = r"Expected array-like \(array or non-string sequence\).*"
+        with pytest.raises(ValueError, match=msg_regex):
+            type_of_target(example)
+
+    for example in MULTILABEL_SEQUENCES:
+        msg = (
+            "You appear to be using a legacy multi-label data "
+            "representation. Sequence of sequences are no longer supported;"
+            " use a binary array or sparse matrix instead."
+        )
+        with pytest.raises(ValueError, match=msg):
+            type_of_target(example)
+
+
+def test_type_of_target_pandas_sparse():
+    pd = pytest.importorskip("pandas")
+
+    y = pd.arrays.SparseArray([1, np.nan, np.nan, 1, np.nan])
+    msg = "y cannot be class 'SparseSeries' or 'SparseArray'"
+    with pytest.raises(ValueError, match=msg):
+        type_of_target(y)
+
+
+def test_type_of_target_pandas_nullable():
+    """Check that type_of_target works with pandas nullable dtypes."""
+    pd = pytest.importorskip("pandas")
+
+    for dtype in ["Int32", "Float32"]:
+        y_true = pd.Series([1, 0, 2, 3, 4], dtype=dtype)
+        assert type_of_target(y_true) == "multiclass"
+
+        y_true = pd.Series([1, 0, 1, 0], dtype=dtype)
+        assert type_of_target(y_true) == "binary"
+
+    y_true = pd.DataFrame([[1.4, 3.1], [3.1, 1.4]], dtype="Float32")
+    assert type_of_target(y_true) == "continuous-multioutput"
+
+    y_true = pd.DataFrame([[0, 1], [1, 1]], dtype="Int32")
+    assert type_of_target(y_true) == "multilabel-indicator"
+
+    y_true = pd.DataFrame([[1, 2], [3, 1]], dtype="Int32")
+    assert type_of_target(y_true) == "multiclass-multioutput"
+
+
+@pytest.mark.parametrize("dtype", ["Int64", "Float64", "boolean"])
+def test_unique_labels_pandas_nullable(dtype):
+    """Checks that unique_labels work with pandas nullable dtypes.
+
+    Non-regression test for gh-25634.
+    """
+    pd = pytest.importorskip("pandas")
+
+    y_true = pd.Series([1, 0, 0, 1, 0, 1, 1, 0, 1], dtype=dtype)
+    y_predicted = pd.Series([0, 0, 1, 1, 0, 1, 1, 1, 1], dtype="int64")
+
+    labels = unique_labels(y_true, y_predicted)
+    assert_array_equal(labels, [0, 1])
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+def test_class_distribution(csc_container):
+    y = np.array(
+        [
+            [1, 0, 0, 1],
+            [2, 2, 0, 1],
+            [1, 3, 0, 1],
+            [4, 2, 0, 1],
+            [2, 0, 0, 1],
+            [1, 3, 0, 1],
+        ]
+    )
+    # Define the sparse matrix with a mix of implicit and explicit zeros
+    data = np.array([1, 2, 1, 4, 2, 1, 0, 2, 3, 2, 3, 1, 1, 1, 1, 1, 1])
+    indices = np.array([0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 5, 0, 1, 2, 3, 4, 5])
+    indptr = np.array([0, 6, 11, 11, 17])
+    y_sp = csc_container((data, indices, indptr), shape=(6, 4))
+
+    classes, n_classes, class_prior = class_distribution(y)
+    classes_sp, n_classes_sp, class_prior_sp = class_distribution(y_sp)
+    classes_expected = [[1, 2, 4], [0, 2, 3], [0], [1]]
+    n_classes_expected = [3, 3, 1, 1]
+    class_prior_expected = [[3 / 6, 2 / 6, 1 / 6], [1 / 3, 1 / 3, 1 / 3], [1.0], [1.0]]
+
+    for k in range(y.shape[1]):
+        assert_array_almost_equal(classes[k], classes_expected[k])
+        assert_array_almost_equal(n_classes[k], n_classes_expected[k])
+        assert_array_almost_equal(class_prior[k], class_prior_expected[k])
+
+        assert_array_almost_equal(classes_sp[k], classes_expected[k])
+        assert_array_almost_equal(n_classes_sp[k], n_classes_expected[k])
+        assert_array_almost_equal(class_prior_sp[k], class_prior_expected[k])
+
+    # Test again with explicit sample weights
+    (classes, n_classes, class_prior) = class_distribution(
+        y, [1.0, 2.0, 1.0, 2.0, 1.0, 2.0]
+    )
+    (classes_sp, n_classes_sp, class_prior_sp) = class_distribution(
+        y, [1.0, 2.0, 1.0, 2.0, 1.0, 2.0]
+    )
+    class_prior_expected = [[4 / 9, 3 / 9, 2 / 9], [2 / 9, 4 / 9, 3 / 9], [1.0], [1.0]]
+
+    for k in range(y.shape[1]):
+        assert_array_almost_equal(classes[k], classes_expected[k])
+        assert_array_almost_equal(n_classes[k], n_classes_expected[k])
+        assert_array_almost_equal(class_prior[k], class_prior_expected[k])
+
+        assert_array_almost_equal(classes_sp[k], classes_expected[k])
+        assert_array_almost_equal(n_classes_sp[k], n_classes_expected[k])
+        assert_array_almost_equal(class_prior_sp[k], class_prior_expected[k])
+
+
+def test_safe_split_with_precomputed_kernel():
+    clf = SVC()
+    clfp = SVC(kernel="precomputed")
+
+    iris = datasets.load_iris()
+    X, y = iris.data, iris.target
+    K = np.dot(X, X.T)
+
+    cv = ShuffleSplit(test_size=0.25, random_state=0)
+    train, test = next(iter(cv.split(X)))
+
+    X_train, y_train = _safe_split(clf, X, y, train)
+    K_train, y_train2 = _safe_split(clfp, K, y, train)
+    assert_array_almost_equal(K_train, np.dot(X_train, X_train.T))
+    assert_array_almost_equal(y_train, y_train2)
+
+    X_test, y_test = _safe_split(clf, X, y, test, train)
+    K_test, y_test2 = _safe_split(clfp, K, y, test, train)
+    assert_array_almost_equal(K_test, np.dot(X_test, X_train.T))
+    assert_array_almost_equal(y_test, y_test2)
+
+
+def test_ovr_decision_function():
+    # test properties for ovr decision function
+
+    predictions = np.array([[0, 1, 1], [0, 1, 0], [0, 1, 1], [0, 1, 1]])
+
+    confidences = np.array(
+        [[-1e16, 0, -1e16], [1.0, 2.0, -3.0], [-5.0, 2.0, 5.0], [-0.5, 0.2, 0.5]]
+    )
+
+    n_classes = 3
+
+    dec_values = _ovr_decision_function(predictions, confidences, n_classes)
+
+    # check that the decision values are within 0.5 range of the votes
+    votes = np.array([[1, 0, 2], [1, 1, 1], [1, 0, 2], [1, 0, 2]])
+
+    assert_allclose(votes, dec_values, atol=0.5)
+
+    # check that the prediction are what we expect
+    # highest vote or highest confidence if there is a tie.
+    # for the second sample we have a tie (should be won by 1)
+    expected_prediction = np.array([2, 1, 2, 2])
+    assert_array_equal(np.argmax(dec_values, axis=1), expected_prediction)
+
+    # third and fourth sample have the same vote but third sample
+    # has higher confidence, this should reflect on the decision values
+    assert dec_values[2, 2] > dec_values[3, 2]
+
+    # assert subset invariance.
+    dec_values_one = [
+        _ovr_decision_function(
+            np.array([predictions[i]]), np.array([confidences[i]]), n_classes
+        )[0]
+        for i in range(4)
+    ]
+
+    assert_allclose(dec_values, dec_values_one, atol=1e-6)
+
+
+@pytest.mark.parametrize("input_type", ["list", "array"])
+def test_labels_in_bytes_format_error(input_type):
+    # check that we raise an error with bytes encoded labels
+    # non-regression test for:
+    # https://github.com/scikit-learn/scikit-learn/issues/16980
+    target = _convert_container([b"a", b"b"], input_type)
+    err_msg = "Support for labels represented as bytes is not supported"
+    with pytest.raises(TypeError, match=err_msg):
+        type_of_target(target)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_murmurhash.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_murmurhash.py
new file mode 100644
index 0000000000000000000000000000000000000000..20721c6e98f524ff03db28e60909fb8979090e81
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_murmurhash.py
@@ -0,0 +1,73 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+
+from sklearn.utils.murmurhash import murmurhash3_32
+
+
+def test_mmhash3_int():
+    assert murmurhash3_32(3) == 847579505
+    assert murmurhash3_32(3, seed=0) == 847579505
+    assert murmurhash3_32(3, seed=42) == -1823081949
+
+    assert murmurhash3_32(3, positive=False) == 847579505
+    assert murmurhash3_32(3, seed=0, positive=False) == 847579505
+    assert murmurhash3_32(3, seed=42, positive=False) == -1823081949
+
+    assert murmurhash3_32(3, positive=True) == 847579505
+    assert murmurhash3_32(3, seed=0, positive=True) == 847579505
+    assert murmurhash3_32(3, seed=42, positive=True) == 2471885347
+
+
+def test_mmhash3_int_array():
+    rng = np.random.RandomState(42)
+    keys = rng.randint(-5342534, 345345, size=3 * 2 * 1).astype(np.int32)
+    keys = keys.reshape((3, 2, 1))
+
+    for seed in [0, 42]:
+        expected = np.array([murmurhash3_32(int(k), seed) for k in keys.flat])
+        expected = expected.reshape(keys.shape)
+        assert_array_equal(murmurhash3_32(keys, seed), expected)
+
+    for seed in [0, 42]:
+        expected = np.array([murmurhash3_32(k, seed, positive=True) for k in keys.flat])
+        expected = expected.reshape(keys.shape)
+        assert_array_equal(murmurhash3_32(keys, seed, positive=True), expected)
+
+
+def test_mmhash3_bytes():
+    assert murmurhash3_32(b"foo", 0) == -156908512
+    assert murmurhash3_32(b"foo", 42) == -1322301282
+
+    assert murmurhash3_32(b"foo", 0, positive=True) == 4138058784
+    assert murmurhash3_32(b"foo", 42, positive=True) == 2972666014
+
+
+def test_mmhash3_unicode():
+    assert murmurhash3_32("foo", 0) == -156908512
+    assert murmurhash3_32("foo", 42) == -1322301282
+
+    assert murmurhash3_32("foo", 0, positive=True) == 4138058784
+    assert murmurhash3_32("foo", 42, positive=True) == 2972666014
+
+
+def test_no_collision_on_byte_range():
+    previous_hashes = set()
+    for i in range(100):
+        h = murmurhash3_32(" " * i, 0)
+        assert h not in previous_hashes, "Found collision on growing empty string"
+
+
+def test_uniform_distribution():
+    n_bins, n_samples = 10, 100000
+    bins = np.zeros(n_bins, dtype=np.float64)
+
+    for i in range(n_samples):
+        bins[murmurhash3_32(i, positive=True) % n_bins] += 1
+
+    means = bins / n_samples
+    expected = np.full(n_bins, 1.0 / n_bins)
+
+    assert_array_almost_equal(means / expected, np.ones(n_bins), 2)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_optimize.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_optimize.py
new file mode 100644
index 0000000000000000000000000000000000000000..f99f3a91318082b22a772642b73f376ef9493273
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_optimize.py
@@ -0,0 +1,220 @@
+import warnings
+
+import numpy as np
+import pytest
+from scipy.optimize import fmin_ncg
+
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.utils._bunch import Bunch
+from sklearn.utils._testing import assert_allclose
+from sklearn.utils.optimize import _check_optimize_result, _newton_cg
+
+
+def test_newton_cg(global_random_seed):
+    # Test that newton_cg gives same result as scipy's fmin_ncg
+
+    rng = np.random.RandomState(global_random_seed)
+    A = rng.normal(size=(10, 10))
+    x0 = np.ones(10)
+
+    def func(x):
+        Ax = A.dot(x)
+        return 0.5 * (Ax).dot(Ax)
+
+    def grad(x):
+        return A.T.dot(A.dot(x))
+
+    def hess(x, p):
+        return p.dot(A.T.dot(A.dot(x.all())))
+
+    def grad_hess(x):
+        return grad(x), lambda x: A.T.dot(A.dot(x))
+
+    # func is a definite positive quadratic form, so the minimum is at x = 0
+    # hence the use of absolute tolerance.
+    assert np.all(np.abs(_newton_cg(grad_hess, func, grad, x0, tol=1e-10)[0]) <= 1e-7)
+    assert_allclose(
+        _newton_cg(grad_hess, func, grad, x0, tol=1e-7)[0],
+        fmin_ncg(f=func, x0=x0, fprime=grad, fhess_p=hess),
+        atol=1e-5,
+    )
+
+
+@pytest.mark.parametrize("verbose", [0, 1, 2])
+def test_newton_cg_verbosity(capsys, verbose):
+    """Test the std output of verbose newton_cg solver."""
+    A = np.eye(2)
+    b = np.array([1, 2], dtype=float)
+
+    _newton_cg(
+        grad_hess=lambda x: (A @ x - b, lambda z: A @ z),
+        func=lambda x: 0.5 * x @ A @ x - b @ x,
+        grad=lambda x: A @ x - b,
+        x0=np.zeros(A.shape[0]),
+        verbose=verbose,
+    )  # returns array([1., 2])
+    captured = capsys.readouterr()
+
+    if verbose == 0:
+        assert captured.out == ""
+    else:
+        msg = [
+            "Newton-CG iter = 1",
+            "Check Convergence",
+            "max |gradient|",
+            "Solver did converge at loss = ",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+    if verbose >= 2:
+        msg = [
+            "Inner CG solver iteration 1 stopped with",
+            "sum(|residuals|) <= tol",
+            "Line Search",
+            "try line search wolfe1",
+            "wolfe1 line search was successful",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+    if verbose >= 2:
+        # Set up a badly scaled singular Hessian with a completely wrong starting
+        # position. This should trigger 2nd line search check
+        A = np.array([[1.0, 2], [2, 4]]) * 1e30  # collinear columns
+        b = np.array([1.0, 2.0])
+        # Note that scipy.optimize._linesearch LineSearchWarning inherits from
+        # RuntimeWarning, but we do not want to import from non public APIs.
+        with pytest.warns(RuntimeWarning):
+            _newton_cg(
+                grad_hess=lambda x: (A @ x - b, lambda z: A @ z),
+                func=lambda x: 0.5 * x @ A @ x - b @ x,
+                grad=lambda x: A @ x - b,
+                x0=np.array([-2.0, 1]),  # null space of hessian
+                verbose=verbose,
+            )
+        captured = capsys.readouterr()
+        msg = [
+            "wolfe1 line search was not successful",
+            "check loss |improvement| <= eps * |loss_old|:",
+            "check sum(|gradient|) < sum(|gradient_old|):",
+            "last resort: try line search wolfe2",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+        # Set up a badly conditioned Hessian that leads to tiny curvature.
+        # X.T @ X have singular values array([1.00000400e+01, 1.00008192e-11])
+        A = np.array([[1.0, 2], [1, 2 + 1e-15]])
+        b = np.array([-2.0, 1])
+        with pytest.warns(ConvergenceWarning):
+            _newton_cg(
+                grad_hess=lambda x: (A @ x - b, lambda z: A @ z),
+                func=lambda x: 0.5 * x @ A @ x - b @ x,
+                grad=lambda x: A @ x - b,
+                x0=b,
+                verbose=verbose,
+                maxiter=2,
+            )
+        captured = capsys.readouterr()
+        msg = [
+            "tiny_|p| = eps * ||p||^2",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+        # Test for a case with negative Hessian.
+        # We do not trigger "Inner CG solver iteration {i} stopped with negative
+        # curvature", but that is very hard to trigger.
+        A = np.eye(2)
+        b = np.array([-2.0, 1])
+        with pytest.warns(RuntimeWarning):
+            _newton_cg(
+                # Note the wrong sign in the hessian product.
+                grad_hess=lambda x: (A @ x - b, lambda z: -A @ z),
+                func=lambda x: 0.5 * x @ A @ x - b @ x,
+                grad=lambda x: A @ x - b,
+                x0=np.array([1.0, 1.0]),
+                verbose=verbose,
+                maxiter=3,
+            )
+        captured = capsys.readouterr()
+        msg = [
+            "Inner CG solver iteration 0 fell back to steepest descent",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+        A = np.diag([1e-3, 1, 1e3])
+        b = np.array([-2.0, 1, 2.0])
+        with pytest.warns(ConvergenceWarning):
+            _newton_cg(
+                grad_hess=lambda x: (A @ x - b, lambda z: A @ z),
+                func=lambda x: 0.5 * x @ A @ x - b @ x,
+                grad=lambda x: A @ x - b,
+                x0=np.ones_like(b),
+                verbose=verbose,
+                maxiter=2,
+                maxinner=1,
+            )
+        captured = capsys.readouterr()
+        msg = [
+            "Inner CG solver stopped reaching maxiter=1",
+        ]
+        for m in msg:
+            assert m in captured.out
+
+
+def test_check_optimize():
+    # Mock some lbfgs output using a Bunch instance:
+    result = Bunch()
+
+    # First case: no warnings
+    result.nit = 1
+    result.status = 0
+    result.message = "OK"
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        _check_optimize_result("lbfgs", result)
+
+    # Second case: warning about implicit `max_iter`: do not recommend the user
+    # to increase `max_iter` this is not a user settable parameter.
+    result.status = 1
+    result.message = "STOP: TOTAL NO. OF ITERATIONS REACHED LIMIT"
+    with pytest.warns(ConvergenceWarning) as record:
+        _check_optimize_result("lbfgs", result)
+
+    assert len(record) == 1
+    warn_msg = record[0].message.args[0]
+    assert "lbfgs failed to converge after 1 iteration(s)" in warn_msg
+    assert result.message in warn_msg
+    assert "Increase the number of iterations" not in warn_msg
+    assert "scale the data" in warn_msg
+
+    # Third case: warning about explicit `max_iter`: recommend user to increase
+    # `max_iter`.
+    with pytest.warns(ConvergenceWarning) as record:
+        _check_optimize_result("lbfgs", result, max_iter=1)
+
+    assert len(record) == 1
+    warn_msg = record[0].message.args[0]
+    assert "lbfgs failed to converge after 1 iteration(s)" in warn_msg
+    assert result.message in warn_msg
+    assert "Increase the number of iterations" in warn_msg
+    assert "scale the data" in warn_msg
+
+    # Fourth case: other convergence problem before reaching `max_iter`: do not
+    # recommend increasing `max_iter`.
+    result.nit = 2
+    result.status = 2
+    result.message = "ABNORMAL"
+    with pytest.warns(ConvergenceWarning) as record:
+        _check_optimize_result("lbfgs", result, max_iter=10)
+
+    assert len(record) == 1
+    warn_msg = record[0].message.args[0]
+    assert "lbfgs failed to converge after 2 iteration(s)" in warn_msg
+    assert result.message in warn_msg
+    assert "Increase the number of iterations" not in warn_msg
+    assert "scale the data" in warn_msg
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_parallel.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..e79adf064b44e6ca12ebc85731a970b9f782b4d4
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_parallel.py
@@ -0,0 +1,155 @@
+import time
+import warnings
+
+import joblib
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn import config_context, get_config
+from sklearn.compose import make_column_transformer
+from sklearn.datasets import load_iris
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.model_selection import GridSearchCV
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils.fixes import _IS_WASM
+from sklearn.utils.parallel import Parallel, delayed
+
+
+def get_working_memory():
+    return get_config()["working_memory"]
+
+
+@pytest.mark.parametrize("n_jobs", [1, 2])
+@pytest.mark.parametrize("backend", ["loky", "threading", "multiprocessing"])
+def test_configuration_passes_through_to_joblib(n_jobs, backend):
+    # Tests that the global global configuration is passed to joblib jobs
+
+    with config_context(working_memory=123):
+        results = Parallel(n_jobs=n_jobs, backend=backend)(
+            delayed(get_working_memory)() for _ in range(2)
+        )
+
+    assert_array_equal(results, [123] * 2)
+
+
+def test_parallel_delayed_warnings():
+    """Informative warnings should be raised when mixing sklearn and joblib API"""
+    # We should issue a warning when one wants to use sklearn.utils.fixes.Parallel
+    # with joblib.delayed. The config will not be propagated to the workers.
+    warn_msg = "`sklearn.utils.parallel.Parallel` needs to be used in conjunction"
+    with pytest.warns(UserWarning, match=warn_msg) as records:
+        Parallel()(joblib.delayed(time.sleep)(0) for _ in range(10))
+    assert len(records) == 10
+
+    # We should issue a warning if one wants to use sklearn.utils.fixes.delayed with
+    # joblib.Parallel
+    warn_msg = (
+        "`sklearn.utils.parallel.delayed` should be used with "
+        "`sklearn.utils.parallel.Parallel` to make it possible to propagate"
+    )
+    with pytest.warns(UserWarning, match=warn_msg) as records:
+        joblib.Parallel()(delayed(time.sleep)(0) for _ in range(10))
+    assert len(records) == 10
+
+
+@pytest.mark.parametrize("n_jobs", [1, 2])
+def test_dispatch_config_parallel(n_jobs):
+    """Check that we properly dispatch the configuration in parallel processing.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/25239
+    """
+    pd = pytest.importorskip("pandas")
+    iris = load_iris(as_frame=True)
+
+    class TransformerRequiredDataFrame(StandardScaler):
+        def fit(self, X, y=None):
+            assert isinstance(X, pd.DataFrame), "X should be a DataFrame"
+            return super().fit(X, y)
+
+        def transform(self, X, y=None):
+            assert isinstance(X, pd.DataFrame), "X should be a DataFrame"
+            return super().transform(X, y)
+
+    dropper = make_column_transformer(
+        ("drop", [0]),
+        remainder="passthrough",
+        n_jobs=n_jobs,
+    )
+    param_grid = {"randomforestclassifier__max_depth": [1, 2, 3]}
+    search_cv = GridSearchCV(
+        make_pipeline(
+            dropper,
+            TransformerRequiredDataFrame(),
+            RandomForestClassifier(n_estimators=5, n_jobs=n_jobs),
+        ),
+        param_grid,
+        cv=5,
+        n_jobs=n_jobs,
+        error_score="raise",  # this search should not fail
+    )
+
+    # make sure that `fit` would fail in case we don't request dataframe
+    with pytest.raises(AssertionError, match="X should be a DataFrame"):
+        search_cv.fit(iris.data, iris.target)
+
+    with config_context(transform_output="pandas"):
+        # we expect each intermediate steps to output a DataFrame
+        search_cv.fit(iris.data, iris.target)
+
+    assert not np.isnan(search_cv.cv_results_["mean_test_score"]).any()
+
+
+def raise_warning():
+    warnings.warn("Convergence warning", ConvergenceWarning)
+
+
+@pytest.mark.parametrize("n_jobs", [1, 2])
+@pytest.mark.parametrize("backend", ["loky", "threading", "multiprocessing"])
+def test_filter_warning_propagates(n_jobs, backend):
+    """Check warning propagates to the job."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", category=ConvergenceWarning)
+
+        with pytest.raises(ConvergenceWarning):
+            Parallel(n_jobs=n_jobs, backend=backend)(
+                delayed(raise_warning)() for _ in range(2)
+            )
+
+
+def get_warnings():
+    return warnings.filters
+
+
+def test_check_warnings_threading():
+    """Check that warnings filters are set correctly in the threading backend."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", category=ConvergenceWarning)
+
+        filters = warnings.filters
+        assert ("error", None, ConvergenceWarning, None, 0) in filters
+
+        all_warnings = Parallel(n_jobs=2, backend="threading")(
+            delayed(get_warnings)() for _ in range(2)
+        )
+
+        assert all(w == filters for w in all_warnings)
+
+
+@pytest.mark.xfail(_IS_WASM, reason="Pyodide always use the sequential backend")
+def test_filter_warning_propagates_no_side_effect_with_loky_backend():
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", category=ConvergenceWarning)
+
+        Parallel(n_jobs=2, backend="loky")(delayed(time.sleep)(0) for _ in range(10))
+
+        # Since loky workers are reused, make sure that inside the loky workers,
+        # warnings filters have been reset to their original value. Using joblib
+        # directly should not turn ConvergenceWarning into an error.
+        joblib.Parallel(n_jobs=2, backend="loky")(
+            joblib.delayed(warnings.warn)("Convergence warning", ConvergenceWarning)
+            for _ in range(10)
+        )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_param_validation.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_param_validation.py
new file mode 100644
index 0000000000000000000000000000000000000000..a47eaace5b9a2362e7abf6326f2e0c7ad10c112f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_param_validation.py
@@ -0,0 +1,786 @@
+from numbers import Integral, Real
+
+import numpy as np
+import pytest
+from scipy.sparse import csr_matrix
+
+from sklearn._config import config_context, get_config
+from sklearn.base import BaseEstimator, _fit_context
+from sklearn.model_selection import LeaveOneOut
+from sklearn.utils import deprecated
+from sklearn.utils._param_validation import (
+    HasMethods,
+    Hidden,
+    Interval,
+    InvalidParameterError,
+    MissingValues,
+    Options,
+    RealNotInt,
+    StrOptions,
+    _ArrayLikes,
+    _Booleans,
+    _Callables,
+    _CVObjects,
+    _InstancesOf,
+    _IterablesNotString,
+    _NanConstraint,
+    _NoneConstraint,
+    _PandasNAConstraint,
+    _RandomStates,
+    _SparseMatrices,
+    _VerboseHelper,
+    generate_invalid_param_val,
+    generate_valid_param,
+    make_constraint,
+    validate_params,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+
+# Some helpers for the tests
+@validate_params(
+    {"a": [Real], "b": [Real], "c": [Real], "d": [Real]},
+    prefer_skip_nested_validation=True,
+)
+def _func(a, b=0, *args, c, d=0, **kwargs):
+    """A function to test the validation of functions."""
+
+
+class _Class:
+    """A class to test the _InstancesOf constraint and the validation of methods."""
+
+    @validate_params({"a": [Real]}, prefer_skip_nested_validation=True)
+    def _method(self, a):
+        """A validated method"""
+
+    @deprecated()
+    @validate_params({"a": [Real]}, prefer_skip_nested_validation=True)
+    def _deprecated_method(self, a):
+        """A deprecated validated method"""
+
+
+class _Estimator(BaseEstimator):
+    """An estimator to test the validation of estimator parameters."""
+
+    _parameter_constraints: dict = {"a": [Real]}
+
+    def __init__(self, a):
+        self.a = a
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X=None, y=None):
+        pass
+
+
+@pytest.mark.parametrize("interval_type", [Integral, Real])
+def test_interval_range(interval_type):
+    """Check the range of values depending on closed."""
+    interval = Interval(interval_type, -2, 2, closed="left")
+    assert -2 in interval
+    assert 2 not in interval
+
+    interval = Interval(interval_type, -2, 2, closed="right")
+    assert -2 not in interval
+    assert 2 in interval
+
+    interval = Interval(interval_type, -2, 2, closed="both")
+    assert -2 in interval
+    assert 2 in interval
+
+    interval = Interval(interval_type, -2, 2, closed="neither")
+    assert -2 not in interval
+    assert 2 not in interval
+
+
+@pytest.mark.parametrize("interval_type", [Integral, Real])
+def test_interval_large_integers(interval_type):
+    """Check that Interval constraint work with large integers.
+
+    non-regression test for #26648.
+    """
+    interval = Interval(interval_type, 0, 2, closed="neither")
+    assert 2**65 not in interval
+    assert 2**128 not in interval
+    assert float(2**65) not in interval
+    assert float(2**128) not in interval
+
+    interval = Interval(interval_type, 0, 2**128, closed="neither")
+    assert 2**65 in interval
+    assert 2**128 not in interval
+    assert float(2**65) in interval
+    assert float(2**128) not in interval
+
+    assert 2**1024 not in interval
+
+
+def test_interval_inf_in_bounds():
+    """Check that inf is included iff a bound is closed and set to None.
+
+    Only valid for real intervals.
+    """
+    interval = Interval(Real, 0, None, closed="right")
+    assert np.inf in interval
+
+    interval = Interval(Real, None, 0, closed="left")
+    assert -np.inf in interval
+
+    interval = Interval(Real, None, None, closed="neither")
+    assert np.inf not in interval
+    assert -np.inf not in interval
+
+
+@pytest.mark.parametrize(
+    "interval",
+    [Interval(Real, 0, 1, closed="left"), Interval(Real, None, None, closed="both")],
+)
+def test_nan_not_in_interval(interval):
+    """Check that np.nan is not in any interval."""
+    assert np.nan not in interval
+
+
+@pytest.mark.parametrize(
+    "params, error, match",
+    [
+        (
+            {"type": Integral, "left": 1.0, "right": 2, "closed": "both"},
+            TypeError,
+            r"Expecting left to be an int for an interval over the integers",
+        ),
+        (
+            {"type": Integral, "left": 1, "right": 2.0, "closed": "neither"},
+            TypeError,
+            "Expecting right to be an int for an interval over the integers",
+        ),
+        (
+            {"type": Integral, "left": None, "right": 0, "closed": "left"},
+            ValueError,
+            r"left can't be None when closed == left",
+        ),
+        (
+            {"type": Integral, "left": 0, "right": None, "closed": "right"},
+            ValueError,
+            r"right can't be None when closed == right",
+        ),
+        (
+            {"type": Integral, "left": 1, "right": -1, "closed": "both"},
+            ValueError,
+            r"right can't be less than left",
+        ),
+    ],
+)
+def test_interval_errors(params, error, match):
+    """Check that informative errors are raised for invalid combination of parameters"""
+    with pytest.raises(error, match=match):
+        Interval(**params)
+
+
+def test_stroptions():
+    """Sanity check for the StrOptions constraint"""
+    options = StrOptions({"a", "b", "c"}, deprecated={"c"})
+    assert options.is_satisfied_by("a")
+    assert options.is_satisfied_by("c")
+    assert not options.is_satisfied_by("d")
+
+    assert "'c' (deprecated)" in str(options)
+
+
+def test_options():
+    """Sanity check for the Options constraint"""
+    options = Options(Real, {-0.5, 0.5, np.inf}, deprecated={-0.5})
+    assert options.is_satisfied_by(-0.5)
+    assert options.is_satisfied_by(np.inf)
+    assert not options.is_satisfied_by(1.23)
+
+    assert "-0.5 (deprecated)" in str(options)
+
+
+@pytest.mark.parametrize(
+    "type, expected_type_name",
+    [
+        (int, "int"),
+        (Integral, "int"),
+        (Real, "float"),
+        (np.ndarray, "numpy.ndarray"),
+    ],
+)
+def test_instances_of_type_human_readable(type, expected_type_name):
+    """Check the string representation of the _InstancesOf constraint."""
+    constraint = _InstancesOf(type)
+    assert str(constraint) == f"an instance of '{expected_type_name}'"
+
+
+def test_hasmethods():
+    """Check the HasMethods constraint."""
+    constraint = HasMethods(["a", "b"])
+
+    class _Good:
+        def a(self):
+            pass  # pragma: no cover
+
+        def b(self):
+            pass  # pragma: no cover
+
+    class _Bad:
+        def a(self):
+            pass  # pragma: no cover
+
+    assert constraint.is_satisfied_by(_Good())
+    assert not constraint.is_satisfied_by(_Bad())
+    assert str(constraint) == "an object implementing 'a' and 'b'"
+
+
+@pytest.mark.parametrize(
+    "constraint",
+    [
+        Interval(Real, None, 0, closed="left"),
+        Interval(Real, 0, None, closed="left"),
+        Interval(Real, None, None, closed="neither"),
+        StrOptions({"a", "b", "c"}),
+        MissingValues(),
+        MissingValues(numeric_only=True),
+        _VerboseHelper(),
+        HasMethods("fit"),
+        _IterablesNotString(),
+        _CVObjects(),
+    ],
+)
+def test_generate_invalid_param_val(constraint):
+    """Check that the value generated does not satisfy the constraint"""
+    bad_value = generate_invalid_param_val(constraint)
+    assert not constraint.is_satisfied_by(bad_value)
+
+
+@pytest.mark.parametrize(
+    "integer_interval, real_interval",
+    [
+        (
+            Interval(Integral, None, 3, closed="right"),
+            Interval(RealNotInt, -5, 5, closed="both"),
+        ),
+        (
+            Interval(Integral, None, 3, closed="right"),
+            Interval(RealNotInt, -5, 5, closed="neither"),
+        ),
+        (
+            Interval(Integral, None, 3, closed="right"),
+            Interval(RealNotInt, 4, 5, closed="both"),
+        ),
+        (
+            Interval(Integral, None, 3, closed="right"),
+            Interval(RealNotInt, 5, None, closed="left"),
+        ),
+        (
+            Interval(Integral, None, 3, closed="right"),
+            Interval(RealNotInt, 4, None, closed="neither"),
+        ),
+        (
+            Interval(Integral, 3, None, closed="left"),
+            Interval(RealNotInt, -5, 5, closed="both"),
+        ),
+        (
+            Interval(Integral, 3, None, closed="left"),
+            Interval(RealNotInt, -5, 5, closed="neither"),
+        ),
+        (
+            Interval(Integral, 3, None, closed="left"),
+            Interval(RealNotInt, 1, 2, closed="both"),
+        ),
+        (
+            Interval(Integral, 3, None, closed="left"),
+            Interval(RealNotInt, None, -5, closed="left"),
+        ),
+        (
+            Interval(Integral, 3, None, closed="left"),
+            Interval(RealNotInt, None, -4, closed="neither"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="both"),
+            Interval(RealNotInt, None, 1, closed="right"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="both"),
+            Interval(RealNotInt, 1, None, closed="left"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="both"),
+            Interval(RealNotInt, -10, -4, closed="neither"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="both"),
+            Interval(RealNotInt, -10, -4, closed="right"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="neither"),
+            Interval(RealNotInt, 6, 10, closed="neither"),
+        ),
+        (
+            Interval(Integral, -5, 5, closed="neither"),
+            Interval(RealNotInt, 6, 10, closed="left"),
+        ),
+        (
+            Interval(Integral, 2, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="both"),
+        ),
+        (
+            Interval(Integral, 1, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="both"),
+        ),
+    ],
+)
+def test_generate_invalid_param_val_2_intervals(integer_interval, real_interval):
+    """Check that the value generated for an interval constraint does not satisfy any of
+    the interval constraints.
+    """
+    bad_value = generate_invalid_param_val(constraint=real_interval)
+    assert not real_interval.is_satisfied_by(bad_value)
+    assert not integer_interval.is_satisfied_by(bad_value)
+
+    bad_value = generate_invalid_param_val(constraint=integer_interval)
+    assert not real_interval.is_satisfied_by(bad_value)
+    assert not integer_interval.is_satisfied_by(bad_value)
+
+
+@pytest.mark.parametrize(
+    "constraint",
+    [
+        _ArrayLikes(),
+        _InstancesOf(list),
+        _Callables(),
+        _NoneConstraint(),
+        _RandomStates(),
+        _SparseMatrices(),
+        _Booleans(),
+        Interval(Integral, None, None, closed="neither"),
+    ],
+)
+def test_generate_invalid_param_val_all_valid(constraint):
+    """Check that the function raises NotImplementedError when there's no invalid value
+    for the constraint.
+    """
+    with pytest.raises(NotImplementedError):
+        generate_invalid_param_val(constraint)
+
+
+@pytest.mark.parametrize(
+    "constraint",
+    [
+        _ArrayLikes(),
+        _Callables(),
+        _InstancesOf(list),
+        _NoneConstraint(),
+        _RandomStates(),
+        _SparseMatrices(),
+        _Booleans(),
+        _VerboseHelper(),
+        MissingValues(),
+        MissingValues(numeric_only=True),
+        StrOptions({"a", "b", "c"}),
+        Options(Integral, {1, 2, 3}),
+        Interval(Integral, None, None, closed="neither"),
+        Interval(Integral, 0, 10, closed="neither"),
+        Interval(Integral, 0, None, closed="neither"),
+        Interval(Integral, None, 0, closed="neither"),
+        Interval(Real, 0, 1, closed="neither"),
+        Interval(Real, 0, None, closed="both"),
+        Interval(Real, None, 0, closed="right"),
+        HasMethods("fit"),
+        _IterablesNotString(),
+        _CVObjects(),
+    ],
+)
+def test_generate_valid_param(constraint):
+    """Check that the value generated does satisfy the constraint."""
+    value = generate_valid_param(constraint)
+    assert constraint.is_satisfied_by(value)
+
+
+@pytest.mark.parametrize(
+    "constraint_declaration, value",
+    [
+        (Interval(Real, 0, 1, closed="both"), 0.42),
+        (Interval(Integral, 0, None, closed="neither"), 42),
+        (StrOptions({"a", "b", "c"}), "b"),
+        (Options(type, {np.float32, np.float64}), np.float64),
+        (callable, lambda x: x + 1),
+        (None, None),
+        ("array-like", [[1, 2], [3, 4]]),
+        ("array-like", np.array([[1, 2], [3, 4]])),
+        ("sparse matrix", csr_matrix([[1, 2], [3, 4]])),
+        *[
+            ("sparse matrix", container([[1, 2], [3, 4]]))
+            for container in CSR_CONTAINERS
+        ],
+        ("random_state", 0),
+        ("random_state", np.random.RandomState(0)),
+        ("random_state", None),
+        (_Class, _Class()),
+        (int, 1),
+        (Real, 0.5),
+        ("boolean", False),
+        ("verbose", 1),
+        ("nan", np.nan),
+        (MissingValues(), -1),
+        (MissingValues(), -1.0),
+        (MissingValues(), 2**1028),
+        (MissingValues(), None),
+        (MissingValues(), float("nan")),
+        (MissingValues(), np.nan),
+        (MissingValues(), "missing"),
+        (HasMethods("fit"), _Estimator(a=0)),
+        ("cv_object", 5),
+    ],
+)
+def test_is_satisfied_by(constraint_declaration, value):
+    """Sanity check for the is_satisfied_by method"""
+    constraint = make_constraint(constraint_declaration)
+    assert constraint.is_satisfied_by(value)
+
+
+@pytest.mark.parametrize(
+    "constraint_declaration, expected_constraint_class",
+    [
+        (Interval(Real, 0, 1, closed="both"), Interval),
+        (StrOptions({"option1", "option2"}), StrOptions),
+        (Options(Real, {0.42, 1.23}), Options),
+        ("array-like", _ArrayLikes),
+        ("sparse matrix", _SparseMatrices),
+        ("random_state", _RandomStates),
+        (None, _NoneConstraint),
+        (callable, _Callables),
+        (int, _InstancesOf),
+        ("boolean", _Booleans),
+        ("verbose", _VerboseHelper),
+        (MissingValues(numeric_only=True), MissingValues),
+        (HasMethods("fit"), HasMethods),
+        ("cv_object", _CVObjects),
+        ("nan", _NanConstraint),
+        (np.nan, _NanConstraint),
+    ],
+)
+def test_make_constraint(constraint_declaration, expected_constraint_class):
+    """Check that make_constraint dispatches to the appropriate constraint class"""
+    constraint = make_constraint(constraint_declaration)
+    assert constraint.__class__ is expected_constraint_class
+
+
+def test_make_constraint_unknown():
+    """Check that an informative error is raised when an unknown constraint is passed"""
+    with pytest.raises(ValueError, match="Unknown constraint"):
+        make_constraint("not a valid constraint")
+
+
+def test_validate_params():
+    """Check that validate_params works no matter how the arguments are passed"""
+    with pytest.raises(
+        InvalidParameterError, match="The 'a' parameter of _func must be"
+    ):
+        _func("wrong", c=1)
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'b' parameter of _func must be"
+    ):
+        _func(*[1, "wrong"], c=1)
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'c' parameter of _func must be"
+    ):
+        _func(1, **{"c": "wrong"})
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'd' parameter of _func must be"
+    ):
+        _func(1, c=1, d="wrong")
+
+    # check in the presence of extra positional and keyword args
+    with pytest.raises(
+        InvalidParameterError, match="The 'b' parameter of _func must be"
+    ):
+        _func(0, *["wrong", 2, 3], c=4, **{"e": 5})
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'c' parameter of _func must be"
+    ):
+        _func(0, *[1, 2, 3], c="four", **{"e": 5})
+
+
+def test_validate_params_missing_params():
+    """Check that no error is raised when there are parameters without
+    constraints
+    """
+
+    @validate_params({"a": [int]}, prefer_skip_nested_validation=True)
+    def func(a, b):
+        pass
+
+    func(1, 2)
+
+
+def test_decorate_validated_function():
+    """Check that validate_params functions can be decorated"""
+    decorated_function = deprecated()(_func)
+
+    with pytest.warns(FutureWarning, match="Function _func is deprecated"):
+        decorated_function(1, 2, c=3)
+
+    # outer decorator does not interfere with validation
+    with pytest.warns(FutureWarning, match="Function _func is deprecated"):
+        with pytest.raises(
+            InvalidParameterError, match=r"The 'c' parameter of _func must be"
+        ):
+            decorated_function(1, 2, c="wrong")
+
+
+def test_validate_params_method():
+    """Check that validate_params works with methods"""
+    with pytest.raises(
+        InvalidParameterError, match="The 'a' parameter of _Class._method must be"
+    ):
+        _Class()._method("wrong")
+
+    # validated method can be decorated
+    with pytest.warns(FutureWarning, match="Function _deprecated_method is deprecated"):
+        with pytest.raises(
+            InvalidParameterError,
+            match="The 'a' parameter of _Class._deprecated_method must be",
+        ):
+            _Class()._deprecated_method("wrong")
+
+
+def test_validate_params_estimator():
+    """Check that validate_params works with Estimator instances"""
+    # no validation in init
+    est = _Estimator("wrong")
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'a' parameter of _Estimator must be"
+    ):
+        est.fit()
+
+
+def test_stroptions_deprecated_subset():
+    """Check that the deprecated parameter must be a subset of options."""
+    with pytest.raises(ValueError, match="deprecated options must be a subset"):
+        StrOptions({"a", "b", "c"}, deprecated={"a", "d"})
+
+
+def test_hidden_constraint():
+    """Check that internal constraints are not exposed in the error message."""
+
+    @validate_params(
+        {"param": [Hidden(list), dict]}, prefer_skip_nested_validation=True
+    )
+    def f(param):
+        pass
+
+    # list and dict are valid params
+    f({"a": 1, "b": 2, "c": 3})
+    f([1, 2, 3])
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'param' parameter"
+    ) as exc_info:
+        f(param="bad")
+
+    # the list option is not exposed in the error message
+    err_msg = str(exc_info.value)
+    assert "an instance of 'dict'" in err_msg
+    assert "an instance of 'list'" not in err_msg
+
+
+def test_hidden_stroptions():
+    """Check that we can have 2 StrOptions constraints, one being hidden."""
+
+    @validate_params(
+        {"param": [StrOptions({"auto"}), Hidden(StrOptions({"warn"}))]},
+        prefer_skip_nested_validation=True,
+    )
+    def f(param):
+        pass
+
+    # "auto" and "warn" are valid params
+    f("auto")
+    f("warn")
+
+    with pytest.raises(
+        InvalidParameterError, match="The 'param' parameter"
+    ) as exc_info:
+        f(param="bad")
+
+    # the "warn" option is not exposed in the error message
+    err_msg = str(exc_info.value)
+    assert "auto" in err_msg
+    assert "warn" not in err_msg
+
+
+def test_validate_params_set_param_constraints_attribute():
+    """Check that the validate_params decorator properly sets the parameter constraints
+    as attribute of the decorated function/method.
+    """
+    assert hasattr(_func, "_skl_parameter_constraints")
+    assert hasattr(_Class()._method, "_skl_parameter_constraints")
+
+
+def test_boolean_constraint_deprecated_int():
+    """Check that validate_params raise a deprecation message but still passes
+    validation when using an int for a parameter accepting a boolean.
+    """
+
+    @validate_params({"param": ["boolean"]}, prefer_skip_nested_validation=True)
+    def f(param):
+        pass
+
+    # True/False and np.bool_(True/False) are valid params
+    f(True)
+    f(np.bool_(False))
+
+
+def test_no_validation():
+    """Check that validation can be skipped for a parameter."""
+
+    @validate_params(
+        {"param1": [int, None], "param2": "no_validation"},
+        prefer_skip_nested_validation=True,
+    )
+    def f(param1=None, param2=None):
+        pass
+
+    # param1 is validated
+    with pytest.raises(InvalidParameterError, match="The 'param1' parameter"):
+        f(param1="wrong")
+
+    # param2 is not validated: any type is valid.
+    class SomeType:
+        pass
+
+    f(param2=SomeType)
+    f(param2=SomeType())
+
+
+def test_pandas_na_constraint_with_pd_na():
+    """Add a specific test for checking support for `pandas.NA`."""
+    pd = pytest.importorskip("pandas")
+
+    na_constraint = _PandasNAConstraint()
+    assert na_constraint.is_satisfied_by(pd.NA)
+    assert not na_constraint.is_satisfied_by(np.array([1, 2, 3]))
+
+
+def test_iterable_not_string():
+    """Check that a string does not satisfy the _IterableNotString constraint."""
+    constraint = _IterablesNotString()
+    assert constraint.is_satisfied_by([1, 2, 3])
+    assert constraint.is_satisfied_by(range(10))
+    assert not constraint.is_satisfied_by("some string")
+
+
+def test_cv_objects():
+    """Check that the _CVObjects constraint accepts all current ways
+    to pass cv objects."""
+    constraint = _CVObjects()
+    assert constraint.is_satisfied_by(5)
+    assert constraint.is_satisfied_by(LeaveOneOut())
+    assert constraint.is_satisfied_by([([1, 2], [3, 4]), ([3, 4], [1, 2])])
+    assert constraint.is_satisfied_by(None)
+    assert not constraint.is_satisfied_by("not a CV object")
+
+
+def test_third_party_estimator():
+    """Check that the validation from a scikit-learn estimator inherited by a third
+    party estimator does not impose a match between the dict of constraints and the
+    parameters of the estimator.
+    """
+
+    class ThirdPartyEstimator(_Estimator):
+        def __init__(self, b):
+            self.b = b
+            super().__init__(a=0)
+
+        def fit(self, X=None, y=None):
+            super().fit(X, y)
+
+    # does not raise, even though "b" is not in the constraints dict and "a" is not
+    # a parameter of the estimator.
+    ThirdPartyEstimator(b=0).fit()
+
+
+def test_interval_real_not_int():
+    """Check for the type RealNotInt in the Interval constraint."""
+    constraint = Interval(RealNotInt, 0, 1, closed="both")
+    assert constraint.is_satisfied_by(1.0)
+    assert not constraint.is_satisfied_by(1)
+
+
+def test_real_not_int():
+    """Check for the RealNotInt type."""
+    assert isinstance(1.0, RealNotInt)
+    assert not isinstance(1, RealNotInt)
+    assert isinstance(np.float64(1), RealNotInt)
+    assert not isinstance(np.int64(1), RealNotInt)
+
+
+def test_skip_param_validation():
+    """Check that param validation can be skipped using config_context."""
+
+    @validate_params({"a": [int]}, prefer_skip_nested_validation=True)
+    def f(a):
+        pass
+
+    with pytest.raises(InvalidParameterError, match="The 'a' parameter"):
+        f(a="1")
+
+    # does not raise
+    with config_context(skip_parameter_validation=True):
+        f(a="1")
+
+
+@pytest.mark.parametrize("prefer_skip_nested_validation", [True, False])
+def test_skip_nested_validation(prefer_skip_nested_validation):
+    """Check that nested validation can be skipped."""
+
+    @validate_params({"a": [int]}, prefer_skip_nested_validation=True)
+    def f(a):
+        pass
+
+    @validate_params(
+        {"b": [int]},
+        prefer_skip_nested_validation=prefer_skip_nested_validation,
+    )
+    def g(b):
+        # calls f with a bad parameter type
+        return f(a="invalid_param_value")
+
+    # Validation for g is never skipped.
+    with pytest.raises(InvalidParameterError, match="The 'b' parameter"):
+        g(b="invalid_param_value")
+
+    if prefer_skip_nested_validation:
+        g(b=1)  # does not raise because inner f is not validated
+    else:
+        with pytest.raises(InvalidParameterError, match="The 'a' parameter"):
+            g(b=1)
+
+
+@pytest.mark.parametrize(
+    "skip_parameter_validation, prefer_skip_nested_validation, expected_skipped",
+    [
+        (True, True, True),
+        (True, False, True),
+        (False, True, True),
+        (False, False, False),
+    ],
+)
+def test_skip_nested_validation_and_config_context(
+    skip_parameter_validation, prefer_skip_nested_validation, expected_skipped
+):
+    """Check interaction between global skip and local skip."""
+
+    @validate_params(
+        {"a": [int]}, prefer_skip_nested_validation=prefer_skip_nested_validation
+    )
+    def g(a):
+        return get_config()["skip_parameter_validation"]
+
+    with config_context(skip_parameter_validation=skip_parameter_validation):
+        actual_skipped = g(1)
+
+    assert actual_skipped == expected_skipped
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_plotting.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_plotting.py
new file mode 100644
index 0000000000000000000000000000000000000000..db2f797ac2547a50eb75c7abcc6be027f64cffba
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_plotting.py
@@ -0,0 +1,544 @@
+import numpy as np
+import pytest
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.utils._plotting import (
+    _BinaryClassifierCurveDisplayMixin,
+    _deprecate_estimator_name,
+    _despine,
+    _interval_max_min_ratio,
+    _validate_score_name,
+    _validate_style_kwargs,
+)
+from sklearn.utils._response import _get_response_values_binary
+from sklearn.utils._testing import assert_allclose
+
+
+@pytest.mark.parametrize("ax", [None, "Ax"])
+@pytest.mark.parametrize(
+    "name, expected_name_out", [(None, "TestEstimator"), ("CustomName", "CustomName")]
+)
+def test_validate_plot_params(pyplot, ax, name, expected_name_out):
+    """Check `_validate_plot_params` returns the correct values."""
+    display = _BinaryClassifierCurveDisplayMixin()
+    display.estimator_name = "TestEstimator"
+    if ax:
+        _, ax = pyplot.subplots()
+    ax_out, _, name_out = display._validate_plot_params(ax=ax, name=name)
+
+    assert name_out == expected_name_out
+
+    if ax:
+        assert ax == ax_out
+
+
+@pytest.mark.parametrize("pos_label", [None, 0])
+@pytest.mark.parametrize("name", [None, "CustomName"])
+@pytest.mark.parametrize(
+    "response_method", ["auto", "predict_proba", "decision_function"]
+)
+def test_validate_and_get_response_values(pyplot, pos_label, name, response_method):
+    """Check `_validate_and_get_response_values` returns the correct values."""
+    X = np.array([[0, 0], [1, 1], [2, 2], [3, 3]])
+    y = np.array([0, 0, 2, 2])
+    estimator = LogisticRegression().fit(X, y)
+
+    y_pred, pos_label, name_out = (
+        _BinaryClassifierCurveDisplayMixin._validate_and_get_response_values(
+            estimator,
+            X,
+            y,
+            response_method=response_method,
+            pos_label=pos_label,
+            name=name,
+        )
+    )
+
+    expected_y_pred, expected_pos_label = _get_response_values_binary(
+        estimator, X, response_method=response_method, pos_label=pos_label
+    )
+
+    assert_allclose(y_pred, expected_y_pred)
+    assert pos_label == expected_pos_label
+
+    # Check name is handled correctly
+    expected_name = name if name is not None else "LogisticRegression"
+    assert name_out == expected_name
+
+
+@pytest.mark.parametrize(
+    "y_true, error_message",
+    [
+        (np.array([0, 1, 2]), "The target y is not binary."),
+        (np.array([0, 1]), "Found input variables with inconsistent"),
+        (np.array([0, 2, 0, 2]), r"y_true takes value in \{0, 2\} and pos_label"),
+    ],
+)
+def test_validate_from_predictions_params_errors(pyplot, y_true, error_message):
+    """Check `_validate_from_predictions_params` raises the correct errors."""
+    y_pred = np.array([0.1, 0.2, 0.3, 0.4])
+    sample_weight = np.ones(4)
+
+    with pytest.raises(ValueError, match=error_message):
+        _BinaryClassifierCurveDisplayMixin._validate_from_predictions_params(
+            y_true=y_true,
+            y_pred=y_pred,
+            sample_weight=sample_weight,
+            pos_label=None,
+        )
+
+
+@pytest.mark.parametrize("name", [None, "CustomName"])
+@pytest.mark.parametrize(
+    "pos_label, y_true",
+    [
+        (None, np.array([0, 1, 0, 1])),
+        (2, np.array([0, 2, 0, 2])),
+    ],
+)
+def test_validate_from_predictions_params_returns(pyplot, name, pos_label, y_true):
+    """Check `_validate_from_predictions_params` returns the correct values."""
+    y_pred = np.array([0.1, 0.2, 0.3, 0.4])
+    pos_label_out, name_out = (
+        _BinaryClassifierCurveDisplayMixin._validate_from_predictions_params(
+            y_true=y_true,
+            y_pred=y_pred,
+            sample_weight=None,
+            pos_label=pos_label,
+            name=name,
+        )
+    )
+
+    # Check name is handled correctly
+    expected_name = name if name is not None else "Classifier"
+    assert name_out == expected_name
+
+    # Check pos_label is handled correctly
+    expected_pos_label = pos_label if pos_label is not None else 1
+    assert pos_label_out == expected_pos_label
+
+
+@pytest.mark.parametrize(
+    "params, err_msg",
+    [
+        (
+            {
+                # Missing "indices" key
+                "cv_results": {"estimator": "dummy"},
+                "X": np.array([[1, 2], [3, 4]]),
+                "y": np.array([0, 1]),
+                "sample_weight": None,
+                "pos_label": None,
+            },
+            "`cv_results` does not contain one of the following",
+        ),
+        (
+            {
+                "cv_results": {
+                    "estimator": "dummy",
+                    "indices": {"test": [[1, 2], [1, 2]], "train": [[3, 4], [3, 4]]},
+                },
+                # `X` wrong length
+                "X": np.array([[1, 2]]),
+                "y": np.array([0, 1]),
+                "sample_weight": None,
+                "pos_label": None,
+            },
+            "`X` does not contain the correct number of",
+        ),
+        (
+            {
+                "cv_results": {
+                    "estimator": "dummy",
+                    "indices": {"test": [[1, 2], [1, 2]], "train": [[3, 4], [3, 4]]},
+                },
+                "X": np.array([1, 2, 3, 4]),
+                # `y` not binary
+                "y": np.array([0, 2, 1, 3]),
+                "sample_weight": None,
+                "pos_label": None,
+            },
+            "The target `y` is not binary",
+        ),
+        (
+            {
+                "cv_results": {
+                    "estimator": "dummy",
+                    "indices": {"test": [[1, 2], [1, 2]], "train": [[3, 4], [3, 4]]},
+                },
+                "X": np.array([1, 2, 3, 4]),
+                "y": np.array([0, 1, 0, 1]),
+                # `sample_weight` wrong length
+                "sample_weight": np.array([0.5]),
+                "pos_label": None,
+            },
+            "Found input variables with inconsistent",
+        ),
+        (
+            {
+                "cv_results": {
+                    "estimator": "dummy",
+                    "indices": {"test": [[1, 2], [1, 2]], "train": [[3, 4], [3, 4]]},
+                },
+                "X": np.array([1, 2, 3, 4]),
+                "y": np.array([2, 3, 2, 3]),
+                "sample_weight": None,
+                # Not specified when `y` not in {0, 1} or {-1, 1}
+                "pos_label": None,
+            },
+            "y takes value in {2, 3} and pos_label is not specified",
+        ),
+    ],
+)
+def test_validate_from_cv_results_params(pyplot, params, err_msg):
+    """Check parameter validation is performed correctly."""
+    with pytest.raises(ValueError, match=err_msg):
+        _BinaryClassifierCurveDisplayMixin()._validate_from_cv_results_params(**params)
+
+
+@pytest.mark.parametrize(
+    "curve_legend_metric, curve_name, expected_label",
+    [
+        (0.85, None, "AUC = 0.85"),
+        (None, "Model A", "Model A"),
+        (0.95, "Random Forest", "Random Forest (AUC = 0.95)"),
+        (None, None, None),
+    ],
+)
+def test_get_legend_label(curve_legend_metric, curve_name, expected_label):
+    """Check `_get_legend_label` returns the correct label."""
+    legend_metric_name = "AUC"
+    label = _BinaryClassifierCurveDisplayMixin._get_legend_label(
+        curve_legend_metric, curve_name, legend_metric_name
+    )
+    assert label == expected_label
+
+
+# TODO(1.9) : Remove
+@pytest.mark.parametrize("curve_kwargs", [{"alpha": 1.0}, None])
+@pytest.mark.parametrize("kwargs", [{}, {"alpha": 1.0}])
+def test_validate_curve_kwargs_deprecate_kwargs(curve_kwargs, kwargs):
+    """Check `_validate_curve_kwargs` deprecates kwargs correctly."""
+    n_curves = 1
+    name = None
+    legend_metric = {"mean": 0.8, "std": 0.1}
+    legend_metric_name = "AUC"
+
+    if curve_kwargs and kwargs:
+        with pytest.raises(ValueError, match="Cannot provide both `curve_kwargs`"):
+            _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+                n_curves,
+                name,
+                legend_metric,
+                legend_metric_name,
+                curve_kwargs,
+                **kwargs,
+            )
+    elif kwargs:
+        with pytest.warns(FutureWarning, match=r"`\*\*kwargs` is deprecated and"):
+            _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+                n_curves,
+                name,
+                legend_metric,
+                legend_metric_name,
+                curve_kwargs,
+                **kwargs,
+            )
+    else:
+        # No warning or error should be raised
+        _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+            n_curves, name, legend_metric, legend_metric_name, curve_kwargs, **kwargs
+        )
+
+
+def test_validate_curve_kwargs_error():
+    """Check `_validate_curve_kwargs` performs parameter validation correctly."""
+    n_curves = 3
+    legend_metric = {"mean": 0.8, "std": 0.1}
+    legend_metric_name = "AUC"
+    with pytest.raises(ValueError, match="`curve_kwargs` must be None"):
+        _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+            n_curves=n_curves,
+            name=None,
+            legend_metric=legend_metric,
+            legend_metric_name=legend_metric_name,
+            curve_kwargs=[{"alpha": 1.0}],
+        )
+    with pytest.raises(ValueError, match="To avoid labeling individual curves"):
+        name = ["one", "two", "three"]
+        _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+            n_curves=n_curves,
+            name=name,
+            legend_metric=legend_metric,
+            legend_metric_name=legend_metric_name,
+            curve_kwargs=None,
+        )
+        _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+            n_curves=n_curves,
+            name=name,
+            legend_metric=legend_metric,
+            legend_metric_name=legend_metric_name,
+            curve_kwargs={"alpha": 1.0},
+        )
+
+
+@pytest.mark.parametrize("name", [None, "curve_name", ["curve_name"]])
+@pytest.mark.parametrize(
+    "legend_metric",
+    [
+        {"mean": 0.8, "std": 0.2},
+        {"mean": None, "std": None},
+    ],
+)
+@pytest.mark.parametrize("legend_metric_name", ["AUC", "AP"])
+@pytest.mark.parametrize(
+    "curve_kwargs",
+    [
+        None,
+        {"color": "red"},
+    ],
+)
+def test_validate_curve_kwargs_single_legend(
+    name, legend_metric, legend_metric_name, curve_kwargs
+):
+    """Check `_validate_curve_kwargs` returns correct kwargs for single legend entry."""
+    n_curves = 3
+    curve_kwargs_out = _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+        n_curves=n_curves,
+        name=name,
+        legend_metric=legend_metric,
+        legend_metric_name=legend_metric_name,
+        curve_kwargs=curve_kwargs,
+    )
+
+    assert isinstance(curve_kwargs_out, list)
+    assert len(curve_kwargs_out) == n_curves
+
+    expected_label = None
+    if isinstance(name, list):
+        name = name[0]
+    if name is not None:
+        expected_label = name
+        if legend_metric["mean"] is not None:
+            expected_label = expected_label + f" ({legend_metric_name} = 0.80 +/- 0.20)"
+    # `name` is None
+    elif legend_metric["mean"] is not None:
+        expected_label = f"{legend_metric_name} = 0.80 +/- 0.20"
+
+    assert curve_kwargs_out[0]["label"] == expected_label
+    # All remaining curves should have None as "label"
+    assert curve_kwargs_out[1]["label"] is None
+    assert curve_kwargs_out[2]["label"] is None
+
+    # Default multi-curve kwargs
+    if curve_kwargs is None:
+        assert all(len(kwargs) == 4 for kwargs in curve_kwargs_out)
+        assert all(kwargs["alpha"] == 0.5 for kwargs in curve_kwargs_out)
+        assert all(kwargs["linestyle"] == "--" for kwargs in curve_kwargs_out)
+        assert all(kwargs["color"] == "blue" for kwargs in curve_kwargs_out)
+    else:
+        assert all(len(kwargs) == 2 for kwargs in curve_kwargs_out)
+        assert all(kwargs["color"] == "red" for kwargs in curve_kwargs_out)
+
+
+@pytest.mark.parametrize("name", [None, "curve_name", ["one", "two", "three"]])
+@pytest.mark.parametrize(
+    "legend_metric", [{"metric": [1.0, 1.0, 1.0]}, {"metric": [None, None, None]}]
+)
+@pytest.mark.parametrize("legend_metric_name", ["AUC", "AP"])
+def test_validate_curve_kwargs_multi_legend(name, legend_metric, legend_metric_name):
+    """Check `_validate_curve_kwargs` returns correct kwargs for multi legend entry."""
+    n_curves = 3
+    curve_kwargs = [{"color": "red"}, {"color": "yellow"}, {"color": "blue"}]
+    curve_kwargs_out = _BinaryClassifierCurveDisplayMixin._validate_curve_kwargs(
+        n_curves=n_curves,
+        name=name,
+        legend_metric=legend_metric,
+        legend_metric_name=legend_metric_name,
+        curve_kwargs=curve_kwargs,
+    )
+
+    assert isinstance(curve_kwargs_out, list)
+    assert len(curve_kwargs_out) == n_curves
+
+    expected_labels = [None, None, None]
+    if isinstance(name, str):
+        expected_labels = "curve_name"
+        if legend_metric["metric"][0] is not None:
+            expected_labels = expected_labels + f" ({legend_metric_name} = 1.00)"
+        expected_labels = [expected_labels] * n_curves
+    elif isinstance(name, list) and legend_metric["metric"][0] is None:
+        expected_labels = name
+    elif isinstance(name, list) and legend_metric["metric"][0] is not None:
+        expected_labels = [
+            f"{name_single} ({legend_metric_name} = 1.00)" for name_single in name
+        ]
+    # `name` is None
+    elif legend_metric["metric"][0] is not None:
+        expected_labels = [f"{legend_metric_name} = 1.00"] * n_curves
+
+    for idx, expected_label in enumerate(expected_labels):
+        assert curve_kwargs_out[idx]["label"] == expected_label
+
+    assert all(len(kwargs) == 2 for kwargs in curve_kwargs_out)
+    for curve_kwarg, curve_kwarg_out in zip(curve_kwargs, curve_kwargs_out):
+        assert curve_kwarg_out["color"] == curve_kwarg["color"]
+
+
+def metric():
+    pass  # pragma: no cover
+
+
+def neg_metric():
+    pass  # pragma: no cover
+
+
+@pytest.mark.parametrize(
+    "score_name, scoring, negate_score, expected_score_name",
+    [
+        ("accuracy", None, False, "accuracy"),  # do not transform the name
+        (None, "accuracy", False, "Accuracy"),  # capitalize the name
+        (None, "accuracy", True, "Negative accuracy"),  # add "Negative"
+        (None, "neg_mean_absolute_error", False, "Negative mean absolute error"),
+        (None, "neg_mean_absolute_error", True, "Mean absolute error"),  # remove "neg_"
+        ("MAE", "neg_mean_absolute_error", True, "MAE"),  # keep score_name
+        (None, None, False, "Score"),  # default name
+        (None, None, True, "Negative score"),  # default name but negated
+        ("Some metric", metric, False, "Some metric"),  # do not transform the name
+        ("Some metric", metric, True, "Some metric"),  # do not transform the name
+        (None, metric, False, "Metric"),  # default name
+        (None, metric, True, "Negative metric"),  # default name but negated
+        ("Some metric", neg_metric, False, "Some metric"),  # do not transform the name
+        ("Some metric", neg_metric, True, "Some metric"),  # do not transform the name
+        (None, neg_metric, False, "Negative metric"),  # default name
+        (None, neg_metric, True, "Metric"),  # default name but negated
+    ],
+)
+def test_validate_score_name(score_name, scoring, negate_score, expected_score_name):
+    """Check that we return the right score name."""
+    assert (
+        _validate_score_name(score_name, scoring, negate_score) == expected_score_name
+    )
+
+
+# In the following test, we check the value of the max to min ratio
+# for parameter value intervals to check that using a decision threshold
+# of 5. is a good heuristic to decide between linear and log scales on
+# common ranges of parameter values.
+@pytest.mark.parametrize(
+    "data, lower_bound, upper_bound",
+    [
+        # Such a range could be clearly displayed with either log scale or linear
+        # scale.
+        (np.geomspace(0.1, 1, 5), 5, 6),
+        # Checking that the ratio is still positive on a negative log scale.
+        (-np.geomspace(0.1, 1, 10), 7, 8),
+        # Evenly spaced parameter values lead to a ratio of 1.
+        (np.linspace(0, 1, 5), 0.9, 1.1),
+        # This is not exactly spaced on a log scale but we will benefit from treating
+        # it as such for visualization.
+        ([1, 2, 5, 10, 20, 50], 20, 40),
+    ],
+)
+def test_inverval_max_min_ratio(data, lower_bound, upper_bound):
+    assert lower_bound < _interval_max_min_ratio(data) < upper_bound
+
+
+@pytest.mark.parametrize(
+    "default_kwargs, user_kwargs, expected",
+    [
+        (
+            {"color": "blue", "linewidth": 2},
+            {"linestyle": "dashed"},
+            {"color": "blue", "linewidth": 2, "linestyle": "dashed"},
+        ),
+        (
+            {"color": "blue", "linestyle": "solid"},
+            {"c": "red", "ls": "dashed"},
+            {"color": "red", "linestyle": "dashed"},
+        ),
+        (
+            {"label": "xxx", "color": "k", "linestyle": "--"},
+            {"ls": "-."},
+            {"label": "xxx", "color": "k", "linestyle": "-."},
+        ),
+        ({}, {}, {}),
+        (
+            {},
+            {
+                "ls": "dashed",
+                "c": "red",
+                "ec": "black",
+                "fc": "yellow",
+                "lw": 2,
+                "mec": "green",
+                "mfcalt": "blue",
+                "ms": 5,
+            },
+            {
+                "linestyle": "dashed",
+                "color": "red",
+                "edgecolor": "black",
+                "facecolor": "yellow",
+                "linewidth": 2,
+                "markeredgecolor": "green",
+                "markerfacecoloralt": "blue",
+                "markersize": 5,
+            },
+        ),
+    ],
+)
+def test_validate_style_kwargs(default_kwargs, user_kwargs, expected):
+    """Check the behaviour of `validate_style_kwargs` with various type of entries."""
+    result = _validate_style_kwargs(default_kwargs, user_kwargs)
+    assert result == expected, (
+        "The validation of style keywords does not provide the expected results: "
+        f"Got {result} instead of {expected}."
+    )
+
+
+@pytest.mark.parametrize(
+    "default_kwargs, user_kwargs",
+    [({}, {"ls": 2, "linestyle": 3}), ({}, {"c": "r", "color": "blue"})],
+)
+def test_validate_style_kwargs_error(default_kwargs, user_kwargs):
+    """Check that `validate_style_kwargs` raises TypeError"""
+    with pytest.raises(TypeError):
+        _validate_style_kwargs(default_kwargs, user_kwargs)
+
+
+def test_despine(pyplot):
+    ax = pyplot.gca()
+    _despine(ax)
+    assert ax.spines["top"].get_visible() is False
+    assert ax.spines["right"].get_visible() is False
+    assert ax.spines["bottom"].get_bounds() == (0, 1)
+    assert ax.spines["left"].get_bounds() == (0, 1)
+
+
+@pytest.mark.parametrize("estimator_name", ["my_est_name", "deprecated"])
+@pytest.mark.parametrize("name", [None, "my_name"])
+def test_deprecate_estimator_name(estimator_name, name):
+    """Check `_deprecate_estimator_name` behaves correctly"""
+    version = "1.7"
+    version_remove = "1.9"
+
+    if estimator_name == "deprecated":
+        name_out = _deprecate_estimator_name(estimator_name, name, version)
+        assert name_out == name
+    # `estimator_name` is provided and `name` is:
+    elif name is None:
+        warning_message = (
+            f"`estimator_name` is deprecated in {version} and will be removed in "
+            f"{version_remove}. Use `name` instead."
+        )
+        with pytest.warns(FutureWarning, match=warning_message):
+            result = _deprecate_estimator_name(estimator_name, name, version)
+        assert result == estimator_name
+    elif name is not None:
+        error_message = (
+            f"Cannot provide both `estimator_name` and `name`. `estimator_name` "
+            f"is deprecated in {version} and will be removed in {version_remove}. "
+        )
+        with pytest.raises(ValueError, match=error_message):
+            _deprecate_estimator_name(estimator_name, name, version)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_pprint.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_pprint.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee3e267dd5cbe317d93f52d3a1db350465050996
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_pprint.py
@@ -0,0 +1,695 @@
+import re
+from pprint import PrettyPrinter
+
+import numpy as np
+import pytest
+
+from sklearn import config_context
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.feature_selection import SelectKBest, chi2
+from sklearn.linear_model import LogisticRegressionCV
+from sklearn.pipeline import make_pipeline
+from sklearn.utils._pprint import _EstimatorPrettyPrinter
+
+
+# Constructors excerpted to test pprinting
+class LogisticRegression(BaseEstimator):
+    def __init__(
+        self,
+        penalty="l2",
+        dual=False,
+        tol=1e-4,
+        C=1.0,
+        fit_intercept=True,
+        intercept_scaling=1,
+        class_weight=None,
+        random_state=None,
+        solver="warn",
+        max_iter=100,
+        multi_class="warn",
+        verbose=0,
+        warm_start=False,
+        n_jobs=None,
+        l1_ratio=None,
+    ):
+        self.penalty = penalty
+        self.dual = dual
+        self.tol = tol
+        self.C = C
+        self.fit_intercept = fit_intercept
+        self.intercept_scaling = intercept_scaling
+        self.class_weight = class_weight
+        self.random_state = random_state
+        self.solver = solver
+        self.max_iter = max_iter
+        self.multi_class = multi_class
+        self.verbose = verbose
+        self.warm_start = warm_start
+        self.n_jobs = n_jobs
+        self.l1_ratio = l1_ratio
+
+    def fit(self, X, y):
+        return self
+
+
+class StandardScaler(TransformerMixin, BaseEstimator):
+    def __init__(self, copy=True, with_mean=True, with_std=True):
+        self.with_mean = with_mean
+        self.with_std = with_std
+        self.copy = copy
+
+    def transform(self, X, copy=None):
+        return self
+
+
+class RFE(BaseEstimator):
+    def __init__(self, estimator, n_features_to_select=None, step=1, verbose=0):
+        self.estimator = estimator
+        self.n_features_to_select = n_features_to_select
+        self.step = step
+        self.verbose = verbose
+
+
+class GridSearchCV(BaseEstimator):
+    def __init__(
+        self,
+        estimator,
+        param_grid,
+        scoring=None,
+        n_jobs=None,
+        iid="warn",
+        refit=True,
+        cv="warn",
+        verbose=0,
+        pre_dispatch="2*n_jobs",
+        error_score="raise-deprecating",
+        return_train_score=False,
+    ):
+        self.estimator = estimator
+        self.param_grid = param_grid
+        self.scoring = scoring
+        self.n_jobs = n_jobs
+        self.iid = iid
+        self.refit = refit
+        self.cv = cv
+        self.verbose = verbose
+        self.pre_dispatch = pre_dispatch
+        self.error_score = error_score
+        self.return_train_score = return_train_score
+
+
+class CountVectorizer(BaseEstimator):
+    def __init__(
+        self,
+        input="content",
+        encoding="utf-8",
+        decode_error="strict",
+        strip_accents=None,
+        lowercase=True,
+        preprocessor=None,
+        tokenizer=None,
+        stop_words=None,
+        token_pattern=r"(?u)\b\w\w+\b",
+        ngram_range=(1, 1),
+        analyzer="word",
+        max_df=1.0,
+        min_df=1,
+        max_features=None,
+        vocabulary=None,
+        binary=False,
+        dtype=np.int64,
+    ):
+        self.input = input
+        self.encoding = encoding
+        self.decode_error = decode_error
+        self.strip_accents = strip_accents
+        self.preprocessor = preprocessor
+        self.tokenizer = tokenizer
+        self.analyzer = analyzer
+        self.lowercase = lowercase
+        self.token_pattern = token_pattern
+        self.stop_words = stop_words
+        self.max_df = max_df
+        self.min_df = min_df
+        self.max_features = max_features
+        self.ngram_range = ngram_range
+        self.vocabulary = vocabulary
+        self.binary = binary
+        self.dtype = dtype
+
+
+class Pipeline(BaseEstimator):
+    def __init__(self, steps, memory=None):
+        self.steps = steps
+        self.memory = memory
+
+
+class SVC(BaseEstimator):
+    def __init__(
+        self,
+        C=1.0,
+        kernel="rbf",
+        degree=3,
+        gamma="auto_deprecated",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        random_state=None,
+    ):
+        self.kernel = kernel
+        self.degree = degree
+        self.gamma = gamma
+        self.coef0 = coef0
+        self.tol = tol
+        self.C = C
+        self.shrinking = shrinking
+        self.probability = probability
+        self.cache_size = cache_size
+        self.class_weight = class_weight
+        self.verbose = verbose
+        self.max_iter = max_iter
+        self.decision_function_shape = decision_function_shape
+        self.random_state = random_state
+
+
+class PCA(BaseEstimator):
+    def __init__(
+        self,
+        n_components=None,
+        copy=True,
+        whiten=False,
+        svd_solver="auto",
+        tol=0.0,
+        iterated_power="auto",
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.whiten = whiten
+        self.svd_solver = svd_solver
+        self.tol = tol
+        self.iterated_power = iterated_power
+        self.random_state = random_state
+
+
+class NMF(BaseEstimator):
+    def __init__(
+        self,
+        n_components=None,
+        init=None,
+        solver="cd",
+        beta_loss="frobenius",
+        tol=1e-4,
+        max_iter=200,
+        random_state=None,
+        alpha=0.0,
+        l1_ratio=0.0,
+        verbose=0,
+        shuffle=False,
+    ):
+        self.n_components = n_components
+        self.init = init
+        self.solver = solver
+        self.beta_loss = beta_loss
+        self.tol = tol
+        self.max_iter = max_iter
+        self.random_state = random_state
+        self.alpha = alpha
+        self.l1_ratio = l1_ratio
+        self.verbose = verbose
+        self.shuffle = shuffle
+
+
+class SimpleImputer(BaseEstimator):
+    def __init__(
+        self,
+        missing_values=np.nan,
+        strategy="mean",
+        fill_value=None,
+        verbose=0,
+        copy=True,
+    ):
+        self.missing_values = missing_values
+        self.strategy = strategy
+        self.fill_value = fill_value
+        self.verbose = verbose
+        self.copy = copy
+
+
+def test_basic(print_changed_only_false):
+    # Basic pprint test
+    lr = LogisticRegression()
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter=100,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert lr.__repr__() == expected
+
+
+def test_changed_only():
+    # Make sure the changed_only param is correctly used when True (default)
+    lr = LogisticRegression(C=99)
+    expected = """LogisticRegression(C=99)"""
+    assert lr.__repr__() == expected
+
+    # Check with a repr that doesn't fit on a single line
+    lr = LogisticRegression(
+        C=99, class_weight=0.4, fit_intercept=False, tol=1234, verbose=True
+    )
+    expected = """
+LogisticRegression(C=99, class_weight=0.4, fit_intercept=False, tol=1234,
+                   verbose=True)"""
+    expected = expected[1:]  # remove first \n
+    assert lr.__repr__() == expected
+
+    imputer = SimpleImputer(missing_values=0)
+    expected = """SimpleImputer(missing_values=0)"""
+    assert imputer.__repr__() == expected
+
+    # Defaults to np.nan, trying with float('NaN')
+    imputer = SimpleImputer(missing_values=float("NaN"))
+    expected = """SimpleImputer()"""
+    assert imputer.__repr__() == expected
+
+    # make sure array parameters don't throw error (see #13583)
+    repr(LogisticRegressionCV(Cs=np.array([0.1, 1])))
+
+
+def test_pipeline(print_changed_only_false):
+    # Render a pipeline object
+    pipeline = make_pipeline(StandardScaler(), LogisticRegression(C=999))
+    expected = """
+Pipeline(memory=None,
+         steps=[('standardscaler',
+                 StandardScaler(copy=True, with_mean=True, with_std=True)),
+                ('logisticregression',
+                 LogisticRegression(C=999, class_weight=None, dual=False,
+                                    fit_intercept=True, intercept_scaling=1,
+                                    l1_ratio=None, max_iter=100,
+                                    multi_class='warn', n_jobs=None,
+                                    penalty='l2', random_state=None,
+                                    solver='warn', tol=0.0001, verbose=0,
+                                    warm_start=False))],
+         transform_input=None, verbose=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pipeline.__repr__() == expected
+
+
+def test_deeply_nested(print_changed_only_false):
+    # Render a deeply nested estimator
+    rfe = RFE(RFE(RFE(RFE(RFE(RFE(RFE(LogisticRegression())))))))
+    expected = """
+RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=LogisticRegression(C=1.0,
+                                                                                                                     class_weight=None,
+                                                                                                                     dual=False,
+                                                                                                                     fit_intercept=True,
+                                                                                                                     intercept_scaling=1,
+                                                                                                                     l1_ratio=None,
+                                                                                                                     max_iter=100,
+                                                                                                                     multi_class='warn',
+                                                                                                                     n_jobs=None,
+                                                                                                                     penalty='l2',
+                                                                                                                     random_state=None,
+                                                                                                                     solver='warn',
+                                                                                                                     tol=0.0001,
+                                                                                                                     verbose=0,
+                                                                                                                     warm_start=False),
+                                                                                        n_features_to_select=None,
+                                                                                        step=1,
+                                                                                        verbose=0),
+                                                                          n_features_to_select=None,
+                                                                          step=1,
+                                                                          verbose=0),
+                                                            n_features_to_select=None,
+                                                            step=1, verbose=0),
+                                              n_features_to_select=None, step=1,
+                                              verbose=0),
+                                n_features_to_select=None, step=1, verbose=0),
+                  n_features_to_select=None, step=1, verbose=0),
+    n_features_to_select=None, step=1, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert rfe.__repr__() == expected
+
+
+@pytest.mark.parametrize(
+    ("print_changed_only", "expected"),
+    [
+        (True, "RFE(estimator=RFE(...))"),
+        (
+            False,
+            "RFE(estimator=RFE(...), n_features_to_select=None, step=1, verbose=0)",
+        ),
+    ],
+)
+def test_print_estimator_max_depth(print_changed_only, expected):
+    with config_context(print_changed_only=print_changed_only):
+        pp = _EstimatorPrettyPrinter(depth=1)
+
+        rfe = RFE(RFE(RFE(RFE(RFE(LogisticRegression())))))
+        assert pp.pformat(rfe) == expected
+
+
+def test_gridsearch(print_changed_only_false):
+    # render a gridsearch
+    param_grid = [
+        {"kernel": ["rbf"], "gamma": [1e-3, 1e-4], "C": [1, 10, 100, 1000]},
+        {"kernel": ["linear"], "C": [1, 10, 100, 1000]},
+    ]
+    gs = GridSearchCV(SVC(), param_grid, cv=5)
+
+    expected = """
+GridSearchCV(cv=5, error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid=[{'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001],
+                          'kernel': ['rbf']},
+                         {'C': [1, 10, 100, 1000], 'kernel': ['linear']}],
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert gs.__repr__() == expected
+
+
+def test_gridsearch_pipeline(print_changed_only_false):
+    # render a pipeline inside a gridsearch
+    pp = _EstimatorPrettyPrinter(compact=True, indent=1, indent_at_name=True)
+
+    pipeline = Pipeline([("reduce_dim", PCA()), ("classify", SVC())])
+    N_FEATURES_OPTIONS = [2, 4, 8]
+    C_OPTIONS = [1, 10, 100, 1000]
+    param_grid = [
+        {
+            "reduce_dim": [PCA(iterated_power=7), NMF()],
+            "reduce_dim__n_components": N_FEATURES_OPTIONS,
+            "classify__C": C_OPTIONS,
+        },
+        {
+            "reduce_dim": [SelectKBest(chi2)],
+            "reduce_dim__k": N_FEATURES_OPTIONS,
+            "classify__C": C_OPTIONS,
+        },
+    ]
+    gspipline = GridSearchCV(pipeline, cv=3, n_jobs=1, param_grid=param_grid)
+    expected = """
+GridSearchCV(cv=3, error_score='raise-deprecating',
+             estimator=Pipeline(memory=None,
+                                steps=[('reduce_dim',
+                                        PCA(copy=True, iterated_power='auto',
+                                            n_components=None,
+                                            random_state=None,
+                                            svd_solver='auto', tol=0.0,
+                                            whiten=False)),
+                                       ('classify',
+                                        SVC(C=1.0, cache_size=200,
+                                            class_weight=None, coef0=0.0,
+                                            decision_function_shape='ovr',
+                                            degree=3, gamma='auto_deprecated',
+                                            kernel='rbf', max_iter=-1,
+                                            probability=False,
+                                            random_state=None, shrinking=True,
+                                            tol=0.001, verbose=False))]),
+             iid='warn', n_jobs=1,
+             param_grid=[{'classify__C': [1, 10, 100, 1000],
+                          'reduce_dim': [PCA(copy=True, iterated_power=7,
+                                             n_components=None,
+                                             random_state=None,
+                                             svd_solver='auto', tol=0.0,
+                                             whiten=False),
+                                         NMF(alpha=0.0, beta_loss='frobenius',
+                                             init=None, l1_ratio=0.0,
+                                             max_iter=200, n_components=None,
+                                             random_state=None, shuffle=False,
+                                             solver='cd', tol=0.0001,
+                                             verbose=0)],
+                          'reduce_dim__n_components': [2, 4, 8]},
+                         {'classify__C': [1, 10, 100, 1000],
+                          'reduce_dim': [SelectKBest(k=10,
+                                                     score_func=<function chi2 at some_address>)],
+                          'reduce_dim__k': [2, 4, 8]}],
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""  # noqa: E501
+
+    expected = expected[1:]  # remove first \n
+    repr_ = pp.pformat(gspipline)
+    # Remove address of '<function chi2 at 0x.....>' for reproducibility
+    repr_ = re.sub("function chi2 at 0x.*>", "function chi2 at some_address>", repr_)
+    assert repr_ == expected
+
+
+def test_n_max_elements_to_show(print_changed_only_false):
+    n_max_elements_to_show = 30
+    pp = _EstimatorPrettyPrinter(
+        compact=True,
+        indent=1,
+        indent_at_name=True,
+        n_max_elements_to_show=n_max_elements_to_show,
+    )
+
+    # No ellipsis
+    vocabulary = {i: i for i in range(n_max_elements_to_show)}
+    vectorizer = CountVectorizer(vocabulary=vocabulary)
+
+    expected = r"""
+CountVectorizer(analyzer='word', binary=False, decode_error='strict',
+                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',
+                lowercase=True, max_df=1.0, max_features=None, min_df=1,
+                ngram_range=(1, 1), preprocessor=None, stop_words=None,
+                strip_accents=None, token_pattern='(?u)\\b\\w\\w+\\b',
+                tokenizer=None,
+                vocabulary={0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7,
+                            8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14,
+                            15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20,
+                            21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26,
+                            27: 27, 28: 28, 29: 29})"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(vectorizer) == expected
+
+    # Now with ellipsis
+    vocabulary = {i: i for i in range(n_max_elements_to_show + 1)}
+    vectorizer = CountVectorizer(vocabulary=vocabulary)
+
+    expected = r"""
+CountVectorizer(analyzer='word', binary=False, decode_error='strict',
+                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',
+                lowercase=True, max_df=1.0, max_features=None, min_df=1,
+                ngram_range=(1, 1), preprocessor=None, stop_words=None,
+                strip_accents=None, token_pattern='(?u)\\b\\w\\w+\\b',
+                tokenizer=None,
+                vocabulary={0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7,
+                            8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14,
+                            15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20,
+                            21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26,
+                            27: 27, 28: 28, 29: 29, ...})"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(vectorizer) == expected
+
+    # Also test with lists
+    param_grid = {"C": list(range(n_max_elements_to_show))}
+    gs = GridSearchCV(SVC(), param_grid)
+    expected = """
+GridSearchCV(cv='warn', error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid={'C': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                               15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                               27, 28, 29]},
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(gs) == expected
+
+    # Now with ellipsis
+    param_grid = {"C": list(range(n_max_elements_to_show + 1))}
+    gs = GridSearchCV(SVC(), param_grid)
+    expected = """
+GridSearchCV(cv='warn', error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid={'C': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                               15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                               27, 28, 29, ...]},
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(gs) == expected
+
+
+def test_bruteforce_ellipsis(print_changed_only_false):
+    # Check that the bruteforce ellipsis (used when the number of non-blank
+    # characters exceeds N_CHAR_MAX) renders correctly.
+
+    lr = LogisticRegression()
+
+    # test when the left and right side of the ellipsis aren't on the same
+    # line.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   in...
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=150)
+
+    # test with very small N_CHAR_MAX
+    # Note that N_CHAR_MAX is not strictly enforced, but it's normal: to avoid
+    # weird reprs we still keep the whole line of the right part (after the
+    # ellipsis).
+    expected = """
+Lo...
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=4)
+
+    # test with N_CHAR_MAX == number of non-blank characters: In this case we
+    # don't want ellipsis
+    full_repr = lr.__repr__(N_CHAR_MAX=float("inf"))
+    n_nonblank = len("".join(full_repr.split()))
+    assert lr.__repr__(N_CHAR_MAX=n_nonblank) == full_repr
+    assert "..." not in full_repr
+
+    # test with N_CHAR_MAX == number of non-blank characters - 10: the left and
+    # right side of the ellispsis are on different lines. In this case we
+    # want to expend the whole line of the right side
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_i...
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 10)
+
+    # test with N_CHAR_MAX == number of non-blank characters - 10: the left and
+    # right side of the ellispsis are on the same line. In this case we don't
+    # want to expend the whole line of the right side, just add the ellispsis
+    # between the 2 sides.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter...,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 4)
+
+    # test with N_CHAR_MAX == number of non-blank characters - 2: the left and
+    # right side of the ellispsis are on the same line, but adding the ellipsis
+    # would actually make the repr longer. So we don't add the ellipsis.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter=100,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 2)
+
+
+def test_builtin_prettyprinter():
+    # non regression test than ensures we can still use the builtin
+    # PrettyPrinter class for estimators (as done e.g. by joblib).
+    # Used to be a bug
+
+    PrettyPrinter().pprint(LogisticRegression())
+
+
+def test_kwargs_in_init():
+    # Make sure the changed_only=True mode is OK when an argument is passed as
+    # kwargs.
+    # Non-regression test for
+    # https://github.com/scikit-learn/scikit-learn/issues/17206
+
+    class WithKWargs(BaseEstimator):
+        # Estimator with a kwargs argument. These need to hack around
+        # set_params and get_params. Here we mimic what LightGBM does.
+        def __init__(self, a="willchange", b="unchanged", **kwargs):
+            self.a = a
+            self.b = b
+            self._other_params = {}
+            self.set_params(**kwargs)
+
+        def get_params(self, deep=True):
+            params = super().get_params(deep=deep)
+            params.update(self._other_params)
+            return params
+
+        def set_params(self, **params):
+            for key, value in params.items():
+                setattr(self, key, value)
+                self._other_params[key] = value
+            return self
+
+    est = WithKWargs(a="something", c="abcd", d=None)
+
+    expected = "WithKWargs(a='something', c='abcd', d=None)"
+    assert expected == est.__repr__()
+
+    with config_context(print_changed_only=False):
+        expected = "WithKWargs(a='something', b='unchanged', c='abcd', d=None)"
+        assert expected == est.__repr__()
+
+
+def test_complexity_print_changed_only():
+    # Make sure `__repr__` is called the same amount of times
+    # whether `print_changed_only` is True or False
+    # Non-regression test for
+    # https://github.com/scikit-learn/scikit-learn/issues/18490
+
+    class DummyEstimator(TransformerMixin, BaseEstimator):
+        nb_times_repr_called = 0
+
+        def __init__(self, estimator=None):
+            self.estimator = estimator
+
+        def __repr__(self):
+            DummyEstimator.nb_times_repr_called += 1
+            return super().__repr__()
+
+        def transform(self, X, copy=None):  # pragma: no cover
+            return X
+
+    estimator = DummyEstimator(
+        make_pipeline(DummyEstimator(DummyEstimator()), DummyEstimator(), "passthrough")
+    )
+    with config_context(print_changed_only=False):
+        repr(estimator)
+        nb_repr_print_changed_only_false = DummyEstimator.nb_times_repr_called
+
+    DummyEstimator.nb_times_repr_called = 0
+    with config_context(print_changed_only=True):
+        repr(estimator)
+        nb_repr_print_changed_only_true = DummyEstimator.nb_times_repr_called
+
+    assert nb_repr_print_changed_only_false == nb_repr_print_changed_only_true
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_random.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_random.py
new file mode 100644
index 0000000000000000000000000000000000000000..13e1c9f1951b9b4390606b1b7b7725b4cdeba5e5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_random.py
@@ -0,0 +1,192 @@
+import numpy as np
+import pytest
+import scipy.sparse as sp
+from numpy.testing import assert_array_almost_equal
+from scipy.special import comb
+
+from sklearn.utils._random import _our_rand_r_py
+from sklearn.utils.random import _random_choice_csc, sample_without_replacement
+
+
+###############################################################################
+# test custom sampling without replacement algorithm
+###############################################################################
+def test_invalid_sample_without_replacement_algorithm():
+    with pytest.raises(ValueError):
+        sample_without_replacement(5, 4, "unknown")
+
+
+def test_sample_without_replacement_algorithms():
+    methods = ("auto", "tracking_selection", "reservoir_sampling", "pool")
+
+    for m in methods:
+
+        def sample_without_replacement_method(
+            n_population, n_samples, random_state=None
+        ):
+            return sample_without_replacement(
+                n_population, n_samples, method=m, random_state=random_state
+            )
+
+        check_edge_case_of_sample_int(sample_without_replacement_method)
+        check_sample_int(sample_without_replacement_method)
+        check_sample_int_distribution(sample_without_replacement_method)
+
+
+def check_edge_case_of_sample_int(sample_without_replacement):
+    # n_population < n_sample
+    with pytest.raises(ValueError):
+        sample_without_replacement(0, 1)
+    with pytest.raises(ValueError):
+        sample_without_replacement(1, 2)
+
+    # n_population == n_samples
+    assert sample_without_replacement(0, 0).shape == (0,)
+
+    assert sample_without_replacement(1, 1).shape == (1,)
+
+    # n_population >= n_samples
+    assert sample_without_replacement(5, 0).shape == (0,)
+    assert sample_without_replacement(5, 1).shape == (1,)
+
+    # n_population < 0 or n_samples < 0
+    with pytest.raises(ValueError):
+        sample_without_replacement(-1, 5)
+    with pytest.raises(ValueError):
+        sample_without_replacement(5, -1)
+
+
+def check_sample_int(sample_without_replacement):
+    # This test is heavily inspired from test_random.py of python-core.
+    #
+    # For the entire allowable range of 0 <= k <= N, validate that
+    # the sample is of the correct length and contains only unique items
+    n_population = 100
+
+    for n_samples in range(n_population + 1):
+        s = sample_without_replacement(n_population, n_samples)
+        assert len(s) == n_samples
+        unique = np.unique(s)
+        assert np.size(unique) == n_samples
+        assert np.all(unique < n_population)
+
+    # test edge case n_population == n_samples == 0
+    assert np.size(sample_without_replacement(0, 0)) == 0
+
+
+def check_sample_int_distribution(sample_without_replacement):
+    # This test is heavily inspired from test_random.py of python-core.
+    #
+    # For the entire allowable range of 0 <= k <= N, validate that
+    # sample generates all possible permutations
+    n_population = 10
+
+    # a large number of trials prevents false negatives without slowing normal
+    # case
+    n_trials = 10000
+
+    for n_samples in range(n_population):
+        # Counting the number of combinations is not as good as counting the
+        # the number of permutations. However, it works with sampling algorithm
+        # that does not provide a random permutation of the subset of integer.
+        n_expected = comb(n_population, n_samples, exact=True)
+
+        output = {}
+        for i in range(n_trials):
+            output[frozenset(sample_without_replacement(n_population, n_samples))] = (
+                None
+            )
+
+            if len(output) == n_expected:
+                break
+        else:
+            raise AssertionError(
+                "number of combinations != number of expected (%s != %s)"
+                % (len(output), n_expected)
+            )
+
+
+def test_random_choice_csc(n_samples=10000, random_state=24):
+    # Explicit class probabilities
+    classes = [np.array([0, 1]), np.array([0, 1, 2])]
+    class_probabilities = [np.array([0.5, 0.5]), np.array([0.6, 0.1, 0.3])]
+
+    got = _random_choice_csc(n_samples, classes, class_probabilities, random_state)
+    assert sp.issparse(got)
+
+    for k in range(len(classes)):
+        p = np.bincount(got[:, [k]].toarray().ravel()) / float(n_samples)
+        assert_array_almost_equal(class_probabilities[k], p, decimal=1)
+
+    # Implicit class probabilities
+    classes = [[0, 1], [1, 2]]  # test for array-like support
+    class_probabilities = [np.array([0.5, 0.5]), np.array([0, 1 / 2, 1 / 2])]
+
+    got = _random_choice_csc(
+        n_samples=n_samples, classes=classes, random_state=random_state
+    )
+    assert sp.issparse(got)
+
+    for k in range(len(classes)):
+        p = np.bincount(got[:, [k]].toarray().ravel()) / float(n_samples)
+        assert_array_almost_equal(class_probabilities[k], p, decimal=1)
+
+    # Edge case probabilities 1.0 and 0.0
+    classes = [np.array([0, 1]), np.array([0, 1, 2])]
+    class_probabilities = [np.array([0.0, 1.0]), np.array([0.0, 1.0, 0.0])]
+
+    got = _random_choice_csc(n_samples, classes, class_probabilities, random_state)
+    assert sp.issparse(got)
+
+    for k in range(len(classes)):
+        p = (
+            np.bincount(
+                got[:, [k]].toarray().ravel(), minlength=len(class_probabilities[k])
+            )
+            / n_samples
+        )
+        assert_array_almost_equal(class_probabilities[k], p, decimal=1)
+
+    # One class target data
+    classes = [[1], [0]]  # test for array-like support
+    class_probabilities = [np.array([0.0, 1.0]), np.array([1.0])]
+
+    got = _random_choice_csc(
+        n_samples=n_samples, classes=classes, random_state=random_state
+    )
+    assert sp.issparse(got)
+
+    for k in range(len(classes)):
+        p = np.bincount(got[:, [k]].toarray().ravel()) / n_samples
+        assert_array_almost_equal(class_probabilities[k], p, decimal=1)
+
+
+def test_random_choice_csc_errors():
+    # the length of an array in classes and class_probabilities is mismatched
+    classes = [np.array([0, 1]), np.array([0, 1, 2, 3])]
+    class_probabilities = [np.array([0.5, 0.5]), np.array([0.6, 0.1, 0.3])]
+    with pytest.raises(ValueError):
+        _random_choice_csc(4, classes, class_probabilities, 1)
+
+    # the class dtype is not supported
+    classes = [np.array(["a", "1"]), np.array(["z", "1", "2"])]
+    class_probabilities = [np.array([0.5, 0.5]), np.array([0.6, 0.1, 0.3])]
+    with pytest.raises(ValueError):
+        _random_choice_csc(4, classes, class_probabilities, 1)
+
+    # the class dtype is not supported
+    classes = [np.array([4.2, 0.1]), np.array([0.1, 0.2, 9.4])]
+    class_probabilities = [np.array([0.5, 0.5]), np.array([0.6, 0.1, 0.3])]
+    with pytest.raises(ValueError):
+        _random_choice_csc(4, classes, class_probabilities, 1)
+
+    # Given probabilities don't sum to 1
+    classes = [np.array([0, 1]), np.array([0, 1, 2])]
+    class_probabilities = [np.array([0.5, 0.6]), np.array([0.6, 0.1, 0.3])]
+    with pytest.raises(ValueError):
+        _random_choice_csc(4, classes, class_probabilities, 1)
+
+
+def test_our_rand_r():
+    assert 131541053 == _our_rand_r_py(1273642419)
+    assert 270369 == _our_rand_r_py(0)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_response.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_response.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f791b59dfaa3aa94ca71295f5b9f74fd885964e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_response.py
@@ -0,0 +1,394 @@
+import warnings
+
+import numpy as np
+import pytest
+
+from sklearn.datasets import (
+    load_iris,
+    make_classification,
+    make_multilabel_classification,
+    make_regression,
+)
+from sklearn.ensemble import IsolationForest
+from sklearn.linear_model import (
+    LinearRegression,
+    LogisticRegression,
+)
+from sklearn.multioutput import ClassifierChain
+from sklearn.preprocessing import scale
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.utils._mocking import _MockEstimatorOnOffPrediction
+from sklearn.utils._response import _get_response_values, _get_response_values_binary
+from sklearn.utils._testing import assert_allclose, assert_array_equal
+
+X, y = load_iris(return_X_y=True)
+# scale the data to avoid ConvergenceWarning with LogisticRegression
+X = scale(X, copy=False)
+X_binary, y_binary = X[:100], y[:100]
+
+
+@pytest.mark.parametrize(
+    "response_method", ["decision_function", "predict_proba", "predict_log_proba"]
+)
+def test_get_response_values_regressor_error(response_method):
+    """Check the error message with regressor an not supported response
+    method."""
+    my_estimator = _MockEstimatorOnOffPrediction(response_methods=[response_method])
+    X = "mocking_data", "mocking_target"
+    err_msg = f"{my_estimator.__class__.__name__} should either be a classifier"
+    with pytest.raises(ValueError, match=err_msg):
+        _get_response_values(my_estimator, X, response_method=response_method)
+
+
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+def test_get_response_values_regressor(return_response_method_used):
+    """Check the behaviour of `_get_response_values` with regressor."""
+    X, y = make_regression(n_samples=10, random_state=0)
+    regressor = LinearRegression().fit(X, y)
+    results = _get_response_values(
+        regressor,
+        X,
+        response_method="predict",
+        return_response_method_used=return_response_method_used,
+    )
+    assert_array_equal(results[0], regressor.predict(X))
+    assert results[1] is None
+    if return_response_method_used:
+        assert results[2] == "predict"
+
+
+@pytest.mark.parametrize(
+    "response_method",
+    ["predict", "decision_function", ["decision_function", "predict"]],
+)
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+def test_get_response_values_outlier_detection(
+    response_method, return_response_method_used
+):
+    """Check the behaviour of `_get_response_values` with outlier detector."""
+    X, y = make_classification(n_samples=50, random_state=0)
+    outlier_detector = IsolationForest(random_state=0).fit(X, y)
+    results = _get_response_values(
+        outlier_detector,
+        X,
+        response_method=response_method,
+        return_response_method_used=return_response_method_used,
+    )
+    chosen_response_method = (
+        response_method[0] if isinstance(response_method, list) else response_method
+    )
+    prediction_method = getattr(outlier_detector, chosen_response_method)
+    assert_array_equal(results[0], prediction_method(X))
+    assert results[1] is None
+    if return_response_method_used:
+        assert results[2] == chosen_response_method
+
+
+@pytest.mark.parametrize(
+    "response_method",
+    ["predict_proba", "decision_function", "predict", "predict_log_proba"],
+)
+def test_get_response_values_classifier_unknown_pos_label(response_method):
+    """Check that `_get_response_values` raises the proper error message with
+    classifier."""
+    X, y = make_classification(n_samples=10, n_classes=2, random_state=0)
+    classifier = LogisticRegression().fit(X, y)
+
+    # provide a `pos_label` which is not in `y`
+    err_msg = r"pos_label=whatever is not a valid label: It should be one of \[0 1\]"
+    with pytest.raises(ValueError, match=err_msg):
+        _get_response_values(
+            classifier,
+            X,
+            response_method=response_method,
+            pos_label="whatever",
+        )
+
+
+@pytest.mark.parametrize("response_method", ["predict_proba", "predict_log_proba"])
+def test_get_response_values_classifier_inconsistent_y_pred_for_binary_proba(
+    response_method,
+):
+    """Check that `_get_response_values` will raise an error when `y_pred` has a
+    single class with `predict_proba`."""
+    X, y_two_class = make_classification(n_samples=10, n_classes=2, random_state=0)
+    y_single_class = np.zeros_like(y_two_class)
+    classifier = DecisionTreeClassifier().fit(X, y_single_class)
+
+    err_msg = (
+        r"Got predict_proba of shape \(10, 1\), but need classifier with "
+        r"two classes"
+    )
+    with pytest.raises(ValueError, match=err_msg):
+        _get_response_values(classifier, X, response_method=response_method)
+
+
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+def test_get_response_values_binary_classifier_decision_function(
+    return_response_method_used,
+):
+    """Check the behaviour of `_get_response_values` with `decision_function`
+    and binary classifier."""
+    X, y = make_classification(
+        n_samples=10,
+        n_classes=2,
+        weights=[0.3, 0.7],
+        random_state=0,
+    )
+    classifier = LogisticRegression().fit(X, y)
+    response_method = "decision_function"
+
+    # default `pos_label`
+    results = _get_response_values(
+        classifier,
+        X,
+        response_method=response_method,
+        pos_label=None,
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.decision_function(X))
+    assert results[1] == 1
+    if return_response_method_used:
+        assert results[2] == "decision_function"
+
+    # when forcing `pos_label=classifier.classes_[0]`
+    results = _get_response_values(
+        classifier,
+        X,
+        response_method=response_method,
+        pos_label=classifier.classes_[0],
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.decision_function(X) * -1)
+    assert results[1] == 0
+    if return_response_method_used:
+        assert results[2] == "decision_function"
+
+
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+@pytest.mark.parametrize("response_method", ["predict_proba", "predict_log_proba"])
+def test_get_response_values_binary_classifier_predict_proba(
+    return_response_method_used, response_method
+):
+    """Check that `_get_response_values` with `predict_proba` and binary
+    classifier."""
+    X, y = make_classification(
+        n_samples=10,
+        n_classes=2,
+        weights=[0.3, 0.7],
+        random_state=0,
+    )
+    classifier = LogisticRegression().fit(X, y)
+
+    # default `pos_label`
+    results = _get_response_values(
+        classifier,
+        X,
+        response_method=response_method,
+        pos_label=None,
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], getattr(classifier, response_method)(X)[:, 1])
+    assert results[1] == 1
+    if return_response_method_used:
+        assert len(results) == 3
+        assert results[2] == response_method
+    else:
+        assert len(results) == 2
+
+    # when forcing `pos_label=classifier.classes_[0]`
+    y_pred, pos_label, *_ = _get_response_values(
+        classifier,
+        X,
+        response_method=response_method,
+        pos_label=classifier.classes_[0],
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(y_pred, getattr(classifier, response_method)(X)[:, 0])
+    assert pos_label == 0
+
+
+@pytest.mark.parametrize(
+    "estimator, X, y, err_msg, params",
+    [
+        (
+            DecisionTreeRegressor(),
+            X_binary,
+            y_binary,
+            "Expected 'estimator' to be a binary classifier",
+            {"response_method": "auto"},
+        ),
+        (
+            DecisionTreeClassifier(),
+            X_binary,
+            y_binary,
+            r"pos_label=unknown is not a valid label: It should be one of \[0 1\]",
+            {"response_method": "auto", "pos_label": "unknown"},
+        ),
+        (
+            DecisionTreeClassifier(),
+            X,
+            y,
+            "be a binary classifier. Got 3 classes instead.",
+            {"response_method": "predict_proba"},
+        ),
+    ],
+)
+def test_get_response_error(estimator, X, y, err_msg, params):
+    """Check that we raise the proper error messages in _get_response_values_binary."""
+
+    estimator.fit(X, y)
+    with pytest.raises(ValueError, match=err_msg):
+        _get_response_values_binary(estimator, X, **params)
+
+
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+def test_get_response_predict_proba(return_response_method_used):
+    """Check the behaviour of `_get_response_values_binary` using `predict_proba`."""
+    classifier = DecisionTreeClassifier().fit(X_binary, y_binary)
+    results = _get_response_values_binary(
+        classifier,
+        X_binary,
+        response_method="predict_proba",
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.predict_proba(X_binary)[:, 1])
+    assert results[1] == 1
+    if return_response_method_used:
+        assert results[2] == "predict_proba"
+
+    results = _get_response_values_binary(
+        classifier,
+        X_binary,
+        response_method="predict_proba",
+        pos_label=0,
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.predict_proba(X_binary)[:, 0])
+    assert results[1] == 0
+    if return_response_method_used:
+        assert results[2] == "predict_proba"
+
+
+@pytest.mark.parametrize("return_response_method_used", [True, False])
+def test_get_response_decision_function(return_response_method_used):
+    """Check the behaviour of `_get_response_values_binary` using decision_function."""
+    classifier = LogisticRegression().fit(X_binary, y_binary)
+    results = _get_response_values_binary(
+        classifier,
+        X_binary,
+        response_method="decision_function",
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.decision_function(X_binary))
+    assert results[1] == 1
+    if return_response_method_used:
+        assert results[2] == "decision_function"
+
+    results = _get_response_values_binary(
+        classifier,
+        X_binary,
+        response_method="decision_function",
+        pos_label=0,
+        return_response_method_used=return_response_method_used,
+    )
+    assert_allclose(results[0], classifier.decision_function(X_binary) * -1)
+    assert results[1] == 0
+    if return_response_method_used:
+        assert results[2] == "decision_function"
+
+
+@pytest.mark.parametrize(
+    "estimator, response_method",
+    [
+        (DecisionTreeClassifier(max_depth=2, random_state=0), "predict_proba"),
+        (DecisionTreeClassifier(max_depth=2, random_state=0), "predict_log_proba"),
+        (LogisticRegression(), "decision_function"),
+    ],
+)
+def test_get_response_values_multiclass(estimator, response_method):
+    """Check that we can call `_get_response_values` with a multiclass estimator.
+    It should return the predictions untouched.
+    """
+    estimator.fit(X, y)
+    predictions, pos_label = _get_response_values(
+        estimator, X, response_method=response_method
+    )
+
+    assert pos_label is None
+    assert predictions.shape == (X.shape[0], len(estimator.classes_))
+    if response_method == "predict_proba":
+        assert np.logical_and(predictions >= 0, predictions <= 1).all()
+    elif response_method == "predict_log_proba":
+        assert (predictions <= 0.0).all()
+
+
+def test_get_response_values_with_response_list():
+    """Check the behaviour of passing a list of responses to `_get_response_values`."""
+    classifier = LogisticRegression().fit(X_binary, y_binary)
+
+    # it should use `predict_proba`
+    y_pred, pos_label, response_method = _get_response_values(
+        classifier,
+        X_binary,
+        response_method=["predict_proba", "decision_function"],
+        return_response_method_used=True,
+    )
+    assert_allclose(y_pred, classifier.predict_proba(X_binary)[:, 1])
+    assert pos_label == 1
+    assert response_method == "predict_proba"
+
+    # it should use `decision_function`
+    y_pred, pos_label, response_method = _get_response_values(
+        classifier,
+        X_binary,
+        response_method=["decision_function", "predict_proba"],
+        return_response_method_used=True,
+    )
+    assert_allclose(y_pred, classifier.decision_function(X_binary))
+    assert pos_label == 1
+    assert response_method == "decision_function"
+
+
+@pytest.mark.parametrize(
+    "response_method", ["predict_proba", "decision_function", "predict"]
+)
+def test_get_response_values_multilabel_indicator(response_method):
+    X, Y = make_multilabel_classification(random_state=0)
+    estimator = ClassifierChain(LogisticRegression()).fit(X, Y)
+
+    y_pred, pos_label = _get_response_values(
+        estimator, X, response_method=response_method
+    )
+    assert pos_label is None
+    assert y_pred.shape == Y.shape
+
+    if response_method == "predict_proba":
+        assert np.logical_and(y_pred >= 0, y_pred <= 1).all()
+    elif response_method == "decision_function":
+        # values returned by `decision_function` are not bounded in [0, 1]
+        assert (y_pred < 0).sum() > 0
+        assert (y_pred > 1).sum() > 0
+    else:  # response_method == "predict"
+        assert np.logical_or(y_pred == 0, y_pred == 1).all()
+
+
+def test_response_values_type_of_target_on_classes_no_warning():
+    """
+    Ensure `_get_response_values` doesn't raise spurious warning.
+
+    "The number of unique classes is greater than > 50% of samples"
+    warning should not be raised when calling `type_of_target(classes_)`.
+
+    Non-regression test for issue #31583.
+    """
+    X = np.random.RandomState(0).randn(120, 3)
+    # 30 classes, less than 50% of number of samples
+    y = np.repeat(np.arange(30), 4)
+
+    clf = LogisticRegression().fit(X, y)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+
+        _get_response_values(clf, X, response_method="predict_proba")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_seq_dataset.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_seq_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c3420aeb83c224e0bb47f9f918c80f7ac3e9bd1
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_seq_dataset.py
@@ -0,0 +1,183 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from itertools import product
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn.datasets import load_iris
+from sklearn.utils._seq_dataset import (
+    ArrayDataset32,
+    ArrayDataset64,
+    CSRDataset32,
+    CSRDataset64,
+)
+from sklearn.utils._testing import assert_allclose
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+iris = load_iris()
+X64 = iris.data.astype(np.float64)
+y64 = iris.target.astype(np.float64)
+sample_weight64 = np.arange(y64.size, dtype=np.float64)
+
+X32 = iris.data.astype(np.float32)
+y32 = iris.target.astype(np.float32)
+sample_weight32 = np.arange(y32.size, dtype=np.float32)
+
+floating = [np.float32, np.float64]
+
+
+def assert_csr_equal_values(current, expected):
+    current.eliminate_zeros()
+    expected.eliminate_zeros()
+    expected = expected.astype(current.dtype)
+    assert current.shape[0] == expected.shape[0]
+    assert current.shape[1] == expected.shape[1]
+    assert_array_equal(current.data, expected.data)
+    assert_array_equal(current.indices, expected.indices)
+    assert_array_equal(current.indptr, expected.indptr)
+
+
+def _make_dense_dataset(float_dtype):
+    if float_dtype == np.float32:
+        return ArrayDataset32(X32, y32, sample_weight32, seed=42)
+    return ArrayDataset64(X64, y64, sample_weight64, seed=42)
+
+
+def _make_sparse_dataset(csr_container, float_dtype):
+    if float_dtype == np.float32:
+        X, y, sample_weight, csr_dataset = X32, y32, sample_weight32, CSRDataset32
+    else:
+        X, y, sample_weight, csr_dataset = X64, y64, sample_weight64, CSRDataset64
+    X = csr_container(X)
+    return csr_dataset(X.data, X.indptr, X.indices, y, sample_weight, seed=42)
+
+
+def _make_dense_datasets():
+    return [_make_dense_dataset(float_dtype) for float_dtype in floating]
+
+
+def _make_sparse_datasets():
+    return [
+        _make_sparse_dataset(csr_container, float_dtype)
+        for csr_container, float_dtype in product(CSR_CONTAINERS, floating)
+    ]
+
+
+def _make_fused_types_datasets():
+    all_datasets = _make_dense_datasets() + _make_sparse_datasets()
+    # group dataset by array types to get a tuple (float32, float64)
+    return (all_datasets[idx : idx + 2] for idx in range(0, len(all_datasets), 2))
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("dataset", _make_dense_datasets() + _make_sparse_datasets())
+def test_seq_dataset_basic_iteration(dataset, csr_container):
+    NUMBER_OF_RUNS = 5
+    X_csr64 = csr_container(X64)
+    for _ in range(NUMBER_OF_RUNS):
+        # next sample
+        xi_, yi, swi, idx = dataset._next_py()
+        xi = csr_container(xi_, shape=(1, X64.shape[1]))
+
+        assert_csr_equal_values(xi, X_csr64[[idx]])
+        assert yi == y64[idx]
+        assert swi == sample_weight64[idx]
+
+        # random sample
+        xi_, yi, swi, idx = dataset._random_py()
+        xi = csr_container(xi_, shape=(1, X64.shape[1]))
+
+        assert_csr_equal_values(xi, X_csr64[[idx]])
+        assert yi == y64[idx]
+        assert swi == sample_weight64[idx]
+
+
+@pytest.mark.parametrize(
+    "dense_dataset,sparse_dataset",
+    [
+        (
+            _make_dense_dataset(float_dtype),
+            _make_sparse_dataset(csr_container, float_dtype),
+        )
+        for float_dtype, csr_container in product(floating, CSR_CONTAINERS)
+    ],
+)
+def test_seq_dataset_shuffle(dense_dataset, sparse_dataset):
+    # not shuffled
+    for i in range(5):
+        _, _, _, idx1 = dense_dataset._next_py()
+        _, _, _, idx2 = sparse_dataset._next_py()
+        assert idx1 == i
+        assert idx2 == i
+
+    for i in [132, 50, 9, 18, 58]:
+        _, _, _, idx1 = dense_dataset._random_py()
+        _, _, _, idx2 = sparse_dataset._random_py()
+        assert idx1 == i
+        assert idx2 == i
+
+    seed = 77
+    dense_dataset._shuffle_py(seed)
+    sparse_dataset._shuffle_py(seed)
+
+    idx_next = [63, 91, 148, 87, 29]
+    idx_shuffle = [137, 125, 56, 121, 127]
+    for i, j in zip(idx_next, idx_shuffle):
+        _, _, _, idx1 = dense_dataset._next_py()
+        _, _, _, idx2 = sparse_dataset._next_py()
+        assert idx1 == i
+        assert idx2 == i
+
+        _, _, _, idx1 = dense_dataset._random_py()
+        _, _, _, idx2 = sparse_dataset._random_py()
+        assert idx1 == j
+        assert idx2 == j
+
+
+@pytest.mark.parametrize("dataset_32,dataset_64", _make_fused_types_datasets())
+def test_fused_types_consistency(dataset_32, dataset_64):
+    NUMBER_OF_RUNS = 5
+    for _ in range(NUMBER_OF_RUNS):
+        # next sample
+        (xi_data32, _, _), yi32, _, _ = dataset_32._next_py()
+        (xi_data64, _, _), yi64, _, _ = dataset_64._next_py()
+
+        assert xi_data32.dtype == np.float32
+        assert xi_data64.dtype == np.float64
+
+        assert_allclose(xi_data64, xi_data32, rtol=1e-5)
+        assert_allclose(yi64, yi32, rtol=1e-5)
+
+
+def test_buffer_dtype_mismatch_error():
+    with pytest.raises(ValueError, match="Buffer dtype mismatch"):
+        ArrayDataset64(X32, y32, sample_weight32, seed=42)
+
+    with pytest.raises(ValueError, match="Buffer dtype mismatch"):
+        ArrayDataset32(X64, y64, sample_weight64, seed=42)
+
+    for csr_container in CSR_CONTAINERS:
+        X_csr32 = csr_container(X32)
+        X_csr64 = csr_container(X64)
+        with pytest.raises(ValueError, match="Buffer dtype mismatch"):
+            CSRDataset64(
+                X_csr32.data,
+                X_csr32.indptr,
+                X_csr32.indices,
+                y32,
+                sample_weight32,
+                seed=42,
+            )
+
+        with pytest.raises(ValueError, match="Buffer dtype mismatch"):
+            CSRDataset32(
+                X_csr64.data,
+                X_csr64.indptr,
+                X_csr64.indices,
+                y64,
+                sample_weight64,
+                seed=42,
+            )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_set_output.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_set_output.py
new file mode 100644
index 0000000000000000000000000000000000000000..146f0a6c28592694ad52f672c38ad1d5a5505a14
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_set_output.py
@@ -0,0 +1,471 @@
+import importlib
+from collections import namedtuple
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn._config import config_context, get_config
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils._set_output import (
+    ADAPTERS_MANAGER,
+    ContainerAdapterProtocol,
+    _get_adapter_from_container,
+    _get_output_config,
+    _safe_set_output,
+    _SetOutputMixin,
+    _wrap_data_with_container,
+    check_library_installed,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+
+def test_pandas_adapter():
+    """Check pandas adapter has expected behavior."""
+    pd = pytest.importorskip("pandas")
+    X_np = np.asarray([[1, 0, 3], [0, 0, 1]])
+    columns = np.asarray(["f0", "f1", "f2"], dtype=object)
+    index = np.asarray([1, 2])
+    X_df_orig = pd.DataFrame([[1, 2], [1, 3]], index=index)
+    X_ser_orig = pd.Series([2, 3], index=index)
+
+    adapter = ADAPTERS_MANAGER.adapters["pandas"]
+    X_container = adapter.create_container(X_np, X_df_orig, columns=lambda: columns)
+    assert isinstance(X_container, pd.DataFrame)
+    assert_array_equal(X_container.columns, columns)
+    assert_array_equal(X_container.index, index)
+
+    # use original index when the original is a series
+    X_container = adapter.create_container(X_np, X_ser_orig, columns=lambda: columns)
+    assert isinstance(X_container, pd.DataFrame)
+    assert_array_equal(X_container.columns, columns)
+    assert_array_equal(X_container.index, index)
+
+    # Input dataframe's index does not change
+    new_columns = np.asarray(["f0", "f1"], dtype=object)
+    X_df = pd.DataFrame([[1, 2], [1, 3]], index=[10, 12])
+    new_df = adapter.create_container(X_df, X_df_orig, columns=new_columns)
+    assert_array_equal(new_df.columns, new_columns)
+    assert_array_equal(new_df.index, X_df.index)
+
+    assert adapter.is_supported_container(X_df)
+    assert not adapter.is_supported_container(X_np)
+
+    # adapter.update_columns updates the columns
+    new_columns = np.array(["a", "c"], dtype=object)
+    new_df = adapter.rename_columns(X_df, new_columns)
+    assert_array_equal(new_df.columns, new_columns)
+
+    # adapter.hstack stacks the dataframes horizontally.
+    X_df_1 = pd.DataFrame([[1, 2, 5], [3, 4, 6]], columns=["a", "b", "e"])
+    X_df_2 = pd.DataFrame([[4], [5]], columns=["c"])
+    X_stacked = adapter.hstack([X_df_1, X_df_2])
+
+    expected_df = pd.DataFrame(
+        [[1, 2, 5, 4], [3, 4, 6, 5]], columns=["a", "b", "e", "c"]
+    )
+    pd.testing.assert_frame_equal(X_stacked, expected_df)
+
+    # check that we update properly the columns even with duplicate column names
+    # this use-case potentially happen when using ColumnTransformer
+    # non-regression test for gh-28260
+    X_df = pd.DataFrame([[1, 2], [1, 3]], columns=["a", "a"])
+    new_columns = np.array(["x__a", "y__a"], dtype=object)
+    new_df = adapter.rename_columns(X_df, new_columns)
+    assert_array_equal(new_df.columns, new_columns)
+
+    # check the behavior of the inplace parameter in `create_container`
+    # we should trigger a copy
+    X_df = pd.DataFrame([[1, 2], [1, 3]], index=index)
+    X_output = adapter.create_container(X_df, X_df, columns=["a", "b"], inplace=False)
+    assert X_output is not X_df
+    assert list(X_df.columns) == [0, 1]
+    assert list(X_output.columns) == ["a", "b"]
+
+    # the operation is inplace
+    X_df = pd.DataFrame([[1, 2], [1, 3]], index=index)
+    X_output = adapter.create_container(X_df, X_df, columns=["a", "b"], inplace=True)
+    assert X_output is X_df
+    assert list(X_df.columns) == ["a", "b"]
+    assert list(X_output.columns) == ["a", "b"]
+
+
+def test_polars_adapter():
+    """Check Polars adapter has expected behavior."""
+    pl = pytest.importorskip("polars")
+    X_np = np.array([[1, 0, 3], [0, 0, 1]])
+    columns = ["f1", "f2", "f3"]
+    X_df_orig = pl.DataFrame(X_np, schema=columns, orient="row")
+
+    adapter = ADAPTERS_MANAGER.adapters["polars"]
+    X_container = adapter.create_container(X_np, X_df_orig, columns=lambda: columns)
+
+    assert isinstance(X_container, pl.DataFrame)
+    assert_array_equal(X_container.columns, columns)
+
+    # Update columns with create_container
+    new_columns = np.asarray(["a", "b", "c"], dtype=object)
+    new_df = adapter.create_container(X_df_orig, X_df_orig, columns=new_columns)
+    assert_array_equal(new_df.columns, new_columns)
+
+    assert adapter.is_supported_container(X_df_orig)
+    assert not adapter.is_supported_container(X_np)
+
+    # adapter.update_columns updates the columns
+    new_columns = np.array(["a", "c", "g"], dtype=object)
+    new_df = adapter.rename_columns(X_df_orig, new_columns)
+    assert_array_equal(new_df.columns, new_columns)
+
+    # adapter.hstack stacks the dataframes horizontally.
+    X_df_1 = pl.DataFrame([[1, 2, 5], [3, 4, 6]], schema=["a", "b", "e"], orient="row")
+    X_df_2 = pl.DataFrame([[4], [5]], schema=["c"], orient="row")
+    X_stacked = adapter.hstack([X_df_1, X_df_2])
+
+    expected_df = pl.DataFrame(
+        [[1, 2, 5, 4], [3, 4, 6, 5]], schema=["a", "b", "e", "c"], orient="row"
+    )
+    from polars.testing import assert_frame_equal
+
+    assert_frame_equal(X_stacked, expected_df)
+
+    # check the behavior of the inplace parameter in `create_container`
+    # we should trigger a copy
+    X_df = pl.DataFrame([[1, 2], [1, 3]], schema=["a", "b"], orient="row")
+    X_output = adapter.create_container(X_df, X_df, columns=["c", "d"], inplace=False)
+    assert X_output is not X_df
+    assert list(X_df.columns) == ["a", "b"]
+    assert list(X_output.columns) == ["c", "d"]
+
+    # the operation is inplace
+    X_df = pl.DataFrame([[1, 2], [1, 3]], schema=["a", "b"], orient="row")
+    X_output = adapter.create_container(X_df, X_df, columns=["c", "d"], inplace=True)
+    assert X_output is X_df
+    assert list(X_df.columns) == ["c", "d"]
+    assert list(X_output.columns) == ["c", "d"]
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test__container_error_validation(csr_container):
+    """Check errors in _wrap_data_with_container."""
+    X = np.asarray([[1, 0, 3], [0, 0, 1]])
+    X_csr = csr_container(X)
+    match = "The transformer outputs a scipy sparse matrix."
+    with config_context(transform_output="pandas"):
+        with pytest.raises(ValueError, match=match):
+            _wrap_data_with_container("transform", X_csr, X, StandardScaler())
+
+
+class EstimatorWithoutSetOutputAndWithoutTransform:
+    pass
+
+
+class EstimatorNoSetOutputWithTransform:
+    def transform(self, X, y=None):
+        return X  # pragma: no cover
+
+
+class EstimatorWithSetOutput(_SetOutputMixin):
+    def fit(self, X, y=None):
+        self.n_features_in_ = X.shape[1]
+        return self
+
+    def transform(self, X, y=None):
+        return X
+
+    def get_feature_names_out(self, input_features=None):
+        return np.asarray([f"X{i}" for i in range(self.n_features_in_)], dtype=object)
+
+
+def test__safe_set_output():
+    """Check _safe_set_output works as expected."""
+
+    # Estimator without transform will not raise when setting set_output for transform.
+    est = EstimatorWithoutSetOutputAndWithoutTransform()
+    _safe_set_output(est, transform="pandas")
+
+    # Estimator with transform but without set_output will raise
+    est = EstimatorNoSetOutputWithTransform()
+    with pytest.raises(ValueError, match="Unable to configure output"):
+        _safe_set_output(est, transform="pandas")
+
+    est = EstimatorWithSetOutput().fit(np.asarray([[1, 2, 3]]))
+    _safe_set_output(est, transform="pandas")
+    config = _get_output_config("transform", est)
+    assert config["dense"] == "pandas"
+
+    _safe_set_output(est, transform="default")
+    config = _get_output_config("transform", est)
+    assert config["dense"] == "default"
+
+    # transform is None is a no-op, so the config remains "default"
+    _safe_set_output(est, transform=None)
+    config = _get_output_config("transform", est)
+    assert config["dense"] == "default"
+
+
+class EstimatorNoSetOutputWithTransformNoFeatureNamesOut(_SetOutputMixin):
+    def transform(self, X, y=None):
+        return X  # pragma: no cover
+
+
+def test_set_output_mixin():
+    """Estimator without get_feature_names_out does not define `set_output`."""
+    est = EstimatorNoSetOutputWithTransformNoFeatureNamesOut()
+    assert not hasattr(est, "set_output")
+
+
+def test__safe_set_output_error():
+    """Check transform with invalid config."""
+    X = np.asarray([[1, 0, 3], [0, 0, 1]])
+
+    est = EstimatorWithSetOutput()
+    _safe_set_output(est, transform="bad")
+
+    msg = "output config must be in"
+    with pytest.raises(ValueError, match=msg):
+        est.transform(X)
+
+
+@pytest.mark.parametrize("dataframe_lib", ["pandas", "polars"])
+def test_set_output_method(dataframe_lib):
+    """Check that the output is a dataframe."""
+    lib = pytest.importorskip(dataframe_lib)
+
+    X = np.asarray([[1, 0, 3], [0, 0, 1]])
+    est = EstimatorWithSetOutput().fit(X)
+
+    # transform=None is a no-op
+    est2 = est.set_output(transform=None)
+    assert est2 is est
+    X_trans_np = est2.transform(X)
+    assert isinstance(X_trans_np, np.ndarray)
+
+    est.set_output(transform=dataframe_lib)
+
+    X_trans_pd = est.transform(X)
+
+    assert isinstance(X_trans_pd, lib.DataFrame)
+
+
+def test_set_output_method_error():
+    """Check transform fails with invalid transform."""
+
+    X = np.asarray([[1, 0, 3], [0, 0, 1]])
+    est = EstimatorWithSetOutput().fit(X)
+    est.set_output(transform="bad")
+
+    msg = "output config must be in"
+    with pytest.raises(ValueError, match=msg):
+        est.transform(X)
+
+
+@pytest.mark.parametrize("transform_output", ["pandas", "polars"])
+def test__get_output_config(transform_output):
+    """Check _get_output_config works as expected."""
+
+    # Without a configuration set, the global config is used
+    global_config = get_config()["transform_output"]
+    config = _get_output_config("transform")
+    assert config["dense"] == global_config
+
+    with config_context(transform_output=transform_output):
+        # with estimator=None, the global config is used
+        config = _get_output_config("transform")
+        assert config["dense"] == transform_output
+
+        est = EstimatorNoSetOutputWithTransform()
+        config = _get_output_config("transform", est)
+        assert config["dense"] == transform_output
+
+        est = EstimatorWithSetOutput()
+        # If estimator has not config, use global config
+        config = _get_output_config("transform", est)
+        assert config["dense"] == transform_output
+
+        # If estimator has a config, use local config
+        est.set_output(transform="default")
+        config = _get_output_config("transform", est)
+        assert config["dense"] == "default"
+
+    est.set_output(transform=transform_output)
+    config = _get_output_config("transform", est)
+    assert config["dense"] == transform_output
+
+
+class EstimatorWithSetOutputNoAutoWrap(_SetOutputMixin, auto_wrap_output_keys=None):
+    def transform(self, X, y=None):
+        return X
+
+
+def test_get_output_auto_wrap_false():
+    """Check that auto_wrap_output_keys=None does not wrap."""
+    est = EstimatorWithSetOutputNoAutoWrap()
+    assert not hasattr(est, "set_output")
+
+    X = np.asarray([[1, 0, 3], [0, 0, 1]])
+    assert X is est.transform(X)
+
+
+def test_auto_wrap_output_keys_errors_with_incorrect_input():
+    msg = "auto_wrap_output_keys must be None or a tuple of keys."
+    with pytest.raises(ValueError, match=msg):
+
+        class BadEstimator(_SetOutputMixin, auto_wrap_output_keys="bad_parameter"):
+            pass
+
+
+class AnotherMixin:
+    def __init_subclass__(cls, custom_parameter, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.custom_parameter = custom_parameter
+
+
+def test_set_output_mixin_custom_mixin():
+    """Check that multiple init_subclasses passes parameters up."""
+
+    class BothMixinEstimator(_SetOutputMixin, AnotherMixin, custom_parameter=123):
+        def transform(self, X, y=None):
+            return X
+
+        def get_feature_names_out(self, input_features=None):
+            return input_features
+
+    est = BothMixinEstimator()
+    assert est.custom_parameter == 123
+    assert hasattr(est, "set_output")
+
+
+def test_set_output_mro():
+    """Check that multi-inheritance resolves to the correct class method.
+
+    Non-regression test gh-25293.
+    """
+
+    class Base(_SetOutputMixin):
+        def transform(self, X):
+            return "Base"
+
+    class A(Base):
+        pass
+
+    class B(Base):
+        def transform(self, X):
+            return "B"
+
+    class C(A, B):
+        pass
+
+    assert C().transform(None) == "B"
+
+
+class EstimatorWithSetOutputIndex(_SetOutputMixin):
+    def fit(self, X, y=None):
+        self.n_features_in_ = X.shape[1]
+        return self
+
+    def transform(self, X, y=None):
+        import pandas as pd
+
+        # transform by giving output a new index.
+        return pd.DataFrame(X.to_numpy(), index=[f"s{i}" for i in range(X.shape[0])])
+
+    def get_feature_names_out(self, input_features=None):
+        return np.asarray([f"X{i}" for i in range(self.n_features_in_)], dtype=object)
+
+
+def test_set_output_pandas_keep_index():
+    """Check that set_output does not override index.
+
+    Non-regression test for gh-25730.
+    """
+    pd = pytest.importorskip("pandas")
+
+    X = pd.DataFrame([[1, 2, 3], [4, 5, 6]], index=[0, 1])
+    est = EstimatorWithSetOutputIndex().set_output(transform="pandas")
+    est.fit(X)
+
+    X_trans = est.transform(X)
+    assert_array_equal(X_trans.index, ["s0", "s1"])
+
+
+class EstimatorReturnTuple(_SetOutputMixin):
+    def __init__(self, OutputTuple):
+        self.OutputTuple = OutputTuple
+
+    def transform(self, X, y=None):
+        return self.OutputTuple(X, 2 * X)
+
+
+def test_set_output_named_tuple_out():
+    """Check that namedtuples are kept by default."""
+    Output = namedtuple("Output", "X, Y")
+    X = np.asarray([[1, 2, 3]])
+    est = EstimatorReturnTuple(OutputTuple=Output)
+    X_trans = est.transform(X)
+
+    assert isinstance(X_trans, Output)
+    assert_array_equal(X_trans.X, X)
+    assert_array_equal(X_trans.Y, 2 * X)
+
+
+class EstimatorWithListInput(_SetOutputMixin):
+    def fit(self, X, y=None):
+        assert isinstance(X, list)
+        self.n_features_in_ = len(X[0])
+        return self
+
+    def transform(self, X, y=None):
+        return X
+
+    def get_feature_names_out(self, input_features=None):
+        return np.asarray([f"X{i}" for i in range(self.n_features_in_)], dtype=object)
+
+
+@pytest.mark.parametrize("dataframe_lib", ["pandas", "polars"])
+def test_set_output_list_input(dataframe_lib):
+    """Check set_output for list input.
+
+    Non-regression test for #27037.
+    """
+    lib = pytest.importorskip(dataframe_lib)
+
+    X = [[0, 1, 2, 3], [4, 5, 6, 7]]
+    est = EstimatorWithListInput()
+    est.set_output(transform=dataframe_lib)
+
+    X_out = est.fit(X).transform(X)
+    assert isinstance(X_out, lib.DataFrame)
+    assert_array_equal(X_out.columns, ["X0", "X1", "X2", "X3"])
+
+
+@pytest.mark.parametrize("name", sorted(ADAPTERS_MANAGER.adapters))
+def test_adapter_class_has_interface(name):
+    """Check adapters have the correct interface."""
+    assert isinstance(ADAPTERS_MANAGER.adapters[name], ContainerAdapterProtocol)
+
+
+def test_check_library_installed(monkeypatch):
+    """Check import error changed."""
+    orig_import_module = importlib.import_module
+
+    def patched_import_module(name):
+        if name == "pandas":
+            raise ImportError()
+        orig_import_module(name, package=None)
+
+    monkeypatch.setattr(importlib, "import_module", patched_import_module)
+
+    msg = "Setting output container to 'pandas' requires"
+    with pytest.raises(ImportError, match=msg):
+        check_library_installed("pandas")
+
+
+def test_get_adapter_from_container():
+    """Check the behavior fo `_get_adapter_from_container`."""
+    pd = pytest.importorskip("pandas")
+    X = pd.DataFrame({"a": [1, 2, 3], "b": [10, 20, 100]})
+    adapter = _get_adapter_from_container(X)
+    assert adapter.container_lib == "pandas"
+    err_msg = "The container does not have a registered adapter in scikit-learn."
+    with pytest.raises(ValueError, match=err_msg):
+        _get_adapter_from_container(X.to_numpy())
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_shortest_path.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_shortest_path.py
new file mode 100644
index 0000000000000000000000000000000000000000..c070ccd70b63dc413b7cfa867d32cb27c67d462e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_shortest_path.py
@@ -0,0 +1,65 @@
+from collections import defaultdict
+
+import numpy as np
+from numpy.testing import assert_array_almost_equal
+
+from sklearn.utils.graph import single_source_shortest_path_length
+
+
+def floyd_warshall_slow(graph, directed=False):
+    N = graph.shape[0]
+
+    # set nonzero entries to infinity
+    graph[np.where(graph == 0)] = np.inf
+
+    # set diagonal to zero
+    graph.flat[:: N + 1] = 0
+
+    if not directed:
+        graph = np.minimum(graph, graph.T)
+
+    for k in range(N):
+        for i in range(N):
+            for j in range(N):
+                graph[i, j] = min(graph[i, j], graph[i, k] + graph[k, j])
+
+    graph[np.where(np.isinf(graph))] = 0
+
+    return graph
+
+
+def generate_graph(N=20):
+    # sparse grid of distances
+    rng = np.random.RandomState(0)
+    dist_matrix = rng.random_sample((N, N))
+
+    # make symmetric: distances are not direction-dependent
+    dist_matrix = dist_matrix + dist_matrix.T
+
+    # make graph sparse
+    i = (rng.randint(N, size=N * N // 2), rng.randint(N, size=N * N // 2))
+    dist_matrix[i] = 0
+
+    # set diagonal to zero
+    dist_matrix.flat[:: N + 1] = 0
+
+    return dist_matrix
+
+
+def test_shortest_path():
+    dist_matrix = generate_graph(20)
+    # We compare path length and not costs (-> set distances to 0 or 1)
+    dist_matrix[dist_matrix != 0] = 1
+
+    for directed in (True, False):
+        if not directed:
+            dist_matrix = np.minimum(dist_matrix, dist_matrix.T)
+
+        graph_py = floyd_warshall_slow(dist_matrix.copy(), directed)
+        for i in range(dist_matrix.shape[0]):
+            # Non-reachable nodes have distance 0 in graph_py
+            dist_dict = defaultdict(int)
+            dist_dict.update(single_source_shortest_path_length(dist_matrix, i))
+
+            for j in range(graph_py[i].shape[0]):
+                assert_array_almost_equal(dist_dict[j], graph_py[i, j])
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_show_versions.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_show_versions.py
new file mode 100644
index 0000000000000000000000000000000000000000..aade231e46f560cb3b42d1616fe208d8996b1ab3
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_show_versions.py
@@ -0,0 +1,40 @@
+from threadpoolctl import threadpool_info
+
+from sklearn.utils._show_versions import _get_deps_info, _get_sys_info, show_versions
+from sklearn.utils._testing import ignore_warnings
+
+
+def test_get_sys_info():
+    sys_info = _get_sys_info()
+
+    assert "python" in sys_info
+    assert "executable" in sys_info
+    assert "machine" in sys_info
+
+
+def test_get_deps_info():
+    with ignore_warnings():
+        deps_info = _get_deps_info()
+
+    assert "pip" in deps_info
+    assert "setuptools" in deps_info
+    assert "sklearn" in deps_info
+    assert "numpy" in deps_info
+    assert "scipy" in deps_info
+    assert "Cython" in deps_info
+    assert "pandas" in deps_info
+    assert "matplotlib" in deps_info
+    assert "joblib" in deps_info
+
+
+def test_show_versions(capsys):
+    with ignore_warnings():
+        show_versions()
+        out, err = capsys.readouterr()
+
+    assert "python" in out
+    assert "numpy" in out
+
+    info = threadpool_info()
+    if info:
+        assert "threadpoolctl info:" in out
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_sparsefuncs.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_sparsefuncs.py
new file mode 100644
index 0000000000000000000000000000000000000000..f80b75c02d515388e0607b002f4712e8d4af54b6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_sparsefuncs.py
@@ -0,0 +1,998 @@
+import numpy as np
+import pytest
+import scipy.sparse as sp
+from numpy.random import RandomState
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+from scipy import linalg
+
+from sklearn.datasets import make_classification
+from sklearn.utils._testing import assert_allclose
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS, LIL_CONTAINERS
+from sklearn.utils.sparsefuncs import (
+    _implicit_column_offset,
+    count_nonzero,
+    csc_median_axis_0,
+    incr_mean_variance_axis,
+    inplace_column_scale,
+    inplace_row_scale,
+    inplace_swap_column,
+    inplace_swap_row,
+    mean_variance_axis,
+    min_max_axis,
+)
+from sklearn.utils.sparsefuncs_fast import (
+    assign_rows_csr,
+    csr_row_norms,
+    inplace_csr_row_normalize_l1,
+    inplace_csr_row_normalize_l2,
+)
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_mean_variance_axis0(csc_container, csr_container, lil_container):
+    X, _ = make_classification(5, 4, random_state=0)
+    # Sparsify the array a little bit
+    X[0, 0] = 0
+    X[2, 1] = 0
+    X[4, 3] = 0
+    X_lil = lil_container(X)
+    X_lil[1, 0] = 0
+    X[1, 0] = 0
+
+    with pytest.raises(TypeError):
+        mean_variance_axis(X_lil, axis=0)
+
+    X_csr = csr_container(X_lil)
+    X_csc = csc_container(X_lil)
+
+    expected_dtypes = [
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+    ]
+
+    for input_dtype, output_dtype in expected_dtypes:
+        X_test = X.astype(input_dtype)
+        for X_sparse in (X_csr, X_csc):
+            X_sparse = X_sparse.astype(input_dtype)
+            X_means, X_vars = mean_variance_axis(X_sparse, axis=0)
+            assert X_means.dtype == output_dtype
+            assert X_vars.dtype == output_dtype
+            assert_array_almost_equal(X_means, np.mean(X_test, axis=0))
+            assert_array_almost_equal(X_vars, np.var(X_test, axis=0))
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("sparse_constructor", CSC_CONTAINERS + CSR_CONTAINERS)
+def test_mean_variance_axis0_precision(dtype, sparse_constructor):
+    # Check that there's no big loss of precision when the real variance is
+    # exactly 0. (#19766)
+    rng = np.random.RandomState(0)
+    X = np.full(fill_value=100.0, shape=(1000, 1), dtype=dtype)
+    # Add some missing records which should be ignored:
+    missing_indices = rng.choice(np.arange(X.shape[0]), 10, replace=False)
+    X[missing_indices, 0] = np.nan
+    X = sparse_constructor(X)
+
+    # Random positive weights:
+    sample_weight = rng.rand(X.shape[0]).astype(dtype)
+
+    _, var = mean_variance_axis(X, weights=sample_weight, axis=0)
+
+    assert var < np.finfo(dtype).eps
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_mean_variance_axis1(csc_container, csr_container, lil_container):
+    X, _ = make_classification(5, 4, random_state=0)
+    # Sparsify the array a little bit
+    X[0, 0] = 0
+    X[2, 1] = 0
+    X[4, 3] = 0
+    X_lil = lil_container(X)
+    X_lil[1, 0] = 0
+    X[1, 0] = 0
+
+    with pytest.raises(TypeError):
+        mean_variance_axis(X_lil, axis=1)
+
+    X_csr = csr_container(X_lil)
+    X_csc = csc_container(X_lil)
+
+    expected_dtypes = [
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+    ]
+
+    for input_dtype, output_dtype in expected_dtypes:
+        X_test = X.astype(input_dtype)
+        for X_sparse in (X_csr, X_csc):
+            X_sparse = X_sparse.astype(input_dtype)
+            X_means, X_vars = mean_variance_axis(X_sparse, axis=0)
+            assert X_means.dtype == output_dtype
+            assert X_vars.dtype == output_dtype
+            assert_array_almost_equal(X_means, np.mean(X_test, axis=0))
+            assert_array_almost_equal(X_vars, np.var(X_test, axis=0))
+
+
+@pytest.mark.parametrize(
+    ["Xw", "X", "weights"],
+    [
+        ([[0, 0, 1], [0, 2, 3]], [[0, 0, 1], [0, 2, 3]], [1, 1, 1]),
+        ([[0, 0, 1], [0, 1, 1]], [[0, 0, 0, 1], [0, 1, 1, 1]], [1, 2, 1]),
+        ([[0, 0, 1], [0, 1, 1]], [[0, 0, 1], [0, 1, 1]], None),
+        (
+            [[0, np.nan, 2], [0, np.nan, np.nan]],
+            [[0, np.nan, 2], [0, np.nan, np.nan]],
+            [1.0, 1.0, 1.0],
+        ),
+        (
+            [[0, 0], [1, np.nan], [2, 0], [0, 3], [np.nan, np.nan], [np.nan, 2]],
+            [
+                [0, 0, 0],
+                [1, 1, np.nan],
+                [2, 2, 0],
+                [0, 0, 3],
+                [np.nan, np.nan, np.nan],
+                [np.nan, np.nan, 2],
+            ],
+            [2.0, 1.0],
+        ),
+        (
+            [[1, 0, 1], [0, 3, 1]],
+            [[1, 0, 0, 0, 1], [0, 3, 3, 3, 1]],
+            np.array([1, 3, 1]),
+        ),
+    ],
+)
+@pytest.mark.parametrize("sparse_constructor", CSC_CONTAINERS + CSR_CONTAINERS)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incr_mean_variance_axis_weighted_axis1(
+    Xw, X, weights, sparse_constructor, dtype
+):
+    axis = 1
+    Xw_sparse = sparse_constructor(Xw).astype(dtype)
+    X_sparse = sparse_constructor(X).astype(dtype)
+
+    last_mean = np.zeros(np.shape(Xw)[0], dtype=dtype)
+    last_var = np.zeros_like(last_mean, dtype=dtype)
+    last_n = np.zeros_like(last_mean, dtype=np.int64)
+    means0, vars0, n_incr0 = incr_mean_variance_axis(
+        X=X_sparse,
+        axis=axis,
+        last_mean=last_mean,
+        last_var=last_var,
+        last_n=last_n,
+        weights=None,
+    )
+
+    means_w0, vars_w0, n_incr_w0 = incr_mean_variance_axis(
+        X=Xw_sparse,
+        axis=axis,
+        last_mean=last_mean,
+        last_var=last_var,
+        last_n=last_n,
+        weights=weights,
+    )
+
+    assert means_w0.dtype == dtype
+    assert vars_w0.dtype == dtype
+    assert n_incr_w0.dtype == dtype
+
+    means_simple, vars_simple = mean_variance_axis(X=X_sparse, axis=axis)
+
+    assert_array_almost_equal(means0, means_w0)
+    assert_array_almost_equal(means0, means_simple)
+    assert_array_almost_equal(vars0, vars_w0)
+    assert_array_almost_equal(vars0, vars_simple)
+    assert_array_almost_equal(n_incr0, n_incr_w0)
+
+    # check second round for incremental
+    means1, vars1, n_incr1 = incr_mean_variance_axis(
+        X=X_sparse,
+        axis=axis,
+        last_mean=means0,
+        last_var=vars0,
+        last_n=n_incr0,
+        weights=None,
+    )
+
+    means_w1, vars_w1, n_incr_w1 = incr_mean_variance_axis(
+        X=Xw_sparse,
+        axis=axis,
+        last_mean=means_w0,
+        last_var=vars_w0,
+        last_n=n_incr_w0,
+        weights=weights,
+    )
+
+    assert_array_almost_equal(means1, means_w1)
+    assert_array_almost_equal(vars1, vars_w1)
+    assert_array_almost_equal(n_incr1, n_incr_w1)
+
+    assert means_w1.dtype == dtype
+    assert vars_w1.dtype == dtype
+    assert n_incr_w1.dtype == dtype
+
+
+@pytest.mark.parametrize(
+    ["Xw", "X", "weights"],
+    [
+        ([[0, 0, 1], [0, 2, 3]], [[0, 0, 1], [0, 2, 3]], [1, 1]),
+        ([[0, 0, 1], [0, 1, 1]], [[0, 0, 1], [0, 1, 1], [0, 1, 1]], [1, 2]),
+        ([[0, 0, 1], [0, 1, 1]], [[0, 0, 1], [0, 1, 1]], None),
+        (
+            [[0, np.nan, 2], [0, np.nan, np.nan]],
+            [[0, np.nan, 2], [0, np.nan, np.nan]],
+            [1.0, 1.0],
+        ),
+        (
+            [[0, 0, 1, np.nan, 2, 0], [0, 3, np.nan, np.nan, np.nan, 2]],
+            [
+                [0, 0, 1, np.nan, 2, 0],
+                [0, 0, 1, np.nan, 2, 0],
+                [0, 3, np.nan, np.nan, np.nan, 2],
+            ],
+            [2.0, 1.0],
+        ),
+        (
+            [[1, 0, 1], [0, 0, 1]],
+            [[1, 0, 1], [0, 0, 1], [0, 0, 1], [0, 0, 1]],
+            np.array([1, 3]),
+        ),
+    ],
+)
+@pytest.mark.parametrize("sparse_constructor", CSC_CONTAINERS + CSR_CONTAINERS)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incr_mean_variance_axis_weighted_axis0(
+    Xw, X, weights, sparse_constructor, dtype
+):
+    axis = 0
+    Xw_sparse = sparse_constructor(Xw).astype(dtype)
+    X_sparse = sparse_constructor(X).astype(dtype)
+
+    last_mean = np.zeros(np.size(Xw, 1), dtype=dtype)
+    last_var = np.zeros_like(last_mean)
+    last_n = np.zeros_like(last_mean, dtype=np.int64)
+    means0, vars0, n_incr0 = incr_mean_variance_axis(
+        X=X_sparse,
+        axis=axis,
+        last_mean=last_mean,
+        last_var=last_var,
+        last_n=last_n,
+        weights=None,
+    )
+
+    means_w0, vars_w0, n_incr_w0 = incr_mean_variance_axis(
+        X=Xw_sparse,
+        axis=axis,
+        last_mean=last_mean,
+        last_var=last_var,
+        last_n=last_n,
+        weights=weights,
+    )
+
+    assert means_w0.dtype == dtype
+    assert vars_w0.dtype == dtype
+    assert n_incr_w0.dtype == dtype
+
+    means_simple, vars_simple = mean_variance_axis(X=X_sparse, axis=axis)
+
+    assert_array_almost_equal(means0, means_w0)
+    assert_array_almost_equal(means0, means_simple)
+    assert_array_almost_equal(vars0, vars_w0)
+    assert_array_almost_equal(vars0, vars_simple)
+    assert_array_almost_equal(n_incr0, n_incr_w0)
+
+    # check second round for incremental
+    means1, vars1, n_incr1 = incr_mean_variance_axis(
+        X=X_sparse,
+        axis=axis,
+        last_mean=means0,
+        last_var=vars0,
+        last_n=n_incr0,
+        weights=None,
+    )
+
+    means_w1, vars_w1, n_incr_w1 = incr_mean_variance_axis(
+        X=Xw_sparse,
+        axis=axis,
+        last_mean=means_w0,
+        last_var=vars_w0,
+        last_n=n_incr_w0,
+        weights=weights,
+    )
+
+    assert_array_almost_equal(means1, means_w1)
+    assert_array_almost_equal(vars1, vars_w1)
+    assert_array_almost_equal(n_incr1, n_incr_w1)
+
+    assert means_w1.dtype == dtype
+    assert vars_w1.dtype == dtype
+    assert n_incr_w1.dtype == dtype
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_incr_mean_variance_axis(csc_container, csr_container, lil_container):
+    for axis in [0, 1]:
+        rng = np.random.RandomState(0)
+        n_features = 50
+        n_samples = 10
+        if axis == 0:
+            data_chunks = [rng.randint(0, 2, size=n_features) for i in range(n_samples)]
+        else:
+            data_chunks = [rng.randint(0, 2, size=n_samples) for i in range(n_features)]
+
+        # default params for incr_mean_variance
+        last_mean = np.zeros(n_features) if axis == 0 else np.zeros(n_samples)
+        last_var = np.zeros_like(last_mean)
+        last_n = np.zeros_like(last_mean, dtype=np.int64)
+
+        # Test errors
+        X = np.array(data_chunks[0])
+        X = np.atleast_2d(X)
+        X = X.T if axis == 1 else X
+        X_lil = lil_container(X)
+        X_csr = csr_container(X_lil)
+
+        with pytest.raises(TypeError):
+            incr_mean_variance_axis(
+                X=axis, axis=last_mean, last_mean=last_var, last_var=last_n
+            )
+        with pytest.raises(TypeError):
+            incr_mean_variance_axis(
+                X_lil, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+            )
+
+        # Test _incr_mean_and_var with a 1 row input
+        X_means, X_vars = mean_variance_axis(X_csr, axis)
+        X_means_incr, X_vars_incr, n_incr = incr_mean_variance_axis(
+            X_csr, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+        )
+        assert_array_almost_equal(X_means, X_means_incr)
+        assert_array_almost_equal(X_vars, X_vars_incr)
+        # X.shape[axis] picks # samples
+        assert_array_equal(X.shape[axis], n_incr)
+
+        X_csc = csc_container(X_lil)
+        X_means, X_vars = mean_variance_axis(X_csc, axis)
+        assert_array_almost_equal(X_means, X_means_incr)
+        assert_array_almost_equal(X_vars, X_vars_incr)
+        assert_array_equal(X.shape[axis], n_incr)
+
+        # Test _incremental_mean_and_var with whole data
+        X = np.vstack(data_chunks)
+        X = X.T if axis == 1 else X
+        X_lil = lil_container(X)
+        X_csr = csr_container(X_lil)
+        X_csc = csc_container(X_lil)
+
+        expected_dtypes = [
+            (np.float32, np.float32),
+            (np.float64, np.float64),
+            (np.int32, np.float64),
+            (np.int64, np.float64),
+        ]
+
+        for input_dtype, output_dtype in expected_dtypes:
+            for X_sparse in (X_csr, X_csc):
+                X_sparse = X_sparse.astype(input_dtype)
+                last_mean = last_mean.astype(output_dtype)
+                last_var = last_var.astype(output_dtype)
+                X_means, X_vars = mean_variance_axis(X_sparse, axis)
+                X_means_incr, X_vars_incr, n_incr = incr_mean_variance_axis(
+                    X_sparse,
+                    axis=axis,
+                    last_mean=last_mean,
+                    last_var=last_var,
+                    last_n=last_n,
+                )
+                assert X_means_incr.dtype == output_dtype
+                assert X_vars_incr.dtype == output_dtype
+                assert_array_almost_equal(X_means, X_means_incr)
+                assert_array_almost_equal(X_vars, X_vars_incr)
+                assert_array_equal(X.shape[axis], n_incr)
+
+
+@pytest.mark.parametrize("sparse_constructor", CSC_CONTAINERS + CSR_CONTAINERS)
+def test_incr_mean_variance_axis_dim_mismatch(sparse_constructor):
+    """Check that we raise proper error when axis=1 and the dimension mismatch.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/pull/18655
+    """
+    n_samples, n_features = 60, 4
+    rng = np.random.RandomState(42)
+    X = sparse_constructor(rng.rand(n_samples, n_features))
+
+    last_mean = np.zeros(n_features)
+    last_var = np.zeros_like(last_mean)
+    last_n = np.zeros(last_mean.shape, dtype=np.int64)
+
+    kwargs = dict(last_mean=last_mean, last_var=last_var, last_n=last_n)
+    mean0, var0, _ = incr_mean_variance_axis(X, axis=0, **kwargs)
+    assert_allclose(np.mean(X.toarray(), axis=0), mean0)
+    assert_allclose(np.var(X.toarray(), axis=0), var0)
+
+    # test ValueError if axis=1 and last_mean.size == n_features
+    with pytest.raises(ValueError):
+        incr_mean_variance_axis(X, axis=1, **kwargs)
+
+    # test inconsistent shapes of last_mean, last_var, last_n
+    kwargs = dict(last_mean=last_mean[:-1], last_var=last_var, last_n=last_n)
+    with pytest.raises(ValueError):
+        incr_mean_variance_axis(X, axis=0, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "X1, X2",
+    [
+        (
+            sp.random(5, 2, density=0.8, format="csr", random_state=0),
+            sp.random(13, 2, density=0.8, format="csr", random_state=0),
+        ),
+        (
+            sp.random(5, 2, density=0.8, format="csr", random_state=0),
+            sp.hstack(
+                [
+                    np.full((13, 1), fill_value=np.nan),
+                    sp.random(13, 1, density=0.8, random_state=42),
+                ],
+                format="csr",
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_incr_mean_variance_axis_equivalence_mean_variance(X1, X2, csr_container):
+    # non-regression test for:
+    # https://github.com/scikit-learn/scikit-learn/issues/16448
+    # check that computing the incremental mean and variance is equivalent to
+    # computing the mean and variance on the stacked dataset.
+    X1 = csr_container(X1)
+    X2 = csr_container(X2)
+    axis = 0
+    last_mean, last_var = np.zeros(X1.shape[1]), np.zeros(X1.shape[1])
+    last_n = np.zeros(X1.shape[1], dtype=np.int64)
+    updated_mean, updated_var, updated_n = incr_mean_variance_axis(
+        X1, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+    )
+    updated_mean, updated_var, updated_n = incr_mean_variance_axis(
+        X2, axis=axis, last_mean=updated_mean, last_var=updated_var, last_n=updated_n
+    )
+    X = sp.vstack([X1, X2])
+    assert_allclose(updated_mean, np.nanmean(X.toarray(), axis=axis))
+    assert_allclose(updated_var, np.nanvar(X.toarray(), axis=axis))
+    assert_allclose(updated_n, np.count_nonzero(~np.isnan(X.toarray()), axis=0))
+
+
+def test_incr_mean_variance_no_new_n():
+    # check the behaviour when we update the variance with an empty matrix
+    axis = 0
+    X1 = sp.random(5, 1, density=0.8, random_state=0).tocsr()
+    X2 = sp.random(0, 1, density=0.8, random_state=0).tocsr()
+    last_mean, last_var = np.zeros(X1.shape[1]), np.zeros(X1.shape[1])
+    last_n = np.zeros(X1.shape[1], dtype=np.int64)
+    last_mean, last_var, last_n = incr_mean_variance_axis(
+        X1, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+    )
+    # update statistic with a column which should ignored
+    updated_mean, updated_var, updated_n = incr_mean_variance_axis(
+        X2, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+    )
+    assert_allclose(updated_mean, last_mean)
+    assert_allclose(updated_var, last_var)
+    assert_allclose(updated_n, last_n)
+
+
+def test_incr_mean_variance_n_float():
+    # check the behaviour when last_n is just a number
+    axis = 0
+    X = sp.random(5, 2, density=0.8, random_state=0).tocsr()
+    last_mean, last_var = np.zeros(X.shape[1]), np.zeros(X.shape[1])
+    last_n = 0
+    _, _, new_n = incr_mean_variance_axis(
+        X, axis=axis, last_mean=last_mean, last_var=last_var, last_n=last_n
+    )
+    assert_allclose(new_n, np.full(X.shape[1], X.shape[0]))
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.parametrize("sparse_constructor", CSC_CONTAINERS + CSR_CONTAINERS)
+def test_incr_mean_variance_axis_ignore_nan(axis, sparse_constructor):
+    old_means = np.array([535.0, 535.0, 535.0, 535.0])
+    old_variances = np.array([4225.0, 4225.0, 4225.0, 4225.0])
+    old_sample_count = np.array([2, 2, 2, 2], dtype=np.int64)
+
+    X = sparse_constructor(
+        np.array([[170, 170, 170, 170], [430, 430, 430, 430], [300, 300, 300, 300]])
+    )
+
+    X_nan = sparse_constructor(
+        np.array(
+            [
+                [170, np.nan, 170, 170],
+                [np.nan, 170, 430, 430],
+                [430, 430, np.nan, 300],
+                [300, 300, 300, np.nan],
+            ]
+        )
+    )
+
+    # we avoid creating specific data for axis 0 and 1: translating the data is
+    # enough.
+    if axis:
+        X = X.T
+        X_nan = X_nan.T
+
+    # take a copy of the old statistics since they are modified in place.
+    X_means, X_vars, X_sample_count = incr_mean_variance_axis(
+        X,
+        axis=axis,
+        last_mean=old_means.copy(),
+        last_var=old_variances.copy(),
+        last_n=old_sample_count.copy(),
+    )
+    X_nan_means, X_nan_vars, X_nan_sample_count = incr_mean_variance_axis(
+        X_nan,
+        axis=axis,
+        last_mean=old_means.copy(),
+        last_var=old_variances.copy(),
+        last_n=old_sample_count.copy(),
+    )
+
+    assert_allclose(X_nan_means, X_means)
+    assert_allclose(X_nan_vars, X_vars)
+    assert_allclose(X_nan_sample_count, X_sample_count)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_mean_variance_illegal_axis(csr_container):
+    X, _ = make_classification(5, 4, random_state=0)
+    # Sparsify the array a little bit
+    X[0, 0] = 0
+    X[2, 1] = 0
+    X[4, 3] = 0
+    X_csr = csr_container(X)
+    with pytest.raises(ValueError):
+        mean_variance_axis(X_csr, axis=-3)
+    with pytest.raises(ValueError):
+        mean_variance_axis(X_csr, axis=2)
+    with pytest.raises(ValueError):
+        mean_variance_axis(X_csr, axis=-1)
+
+    with pytest.raises(ValueError):
+        incr_mean_variance_axis(
+            X_csr, axis=-3, last_mean=None, last_var=None, last_n=None
+        )
+
+    with pytest.raises(ValueError):
+        incr_mean_variance_axis(
+            X_csr, axis=2, last_mean=None, last_var=None, last_n=None
+        )
+
+    with pytest.raises(ValueError):
+        incr_mean_variance_axis(
+            X_csr, axis=-1, last_mean=None, last_var=None, last_n=None
+        )
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_densify_rows(csr_container):
+    for dtype in (np.float32, np.float64):
+        X = csr_container(
+            [[0, 3, 0], [2, 4, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=dtype
+        )
+        X_rows = np.array([0, 2, 3], dtype=np.intp)
+        out = np.ones((6, X.shape[1]), dtype=dtype)
+        out_rows = np.array([1, 3, 4], dtype=np.intp)
+
+        expect = np.ones_like(out)
+        expect[out_rows] = X[X_rows, :].toarray()
+
+        assign_rows_csr(X, X_rows, out_rows, out)
+        assert_array_equal(out, expect)
+
+
+def test_inplace_column_scale():
+    rng = np.random.RandomState(0)
+    X = sp.random(100, 200, density=0.05)
+    Xr = X.tocsr()
+    Xc = X.tocsc()
+    XA = X.toarray()
+    scale = rng.rand(200)
+    XA *= scale
+
+    inplace_column_scale(Xc, scale)
+    inplace_column_scale(Xr, scale)
+    assert_array_almost_equal(Xr.toarray(), Xc.toarray())
+    assert_array_almost_equal(XA, Xc.toarray())
+    assert_array_almost_equal(XA, Xr.toarray())
+    with pytest.raises(TypeError):
+        inplace_column_scale(X.tolil(), scale)
+
+    X = X.astype(np.float32)
+    scale = scale.astype(np.float32)
+    Xr = X.tocsr()
+    Xc = X.tocsc()
+    XA = X.toarray()
+    XA *= scale
+    inplace_column_scale(Xc, scale)
+    inplace_column_scale(Xr, scale)
+    assert_array_almost_equal(Xr.toarray(), Xc.toarray())
+    assert_array_almost_equal(XA, Xc.toarray())
+    assert_array_almost_equal(XA, Xr.toarray())
+    with pytest.raises(TypeError):
+        inplace_column_scale(X.tolil(), scale)
+
+
+def test_inplace_row_scale():
+    rng = np.random.RandomState(0)
+    X = sp.random(100, 200, density=0.05)
+    Xr = X.tocsr()
+    Xc = X.tocsc()
+    XA = X.toarray()
+    scale = rng.rand(100)
+    XA *= scale.reshape(-1, 1)
+
+    inplace_row_scale(Xc, scale)
+    inplace_row_scale(Xr, scale)
+    assert_array_almost_equal(Xr.toarray(), Xc.toarray())
+    assert_array_almost_equal(XA, Xc.toarray())
+    assert_array_almost_equal(XA, Xr.toarray())
+    with pytest.raises(TypeError):
+        inplace_column_scale(X.tolil(), scale)
+
+    X = X.astype(np.float32)
+    scale = scale.astype(np.float32)
+    Xr = X.tocsr()
+    Xc = X.tocsc()
+    XA = X.toarray()
+    XA *= scale.reshape(-1, 1)
+    inplace_row_scale(Xc, scale)
+    inplace_row_scale(Xr, scale)
+    assert_array_almost_equal(Xr.toarray(), Xc.toarray())
+    assert_array_almost_equal(XA, Xc.toarray())
+    assert_array_almost_equal(XA, Xr.toarray())
+    with pytest.raises(TypeError):
+        inplace_column_scale(X.tolil(), scale)
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_inplace_swap_row(csc_container, csr_container):
+    X = np.array(
+        [[0, 3, 0], [2, 4, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float64
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+
+    swap = linalg.get_blas_funcs(("swap",), (X,))
+    swap = swap[0]
+    X[0], X[-1] = swap(X[0], X[-1])
+    inplace_swap_row(X_csr, 0, -1)
+    inplace_swap_row(X_csc, 0, -1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+
+    X[2], X[3] = swap(X[2], X[3])
+    inplace_swap_row(X_csr, 2, 3)
+    inplace_swap_row(X_csc, 2, 3)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    with pytest.raises(TypeError):
+        inplace_swap_row(X_csr.tolil())
+
+    X = np.array(
+        [[0, 3, 0], [2, 4, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float32
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+    swap = linalg.get_blas_funcs(("swap",), (X,))
+    swap = swap[0]
+    X[0], X[-1] = swap(X[0], X[-1])
+    inplace_swap_row(X_csr, 0, -1)
+    inplace_swap_row(X_csc, 0, -1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    X[2], X[3] = swap(X[2], X[3])
+    inplace_swap_row(X_csr, 2, 3)
+    inplace_swap_row(X_csc, 2, 3)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    with pytest.raises(TypeError):
+        inplace_swap_row(X_csr.tolil())
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_inplace_swap_column(csc_container, csr_container):
+    X = np.array(
+        [[0, 3, 0], [2, 4, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float64
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+
+    swap = linalg.get_blas_funcs(("swap",), (X,))
+    swap = swap[0]
+    X[:, 0], X[:, -1] = swap(X[:, 0], X[:, -1])
+    inplace_swap_column(X_csr, 0, -1)
+    inplace_swap_column(X_csc, 0, -1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+
+    X[:, 0], X[:, 1] = swap(X[:, 0], X[:, 1])
+    inplace_swap_column(X_csr, 0, 1)
+    inplace_swap_column(X_csc, 0, 1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    with pytest.raises(TypeError):
+        inplace_swap_column(X_csr.tolil())
+
+    X = np.array(
+        [[0, 3, 0], [2, 4, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float32
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+    swap = linalg.get_blas_funcs(("swap",), (X,))
+    swap = swap[0]
+    X[:, 0], X[:, -1] = swap(X[:, 0], X[:, -1])
+    inplace_swap_column(X_csr, 0, -1)
+    inplace_swap_column(X_csc, 0, -1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    X[:, 0], X[:, 1] = swap(X[:, 0], X[:, 1])
+    inplace_swap_column(X_csr, 0, 1)
+    inplace_swap_column(X_csc, 0, 1)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())
+    with pytest.raises(TypeError):
+        inplace_swap_column(X_csr.tolil())
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("axis", [0, 1, None])
+@pytest.mark.parametrize("sparse_format", CSC_CONTAINERS + CSR_CONTAINERS)
+@pytest.mark.parametrize(
+    "missing_values, min_func, max_func, ignore_nan",
+    [(0, np.min, np.max, False), (np.nan, np.nanmin, np.nanmax, True)],
+)
+@pytest.mark.parametrize("large_indices", [True, False])
+def test_min_max(
+    dtype,
+    axis,
+    sparse_format,
+    missing_values,
+    min_func,
+    max_func,
+    ignore_nan,
+    large_indices,
+):
+    X = np.array(
+        [
+            [0, 3, 0],
+            [2, -1, missing_values],
+            [0, 0, 0],
+            [9, missing_values, 7],
+            [4, 0, 5],
+        ],
+        dtype=dtype,
+    )
+    X_sparse = sparse_format(X)
+
+    if large_indices:
+        X_sparse.indices = X_sparse.indices.astype("int64")
+        X_sparse.indptr = X_sparse.indptr.astype("int64")
+
+    mins_sparse, maxs_sparse = min_max_axis(X_sparse, axis=axis, ignore_nan=ignore_nan)
+    assert_array_equal(mins_sparse, min_func(X, axis=axis))
+    assert_array_equal(maxs_sparse, max_func(X, axis=axis))
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_min_max_axis_errors(csc_container, csr_container):
+    X = np.array(
+        [[0, 3, 0], [2, -1, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float64
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+    with pytest.raises(TypeError):
+        min_max_axis(X_csr.tolil(), axis=0)
+    with pytest.raises(ValueError):
+        min_max_axis(X_csr, axis=2)
+    with pytest.raises(ValueError):
+        min_max_axis(X_csc, axis=-3)
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_count_nonzero(csc_container, csr_container):
+    X = np.array(
+        [[0, 3, 0], [2, -1, 0], [0, 0, 0], [9, 8, 7], [4, 0, 5]], dtype=np.float64
+    )
+    X_csr = csr_container(X)
+    X_csc = csc_container(X)
+    X_nonzero = X != 0
+    sample_weight = [0.5, 0.2, 0.3, 0.1, 0.1]
+    X_nonzero_weighted = X_nonzero * np.array(sample_weight)[:, None]
+
+    for axis in [0, 1, -1, -2, None]:
+        assert_array_almost_equal(
+            count_nonzero(X_csr, axis=axis), X_nonzero.sum(axis=axis)
+        )
+        assert_array_almost_equal(
+            count_nonzero(X_csr, axis=axis, sample_weight=sample_weight),
+            X_nonzero_weighted.sum(axis=axis),
+        )
+
+    with pytest.raises(TypeError):
+        count_nonzero(X_csc)
+    with pytest.raises(ValueError):
+        count_nonzero(X_csr, axis=2)
+
+    assert count_nonzero(X_csr, axis=0).dtype == count_nonzero(X_csr, axis=1).dtype
+    assert (
+        count_nonzero(X_csr, axis=0, sample_weight=sample_weight).dtype
+        == count_nonzero(X_csr, axis=1, sample_weight=sample_weight).dtype
+    )
+
+    # Check dtypes with large sparse matrices too
+    # XXX: test fails on 32bit (Windows/Linux)
+    try:
+        X_csr.indices = X_csr.indices.astype(np.int64)
+        X_csr.indptr = X_csr.indptr.astype(np.int64)
+        assert count_nonzero(X_csr, axis=0).dtype == count_nonzero(X_csr, axis=1).dtype
+        assert (
+            count_nonzero(X_csr, axis=0, sample_weight=sample_weight).dtype
+            == count_nonzero(X_csr, axis=1, sample_weight=sample_weight).dtype
+        )
+    except TypeError as e:
+        assert "according to the rule 'safe'" in e.args[0] and np.intp().nbytes < 8, e
+
+
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_csc_row_median(csc_container, csr_container):
+    # Test csc_row_median actually calculates the median.
+
+    # Test that it gives the same output when X is dense.
+    rng = np.random.RandomState(0)
+    X = rng.rand(100, 50)
+    dense_median = np.median(X, axis=0)
+    csc = csc_container(X)
+    sparse_median = csc_median_axis_0(csc)
+    assert_array_equal(sparse_median, dense_median)
+
+    # Test that it gives the same output when X is sparse
+    X = rng.rand(51, 100)
+    X[X < 0.7] = 0.0
+    ind = rng.randint(0, 50, 10)
+    X[ind] = -X[ind]
+    csc = csc_container(X)
+    dense_median = np.median(X, axis=0)
+    sparse_median = csc_median_axis_0(csc)
+    assert_array_equal(sparse_median, dense_median)
+
+    # Test for toy data.
+    X = [[0, -2], [-1, -1], [1, 0], [2, 1]]
+    csc = csc_container(X)
+    assert_array_equal(csc_median_axis_0(csc), np.array([0.5, -0.5]))
+    X = [[0, -2], [-1, -5], [1, -3]]
+    csc = csc_container(X)
+    assert_array_equal(csc_median_axis_0(csc), np.array([0.0, -3]))
+
+    # Test that it raises an Error for non-csc matrices.
+    with pytest.raises(TypeError):
+        csc_median_axis_0(csr_container(X))
+
+
+@pytest.mark.parametrize(
+    "inplace_csr_row_normalize",
+    (inplace_csr_row_normalize_l1, inplace_csr_row_normalize_l2),
+)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_inplace_normalize(csr_container, inplace_csr_row_normalize):
+    if csr_container is sp.csr_matrix:
+        ones = np.ones((10, 1))
+    else:
+        ones = np.ones(10)
+    rs = RandomState(10)
+
+    for dtype in (np.float64, np.float32):
+        X = rs.randn(10, 5).astype(dtype)
+        X_csr = csr_container(X)
+        for index_dtype in [np.int32, np.int64]:
+            # csr_matrix will use int32 indices by default,
+            # up-casting those to int64 when necessary
+            if index_dtype is np.int64:
+                X_csr.indptr = X_csr.indptr.astype(index_dtype)
+                X_csr.indices = X_csr.indices.astype(index_dtype)
+            assert X_csr.indices.dtype == index_dtype
+            assert X_csr.indptr.dtype == index_dtype
+            inplace_csr_row_normalize(X_csr)
+            assert X_csr.dtype == dtype
+            if inplace_csr_row_normalize is inplace_csr_row_normalize_l2:
+                X_csr.data **= 2
+            assert_array_almost_equal(np.abs(X_csr).sum(axis=1), ones)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_csr_row_norms(dtype):
+    # checks that csr_row_norms returns the same output as
+    # scipy.sparse.linalg.norm, and that the dype is the same as X.dtype.
+    X = sp.random(100, 10, format="csr", dtype=dtype, random_state=42)
+
+    scipy_norms = sp.linalg.norm(X, axis=1) ** 2
+    norms = csr_row_norms(X)
+
+    assert norms.dtype == dtype
+    rtol = 1e-6 if dtype == np.float32 else 1e-7
+    assert_allclose(norms, scipy_norms, rtol=rtol)
+
+
+@pytest.fixture(scope="module", params=CSR_CONTAINERS + CSC_CONTAINERS)
+def centered_matrices(request):
+    """Returns equivalent tuple[sp.linalg.LinearOperator, np.ndarray]."""
+    sparse_container = request.param
+
+    random_state = np.random.default_rng(42)
+
+    X_sparse = sparse_container(
+        sp.random(500, 100, density=0.1, format="csr", random_state=random_state)
+    )
+    X_dense = X_sparse.toarray()
+    mu = np.asarray(X_sparse.mean(axis=0)).ravel()
+
+    X_sparse_centered = _implicit_column_offset(X_sparse, mu)
+    X_dense_centered = X_dense - mu
+
+    return X_sparse_centered, X_dense_centered
+
+
+def test_implicit_center_matmat(global_random_seed, centered_matrices):
+    X_sparse_centered, X_dense_centered = centered_matrices
+    rng = np.random.default_rng(global_random_seed)
+    Y = rng.standard_normal((X_dense_centered.shape[1], 50))
+    assert_allclose(X_dense_centered @ Y, X_sparse_centered.matmat(Y))
+    assert_allclose(X_dense_centered @ Y, X_sparse_centered @ Y)
+
+
+def test_implicit_center_matvec(global_random_seed, centered_matrices):
+    X_sparse_centered, X_dense_centered = centered_matrices
+    rng = np.random.default_rng(global_random_seed)
+    y = rng.standard_normal(X_dense_centered.shape[1])
+    assert_allclose(X_dense_centered @ y, X_sparse_centered.matvec(y))
+    assert_allclose(X_dense_centered @ y, X_sparse_centered @ y)
+
+
+def test_implicit_center_rmatmat(global_random_seed, centered_matrices):
+    X_sparse_centered, X_dense_centered = centered_matrices
+    rng = np.random.default_rng(global_random_seed)
+    Y = rng.standard_normal((X_dense_centered.shape[0], 50))
+    assert_allclose(X_dense_centered.T @ Y, X_sparse_centered.rmatmat(Y))
+    assert_allclose(X_dense_centered.T @ Y, X_sparse_centered.T @ Y)
+
+
+def test_implit_center_rmatvec(global_random_seed, centered_matrices):
+    X_sparse_centered, X_dense_centered = centered_matrices
+    rng = np.random.default_rng(global_random_seed)
+    y = rng.standard_normal(X_dense_centered.shape[0])
+    assert_allclose(X_dense_centered.T @ y, X_sparse_centered.rmatvec(y))
+    assert_allclose(X_dense_centered.T @ y, X_sparse_centered.T @ y)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_stats.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_stats.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c979425f12f8e555dd71b74d87b2e6fdbd03d30
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_stats.py
@@ -0,0 +1,352 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose, assert_array_equal
+from pytest import approx
+
+from sklearn._config import config_context
+from sklearn.utils._array_api import (
+    _convert_to_numpy,
+    get_namespace,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._array_api import device as array_device
+from sklearn.utils.estimator_checks import _array_api_for_tests
+from sklearn.utils.fixes import np_version, parse_version
+from sklearn.utils.stats import _averaged_weighted_percentile, _weighted_percentile
+
+
+def test_averaged_weighted_median():
+    y = np.array([0, 1, 2, 3, 4, 5])
+    sw = np.array([1, 1, 1, 1, 1, 1])
+
+    score = _averaged_weighted_percentile(y, sw, 50)
+
+    assert score == np.median(y)
+
+
+def test_averaged_weighted_percentile(global_random_seed):
+    rng = np.random.RandomState(global_random_seed)
+    y = rng.randint(20, size=10)
+
+    sw = np.ones(10)
+
+    score = _averaged_weighted_percentile(y, sw, 20)
+
+    assert score == np.percentile(y, 20, method="averaged_inverted_cdf")
+
+
+def test_averaged_and_weighted_percentile():
+    y = np.array([0, 1, 2])
+    sw = np.array([5, 1, 5])
+    q = 50
+
+    score_averaged = _averaged_weighted_percentile(y, sw, q)
+    score = _weighted_percentile(y, sw, q)
+
+    assert score_averaged == score
+
+
+def test_weighted_percentile():
+    """Check `weighted_percentile` on artificial data with obvious median."""
+    y = np.empty(102, dtype=np.float64)
+    y[:50] = 0
+    y[-51:] = 2
+    y[-1] = 100000
+    y[50] = 1
+    sw = np.ones(102, dtype=np.float64)
+    sw[-1] = 0.0
+    value = _weighted_percentile(y, sw, 50)
+    assert approx(value) == 1
+
+
+def test_weighted_percentile_equal():
+    """Check `weighted_percentile` with all weights equal to 1."""
+    y = np.empty(102, dtype=np.float64)
+    y.fill(0.0)
+    sw = np.ones(102, dtype=np.float64)
+    score = _weighted_percentile(y, sw, 50)
+    assert approx(score) == 0
+
+
+def test_weighted_percentile_zero_weight():
+    """Check `weighted_percentile` with all weights equal to 0."""
+    y = np.empty(102, dtype=np.float64)
+    y.fill(1.0)
+    sw = np.ones(102, dtype=np.float64)
+    sw.fill(0.0)
+    value = _weighted_percentile(y, sw, 50)
+    assert approx(value) == 1.0
+
+
+def test_weighted_percentile_zero_weight_zero_percentile():
+    """Check `weighted_percentile(percentile_rank=0)` behaves correctly.
+
+    Ensures that (leading)zero-weight observations ignored when `percentile_rank=0`.
+    See #20528 for details.
+    """
+    y = np.array([0, 1, 2, 3, 4, 5])
+    sw = np.array([0, 0, 1, 1, 1, 0])
+    value = _weighted_percentile(y, sw, 0)
+    assert approx(value) == 2
+
+    value = _weighted_percentile(y, sw, 50)
+    assert approx(value) == 3
+
+    value = _weighted_percentile(y, sw, 100)
+    assert approx(value) == 4
+
+
+def test_weighted_median_equal_weights(global_random_seed):
+    """Checks `_weighted_percentile(percentile_rank=50)` is the same as `np.median`.
+
+    `sample_weights` are all 1s and the number of samples is odd.
+    When number of samples is odd, `_weighted_percentile` always falls on a single
+    observation (not between 2 values, in which case the lower value would be taken)
+    and is thus equal to `np.median`.
+    For an even number of samples, this check will not always hold as (note that
+    for some other percentile methods it will always hold). See #17370 for details.
+    """
+    rng = np.random.RandomState(global_random_seed)
+    x = rng.randint(10, size=11)
+    weights = np.ones(x.shape)
+    median = np.median(x)
+    w_median = _weighted_percentile(x, weights)
+    assert median == approx(w_median)
+
+
+def test_weighted_median_integer_weights(global_random_seed):
+    # Checks average weighted percentile_rank=0.5 is same as median when manually weight
+    # data
+    rng = np.random.RandomState(global_random_seed)
+    x = rng.randint(20, size=10)
+    weights = rng.choice(5, size=10)
+    x_manual = np.repeat(x, weights)
+    median = np.median(x_manual)
+    w_median = _averaged_weighted_percentile(x, weights)
+    assert median == approx(w_median)
+
+
+def test_weighted_percentile_2d(global_random_seed):
+    # Check for when array 2D and sample_weight 1D
+    rng = np.random.RandomState(global_random_seed)
+    x1 = rng.randint(10, size=10)
+    w1 = rng.choice(5, size=10)
+
+    x2 = rng.randint(20, size=10)
+    x_2d = np.vstack((x1, x2)).T
+
+    w_median = _weighted_percentile(x_2d, w1)
+    p_axis_0 = [_weighted_percentile(x_2d[:, i], w1) for i in range(x_2d.shape[1])]
+    assert_allclose(w_median, p_axis_0)
+    # Check when array and sample_weight both 2D
+    w2 = rng.choice(5, size=10)
+    w_2d = np.vstack((w1, w2)).T
+
+    w_median = _weighted_percentile(x_2d, w_2d)
+    p_axis_0 = [
+        _weighted_percentile(x_2d[:, i], w_2d[:, i]) for i in range(x_2d.shape[1])
+    ]
+    assert_allclose(w_median, p_axis_0)
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name", yield_namespace_device_dtype_combinations()
+)
+@pytest.mark.parametrize(
+    "data, weights, percentile",
+    [
+        # NumPy scalars input (handled as 0D arrays on array API)
+        (np.float32(42), np.int32(1), 50),
+        # Random 1D array, constant weights
+        (lambda rng: rng.rand(50), np.ones(50).astype(np.int32), 50),
+        # Random 2D array and random 1D weights
+        (lambda rng: rng.rand(50, 3), lambda rng: rng.rand(50).astype(np.float32), 75),
+        # Random 2D array and random 2D weights
+        (
+            lambda rng: rng.rand(20, 3),
+            lambda rng: rng.rand(20, 3).astype(np.float32),
+            25,
+        ),
+        # zero-weights and `rank_percentile=0` (#20528) (`sample_weight` dtype: int64)
+        (np.array([0, 1, 2, 3, 4, 5]), np.array([0, 0, 1, 1, 1, 0]), 0),
+        # np.nan's in data and some zero-weights (`sample_weight` dtype: int64)
+        (np.array([np.nan, np.nan, 0, 3, 4, 5]), np.array([0, 1, 1, 1, 1, 0]), 0),
+        # `sample_weight` dtype: int32
+        (
+            np.array([0, 1, 2, 3, 4, 5]),
+            np.array([0, 1, 1, 1, 1, 0], dtype=np.int32),
+            25,
+        ),
+    ],
+)
+def test_weighted_percentile_array_api_consistency(
+    global_random_seed, array_namespace, device, dtype_name, data, weights, percentile
+):
+    """Check `_weighted_percentile` gives consistent results with array API."""
+    if array_namespace == "array_api_strict":
+        try:
+            import array_api_strict
+        except ImportError:
+            pass
+        else:
+            if device == array_api_strict.Device("device1"):
+                # See https://github.com/data-apis/array-api-strict/issues/134
+                pytest.xfail(
+                    "array_api_strict has bug when indexing with tuple of arrays "
+                    "on non-'CPU_DEVICE' devices."
+                )
+
+    xp = _array_api_for_tests(array_namespace, device)
+
+    # Skip test for percentile=0 edge case (#20528) on namespace/device where
+    # xp.nextafter is broken. This is the case for torch with MPS device:
+    # https://github.com/pytorch/pytorch/issues/150027
+    zero = xp.zeros(1, device=device)
+    one = xp.ones(1, device=device)
+    if percentile == 0 and xp.all(xp.nextafter(zero, one) == zero):
+        pytest.xfail(f"xp.nextafter is broken on {device}")
+
+    rng = np.random.RandomState(global_random_seed)
+    X_np = data(rng) if callable(data) else data
+    weights_np = weights(rng) if callable(weights) else weights
+    # Ensure `data` of correct dtype
+    X_np = X_np.astype(dtype_name)
+
+    result_np = _weighted_percentile(X_np, weights_np, percentile)
+    # Convert to Array API arrays
+    X_xp = xp.asarray(X_np, device=device)
+    weights_xp = xp.asarray(weights_np, device=device)
+
+    with config_context(array_api_dispatch=True):
+        result_xp = _weighted_percentile(X_xp, weights_xp, percentile)
+        assert array_device(result_xp) == array_device(X_xp)
+        assert get_namespace(result_xp)[0] == get_namespace(X_xp)[0]
+        result_xp_np = _convert_to_numpy(result_xp, xp=xp)
+
+    assert result_xp_np.dtype == result_np.dtype
+    assert result_xp_np.shape == result_np.shape
+    assert_allclose(result_np, result_xp_np)
+
+    # Check dtype correct (`sample_weight` should follow `array`)
+    if dtype_name == "float32":
+        assert result_xp_np.dtype == result_np.dtype == np.float32
+    else:
+        assert result_xp_np.dtype == np.float64
+
+
+@pytest.mark.parametrize("sample_weight_ndim", [1, 2])
+def test_weighted_percentile_nan_filtered(sample_weight_ndim, global_random_seed):
+    """Test that calling _weighted_percentile on an array with nan values returns
+    the same results as calling _weighted_percentile on a filtered version of the data.
+    We test both with sample_weight of the same shape as the data and with
+    one-dimensional sample_weight."""
+
+    rng = np.random.RandomState(global_random_seed)
+    array_with_nans = rng.rand(100, 10)
+    array_with_nans[rng.rand(*array_with_nans.shape) < 0.5] = np.nan
+    nan_mask = np.isnan(array_with_nans)
+
+    if sample_weight_ndim == 2:
+        sample_weight = rng.randint(1, 6, size=(100, 10))
+    else:
+        sample_weight = rng.randint(1, 6, size=(100,))
+
+    # Find the weighted percentile on the array with nans:
+    results = _weighted_percentile(array_with_nans, sample_weight, 30)
+
+    # Find the weighted percentile on the filtered array:
+    filtered_array = [
+        array_with_nans[~nan_mask[:, col], col]
+        for col in range(array_with_nans.shape[1])
+    ]
+    if sample_weight.ndim == 1:
+        sample_weight = np.repeat(sample_weight, array_with_nans.shape[1]).reshape(
+            array_with_nans.shape[0], array_with_nans.shape[1]
+        )
+    filtered_weights = [
+        sample_weight[~nan_mask[:, col], col] for col in range(array_with_nans.shape[1])
+    ]
+
+    expected_results = np.array(
+        [
+            _weighted_percentile(filtered_array[col], filtered_weights[col], 30)
+            for col in range(array_with_nans.shape[1])
+        ]
+    )
+
+    assert_array_equal(expected_results, results)
+
+
+def test_weighted_percentile_all_nan_column():
+    """Check that nans are ignored in general, except for all NaN columns."""
+
+    array = np.array(
+        [
+            [np.nan, 5],
+            [np.nan, 1],
+            [np.nan, np.nan],
+            [np.nan, np.nan],
+            [np.nan, 2],
+            [np.nan, np.nan],
+        ]
+    )
+    weights = np.ones_like(array)
+    percentile_rank = 90
+
+    values = _weighted_percentile(array, weights, percentile_rank)
+
+    # The percentile of the second column should be `5` even though there are many nan
+    # values present; the percentile of the first column can only be nan, since there
+    # are no other possible values:
+    assert np.array_equal(values, np.array([np.nan, 5]), equal_nan=True)
+
+
+@pytest.mark.skipif(
+    np_version < parse_version("2.0"),
+    reason="np.quantile only accepts weights since version 2.0",
+)
+@pytest.mark.parametrize("percentile", [66, 10, 50])
+def test_weighted_percentile_like_numpy_quantile(percentile, global_random_seed):
+    """Check that _weighted_percentile delivers equivalent results as np.quantile
+    with weights."""
+
+    rng = np.random.RandomState(global_random_seed)
+    array = rng.rand(10, 100)
+    sample_weight = rng.randint(1, 6, size=(10, 100))
+
+    percentile_weighted_percentile = _weighted_percentile(
+        array, sample_weight, percentile
+    )
+    percentile_numpy_quantile = np.quantile(
+        array, percentile / 100, weights=sample_weight, axis=0, method="inverted_cdf"
+    )
+
+    assert_array_equal(percentile_weighted_percentile, percentile_numpy_quantile)
+
+
+@pytest.mark.skipif(
+    np_version < parse_version("2.0"),
+    reason="np.nanquantile only accepts weights since version 2.0",
+)
+@pytest.mark.parametrize("percentile", [66, 10, 50])
+def test_weighted_percentile_like_numpy_nanquantile(percentile, global_random_seed):
+    """Check that _weighted_percentile delivers equivalent results as np.nanquantile
+    with weights."""
+
+    rng = np.random.RandomState(global_random_seed)
+    array_with_nans = rng.rand(10, 100)
+    array_with_nans[rng.rand(*array_with_nans.shape) < 0.5] = np.nan
+    sample_weight = rng.randint(1, 6, size=(10, 100))
+
+    percentile_weighted_percentile = _weighted_percentile(
+        array_with_nans, sample_weight, percentile
+    )
+    percentile_numpy_nanquantile = np.nanquantile(
+        array_with_nans,
+        percentile / 100,
+        weights=sample_weight,
+        axis=0,
+        method="inverted_cdf",
+    )
+
+    assert_array_equal(percentile_weighted_percentile, percentile_numpy_nanquantile)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_tags.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_tags.py
new file mode 100644
index 0000000000000000000000000000000000000000..38be48e85e38e306ecc58fc365c181331071edee
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_tags.py
@@ -0,0 +1,153 @@
+from dataclasses import dataclass, fields
+
+import numpy as np
+import pytest
+
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.pipeline import Pipeline
+from sklearn.utils import (
+    Tags,
+    get_tags,
+)
+from sklearn.utils.estimator_checks import (
+    check_estimator_tags_renamed,
+    check_valid_tag_types,
+)
+
+
+class NoTagsEstimator:
+    pass
+
+
+class ClassifierEstimator:
+    # This is to test whether not inheriting from mixins works.
+    _estimator_type = "classifier"
+
+
+class EmptyTransformer(TransformerMixin, BaseEstimator):
+    pass
+
+
+class EmptyRegressor(RegressorMixin, BaseEstimator):
+    pass
+
+
+# TODO(1.8): Update when implementing __sklearn_tags__ is required
+@pytest.mark.filterwarnings(
+    "ignore:.*no attribute '__sklearn_tags__'.*:DeprecationWarning"
+)
+@pytest.mark.parametrize(
+    "estimator, value",
+    [
+        [NoTagsEstimator(), False],
+        [ClassifierEstimator(), True],
+        [EmptyTransformer(), False],
+        [EmptyRegressor(), True],
+        [BaseEstimator(), False],
+    ],
+)
+def test_requires_y(estimator, value):
+    assert get_tags(estimator).target_tags.required == value
+
+
+def test_no___sklearn_tags__with_more_tags():
+    """Test that calling `get_tags` on a class that defines `_more_tags` but not
+    `__sklearn_tags__` raises an error.
+    """
+
+    class MoreTagsEstimator(BaseEstimator):
+        def _more_tags(self):
+            return {"requires_y": True}  # pragma: no cover
+
+    with pytest.raises(
+        TypeError, match="has defined either `_more_tags` or `_get_tags`"
+    ):
+        check_estimator_tags_renamed("MoreTagsEstimator", MoreTagsEstimator())
+
+
+def test_tag_test_passes_with_inheritance():
+    @dataclass
+    class MyTags(Tags):
+        my_tag: bool = True  # type: ignore[annotation-unchecked]
+
+    class MyEstimator(BaseEstimator):
+        def __sklearn_tags__(self):
+            tags_orig = super().__sklearn_tags__()
+            as_dict = {
+                field.name: getattr(tags_orig, field.name)
+                for field in fields(tags_orig)
+            }
+            tags = MyTags(**as_dict)
+            tags.my_tag = True
+            return tags
+
+    check_valid_tag_types("MyEstimator", MyEstimator())
+
+
+# TODO(1.8): Update this test to check for errors
+def test_tags_no_sklearn_tags_concrete_implementation():
+    """Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/30479
+
+    Either the estimator doesn't implement `__sklearn_tags` or there is no class
+    implementing `__sklearn_tags__` without calling `super().__sklearn_tags__()` in
+    its mro. Thus, we raise a warning and request to inherit from
+    `BaseEstimator` that implements `__sklearn_tags__`.
+    """
+
+    X = np.array([[1, 2], [2, 3], [3, 4]])
+    y = np.array([1, 0, 1])
+
+    # 1st case, the estimator inherits from a class that only implements
+    # `__sklearn_tags__` by calling `super().__sklearn_tags__()`.
+    class MyEstimator(ClassifierMixin):
+        def __init__(self, *, param=1):
+            self.param = param
+
+        def fit(self, X, y=None):
+            self.is_fitted_ = True
+            return self
+
+        def predict(self, X):
+            return np.full(shape=X.shape[0], fill_value=self.param)
+
+    my_pipeline = Pipeline([("estimator", MyEstimator(param=1))])
+    with pytest.warns(DeprecationWarning, match="The following error was raised"):
+        my_pipeline.fit(X, y).predict(X)
+
+    # 2nd case, the estimator doesn't implement `__sklearn_tags__` at all.
+    class MyEstimator2:
+        def __init__(self, *, param=1):
+            self.param = param
+
+        def fit(self, X, y=None):
+            self.is_fitted_ = True
+            return self
+
+        def predict(self, X):
+            return np.full(shape=X.shape[0], fill_value=self.param)
+
+    my_pipeline = Pipeline([("estimator", MyEstimator2(param=1))])
+    with pytest.warns(DeprecationWarning, match="The following error was raised"):
+        my_pipeline.fit(X, y).predict(X)
+
+    # check that we still raise an error if it is not a AttributeError or related to
+    # __sklearn_tags__
+    class MyEstimator3(MyEstimator, BaseEstimator):
+        def __init__(self, *, param=1, error_type=AttributeError):
+            self.param = param
+            self.error_type = error_type
+
+        def __sklearn_tags__(self):
+            super().__sklearn_tags__()
+            raise self.error_type("test")
+
+    for error_type in (AttributeError, TypeError, ValueError):
+        estimator = MyEstimator3(param=1, error_type=error_type)
+        with pytest.raises(error_type):
+            get_tags(estimator)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_testing.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae9c380941c8ce4c3b661387b9873f6019c75f51
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_testing.py
@@ -0,0 +1,1143 @@
+import atexit
+import os
+import warnings
+
+import numpy as np
+import pytest
+from scipy import sparse
+
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.utils._testing import (
+    TempMemmap,
+    _convert_container,
+    _delete_folder,
+    _get_warnings_filters_info_list,
+    assert_allclose,
+    assert_allclose_dense_sparse,
+    assert_docstring_consistency,
+    assert_run_python_script_without_output,
+    check_docstring_parameters,
+    create_memmap_backed_data,
+    ignore_warnings,
+    raises,
+    set_random_state,
+    skip_if_no_numpydoc,
+    turn_warnings_into_errors,
+)
+from sklearn.utils.deprecation import deprecated
+from sklearn.utils.fixes import (
+    _IS_WASM,
+    CSC_CONTAINERS,
+    CSR_CONTAINERS,
+)
+from sklearn.utils.metaestimators import available_if
+
+
+def test_set_random_state():
+    lda = LinearDiscriminantAnalysis()
+    tree = DecisionTreeClassifier()
+    # Linear Discriminant Analysis doesn't have random state: smoke test
+    set_random_state(lda, 3)
+    set_random_state(tree, 3)
+    assert tree.random_state == 3
+
+
+@pytest.mark.parametrize("csr_container", CSC_CONTAINERS)
+def test_assert_allclose_dense_sparse(csr_container):
+    x = np.arange(9).reshape(3, 3)
+    msg = "Not equal to tolerance "
+    y = csr_container(x)
+    for X in [x, y]:
+        # basic compare
+        with pytest.raises(AssertionError, match=msg):
+            assert_allclose_dense_sparse(X, X * 2)
+        assert_allclose_dense_sparse(X, X)
+
+    with pytest.raises(ValueError, match="Can only compare two sparse"):
+        assert_allclose_dense_sparse(x, y)
+
+    A = sparse.diags(np.ones(5), offsets=0).tocsr()
+    B = csr_container(np.ones((1, 5)))
+    with pytest.raises(AssertionError, match="Arrays are not equal"):
+        assert_allclose_dense_sparse(B, A)
+
+
+def test_ignore_warning():
+    # This check that ignore_warning decorator and context manager are working
+    # as expected
+    def _warning_function():
+        warnings.warn("deprecation warning", DeprecationWarning)
+
+    def _multiple_warning_function():
+        warnings.warn("deprecation warning", DeprecationWarning)
+        warnings.warn("deprecation warning")
+
+    # Check the function directly
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        ignore_warnings(_warning_function)
+        ignore_warnings(_warning_function, category=DeprecationWarning)
+
+    with pytest.warns(DeprecationWarning):
+        ignore_warnings(_warning_function, category=UserWarning)()
+
+    with pytest.warns() as record:
+        ignore_warnings(_multiple_warning_function, category=FutureWarning)()
+    assert len(record) == 2
+    assert isinstance(record[0].message, DeprecationWarning)
+    assert isinstance(record[1].message, UserWarning)
+
+    with pytest.warns() as record:
+        ignore_warnings(_multiple_warning_function, category=UserWarning)()
+    assert len(record) == 1
+    assert isinstance(record[0].message, DeprecationWarning)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        ignore_warnings(_warning_function, category=(DeprecationWarning, UserWarning))
+
+    # Check the decorator
+    @ignore_warnings
+    def decorator_no_warning():
+        _warning_function()
+        _multiple_warning_function()
+
+    @ignore_warnings(category=(DeprecationWarning, UserWarning))
+    def decorator_no_warning_multiple():
+        _multiple_warning_function()
+
+    @ignore_warnings(category=DeprecationWarning)
+    def decorator_no_deprecation_warning():
+        _warning_function()
+
+    @ignore_warnings(category=UserWarning)
+    def decorator_no_user_warning():
+        _warning_function()
+
+    @ignore_warnings(category=DeprecationWarning)
+    def decorator_no_deprecation_multiple_warning():
+        _multiple_warning_function()
+
+    @ignore_warnings(category=UserWarning)
+    def decorator_no_user_multiple_warning():
+        _multiple_warning_function()
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        decorator_no_warning()
+        decorator_no_warning_multiple()
+        decorator_no_deprecation_warning()
+
+    with pytest.warns(DeprecationWarning):
+        decorator_no_user_warning()
+    with pytest.warns(UserWarning):
+        decorator_no_deprecation_multiple_warning()
+    with pytest.warns(DeprecationWarning):
+        decorator_no_user_multiple_warning()
+
+    # Check the context manager
+    def context_manager_no_warning():
+        with ignore_warnings():
+            _warning_function()
+
+    def context_manager_no_warning_multiple():
+        with ignore_warnings(category=(DeprecationWarning, UserWarning)):
+            _multiple_warning_function()
+
+    def context_manager_no_deprecation_warning():
+        with ignore_warnings(category=DeprecationWarning):
+            _warning_function()
+
+    def context_manager_no_user_warning():
+        with ignore_warnings(category=UserWarning):
+            _warning_function()
+
+    def context_manager_no_deprecation_multiple_warning():
+        with ignore_warnings(category=DeprecationWarning):
+            _multiple_warning_function()
+
+    def context_manager_no_user_multiple_warning():
+        with ignore_warnings(category=UserWarning):
+            _multiple_warning_function()
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        context_manager_no_warning()
+        context_manager_no_warning_multiple()
+        context_manager_no_deprecation_warning()
+
+    with pytest.warns(DeprecationWarning):
+        context_manager_no_user_warning()
+    with pytest.warns(UserWarning):
+        context_manager_no_deprecation_multiple_warning()
+    with pytest.warns(DeprecationWarning):
+        context_manager_no_user_multiple_warning()
+
+    # Check that passing warning class as first positional argument
+    warning_class = UserWarning
+    match = "'obj' should be a callable.+you should use 'category=UserWarning'"
+
+    with pytest.raises(ValueError, match=match):
+        silence_warnings_func = ignore_warnings(warning_class)(_warning_function)
+        silence_warnings_func()
+
+    with pytest.raises(ValueError, match=match):
+
+        @ignore_warnings(warning_class)
+        def test():
+            pass
+
+
+# Tests for docstrings:
+
+
+def f_ok(a, b):
+    """Function f
+
+    Parameters
+    ----------
+    a : int
+        Parameter a
+    b : float
+        Parameter b
+
+    Returns
+    -------
+    c : list
+        Parameter c
+    """
+    c = a + b
+    return c
+
+
+def f_bad_sections(a, b):
+    """Function f
+
+    Parameters
+    ----------
+    a : int
+        Parameter a
+    b : float
+        Parameter b
+
+    Results
+    -------
+    c : list
+        Parameter c
+    """
+    c = a + b
+    return c
+
+
+def f_bad_order(b, a):
+    """Function f
+
+    Parameters
+    ----------
+    a : int
+        Parameter a
+    b : float
+        Parameter b
+
+    Returns
+    -------
+    c : list
+        Parameter c
+    """
+    c = a + b
+    return c
+
+
+def f_too_many_param_docstring(a, b):
+    """Function f
+
+    Parameters
+    ----------
+    a : int
+        Parameter a
+    b : int
+        Parameter b
+    c : int
+        Parameter c
+
+    Returns
+    -------
+    d : list
+        Parameter c
+    """
+    d = a + b
+    return d
+
+
+def f_missing(a, b):
+    """Function f
+
+    Parameters
+    ----------
+    a : int
+        Parameter a
+
+    Returns
+    -------
+    c : list
+        Parameter c
+    """
+    c = a + b
+    return c
+
+
+def f_check_param_definition(a, b, c, d, e):
+    """Function f
+
+    Parameters
+    ----------
+    a: int
+        Parameter a
+    b:
+        Parameter b
+    c :
+        This is parsed correctly in numpydoc 1.2
+    d:int
+        Parameter d
+    e
+        No typespec is allowed without colon
+    """
+    return a + b + c + d
+
+
+class Klass:
+    def f_missing(self, X, y):
+        pass
+
+    def f_bad_sections(self, X, y):
+        """Function f
+
+        Parameter
+        ---------
+        a : int
+            Parameter a
+        b : float
+            Parameter b
+
+        Results
+        -------
+        c : list
+            Parameter c
+        """
+        pass
+
+
+class MockEst:
+    def __init__(self):
+        """MockEstimator"""
+
+    def fit(self, X, y):
+        return X
+
+    def predict(self, X):
+        return X
+
+    def predict_proba(self, X):
+        return X
+
+    def score(self, X):
+        return 1.0
+
+
+class MockMetaEstimator:
+    def __init__(self, delegate):
+        """MetaEstimator to check if doctest on delegated methods work.
+
+        Parameters
+        ---------
+        delegate : estimator
+            Delegated estimator.
+        """
+        self.delegate = delegate
+
+    @available_if(lambda self: hasattr(self.delegate, "predict"))
+    def predict(self, X):
+        """This is available only if delegate has predict.
+
+        Parameters
+        ----------
+        y : ndarray
+            Parameter y
+        """
+        return self.delegate.predict(X)
+
+    @available_if(lambda self: hasattr(self.delegate, "score"))
+    @deprecated("Testing a deprecated delegated method")
+    def score(self, X):
+        """This is available only if delegate has score.
+
+        Parameters
+        ---------
+        y : ndarray
+            Parameter y
+        """
+
+    @available_if(lambda self: hasattr(self.delegate, "predict_proba"))
+    def predict_proba(self, X):
+        """This is available only if delegate has predict_proba.
+
+        Parameters
+        ---------
+        X : ndarray
+            Parameter X
+        """
+        return X
+
+    @deprecated("Testing deprecated function with wrong params")
+    def fit(self, X, y):
+        """Incorrect docstring but should not be tested"""
+
+
+@skip_if_no_numpydoc
+def test_check_docstring_parameters():
+    incorrect = check_docstring_parameters(f_ok)
+    assert incorrect == []
+    incorrect = check_docstring_parameters(f_ok, ignore=["b"])
+    assert incorrect == []
+    incorrect = check_docstring_parameters(f_missing, ignore=["b"])
+    assert incorrect == []
+    with pytest.raises(RuntimeError, match="Unknown section Results"):
+        check_docstring_parameters(f_bad_sections)
+    with pytest.raises(RuntimeError, match="Unknown section Parameter"):
+        check_docstring_parameters(Klass.f_bad_sections)
+
+    incorrect = check_docstring_parameters(f_check_param_definition)
+    mock_meta = MockMetaEstimator(delegate=MockEst())
+    mock_meta_name = mock_meta.__class__.__name__
+    assert incorrect == [
+        (
+            "sklearn.utils.tests.test_testing.f_check_param_definition There "
+            "was no space between the param name and colon ('a: int')"
+        ),
+        (
+            "sklearn.utils.tests.test_testing.f_check_param_definition There "
+            "was no space between the param name and colon ('b:')"
+        ),
+        (
+            "sklearn.utils.tests.test_testing.f_check_param_definition There "
+            "was no space between the param name and colon ('d:int')"
+        ),
+    ]
+
+    messages = [
+        [
+            "In function: sklearn.utils.tests.test_testing.f_bad_order",
+            (
+                "There's a parameter name mismatch in function docstring w.r.t."
+                " function signature, at index 0 diff: 'b' != 'a'"
+            ),
+            "Full diff:",
+            "- ['b', 'a']",
+            "+ ['a', 'b']",
+        ],
+        [
+            "In function: sklearn.utils.tests.test_testing.f_too_many_param_docstring",
+            (
+                "Parameters in function docstring have more items w.r.t. function"
+                " signature, first extra item: c"
+            ),
+            "Full diff:",
+            "- ['a', 'b']",
+            "+ ['a', 'b', 'c']",
+            "?          +++++",
+        ],
+        [
+            "In function: sklearn.utils.tests.test_testing.f_missing",
+            (
+                "Parameters in function docstring have less items w.r.t. function"
+                " signature, first missing item: b"
+            ),
+            "Full diff:",
+            "- ['a', 'b']",
+            "+ ['a']",
+        ],
+        [
+            "In function: sklearn.utils.tests.test_testing.Klass.f_missing",
+            (
+                "Parameters in function docstring have less items w.r.t. function"
+                " signature, first missing item: X"
+            ),
+            "Full diff:",
+            "- ['X', 'y']",
+            "+ []",
+        ],
+        [
+            f"In function: sklearn.utils.tests.test_testing.{mock_meta_name}.predict",
+            (
+                "There's a parameter name mismatch in function docstring w.r.t."
+                " function signature, at index 0 diff: 'X' != 'y'"
+            ),
+            "Full diff:",
+            "- ['X']",
+            "?   ^",
+            "+ ['y']",
+            "?   ^",
+        ],
+        [
+            "In function: "
+            f"sklearn.utils.tests.test_testing.{mock_meta_name}."
+            "predict_proba",
+            "potentially wrong underline length... ",
+            "Parameters ",
+            "--------- in ",
+        ],
+        [
+            f"In function: sklearn.utils.tests.test_testing.{mock_meta_name}.score",
+            "potentially wrong underline length... ",
+            "Parameters ",
+            "--------- in ",
+        ],
+        [
+            f"In function: sklearn.utils.tests.test_testing.{mock_meta_name}.fit",
+            (
+                "Parameters in function docstring have less items w.r.t. function"
+                " signature, first missing item: X"
+            ),
+            "Full diff:",
+            "- ['X', 'y']",
+            "+ []",
+        ],
+    ]
+
+    for msg, f in zip(
+        messages,
+        [
+            f_bad_order,
+            f_too_many_param_docstring,
+            f_missing,
+            Klass.f_missing,
+            mock_meta.predict,
+            mock_meta.predict_proba,
+            mock_meta.score,
+            mock_meta.fit,
+        ],
+    ):
+        incorrect = check_docstring_parameters(f)
+        assert msg == incorrect, '\n"%s"\n not in \n"%s"' % (msg, incorrect)
+
+
+def f_one(a, b):  # pragma: no cover
+    """Function one.
+
+    Parameters
+    ----------
+    a : int,   float
+        Parameter a.
+        Second    line.
+
+    b : str
+        Parameter b.
+
+    Returns
+    -------
+    c : int
+       Returning
+
+    d : int
+       Returning
+    """
+    pass
+
+
+def f_two(a, b):  # pragma: no cover
+    """Function two.
+
+    Parameters
+    ----------
+    a :   int, float
+        Parameter a.
+          Second line.
+
+    b : str
+        Parameter bb.
+
+    e : int
+        Extra parameter.
+
+    Returns
+    -------
+    c : int
+       Returning
+
+    d : int
+       Returning
+    """
+    pass
+
+
+def f_three(a, b):  # pragma: no cover
+    """Function two.
+
+    Parameters
+    ----------
+    a :   int, float
+        Parameter a.
+
+    b : str
+        Parameter B!
+
+    e :
+        Extra parameter.
+
+    Returns
+    -------
+    c : int
+       Returning.
+
+    d : int
+       Returning
+    """
+    pass
+
+
+@skip_if_no_numpydoc
+def test_assert_docstring_consistency_object_type():
+    """Check error raised when `objects` incorrect type."""
+    with pytest.raises(TypeError, match="All 'objects' must be one of"):
+        assert_docstring_consistency(["string", f_one])
+
+
+@skip_if_no_numpydoc
+@pytest.mark.parametrize(
+    "objects, kwargs, error",
+    [
+        (
+            [f_one, f_two],
+            {"include_params": ["a"], "exclude_params": ["b"]},
+            "The 'exclude_params' argument",
+        ),
+        (
+            [f_one, f_two],
+            {"include_returns": False, "exclude_returns": ["c"]},
+            "The 'exclude_returns' argument",
+        ),
+    ],
+)
+def test_assert_docstring_consistency_arg_checks(objects, kwargs, error):
+    """Check `assert_docstring_consistency` argument checking correct."""
+    with pytest.raises(TypeError, match=error):
+        assert_docstring_consistency(objects, **kwargs)
+
+
+@skip_if_no_numpydoc
+@pytest.mark.parametrize(
+    "objects, kwargs, error, warn",
+    [
+        pytest.param(
+            [f_one, f_two], {"include_params": ["a"]}, "", "", id="whitespace"
+        ),
+        pytest.param([f_one, f_two], {"include_returns": True}, "", "", id="incl_all"),
+        pytest.param(
+            [f_one, f_two, f_three],
+            {"include_params": ["a"]},
+            (
+                r"The description of Parameter 'a' is inconsistent between "
+                r"\['f_one',\n'f_two'\]"
+            ),
+            "",
+            id="2-1 group",
+        ),
+        pytest.param(
+            [f_one, f_two, f_three],
+            {"include_params": ["b"]},
+            (
+                r"The description of Parameter 'b' is inconsistent between "
+                r"\['f_one'\] and\n\['f_two'\] and"
+            ),
+            "",
+            id="1-1-1 group",
+        ),
+        pytest.param(
+            [f_two, f_three],
+            {"include_params": ["e"]},
+            (
+                r"The type specification of Parameter 'e' is inconsistent between\n"
+                r"\['f_two'\] and"
+            ),
+            "",
+            id="empty type",
+        ),
+        pytest.param(
+            [f_one, f_two],
+            {"include_params": True, "exclude_params": ["b"]},
+            "",
+            r"Checking was skipped for Parameters: \['e'\]",
+            id="skip warn",
+        ),
+    ],
+)
+def test_assert_docstring_consistency(objects, kwargs, error, warn):
+    """Check `assert_docstring_consistency` gives correct results."""
+    if error:
+        with pytest.raises(AssertionError, match=error):
+            assert_docstring_consistency(objects, **kwargs)
+    elif warn:
+        with pytest.warns(UserWarning, match=warn):
+            assert_docstring_consistency(objects, **kwargs)
+    else:
+        assert_docstring_consistency(objects, **kwargs)
+
+
+def f_four(labels):  # pragma: no cover
+    """Function four.
+
+    Parameters
+    ----------
+
+    labels : array-like, default=None
+        The set of labels to include when `average != 'binary'`, and their
+        order if `average is None`. Labels present in the data can be excluded.
+    """
+    pass
+
+
+def f_five(labels):  # pragma: no cover
+    """Function five.
+
+    Parameters
+    ----------
+
+    labels : array-like, default=None
+        The set of labels to include when `average != 'binary'`, and their
+        order if `average is None`. This is an extra line. Labels present in the
+        data can be excluded.
+    """
+    pass
+
+
+def f_six(labels):  # pragma: no cover
+    """Function six.
+
+    Parameters
+    ----------
+
+    labels : array-like, default=None
+        The group of labels to add when `average != 'binary'`, and the
+        order if `average is None`. Labels present on them datas can be excluded.
+    """
+    pass
+
+
+@skip_if_no_numpydoc
+def test_assert_docstring_consistency_error_msg():
+    """Check `assert_docstring_consistency` difference message."""
+    msg = r"""The description of Parameter 'labels' is inconsistent between
+\['f_four'\] and \['f_five'\] and \['f_six'\]:
+
+\*\*\* \['f_four'\]
+--- \['f_five'\]
+\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
+
+\*\*\* 10,25 \*\*\*\*
+
+--- 10,30 ----
+
+  'binary'`, and their order if `average is None`.
+\+ This is an extra line.
+  Labels present in the data can be excluded.
+
+\*\*\* \['f_four'\]
+--- \['f_six'\]
+\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
+
+\*\*\* 1,25 \*\*\*\*
+
+  The
+! set
+  of labels to
+! include
+  when `average != 'binary'`, and
+! their
+  order if `average is None`. Labels present
+! in the data
+  can be excluded.
+--- 1,25 ----
+
+  The
+! group
+  of labels to
+! add
+  when `average != 'binary'`, and
+! the
+  order if `average is None`. Labels present
+! on them datas
+  can be excluded."""
+
+    with pytest.raises(AssertionError, match=msg):
+        assert_docstring_consistency([f_four, f_five, f_six], include_params=True)
+
+
+@skip_if_no_numpydoc
+def test_assert_docstring_consistency_descr_regex_pattern():
+    """Check `assert_docstring_consistency` `descr_regex_pattern` works."""
+    # Check regex that matches full parameter descriptions
+    regex_full = (
+        r"The (set|group) "  # match 'set' or 'group'
+        r"of labels to (include|add) "  # match 'include' or 'add'
+        r"when `average \!\= 'binary'`, and (their|the) "  #  match 'their' or 'the'
+        r"order if `average is None`\."
+        r"[\s\w]*\.* "  # optionally match additional sentence
+        r"Labels present (on|in) "  # match 'on' or 'in'
+        r"(them|the) "  # match 'them' or 'the'
+        r"datas? can be excluded\."  # match 'data' or 'datas'
+    )
+
+    assert_docstring_consistency(
+        [f_four, f_five, f_six],
+        include_params=True,
+        descr_regex_pattern=" ".join(regex_full.split()),
+    )
+    # Check we can just match a few alternate words
+    regex_words = r"(labels|average|binary)"  # match any of these 3 words
+    assert_docstring_consistency(
+        [f_four, f_five, f_six],
+        include_params=True,
+        descr_regex_pattern=" ".join(regex_words.split()),
+    )
+    # Check error raised when regex doesn't match
+    regex_error = r"The set of labels to include when.+"
+    msg = r"The description of Parameter 'labels' in \['f_six'\] does not match"
+    with pytest.raises(AssertionError, match=msg):
+        assert_docstring_consistency(
+            [f_four, f_five, f_six],
+            include_params=True,
+            descr_regex_pattern=" ".join(regex_error.split()),
+        )
+
+
+class RegistrationCounter:
+    def __init__(self):
+        self.nb_calls = 0
+
+    def __call__(self, to_register_func):
+        self.nb_calls += 1
+        assert to_register_func.func is _delete_folder
+
+
+def check_memmap(input_array, mmap_data, mmap_mode="r"):
+    assert isinstance(mmap_data, np.memmap)
+    writeable = mmap_mode != "r"
+    assert mmap_data.flags.writeable is writeable
+    np.testing.assert_array_equal(input_array, mmap_data)
+
+
+def test_tempmemmap(monkeypatch):
+    registration_counter = RegistrationCounter()
+    monkeypatch.setattr(atexit, "register", registration_counter)
+
+    input_array = np.ones(3)
+    with TempMemmap(input_array) as data:
+        check_memmap(input_array, data)
+        temp_folder = os.path.dirname(data.filename)
+    if os.name != "nt":
+        assert not os.path.exists(temp_folder)
+    assert registration_counter.nb_calls == 1
+
+    mmap_mode = "r+"
+    with TempMemmap(input_array, mmap_mode=mmap_mode) as data:
+        check_memmap(input_array, data, mmap_mode=mmap_mode)
+        temp_folder = os.path.dirname(data.filename)
+    if os.name != "nt":
+        assert not os.path.exists(temp_folder)
+    assert registration_counter.nb_calls == 2
+
+
+def test_create_memmap_backed_data(monkeypatch):
+    registration_counter = RegistrationCounter()
+    monkeypatch.setattr(atexit, "register", registration_counter)
+
+    input_array = np.ones(3)
+    data = create_memmap_backed_data(input_array)
+    check_memmap(input_array, data)
+    assert registration_counter.nb_calls == 1
+
+    data, folder = create_memmap_backed_data(input_array, return_folder=True)
+    check_memmap(input_array, data)
+    assert folder == os.path.dirname(data.filename)
+    assert registration_counter.nb_calls == 2
+
+    mmap_mode = "r+"
+    data = create_memmap_backed_data(input_array, mmap_mode=mmap_mode)
+    check_memmap(input_array, data, mmap_mode)
+    assert registration_counter.nb_calls == 3
+
+    input_list = [input_array, input_array + 1, input_array + 2]
+    mmap_data_list = create_memmap_backed_data(input_list)
+    for input_array, data in zip(input_list, mmap_data_list):
+        check_memmap(input_array, data)
+    assert registration_counter.nb_calls == 4
+
+    output_data, other = create_memmap_backed_data([input_array, "not-an-array"])
+    check_memmap(input_array, output_data)
+    assert other == "not-an-array"
+
+
+@pytest.mark.parametrize(
+    "constructor_name, container_type",
+    [
+        ("list", list),
+        ("tuple", tuple),
+        ("array", np.ndarray),
+        ("sparse", sparse.csr_matrix),
+        # using `zip` will only keep the available sparse containers
+        # depending of the installed SciPy version
+        *zip(["sparse_csr", "sparse_csr_array"], CSR_CONTAINERS),
+        *zip(["sparse_csc", "sparse_csc_array"], CSC_CONTAINERS),
+        ("dataframe", lambda: pytest.importorskip("pandas").DataFrame),
+        ("series", lambda: pytest.importorskip("pandas").Series),
+        ("index", lambda: pytest.importorskip("pandas").Index),
+        ("pyarrow", lambda: pytest.importorskip("pyarrow").Table),
+        ("pyarrow_array", lambda: pytest.importorskip("pyarrow").Array),
+        ("polars", lambda: pytest.importorskip("polars").DataFrame),
+        ("polars_series", lambda: pytest.importorskip("polars").Series),
+        ("slice", slice),
+    ],
+)
+@pytest.mark.parametrize(
+    "dtype, superdtype",
+    [
+        (np.int32, np.integer),
+        (np.int64, np.integer),
+        (np.float32, np.floating),
+        (np.float64, np.floating),
+    ],
+)
+def test_convert_container(
+    constructor_name,
+    container_type,
+    dtype,
+    superdtype,
+):
+    """Check that we convert the container to the right type of array with the
+    right data type."""
+    if constructor_name in (
+        "dataframe",
+        "index",
+        "polars",
+        "polars_series",
+        "pyarrow",
+        "pyarrow_array",
+        "series",
+    ):
+        # delay the import of pandas/polars within the function to only skip this test
+        # instead of the whole file
+        container_type = container_type()
+    container = [0, 1]
+
+    container_converted = _convert_container(
+        container,
+        constructor_name,
+        dtype=dtype,
+    )
+    assert isinstance(container_converted, container_type)
+
+    if constructor_name in ("list", "tuple", "index"):
+        # list and tuple will use Python class dtype: int, float
+        # pandas index will always use high precision: np.int64 and np.float64
+        assert np.issubdtype(type(container_converted[0]), superdtype)
+    elif constructor_name in ("polars", "polars_series", "pyarrow", "pyarrow_array"):
+        return
+    elif hasattr(container_converted, "dtype"):
+        assert container_converted.dtype == dtype
+    elif hasattr(container_converted, "dtypes"):
+        assert container_converted.dtypes[0] == dtype
+
+
+def test_convert_container_categories_pandas():
+    pytest.importorskip("pandas")
+    df = _convert_container(
+        [["x"]], "dataframe", ["A"], categorical_feature_names=["A"]
+    )
+    assert df.dtypes.iloc[0] == "category"
+
+
+def test_convert_container_categories_polars():
+    pl = pytest.importorskip("polars")
+    df = _convert_container([["x"]], "polars", ["A"], categorical_feature_names=["A"])
+    assert df.schema["A"] == pl.Categorical()
+
+
+def test_convert_container_categories_pyarrow():
+    pa = pytest.importorskip("pyarrow")
+    df = _convert_container([["x"]], "pyarrow", ["A"], categorical_feature_names=["A"])
+    assert type(df.schema[0].type) is pa.DictionaryType
+
+
+def test_raises():
+    # Tests for the raises context manager
+
+    # Proper type, no match
+    with raises(TypeError):
+        raise TypeError()
+
+    # Proper type, proper match
+    with raises(TypeError, match="how are you") as cm:
+        raise TypeError("hello how are you")
+    assert cm.raised_and_matched
+
+    # Proper type, proper match with multiple patterns
+    with raises(TypeError, match=["not this one", "how are you"]) as cm:
+        raise TypeError("hello how are you")
+    assert cm.raised_and_matched
+
+    # bad type, no match
+    with pytest.raises(ValueError, match="this will be raised"):
+        with raises(TypeError) as cm:
+            raise ValueError("this will be raised")
+    assert not cm.raised_and_matched
+
+    # Bad type, no match, with a err_msg
+    with pytest.raises(AssertionError, match="the failure message"):
+        with raises(TypeError, err_msg="the failure message") as cm:
+            raise ValueError()
+    assert not cm.raised_and_matched
+
+    # bad type, with match (is ignored anyway)
+    with pytest.raises(ValueError, match="this will be raised"):
+        with raises(TypeError, match="this is ignored") as cm:
+            raise ValueError("this will be raised")
+    assert not cm.raised_and_matched
+
+    # proper type but bad match
+    with pytest.raises(
+        AssertionError, match="should contain one of the following patterns"
+    ):
+        with raises(TypeError, match="hello") as cm:
+            raise TypeError("Bad message")
+    assert not cm.raised_and_matched
+
+    # proper type but bad match, with err_msg
+    with pytest.raises(AssertionError, match="the failure message"):
+        with raises(TypeError, match="hello", err_msg="the failure message") as cm:
+            raise TypeError("Bad message")
+    assert not cm.raised_and_matched
+
+    # no raise with default may_pass=False
+    with pytest.raises(AssertionError, match="Did not raise"):
+        with raises(TypeError) as cm:
+            pass
+    assert not cm.raised_and_matched
+
+    # no raise with may_pass=True
+    with raises(TypeError, match="hello", may_pass=True) as cm:
+        pass  # still OK
+    assert not cm.raised_and_matched
+
+    # Multiple exception types:
+    with raises((TypeError, ValueError)):
+        raise TypeError()
+    with raises((TypeError, ValueError)):
+        raise ValueError()
+    with pytest.raises(AssertionError):
+        with raises((TypeError, ValueError)):
+            pass
+
+
+def test_float32_aware_assert_allclose():
+    # The relative tolerance for float32 inputs is 1e-4
+    assert_allclose(np.array([1.0 + 2e-5], dtype=np.float32), 1.0)
+    with pytest.raises(AssertionError):
+        assert_allclose(np.array([1.0 + 2e-4], dtype=np.float32), 1.0)
+
+    # The relative tolerance for other inputs is left to 1e-7 as in
+    # the original numpy version.
+    assert_allclose(np.array([1.0 + 2e-8], dtype=np.float64), 1.0)
+    with pytest.raises(AssertionError):
+        assert_allclose(np.array([1.0 + 2e-7], dtype=np.float64), 1.0)
+
+    # atol is left to 0.0 by default, even for float32
+    with pytest.raises(AssertionError):
+        assert_allclose(np.array([1e-5], dtype=np.float32), 0.0)
+    assert_allclose(np.array([1e-5], dtype=np.float32), 0.0, atol=2e-5)
+
+
+@pytest.mark.xfail(_IS_WASM, reason="cannot start subprocess")
+def test_assert_run_python_script_without_output():
+    code = "x = 1"
+    assert_run_python_script_without_output(code)
+
+    code = "print('something to stdout')"
+    with pytest.raises(AssertionError, match="Expected no output"):
+        assert_run_python_script_without_output(code)
+
+    code = "print('something to stdout')"
+    with pytest.raises(
+        AssertionError,
+        match="output was not supposed to match.+got.+something to stdout",
+    ):
+        assert_run_python_script_without_output(code, pattern="to.+stdout")
+
+    code = "\n".join(["import sys", "print('something to stderr', file=sys.stderr)"])
+    with pytest.raises(
+        AssertionError,
+        match="output was not supposed to match.+got.+something to stderr",
+    ):
+        assert_run_python_script_without_output(code, pattern="to.+stderr")
+
+
+@pytest.mark.parametrize(
+    "constructor_name",
+    [
+        "sparse_csr",
+        "sparse_csc",
+        pytest.param(
+            "sparse_csr_array",
+        ),
+        pytest.param(
+            "sparse_csc_array",
+        ),
+    ],
+)
+def test_convert_container_sparse_to_sparse(constructor_name):
+    """Non-regression test to check that we can still convert a sparse container
+    from a given format to another format.
+    """
+    X_sparse = sparse.random(10, 10, density=0.1, format="csr")
+    _convert_container(X_sparse, constructor_name)
+
+
+def check_warnings_as_errors(warning_info, warnings_as_errors):
+    if warning_info.action == "error" and warnings_as_errors:
+        with pytest.raises(warning_info.category, match=warning_info.message):
+            warnings.warn(
+                message=warning_info.message,
+                category=warning_info.category,
+            )
+    if warning_info.action == "ignore":
+        with warnings.catch_warnings(record=True) as record:
+            message = warning_info.message
+            # Special treatment when regex is used
+            if "Pyarrow" in message:
+                message = "\nPyarrow will become a required dependency"
+
+            warnings.warn(
+                message=message,
+                category=warning_info.category,
+            )
+            assert len(record) == 0 if warnings_as_errors else 1
+            if record:
+                assert str(record[0].message) == message
+                assert record[0].category == warning_info.category
+
+
+@pytest.mark.parametrize("warning_info", _get_warnings_filters_info_list())
+def test_sklearn_warnings_as_errors(warning_info):
+    warnings_as_errors = os.environ.get("SKLEARN_WARNINGS_AS_ERRORS", "0") != "0"
+    check_warnings_as_errors(warning_info, warnings_as_errors=warnings_as_errors)
+
+
+@pytest.mark.parametrize("warning_info", _get_warnings_filters_info_list())
+def test_turn_warnings_into_errors(warning_info):
+    with warnings.catch_warnings():
+        turn_warnings_into_errors()
+        check_warnings_as_errors(warning_info, warnings_as_errors=True)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_typedefs.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_typedefs.py
new file mode 100644
index 0000000000000000000000000000000000000000..da7e7a2df7dbb0c2cdee1b368455e64b643656d3
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_typedefs.py
@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+
+from sklearn.utils._typedefs import testing_make_array_from_typed_val
+
+
+@pytest.mark.parametrize(
+    "type_t, value, expected_dtype",
+    [
+        ("float64_t", 1.0, np.float64),
+        ("float32_t", 1.0, np.float32),
+        ("intp_t", 1, np.intp),
+        ("int8_t", 1, np.int8),
+        ("int32_t", 1, np.int32),
+        ("int64_t", 1, np.int64),
+        ("uint8_t", 1, np.uint8),
+        ("uint32_t", 1, np.uint32),
+        ("uint64_t", 1, np.uint64),
+    ],
+)
+def test_types(type_t, value, expected_dtype):
+    """Check that the types defined in _typedefs correspond to the expected
+    numpy dtypes.
+    """
+    assert testing_make_array_from_typed_val[type_t](value).dtype == expected_dtype
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_unique.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_unique.py
new file mode 100644
index 0000000000000000000000000000000000000000..daa6918b49cda156c0a5316b8df9eba900a15e5e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_unique.py
@@ -0,0 +1,54 @@
+import numpy as np
+from numpy.testing import assert_array_equal
+
+from sklearn.utils._unique import attach_unique, cached_unique
+from sklearn.utils.validation import check_array
+
+
+def test_attach_unique_attaches_unique_to_array():
+    arr = np.array([1, 2, 2, 3, 4, 4, 5])
+    arr_ = attach_unique(arr)
+    assert_array_equal(arr_.dtype.metadata["unique"], np.array([1, 2, 3, 4, 5]))
+    assert_array_equal(arr_, arr)
+
+
+def test_cached_unique_returns_cached_unique():
+    my_dtype = np.dtype(np.float64, metadata={"unique": np.array([1, 2])})
+    arr = np.array([1, 2, 2, 3, 4, 4, 5], dtype=my_dtype)
+    assert_array_equal(cached_unique(arr), np.array([1, 2]))
+
+
+def test_attach_unique_not_ndarray():
+    """Test that when not np.ndarray, we don't touch the array."""
+    arr = [1, 2, 2, 3, 4, 4, 5]
+    arr_ = attach_unique(arr)
+    assert arr_ is arr
+
+
+def test_attach_unique_returns_view():
+    """Test that attach_unique returns a view of the array."""
+    arr = np.array([1, 2, 2, 3, 4, 4, 5])
+    arr_ = attach_unique(arr)
+    assert arr_.base is arr
+
+
+def test_attach_unique_return_tuple():
+    """Test return_tuple argument of the function."""
+    arr = np.array([1, 2, 2, 3, 4, 4, 5])
+    arr_tuple = attach_unique(arr, return_tuple=True)
+    assert isinstance(arr_tuple, tuple)
+    assert len(arr_tuple) == 1
+    assert_array_equal(arr_tuple[0], arr)
+
+    arr_single = attach_unique(arr, return_tuple=False)
+    assert isinstance(arr_single, np.ndarray)
+    assert_array_equal(arr_single, arr)
+
+
+def test_check_array_keeps_unique():
+    """Test that check_array keeps the unique metadata."""
+    arr = np.array([[1, 2, 2, 3, 4, 4, 5]])
+    arr_ = attach_unique(arr)
+    arr_ = check_array(arr_)
+    assert_array_equal(arr_.dtype.metadata["unique"], np.array([1, 2, 3, 4, 5]))
+    assert_array_equal(arr_, arr)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_user_interface.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_user_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..9aa9d41ba9aef78700c3e8b43dcd40e7012c94e2
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_user_interface.py
@@ -0,0 +1,65 @@
+import string
+import timeit
+
+import pytest
+
+from sklearn.utils._user_interface import _message_with_time, _print_elapsed_time
+
+
+@pytest.mark.parametrize(
+    ["source", "message", "is_long"],
+    [
+        ("ABC", string.ascii_lowercase, False),
+        ("ABCDEF", string.ascii_lowercase, False),
+        ("ABC", string.ascii_lowercase * 3, True),
+        ("ABC" * 10, string.ascii_lowercase, True),
+        ("ABC", string.ascii_lowercase + "\u1048", False),
+    ],
+)
+@pytest.mark.parametrize(
+    ["time", "time_str"],
+    [
+        (0.2, "   0.2s"),
+        (20, "  20.0s"),
+        (2000, "33.3min"),
+        (20000, "333.3min"),
+    ],
+)
+def test_message_with_time(source, message, is_long, time, time_str):
+    out = _message_with_time(source, message, time)
+    if is_long:
+        assert len(out) > 70
+    else:
+        assert len(out) == 70
+
+    assert out.startswith("[" + source + "] ")
+    out = out[len(source) + 3 :]
+
+    assert out.endswith(time_str)
+    out = out[: -len(time_str)]
+    assert out.endswith(", total=")
+    out = out[: -len(", total=")]
+    assert out.endswith(message)
+    out = out[: -len(message)]
+    assert out.endswith(" ")
+    out = out[:-1]
+
+    if is_long:
+        assert not out
+    else:
+        assert list(set(out)) == ["."]
+
+
+@pytest.mark.parametrize(
+    ["message", "expected"],
+    [
+        ("hello", _message_with_time("ABC", "hello", 0.1) + "\n"),
+        ("", _message_with_time("ABC", "", 0.1) + "\n"),
+        (None, ""),
+    ],
+)
+def test_print_elapsed_time(message, expected, capsys, monkeypatch):
+    monkeypatch.setattr(timeit, "default_timer", lambda: 0)
+    with _print_elapsed_time("ABC", message):
+        monkeypatch.setattr(timeit, "default_timer", lambda: 0.1)
+    assert capsys.readouterr().out == expected
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_validation.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_validation.py
new file mode 100644
index 0000000000000000000000000000000000000000..99db6cdfb16aa56d7faf2500f7997467f2a69076
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_validation.py
@@ -0,0 +1,2374 @@
+"""Tests for input validation functions"""
+
+import numbers
+import re
+import warnings
+from itertools import product
+from operator import itemgetter
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+from pytest import importorskip
+
+import sklearn
+from sklearn._config import config_context
+from sklearn._min_dependencies import dependent_packages
+from sklearn.base import BaseEstimator
+from sklearn.datasets import make_blobs
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.exceptions import NotFittedError, PositiveSpectrumWarning
+from sklearn.linear_model import ARDRegression
+
+# TODO: add this estimator into the _mocking module in a further refactoring
+from sklearn.metrics.tests.test_score_objects import EstimatorWithFit
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.random_projection import _sparse_random_matrix
+from sklearn.svm import SVR
+from sklearn.utils import (
+    _safe_indexing,
+    as_float_array,
+    check_array,
+    check_symmetric,
+    check_X_y,
+    deprecated,
+)
+from sklearn.utils._array_api import (
+    _get_namespace_device_dtype_ids,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._mocking import (
+    MockDataFrame,
+    _MockEstimatorOnOffPrediction,
+)
+from sklearn.utils._testing import (
+    SkipTest,
+    TempMemmap,
+    _array_api_for_tests,
+    _convert_container,
+    assert_allclose,
+    assert_allclose_dense_sparse,
+    assert_array_equal,
+    create_memmap_backed_data,
+    skip_if_array_api_compat_not_configured,
+)
+from sklearn.utils.estimator_checks import _NotAnArray
+from sklearn.utils.fixes import (
+    COO_CONTAINERS,
+    CSC_CONTAINERS,
+    CSR_CONTAINERS,
+    DIA_CONTAINERS,
+    DOK_CONTAINERS,
+)
+from sklearn.utils.validation import (
+    FLOAT_DTYPES,
+    _allclose_dense_sparse,
+    _check_feature_names_in,
+    _check_method_params,
+    _check_psd_eigenvalues,
+    _check_response_method,
+    _check_sample_weight,
+    _check_y,
+    _deprecate_positional_args,
+    _estimator_has,
+    _get_feature_names,
+    _is_fitted,
+    _is_pandas_df,
+    _is_polars_df,
+    _num_features,
+    _num_samples,
+    _to_object_array,
+    assert_all_finite,
+    check_consistent_length,
+    check_is_fitted,
+    check_memory,
+    check_non_negative,
+    check_random_state,
+    check_scalar,
+    column_or_1d,
+    has_fit_parameter,
+    validate_data,
+)
+
+
+def test_make_rng():
+    # Check the check_random_state utility function behavior
+    assert check_random_state(None) is np.random.mtrand._rand
+    assert check_random_state(np.random) is np.random.mtrand._rand
+
+    rng_42 = np.random.RandomState(42)
+    assert check_random_state(42).randint(100) == rng_42.randint(100)
+
+    rng_42 = np.random.RandomState(42)
+    assert check_random_state(rng_42) is rng_42
+
+    rng_42 = np.random.RandomState(42)
+    assert check_random_state(43).randint(100) != rng_42.randint(100)
+
+    with pytest.raises(ValueError):
+        check_random_state("some invalid seed")
+
+
+def test_as_float_array():
+    # Test function for as_float_array
+    X = np.ones((3, 10), dtype=np.int32)
+    X = X + np.arange(10, dtype=np.int32)
+    X2 = as_float_array(X, copy=False)
+    assert X2.dtype == np.float32
+    # Another test
+    X = X.astype(np.int64)
+    X2 = as_float_array(X, copy=True)
+    # Checking that the array wasn't overwritten
+    assert as_float_array(X, copy=False) is not X
+    assert X2.dtype == np.float64
+    # Test int dtypes <= 32bit
+    tested_dtypes = [bool, np.int8, np.int16, np.int32, np.uint8, np.uint16, np.uint32]
+    for dtype in tested_dtypes:
+        X = X.astype(dtype)
+        X2 = as_float_array(X)
+        assert X2.dtype == np.float32
+
+    # Test object dtype
+    X = X.astype(object)
+    X2 = as_float_array(X, copy=True)
+    assert X2.dtype == np.float64
+
+    # Here, X is of the right type, it shouldn't be modified
+    X = np.ones((3, 2), dtype=np.float32)
+    assert as_float_array(X, copy=False) is X
+    # Test that if X is fortran ordered it stays
+    X = np.asfortranarray(X)
+    assert np.isfortran(as_float_array(X, copy=True))
+
+    # Test the copy parameter with some matrices
+    matrices = [
+        sp.csc_matrix(np.arange(5)).toarray(),
+        _sparse_random_matrix(10, 10, density=0.10).toarray(),
+    ]
+    for M in matrices:
+        N = as_float_array(M, copy=True)
+        N[0, 0] = np.nan
+        assert not np.isnan(M).any()
+
+
+@pytest.mark.parametrize(
+    "X", [np.random.random((10, 2)), sp.random(10, 2, format="csr")]
+)
+def test_as_float_array_nan(X):
+    X[5, 0] = np.nan
+    X[6, 1] = np.nan
+    X_converted = as_float_array(X, ensure_all_finite="allow-nan")
+    assert_allclose_dense_sparse(X_converted, X)
+
+
+def test_np_matrix():
+    # Confirm that input validation code does not return np.matrix
+    X = np.arange(12).reshape(3, 4)
+
+    assert not isinstance(as_float_array(X), np.matrix)
+    assert not isinstance(as_float_array(sp.csc_matrix(X)), np.matrix)
+
+
+def test_memmap():
+    # Confirm that input validation code doesn't copy memory mapped arrays
+
+    asflt = lambda x: as_float_array(x, copy=False)
+
+    with NamedTemporaryFile(prefix="sklearn-test") as tmp:
+        M = np.memmap(tmp, shape=(10, 10), dtype=np.float32)
+        M[:] = 0
+
+        for f in (check_array, np.asarray, asflt):
+            X = f(M)
+            X[:] = 1
+            assert_array_equal(X.ravel(), M.ravel())
+            X[:] = 0
+
+
+def test_ordering():
+    # Check that ordering is enforced correctly by validation utilities.
+    # We need to check each validation utility, because a 'copy' without
+    # 'order=K' will kill the ordering.
+    X = np.ones((10, 5))
+    for A in X, X.T:
+        for copy in (True, False):
+            B = check_array(A, order="C", copy=copy)
+            assert B.flags["C_CONTIGUOUS"]
+            B = check_array(A, order="F", copy=copy)
+            assert B.flags["F_CONTIGUOUS"]
+            if copy:
+                assert A is not B
+
+    X = sp.csr_matrix(X)
+    X.data = X.data[::-1]
+    assert not X.data.flags["C_CONTIGUOUS"]
+
+
+@pytest.mark.parametrize(
+    "value, ensure_all_finite",
+    [(np.inf, False), (np.nan, "allow-nan"), (np.nan, False)],
+)
+@pytest.mark.parametrize("retype", [np.asarray, sp.csr_matrix])
+def test_check_array_ensure_all_finite_valid(value, ensure_all_finite, retype):
+    X = retype(np.arange(4).reshape(2, 2).astype(float))
+    X[0, 0] = value
+    X_checked = check_array(X, ensure_all_finite=ensure_all_finite, accept_sparse=True)
+    assert_allclose_dense_sparse(X, X_checked)
+
+
+@pytest.mark.parametrize(
+    "value, input_name, ensure_all_finite, match_msg",
+    [
+        (np.inf, "", True, "Input contains infinity"),
+        (np.inf, "X", True, "Input X contains infinity"),
+        (np.inf, "sample_weight", True, "Input sample_weight contains infinity"),
+        (np.inf, "X", "allow-nan", "Input X contains infinity"),
+        (np.nan, "", True, "Input contains NaN"),
+        (np.nan, "X", True, "Input X contains NaN"),
+        (np.nan, "y", True, "Input y contains NaN"),
+        (
+            np.nan,
+            "",
+            "allow-inf",
+            "ensure_all_finite should be a bool or 'allow-nan'",
+        ),
+        (np.nan, "", 1, "Input contains NaN"),
+    ],
+)
+@pytest.mark.parametrize("retype", [np.asarray, sp.csr_matrix])
+def test_check_array_ensure_all_finite_invalid(
+    value, input_name, ensure_all_finite, match_msg, retype
+):
+    X = retype(np.arange(4).reshape(2, 2).astype(np.float64))
+    X[0, 0] = value
+    with pytest.raises(ValueError, match=match_msg):
+        check_array(
+            X,
+            input_name=input_name,
+            ensure_all_finite=ensure_all_finite,
+            accept_sparse=True,
+        )
+
+
+@pytest.mark.parametrize("input_name", ["X", "y", "sample_weight"])
+@pytest.mark.parametrize("retype", [np.asarray, sp.csr_matrix])
+def test_check_array_links_to_imputer_doc_only_for_X(input_name, retype):
+    data = retype(np.arange(4).reshape(2, 2).astype(np.float64))
+    data[0, 0] = np.nan
+    estimator = SVR()
+    extended_msg = (
+        f"\n{estimator.__class__.__name__} does not accept missing values"
+        " encoded as NaN natively. For supervised learning, you might want"
+        " to consider sklearn.ensemble.HistGradientBoostingClassifier and Regressor"
+        " which accept missing values encoded as NaNs natively."
+        " Alternatively, it is possible to preprocess the"
+        " data, for instance by using an imputer transformer in a pipeline"
+        " or drop samples with missing values. See"
+        " https://scikit-learn.org/stable/modules/impute.html"
+        " You can find a list of all estimators that handle NaN values"
+        " at the following page:"
+        " https://scikit-learn.org/stable/modules/impute.html"
+        "#estimators-that-handle-nan-values"
+    )
+
+    with pytest.raises(ValueError, match=f"Input {input_name} contains NaN") as ctx:
+        check_array(
+            data,
+            estimator=estimator,
+            input_name=input_name,
+            accept_sparse=True,
+        )
+
+    if input_name == "X":
+        assert extended_msg in ctx.value.args[0]
+    else:
+        assert extended_msg not in ctx.value.args[0]
+
+    if input_name == "X":
+        # Veriy that _validate_data is automatically called with the right argument
+        # to generate the same exception:
+        with pytest.raises(ValueError, match=f"Input {input_name} contains NaN") as ctx:
+            SVR().fit(data, np.ones(data.shape[0]))
+        assert extended_msg in ctx.value.args[0]
+
+
+def test_check_array_ensure_all_finite_object():
+    X = np.array([["a", "b", np.nan]], dtype=object).T
+
+    X_checked = check_array(X, dtype=None, ensure_all_finite="allow-nan")
+    assert X is X_checked
+
+    X_checked = check_array(X, dtype=None, ensure_all_finite=False)
+    assert X is X_checked
+
+    with pytest.raises(ValueError, match="Input contains NaN"):
+        check_array(X, dtype=None, ensure_all_finite=True)
+
+
+@pytest.mark.parametrize(
+    "X, err_msg",
+    [
+        (
+            np.array([[1, np.nan]]),
+            "Input contains NaN.",
+        ),
+        (
+            np.array([[1, np.nan]]),
+            "Input contains NaN.",
+        ),
+        (
+            np.array([[1, np.inf]]),
+            "Input contains infinity or a value too large for.*int",
+        ),
+        (np.array([[1, np.nan]], dtype=object), "cannot convert float NaN to integer"),
+    ],
+)
+@pytest.mark.parametrize("ensure_all_finite", [True, False])
+def test_check_array_ensure_all_finite_object_unsafe_casting(
+    X, err_msg, ensure_all_finite
+):
+    # casting a float array containing NaN or inf to int dtype should
+    # raise an error irrespective of the ensure_all_finite parameter.
+    with pytest.raises(ValueError, match=err_msg):
+        check_array(X, dtype=int, ensure_all_finite=ensure_all_finite)
+
+
+def test_check_array_series_err_msg():
+    """
+    Check that we raise a proper error message when passing a Series and we expect a
+    2-dimensional container.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/27498
+    """
+    pd = pytest.importorskip("pandas")
+    ser = pd.Series([1, 2, 3])
+    msg = f"Expected a 2-dimensional container but got {type(ser)} instead."
+    with pytest.raises(ValueError, match=msg):
+        check_array(ser, ensure_2d=True)
+
+
+@pytest.mark.filterwarnings("ignore:Can't check dok sparse matrix for nan or inf")
+def test_check_array():
+    # accept_sparse == False
+    # raise error on sparse inputs
+    X = [[1, 2], [3, 4]]
+    X_csr = sp.csr_matrix(X)
+    with pytest.raises(TypeError):
+        check_array(X_csr)
+
+    # ensure_2d=False
+    X_array = check_array([0, 1, 2], ensure_2d=False)
+    assert X_array.ndim == 1
+    # ensure_2d=True with 1d array
+    with pytest.raises(ValueError, match="Expected 2D array, got 1D array instead"):
+        check_array([0, 1, 2], ensure_2d=True)
+
+    # ensure_2d=True with scalar array
+    with pytest.raises(ValueError, match="Expected 2D array, got scalar array instead"):
+        check_array(10, ensure_2d=True)
+
+    # ensure_2d=True with 1d sparse array
+    if hasattr(sp, "csr_array"):
+        sparse_row = next(iter(sp.csr_array(X)))
+        if sparse_row.ndim == 1:
+            # In scipy 1.14 and later, sparse row is 1D while it was 2D before.
+            with pytest.raises(ValueError, match="Expected 2D input, got"):
+                check_array(sparse_row, accept_sparse=True, ensure_2d=True)
+
+    # don't allow ndim > 3
+    X_ndim = np.arange(8).reshape(2, 2, 2)
+    with pytest.raises(ValueError):
+        check_array(X_ndim)
+    check_array(X_ndim, allow_nd=True)  # doesn't raise
+
+    # dtype and order enforcement.
+    X_C = np.arange(4).reshape(2, 2).copy("C")
+    X_F = X_C.copy("F")
+    X_int = X_C.astype(int)
+    X_float = X_C.astype(float)
+    Xs = [X_C, X_F, X_int, X_float]
+    dtypes = [np.int32, int, float, np.float32, None, bool, object]
+    orders = ["C", "F", None]
+    copys = [True, False]
+
+    for X, dtype, order, copy in product(Xs, dtypes, orders, copys):
+        X_checked = check_array(X, dtype=dtype, order=order, copy=copy)
+        if dtype is not None:
+            assert X_checked.dtype == dtype
+        else:
+            assert X_checked.dtype == X.dtype
+        if order == "C":
+            assert X_checked.flags["C_CONTIGUOUS"]
+            assert not X_checked.flags["F_CONTIGUOUS"]
+        elif order == "F":
+            assert X_checked.flags["F_CONTIGUOUS"]
+            assert not X_checked.flags["C_CONTIGUOUS"]
+        if copy:
+            assert X is not X_checked
+        else:
+            # doesn't copy if it was already good
+            if (
+                X.dtype == X_checked.dtype
+                and X_checked.flags["C_CONTIGUOUS"] == X.flags["C_CONTIGUOUS"]
+                and X_checked.flags["F_CONTIGUOUS"] == X.flags["F_CONTIGUOUS"]
+            ):
+                assert X is X_checked
+
+    # allowed sparse != None
+
+    # try different type of sparse format
+    Xs = []
+    Xs.extend(
+        [
+            sparse_container(X_C)
+            for sparse_container in CSR_CONTAINERS
+            + CSC_CONTAINERS
+            + COO_CONTAINERS
+            + DOK_CONTAINERS
+        ]
+    )
+    Xs.extend([Xs[0].astype(np.int64), Xs[0].astype(np.float64)])
+
+    accept_sparses = [["csr", "coo"], ["coo", "dok"]]
+    # scipy sparse matrices do not support the object dtype so
+    # this dtype is skipped in this loop
+    non_object_dtypes = [dt for dt in dtypes if dt is not object]
+    for X, dtype, accept_sparse, copy in product(
+        Xs, non_object_dtypes, accept_sparses, copys
+    ):
+        X_checked = check_array(X, dtype=dtype, accept_sparse=accept_sparse, copy=copy)
+        if dtype is not None:
+            assert X_checked.dtype == dtype
+        else:
+            assert X_checked.dtype == X.dtype
+        if X.format in accept_sparse:
+            # no change if allowed
+            assert X.format == X_checked.format
+        else:
+            # got converted
+            assert X_checked.format == accept_sparse[0]
+        if copy:
+            assert X is not X_checked
+        else:
+            # doesn't copy if it was already good
+            if X.dtype == X_checked.dtype and X.format == X_checked.format:
+                assert X is X_checked
+
+    # other input formats
+    # convert lists to arrays
+    X_dense = check_array([[1, 2], [3, 4]])
+    assert isinstance(X_dense, np.ndarray)
+    # raise on too deep lists
+    with pytest.raises(ValueError):
+        check_array(X_ndim.tolist())
+    check_array(X_ndim.tolist(), allow_nd=True)  # doesn't raise
+
+    # convert weird stuff to arrays
+    X_no_array = _NotAnArray(X_dense)
+    result = check_array(X_no_array)
+    assert isinstance(result, np.ndarray)
+
+    # check negative values when ensure_non_negative=True
+    X_neg = check_array([[1, 2], [-3, 4]])
+    err_msg = "Negative values in data passed to X in RandomForestRegressor"
+    with pytest.raises(ValueError, match=err_msg):
+        check_array(
+            X_neg,
+            ensure_non_negative=True,
+            input_name="X",
+            estimator=RandomForestRegressor(),
+        )
+
+
+@pytest.mark.parametrize(
+    "X",
+    [
+        [["1", "2"], ["3", "4"]],
+        np.array([["1", "2"], ["3", "4"]], dtype="U"),
+        np.array([["1", "2"], ["3", "4"]], dtype="S"),
+        [[b"1", b"2"], [b"3", b"4"]],
+        np.array([[b"1", b"2"], [b"3", b"4"]], dtype="V1"),
+    ],
+)
+def test_check_array_numeric_error(X):
+    """Test that check_array errors when it receives an array of bytes/string
+    while a numeric dtype is required."""
+    expected_msg = r"dtype='numeric' is not compatible with arrays of bytes/strings"
+    with pytest.raises(ValueError, match=expected_msg):
+        check_array(X, dtype="numeric")
+
+
+@pytest.mark.parametrize(
+    "pd_dtype", ["Int8", "Int16", "UInt8", "UInt16", "Float32", "Float64"]
+)
+@pytest.mark.parametrize(
+    "dtype, expected_dtype",
+    [
+        ([np.float32, np.float64], np.float32),
+        (np.float64, np.float64),
+        ("numeric", np.float64),
+    ],
+)
+def test_check_array_pandas_na_support(pd_dtype, dtype, expected_dtype):
+    # Test pandas numerical extension arrays with pd.NA
+    pd = pytest.importorskip("pandas")
+
+    if pd_dtype in {"Float32", "Float64"}:
+        # Extension dtypes with Floats was added in 1.2
+        pd = pytest.importorskip("pandas", minversion="1.2")
+
+    X_np = np.array(
+        [[1, 2, 3, np.nan, np.nan], [np.nan, np.nan, 8, 4, 6], [1, 2, 3, 4, 5]]
+    ).T
+
+    # Creates dataframe with numerical extension arrays with pd.NA
+    X = pd.DataFrame(X_np, dtype=pd_dtype, columns=["a", "b", "c"])
+    # column c has no nans
+    X["c"] = X["c"].astype("float")
+    X_checked = check_array(X, ensure_all_finite="allow-nan", dtype=dtype)
+    assert_allclose(X_checked, X_np)
+    assert X_checked.dtype == expected_dtype
+
+    X_checked = check_array(X, ensure_all_finite=False, dtype=dtype)
+    assert_allclose(X_checked, X_np)
+    assert X_checked.dtype == expected_dtype
+
+    msg = "Input contains NaN"
+    with pytest.raises(ValueError, match=msg):
+        check_array(X, ensure_all_finite=True)
+
+
+def test_check_array_panadas_na_support_series():
+    """Check check_array is correct with pd.NA in a series."""
+    pd = pytest.importorskip("pandas")
+
+    X_int64 = pd.Series([1, 2, pd.NA], dtype="Int64")
+
+    msg = "Input contains NaN"
+    with pytest.raises(ValueError, match=msg):
+        check_array(X_int64, ensure_all_finite=True, ensure_2d=False)
+
+    X_out = check_array(X_int64, ensure_all_finite=False, ensure_2d=False)
+    assert_allclose(X_out, [1, 2, np.nan])
+    assert X_out.dtype == np.float64
+
+    X_out = check_array(
+        X_int64, ensure_all_finite=False, ensure_2d=False, dtype=np.float32
+    )
+    assert_allclose(X_out, [1, 2, np.nan])
+    assert X_out.dtype == np.float32
+
+
+def test_check_array_pandas_dtype_casting():
+    # test that data-frames with homogeneous dtype are not upcast
+    pd = pytest.importorskip("pandas")
+    X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+    X_df = pd.DataFrame(X)
+    assert check_array(X_df).dtype == np.float32
+    assert check_array(X_df, dtype=FLOAT_DTYPES).dtype == np.float32
+
+    X_df = X_df.astype({0: np.float16})
+    assert_array_equal(X_df.dtypes, (np.float16, np.float32, np.float32))
+    assert check_array(X_df).dtype == np.float32
+    assert check_array(X_df, dtype=FLOAT_DTYPES).dtype == np.float32
+
+    X_df = X_df.astype({0: np.int16})
+    # float16, int16, float32 casts to float32
+    assert check_array(X_df).dtype == np.float32
+    assert check_array(X_df, dtype=FLOAT_DTYPES).dtype == np.float32
+
+    X_df = X_df.astype({2: np.float16})
+    # float16, int16, float16 casts to float32
+    assert check_array(X_df).dtype == np.float32
+    assert check_array(X_df, dtype=FLOAT_DTYPES).dtype == np.float32
+
+    X_df = X_df.astype(np.int16)
+    assert check_array(X_df).dtype == np.int16
+    # we're not using upcasting rules for determining
+    # the target type yet, so we cast to the default of float64
+    assert check_array(X_df, dtype=FLOAT_DTYPES).dtype == np.float64
+
+    # check that we handle pandas dtypes in a semi-reasonable way
+    # this is actually tricky because we can't really know that this
+    # should be integer ahead of converting it.
+    cat_df = pd.DataFrame({"cat_col": pd.Categorical([1, 2, 3])})
+    assert check_array(cat_df).dtype == np.int64
+    assert check_array(cat_df, dtype=FLOAT_DTYPES).dtype == np.float64
+
+
+def test_check_array_on_mock_dataframe():
+    arr = np.array([[0.2, 0.7], [0.6, 0.5], [0.4, 0.1], [0.7, 0.2]])
+    mock_df = MockDataFrame(arr)
+    checked_arr = check_array(mock_df)
+    assert checked_arr.dtype == arr.dtype
+    checked_arr = check_array(mock_df, dtype=np.float32)
+    assert checked_arr.dtype == np.dtype(np.float32)
+
+
+def test_check_array_dtype_stability():
+    # test that lists with ints don't get converted to floats
+    X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    assert check_array(X).dtype.kind == "i"
+    assert check_array(X, ensure_2d=False).dtype.kind == "i"
+
+
+def test_check_array_dtype_warning():
+    X_int_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    X_float32 = np.asarray(X_int_list, dtype=np.float32)
+    X_int64 = np.asarray(X_int_list, dtype=np.int64)
+    X_csr_float32 = sp.csr_matrix(X_float32)
+    X_csc_float32 = sp.csc_matrix(X_float32)
+    X_csc_int32 = sp.csc_matrix(X_int64, dtype=np.int32)
+    integer_data = [X_int64, X_csc_int32]
+    float32_data = [X_float32, X_csr_float32, X_csc_float32]
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        for X in integer_data:
+            X_checked = check_array(X, dtype=np.float64, accept_sparse=True)
+            assert X_checked.dtype == np.float64
+
+        for X in float32_data:
+            X_checked = check_array(
+                X, dtype=[np.float64, np.float32], accept_sparse=True
+            )
+            assert X_checked.dtype == np.float32
+            assert X_checked is X
+
+            X_checked = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                accept_sparse=["csr", "dok"],
+                copy=True,
+            )
+            assert X_checked.dtype == np.float32
+            assert X_checked is not X
+
+        X_checked = check_array(
+            X_csc_float32,
+            dtype=[np.float64, np.float32],
+            accept_sparse=["csr", "dok"],
+            copy=False,
+        )
+        assert X_checked.dtype == np.float32
+        assert X_checked is not X_csc_float32
+        assert X_checked.format == "csr"
+
+
+def test_check_array_accept_sparse_type_exception():
+    X = [[1, 2], [3, 4]]
+    X_csr = sp.csr_matrix(X)
+    invalid_type = SVR()
+
+    msg = (
+        "Sparse data was passed, but dense data is required. "
+        r"Use '.toarray\(\)' to convert to a dense numpy array."
+    )
+    with pytest.raises(TypeError, match=msg):
+        check_array(X_csr, accept_sparse=False)
+
+    msg = (
+        "Parameter 'accept_sparse' should be a string, "
+        "boolean or list of strings. You provided 'accept_sparse=.*'."
+    )
+    with pytest.raises(ValueError, match=msg):
+        check_array(X_csr, accept_sparse=invalid_type)
+
+    msg = (
+        "When providing 'accept_sparse' as a tuple or list, "
+        "it must contain at least one string value."
+    )
+    with pytest.raises(ValueError, match=msg):
+        check_array(X_csr, accept_sparse=[])
+    with pytest.raises(ValueError, match=msg):
+        check_array(X_csr, accept_sparse=())
+    with pytest.raises(TypeError, match="SVR"):
+        check_array(X_csr, accept_sparse=[invalid_type])
+
+
+def test_check_array_accept_sparse_no_exception():
+    X = [[1, 2], [3, 4]]
+    X_csr = sp.csr_matrix(X)
+
+    check_array(X_csr, accept_sparse=True)
+    check_array(X_csr, accept_sparse="csr")
+    check_array(X_csr, accept_sparse=["csr"])
+    check_array(X_csr, accept_sparse=("csr",))
+
+
+@pytest.fixture(params=["csr", "csc", "coo", "bsr"])
+def X_64bit(request):
+    X = sp.random(20, 10, format=request.param)
+
+    if request.param == "coo":
+        if hasattr(X, "coords"):
+            # for scipy >= 1.13 .coords is a new attribute and is a tuple. The
+            # .col and .row attributes do not seem to be able to change the
+            # dtype, for more details see https://github.com/scipy/scipy/pull/18530/
+            # and https://github.com/scipy/scipy/pull/20003 where .indices was
+            # renamed to .coords
+            X.coords = tuple(v.astype("int64") for v in X.coords)
+        else:
+            # scipy < 1.13
+            X.row = X.row.astype("int64")
+            X.col = X.col.astype("int64")
+    else:
+        X.indices = X.indices.astype("int64")
+        X.indptr = X.indptr.astype("int64")
+
+    yield X
+
+
+def test_check_array_accept_large_sparse_no_exception(X_64bit):
+    # When large sparse are allowed
+    check_array(X_64bit, accept_large_sparse=True, accept_sparse=True)
+
+
+def test_check_array_accept_large_sparse_raise_exception(X_64bit):
+    # When large sparse are not allowed
+    msg = (
+        "Only sparse matrices with 32-bit integer indices "
+        "are accepted. Got int64 indices. Please do report"
+    )
+    with pytest.raises(ValueError, match=msg):
+        check_array(X_64bit, accept_sparse=True, accept_large_sparse=False)
+
+
+def test_check_array_min_samples_and_features_messages():
+    # empty list is considered 2D by default:
+    msg = r"0 feature\(s\) \(shape=\(1, 0\)\) while a minimum of 1 is required."
+    with pytest.raises(ValueError, match=msg):
+        check_array([[]])
+
+    # If considered a 1D collection when ensure_2d=False, then the minimum
+    # number of samples will break:
+    msg = r"0 sample\(s\) \(shape=\(0,\)\) while a minimum of 1 is required."
+    with pytest.raises(ValueError, match=msg):
+        check_array([], ensure_2d=False)
+
+    # Invalid edge case when checking the default minimum sample of a scalar
+    msg = re.escape(
+        (
+            "Input should have at least 1 dimension i.e. satisfy "
+            "`len(x.shape) > 0`, got scalar `array(42)` instead."
+        )
+    )
+    with pytest.raises(TypeError, match=msg):
+        check_array(42, ensure_2d=False)
+
+    # Simulate a model that would need at least 2 samples to be well defined
+    X = np.ones((1, 10))
+    y = np.ones(1)
+    msg = r"1 sample\(s\) \(shape=\(1, 10\)\) while a minimum of 2 is required."
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y, ensure_min_samples=2)
+
+    # The same message is raised if the data has 2 dimensions even if this is
+    # not mandatory
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y, ensure_min_samples=2, ensure_2d=False)
+
+    # Simulate a model that would require at least 3 features (e.g. SelectKBest
+    # with k=3)
+    X = np.ones((10, 2))
+    y = np.ones(2)
+    msg = r"2 feature\(s\) \(shape=\(10, 2\)\) while a minimum of 3 is required."
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y, ensure_min_features=3)
+
+    # Only the feature check is enabled whenever the number of dimensions is 2
+    # even if allow_nd is enabled:
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y, ensure_min_features=3, allow_nd=True)
+
+    # Simulate a case where a pipeline stage as trimmed all the features of a
+    # 2D dataset.
+    X = np.empty(0).reshape(10, 0)
+    y = np.ones(10)
+    msg = r"0 feature\(s\) \(shape=\(10, 0\)\) while a minimum of 1 is required."
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y)
+
+    # nd-data is not checked for any minimum number of features by default:
+    X = np.ones((10, 0, 28, 28))
+    y = np.ones(10)
+    X_checked, y_checked = check_X_y(X, y, allow_nd=True)
+    assert_array_equal(X, X_checked)
+    assert_array_equal(y, y_checked)
+
+
+def test_check_array_complex_data_error():
+    X = np.array([[1 + 2j, 3 + 4j, 5 + 7j], [2 + 3j, 4 + 5j, 6 + 7j]])
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # list of lists
+    X = [[1 + 2j, 3 + 4j, 5 + 7j], [2 + 3j, 4 + 5j, 6 + 7j]]
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # tuple of tuples
+    X = ((1 + 2j, 3 + 4j, 5 + 7j), (2 + 3j, 4 + 5j, 6 + 7j))
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # list of np arrays
+    X = [np.array([1 + 2j, 3 + 4j, 5 + 7j]), np.array([2 + 3j, 4 + 5j, 6 + 7j])]
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # tuple of np arrays
+    X = (np.array([1 + 2j, 3 + 4j, 5 + 7j]), np.array([2 + 3j, 4 + 5j, 6 + 7j]))
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # dataframe
+    X = MockDataFrame(np.array([[1 + 2j, 3 + 4j, 5 + 7j], [2 + 3j, 4 + 5j, 6 + 7j]]))
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # sparse matrix
+    X = sp.coo_matrix([[0, 1 + 2j], [0, 0]])
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        check_array(X)
+
+    # target variable does not always go through check_array but should
+    # never accept complex data either.
+    y = np.array([1 + 2j, 3 + 4j, 5 + 7j, 2 + 3j, 4 + 5j, 6 + 7j])
+    with pytest.raises(ValueError, match="Complex data not supported"):
+        _check_y(y)
+
+
+def test_has_fit_parameter():
+    assert not has_fit_parameter(KNeighborsClassifier, "sample_weight")
+    assert has_fit_parameter(RandomForestRegressor, "sample_weight")
+    assert has_fit_parameter(SVR, "sample_weight")
+    assert has_fit_parameter(SVR(), "sample_weight")
+
+    class TestClassWithDeprecatedFitMethod:
+        @deprecated("Deprecated for the purpose of testing has_fit_parameter")
+        def fit(self, X, y, sample_weight=None):
+            pass
+
+    assert has_fit_parameter(TestClassWithDeprecatedFitMethod, "sample_weight"), (
+        "has_fit_parameter fails for class with deprecated fit method."
+    )
+
+
+def test_check_symmetric():
+    arr_sym = np.array([[0, 1], [1, 2]])
+    arr_bad = np.ones(2)
+    arr_asym = np.array([[0, 2], [0, 2]])
+
+    test_arrays = {
+        "dense": arr_asym,
+        "dok": sp.dok_matrix(arr_asym),
+        "csr": sp.csr_matrix(arr_asym),
+        "csc": sp.csc_matrix(arr_asym),
+        "coo": sp.coo_matrix(arr_asym),
+        "lil": sp.lil_matrix(arr_asym),
+        "bsr": sp.bsr_matrix(arr_asym),
+    }
+
+    # check error for bad inputs
+    with pytest.raises(ValueError):
+        check_symmetric(arr_bad)
+
+    # check that asymmetric arrays are properly symmetrized
+    for arr_format, arr in test_arrays.items():
+        # Check for warnings and errors
+        with pytest.warns(UserWarning):
+            check_symmetric(arr)
+        with pytest.raises(ValueError):
+            check_symmetric(arr, raise_exception=True)
+
+        output = check_symmetric(arr, raise_warning=False)
+        if sp.issparse(output):
+            assert output.format == arr_format
+            assert_array_equal(output.toarray(), arr_sym)
+        else:
+            assert_array_equal(output, arr_sym)
+
+
+def test_check_is_fitted_with_is_fitted():
+    class Estimator(BaseEstimator):
+        def fit(self, **kwargs):
+            self._is_fitted = True
+            return self
+
+        def __sklearn_is_fitted__(self):
+            return hasattr(self, "_is_fitted") and self._is_fitted
+
+    with pytest.raises(NotFittedError):
+        check_is_fitted(Estimator())
+    check_is_fitted(Estimator().fit())
+
+
+def test_check_is_fitted_stateless():
+    """Check that check_is_fitted passes for stateless estimators."""
+
+    class StatelessEstimator(BaseEstimator):
+        def fit(self, **kwargs):
+            return self  # pragma: no cover
+
+        def __sklearn_tags__(self):
+            tags = super().__sklearn_tags__()
+            tags.requires_fit = False
+            return tags
+
+    check_is_fitted(StatelessEstimator())
+
+
+def test_check_is_fitted():
+    # Check is TypeError raised when non estimator instance passed
+    with pytest.raises(TypeError):
+        check_is_fitted(ARDRegression)
+    with pytest.raises(TypeError):
+        check_is_fitted("SVR")
+
+    ard = ARDRegression()
+    svr = SVR()
+
+    try:
+        with pytest.raises(NotFittedError):
+            check_is_fitted(ard)
+        with pytest.raises(NotFittedError):
+            check_is_fitted(svr)
+    except ValueError:
+        assert False, "check_is_fitted failed with ValueError"
+
+    # NotFittedError is a subclass of both ValueError and AttributeError
+    msg = "Random message %(name)s, %(name)s"
+    match = "Random message ARDRegression, ARDRegression"
+    with pytest.raises(ValueError, match=match):
+        check_is_fitted(ard, msg=msg)
+
+    msg = "Another message %(name)s, %(name)s"
+    match = "Another message SVR, SVR"
+    with pytest.raises(AttributeError, match=match):
+        check_is_fitted(svr, msg=msg)
+
+    ard.fit(*make_blobs())
+    svr.fit(*make_blobs())
+
+    assert check_is_fitted(ard) is None
+    assert check_is_fitted(svr) is None
+
+
+def test_check_is_fitted_attributes():
+    class MyEstimator(BaseEstimator):
+        def fit(self, X, y):
+            return self
+
+    msg = "not fitted"
+    est = MyEstimator()
+
+    assert not _is_fitted(est, attributes=["a_", "b_"])
+    with pytest.raises(NotFittedError, match=msg):
+        check_is_fitted(est, attributes=["a_", "b_"])
+    assert not _is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    with pytest.raises(NotFittedError, match=msg):
+        check_is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    assert not _is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+    with pytest.raises(NotFittedError, match=msg):
+        check_is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+
+    est.a_ = "a"
+    assert not _is_fitted(est, attributes=["a_", "b_"])
+    with pytest.raises(NotFittedError, match=msg):
+        check_is_fitted(est, attributes=["a_", "b_"])
+    assert not _is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    with pytest.raises(NotFittedError, match=msg):
+        check_is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    assert _is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+    check_is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+
+    est.b_ = "b"
+    assert _is_fitted(est, attributes=["a_", "b_"])
+    check_is_fitted(est, attributes=["a_", "b_"])
+    assert _is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    check_is_fitted(est, attributes=["a_", "b_"], all_or_any=all)
+    assert _is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+    check_is_fitted(est, attributes=["a_", "b_"], all_or_any=any)
+
+
+@pytest.mark.parametrize(
+    "wrap", [itemgetter(0), list, tuple], ids=["single", "list", "tuple"]
+)
+def test_check_is_fitted_with_attributes(wrap):
+    ard = ARDRegression()
+    with pytest.raises(NotFittedError, match="is not fitted yet"):
+        check_is_fitted(ard, wrap(["coef_"]))
+
+    ard.fit(*make_blobs())
+
+    # Does not raise
+    check_is_fitted(ard, wrap(["coef_"]))
+
+    # Raises when using attribute that is not defined
+    with pytest.raises(NotFittedError, match="is not fitted yet"):
+        check_is_fitted(ard, wrap(["coef_bad_"]))
+
+
+def test_check_consistent_length():
+    """Test that `check_consistent_length` raises on inconsistent lengths and wrong
+    input types trigger TypeErrors."""
+    check_consistent_length([1], [2], [3], [4], [5])
+    check_consistent_length([[1, 2], [[1, 2]]], [1, 2], ["a", "b"])
+    check_consistent_length([1], (2,), np.array([3]), sp.csr_matrix((1, 2)))
+    with pytest.raises(ValueError, match="inconsistent numbers of samples"):
+        check_consistent_length([1, 2], [1])
+    with pytest.raises(TypeError, match=r"got <\w+ 'int'>"):
+        check_consistent_length([1, 2], 1)
+    with pytest.raises(TypeError, match=r"got <\w+ 'object'>"):
+        check_consistent_length([1, 2], object())
+    with pytest.raises(TypeError):
+        check_consistent_length([1, 2], np.array(1))
+    # Despite ensembles having __len__ they must raise TypeError
+    with pytest.raises(TypeError, match="Expected sequence or array-like"):
+        check_consistent_length([1, 2], RandomForestRegressor())
+    # XXX: We should have a test with a string, but what is correct behaviour?
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, _",
+    yield_namespace_device_dtype_combinations(),
+    ids=_get_namespace_device_dtype_ids,
+)
+def test_check_consistent_length_array_api(array_namespace, device, _):
+    """Test that check_consistent_length works with different array types."""
+    xp = _array_api_for_tests(array_namespace, device)
+
+    with config_context(array_api_dispatch=True):
+        check_consistent_length(
+            xp.asarray([1, 2, 3], device=device),
+            xp.asarray([[1, 1], [2, 2], [3, 3]], device=device),
+            [1, 2, 3],
+            ["a", "b", "c"],
+            np.asarray(("a", "b", "c"), dtype=object),
+            sp.csr_array([[0, 1], [1, 0], [0, 0]]),
+        )
+
+        with pytest.raises(ValueError, match="inconsistent numbers of samples"):
+            check_consistent_length(
+                xp.asarray([1, 2], device=device), xp.asarray([1], device=device)
+            )
+
+
+def test_check_dataframe_fit_attribute():
+    # check pandas dataframe with 'fit' column does not raise error
+    # https://github.com/scikit-learn/scikit-learn/issues/8415
+    try:
+        import pandas as pd
+
+        X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        X_df = pd.DataFrame(X, columns=["a", "b", "fit"])
+        check_consistent_length(X_df)
+    except ImportError:
+        raise SkipTest("Pandas not found")
+
+
+def test_suppress_validation():
+    X = np.array([0, np.inf])
+    with pytest.raises(ValueError):
+        assert_all_finite(X)
+    sklearn.set_config(assume_finite=True)
+    assert_all_finite(X)
+    sklearn.set_config(assume_finite=False)
+    with pytest.raises(ValueError):
+        assert_all_finite(X)
+
+
+def test_check_array_series():
+    # regression test that check_array works on pandas Series
+    pd = importorskip("pandas")
+    res = check_array(pd.Series([1, 2, 3]), ensure_2d=False)
+    assert_array_equal(res, np.array([1, 2, 3]))
+
+    # with categorical dtype (not a numpy dtype) (GH12699)
+    s = pd.Series(["a", "b", "c"]).astype("category")
+    res = check_array(s, dtype=None, ensure_2d=False)
+    assert_array_equal(res, np.array(["a", "b", "c"], dtype=object))
+
+
+@pytest.mark.parametrize(
+    "dtype", ((np.float64, np.float32), np.float64, None, "numeric")
+)
+@pytest.mark.parametrize("bool_dtype", ("bool", "boolean"))
+def test_check_dataframe_mixed_float_dtypes(dtype, bool_dtype):
+    # pandas dataframe will coerce a boolean into a object, this is a mismatch
+    # with np.result_type which will return a float
+    # check_array needs to explicitly check for bool dtype in a dataframe for
+    # this situation
+    # https://github.com/scikit-learn/scikit-learn/issues/15787
+
+    pd = importorskip("pandas")
+
+    df = pd.DataFrame(
+        {
+            "int": [1, 2, 3],
+            "float": [0, 0.1, 2.1],
+            "bool": pd.Series([True, False, True], dtype=bool_dtype),
+        },
+        columns=["int", "float", "bool"],
+    )
+
+    array = check_array(df, dtype=dtype)
+    assert array.dtype == np.float64
+    expected_array = np.array(
+        [[1.0, 0.0, 1.0], [2.0, 0.1, 0.0], [3.0, 2.1, 1.0]], dtype=float
+    )
+    assert_allclose_dense_sparse(array, expected_array)
+
+
+def test_check_dataframe_with_only_bool():
+    """Check that dataframe with bool return a boolean arrays."""
+    pd = importorskip("pandas")
+    df = pd.DataFrame({"bool": [True, False, True]})
+
+    array = check_array(df, dtype=None)
+    assert array.dtype == np.bool_
+    assert_array_equal(array, [[True], [False], [True]])
+
+    # common dtype is int for bool + int
+    df = pd.DataFrame(
+        {"bool": [True, False, True], "int": [1, 2, 3]},
+        columns=["bool", "int"],
+    )
+    array = check_array(df, dtype="numeric")
+    assert array.dtype == np.int64
+    assert_array_equal(array, [[1, 1], [0, 2], [1, 3]])
+
+
+def test_check_dataframe_with_only_boolean():
+    """Check that dataframe with boolean return a float array with dtype=None"""
+    pd = importorskip("pandas")
+    df = pd.DataFrame({"bool": pd.Series([True, False, True], dtype="boolean")})
+
+    array = check_array(df, dtype=None)
+    assert array.dtype == np.float64
+    assert_array_equal(array, [[True], [False], [True]])
+
+
+class DummyMemory:
+    def cache(self, func):
+        return func
+
+
+class WrongDummyMemory:
+    pass
+
+
+def test_check_memory(tmp_path):
+    cache_directory = str(tmp_path / "cache_directory")
+    memory = check_memory(cache_directory)
+    assert memory.location == cache_directory
+
+    memory = check_memory(None)
+    assert memory.location is None
+
+    dummy = DummyMemory()
+    memory = check_memory(dummy)
+    assert memory is dummy
+
+    msg = (
+        "'memory' should be None, a string or have the same interface as"
+        " joblib.Memory. Got memory='1' instead."
+    )
+    with pytest.raises(ValueError, match=msg):
+        check_memory(1)
+    dummy = WrongDummyMemory()
+    msg = (
+        "'memory' should be None, a string or have the same interface as"
+        " joblib.Memory. Got memory='{}' instead.".format(dummy)
+    )
+    with pytest.raises(ValueError, match=msg):
+        check_memory(dummy)
+
+
+@pytest.mark.parametrize("copy", [True, False])
+def test_check_array_memmap(copy):
+    X = np.ones((4, 4))
+    with TempMemmap(X, mmap_mode="r") as X_memmap:
+        X_checked = check_array(X_memmap, copy=copy)
+        assert np.may_share_memory(X_memmap, X_checked) == (not copy)
+        assert X_checked.flags["WRITEABLE"] == copy
+
+
+@pytest.mark.parametrize(
+    "estimator_name, estimator_value, delegates, expected_result, expected_exception",
+    [
+        (
+            "estimator_",
+            type("SubEstimator", (), {"attribute_present": True}),
+            None,  # default delegates - ["estimator_", "estimator"]
+            True,  # expected_result is True b/c delegate and attribute are present
+            None,  # expected_exception not relevant for this case
+        ),
+        (
+            "estimator",
+            type("SubEstimator", (), {"attribute_present": True}),
+            None,  # default delegates - ["estimator_", "estimator"]
+            True,  # expected_result is True b/c delegate and attribute are present
+            None,  # expected_exception not relevant for this case
+        ),
+        (
+            "estimators_",
+            [
+                type("SubEstimator", (), {"attribute_present": True})
+            ],  # list of sub-estimators
+            ["estimators_"],
+            True,  # expected_result is True b/c delegate and attribute are present
+            None,  # expected_exception not relevant for this case
+        ),
+        (
+            "custom_estimator",  # custom estimator attribute name
+            type("SubEstimator", (), {"attribute_present": True}),
+            ["custom_estimator"],  # custom delegates
+            True,  # expected_result is True b/c delegate and attribute are present
+            None,  # expected_exception not relevant for this case
+        ),
+        (
+            "no_estimator",  # no estimator attribute name
+            type("SubEstimator", (), {"attribute_present": True}),
+            None,  # default delegates - ["estimator_", "estimator"]
+            None,  # expected_result is not relevant for this case
+            ValueError,  # should raise ValueError b/c no estimator found from delegates
+        ),
+        (
+            "estimator",
+            type("SubEstimator", (), {"attribute_absent": True}),  # attribute_absent
+            None,  # default delegates - ["estimator_", "estimator"]
+            None,  # expected_result is not relevant for this case
+            AttributeError,  # should raise AttributeError b/c attribute is absent
+        ),
+    ],
+    ids=[
+        "fitted_estimator_with_default_delegates",
+        "estimator_with_default_delegates",
+        "list_of_estimators_with_estimators_",
+        "custom_estimator_with_custom_delegates",
+        "no_estimator_with_default_delegates",
+        "estimator_with_default_delegates_but_absent_attribute",
+    ],
+)
+def test_estimator_has(
+    estimator_name, estimator_value, delegates, expected_result, expected_exception
+):
+    """
+    Tests the _estimator_has function by verifying:
+    - Functionality with default and custom delegates.
+    - Raises ValueError if delegates are missing.
+    - Raises AttributeError if the specified attribute is missing.
+    """
+
+    # always checks for attribute - "attribute_present"
+    # ["estimator_", "estimator"] is default value for delegates
+    if delegates is None:
+        check = _estimator_has("attribute_present")
+    else:
+        check = _estimator_has("attribute_present", delegates=delegates)
+
+    class MockEstimator:
+        pass
+
+    a = MockEstimator()
+    setattr(a, estimator_name, estimator_value)
+
+    if expected_exception:
+        with pytest.raises(expected_exception):
+            check(a)
+    else:
+        assert check(a) == expected_result
+
+
+@pytest.mark.parametrize(
+    "retype",
+    [
+        np.asarray,
+        sp.csr_matrix,
+        sp.csc_matrix,
+        sp.coo_matrix,
+        sp.lil_matrix,
+        sp.bsr_matrix,
+        sp.dok_matrix,
+        sp.dia_matrix,
+    ],
+)
+def test_check_non_negative(retype):
+    A = np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
+    X = retype(A)
+    check_non_negative(X, "")
+    X = retype([[0, 0], [0, 0]])
+    check_non_negative(X, "")
+
+    A[0, 0] = -1
+    X = retype(A)
+    with pytest.raises(ValueError, match="Negative "):
+        check_non_negative(X, "")
+
+
+def test_check_X_y_informative_error():
+    X = np.ones((2, 2))
+    y = None
+    msg = "estimator requires y to be passed, but the target y is None"
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y)
+
+    msg = "RandomForestRegressor requires y to be passed, but the target y is None"
+    with pytest.raises(ValueError, match=msg):
+        check_X_y(X, y, estimator=RandomForestRegressor())
+
+
+def test_retrieve_samples_from_non_standard_shape():
+    class TestNonNumericShape:
+        def __init__(self):
+            self.shape = ("not numeric",)
+
+        def __len__(self):
+            return len([1, 2, 3])
+
+    X = TestNonNumericShape()
+    assert _num_samples(X) == len(X)
+
+    # check that it gives a good error if there's no __len__
+    class TestNoLenWeirdShape:
+        def __init__(self):
+            self.shape = ("not numeric",)
+
+    with pytest.raises(TypeError, match="Expected sequence or array-like"):
+        _num_samples(TestNoLenWeirdShape())
+
+
+@pytest.mark.parametrize("x", [2, 3, 2.5, 5])
+def test_check_scalar_valid(x):
+    """Test that check_scalar returns no error/warning if valid inputs are
+    provided"""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        scalar = check_scalar(
+            x,
+            "test_name",
+            target_type=numbers.Real,
+            min_val=2,
+            max_val=5,
+            include_boundaries="both",
+        )
+    assert scalar == x
+
+
+@pytest.mark.parametrize(
+    "x, target_name, target_type, min_val, max_val, include_boundaries, err_msg",
+    [
+        (
+            1,
+            "test_name1",
+            float,
+            2,
+            4,
+            "neither",
+            TypeError("test_name1 must be an instance of float, not int."),
+        ),
+        (
+            None,
+            "test_name1",
+            numbers.Real,
+            2,
+            4,
+            "neither",
+            TypeError("test_name1 must be an instance of float, not NoneType."),
+        ),
+        (
+            None,
+            "test_name1",
+            numbers.Integral,
+            2,
+            4,
+            "neither",
+            TypeError("test_name1 must be an instance of int, not NoneType."),
+        ),
+        (
+            1,
+            "test_name1",
+            (float, bool),
+            2,
+            4,
+            "neither",
+            TypeError("test_name1 must be an instance of {float, bool}, not int."),
+        ),
+        (
+            1,
+            "test_name2",
+            int,
+            2,
+            4,
+            "neither",
+            ValueError("test_name2 == 1, must be > 2."),
+        ),
+        (
+            5,
+            "test_name3",
+            int,
+            2,
+            4,
+            "neither",
+            ValueError("test_name3 == 5, must be < 4."),
+        ),
+        (
+            2,
+            "test_name4",
+            int,
+            2,
+            4,
+            "right",
+            ValueError("test_name4 == 2, must be > 2."),
+        ),
+        (
+            4,
+            "test_name5",
+            int,
+            2,
+            4,
+            "left",
+            ValueError("test_name5 == 4, must be < 4."),
+        ),
+        (
+            4,
+            "test_name6",
+            int,
+            2,
+            4,
+            "bad parameter value",
+            ValueError(
+                "Unknown value for `include_boundaries`: 'bad parameter value'. "
+                "Possible values are: ('left', 'right', 'both', 'neither')."
+            ),
+        ),
+        (
+            4,
+            "test_name7",
+            int,
+            None,
+            4,
+            "left",
+            ValueError(
+                "`include_boundaries`='left' without specifying explicitly `min_val` "
+                "is inconsistent."
+            ),
+        ),
+        (
+            4,
+            "test_name8",
+            int,
+            2,
+            None,
+            "right",
+            ValueError(
+                "`include_boundaries`='right' without specifying explicitly `max_val` "
+                "is inconsistent."
+            ),
+        ),
+    ],
+)
+def test_check_scalar_invalid(
+    x, target_name, target_type, min_val, max_val, include_boundaries, err_msg
+):
+    """Test that check_scalar returns the right error if a wrong input is
+    given"""
+    with pytest.raises(Exception) as raised_error:
+        check_scalar(
+            x,
+            target_name,
+            target_type=target_type,
+            min_val=min_val,
+            max_val=max_val,
+            include_boundaries=include_boundaries,
+        )
+    assert str(raised_error.value) == str(err_msg)
+    assert isinstance(raised_error.value, type(err_msg))
+
+
+_psd_cases_valid = {
+    "nominal": ((1, 2), np.array([1, 2]), None, ""),
+    "nominal_np_array": (np.array([1, 2]), np.array([1, 2]), None, ""),
+    "insignificant_imag": (
+        (5, 5e-5j),
+        np.array([5, 0]),
+        PositiveSpectrumWarning,
+        "There are imaginary parts in eigenvalues \\(1e\\-05 of the maximum real part",
+    ),
+    "insignificant neg": ((5, -5e-5), np.array([5, 0]), PositiveSpectrumWarning, ""),
+    "insignificant neg float32": (
+        np.array([1, -1e-6], dtype=np.float32),
+        np.array([1, 0], dtype=np.float32),
+        PositiveSpectrumWarning,
+        "There are negative eigenvalues \\(1e\\-06 of the maximum positive",
+    ),
+    "insignificant neg float64": (
+        np.array([1, -1e-10], dtype=np.float64),
+        np.array([1, 0], dtype=np.float64),
+        PositiveSpectrumWarning,
+        "There are negative eigenvalues \\(1e\\-10 of the maximum positive",
+    ),
+    "insignificant pos": (
+        (5, 4e-12),
+        np.array([5, 0]),
+        PositiveSpectrumWarning,
+        "the largest eigenvalue is more than 1e\\+12 times the smallest",
+    ),
+}
+
+
+@pytest.mark.parametrize(
+    "lambdas, expected_lambdas, w_type, w_msg",
+    list(_psd_cases_valid.values()),
+    ids=list(_psd_cases_valid.keys()),
+)
+@pytest.mark.parametrize("enable_warnings", [True, False])
+def test_check_psd_eigenvalues_valid(
+    lambdas, expected_lambdas, w_type, w_msg, enable_warnings
+):
+    # Test that ``_check_psd_eigenvalues`` returns the right output for valid
+    # input, possibly raising the right warning
+
+    if not enable_warnings:
+        w_type = None
+
+    if w_type is None:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", PositiveSpectrumWarning)
+            lambdas_fixed = _check_psd_eigenvalues(
+                lambdas, enable_warnings=enable_warnings
+            )
+    else:
+        with pytest.warns(w_type, match=w_msg):
+            lambdas_fixed = _check_psd_eigenvalues(
+                lambdas, enable_warnings=enable_warnings
+            )
+
+    assert_allclose(expected_lambdas, lambdas_fixed)
+
+
+_psd_cases_invalid = {
+    "significant_imag": (
+        (5, 5j),
+        ValueError,
+        "There are significant imaginary parts in eigenv",
+    ),
+    "all negative": (
+        (-5, -1),
+        ValueError,
+        "All eigenvalues are negative \\(maximum is -1",
+    ),
+    "significant neg": (
+        (5, -1),
+        ValueError,
+        "There are significant negative eigenvalues",
+    ),
+    "significant neg float32": (
+        np.array([3e-4, -2e-6], dtype=np.float32),
+        ValueError,
+        "There are significant negative eigenvalues",
+    ),
+    "significant neg float64": (
+        np.array([1e-5, -2e-10], dtype=np.float64),
+        ValueError,
+        "There are significant negative eigenvalues",
+    ),
+}
+
+
+@pytest.mark.parametrize(
+    "lambdas, err_type, err_msg",
+    list(_psd_cases_invalid.values()),
+    ids=list(_psd_cases_invalid.keys()),
+)
+def test_check_psd_eigenvalues_invalid(lambdas, err_type, err_msg):
+    # Test that ``_check_psd_eigenvalues`` raises the right error for invalid
+    # input
+
+    with pytest.raises(err_type, match=err_msg):
+        _check_psd_eigenvalues(lambdas)
+
+
+def test_check_sample_weight():
+    # check array order
+    sample_weight = np.ones(10)[::2]
+    assert not sample_weight.flags["C_CONTIGUOUS"]
+    sample_weight = _check_sample_weight(sample_weight, X=np.ones((5, 1)))
+    assert sample_weight.flags["C_CONTIGUOUS"]
+
+    # check None input
+    sample_weight = _check_sample_weight(None, X=np.ones((5, 2)))
+    assert_allclose(sample_weight, np.ones(5))
+
+    # check numbers input
+    sample_weight = _check_sample_weight(2.0, X=np.ones((5, 2)))
+    assert_allclose(sample_weight, 2 * np.ones(5))
+
+    # check wrong number of dimensions
+    with pytest.raises(ValueError, match="Sample weights must be 1D array or scalar"):
+        _check_sample_weight(np.ones((2, 4)), X=np.ones((2, 2)))
+
+    # check incorrect n_samples
+    msg = r"sample_weight.shape == \(4,\), expected \(2,\)!"
+    with pytest.raises(ValueError, match=msg):
+        _check_sample_weight(np.ones(4), X=np.ones((2, 2)))
+
+    # float32 dtype is preserved
+    X = np.ones((5, 2))
+    sample_weight = np.ones(5, dtype=np.float32)
+    sample_weight = _check_sample_weight(sample_weight, X)
+    assert sample_weight.dtype == np.float32
+
+    # int dtype will be converted to float64 instead
+    X = np.ones((5, 2), dtype=int)
+    sample_weight = _check_sample_weight(None, X, dtype=X.dtype)
+    assert sample_weight.dtype == np.float64
+
+    # check negative weight when ensure_non_negative=True
+    X = np.ones((5, 2))
+    sample_weight = np.ones(_num_samples(X))
+    sample_weight[-1] = -10
+    err_msg = "Negative values in data passed to `sample_weight`"
+    with pytest.raises(ValueError, match=err_msg):
+        _check_sample_weight(sample_weight, X, ensure_non_negative=True)
+
+
+@pytest.mark.parametrize("toarray", [np.array, sp.csr_matrix, sp.csc_matrix])
+def test_allclose_dense_sparse_equals(toarray):
+    base = np.arange(9).reshape(3, 3)
+    x, y = toarray(base), toarray(base)
+    assert _allclose_dense_sparse(x, y)
+
+
+@pytest.mark.parametrize("toarray", [np.array, sp.csr_matrix, sp.csc_matrix])
+def test_allclose_dense_sparse_not_equals(toarray):
+    base = np.arange(9).reshape(3, 3)
+    x, y = toarray(base), toarray(base + 1)
+    assert not _allclose_dense_sparse(x, y)
+
+
+@pytest.mark.parametrize("toarray", [sp.csr_matrix, sp.csc_matrix])
+def test_allclose_dense_sparse_raise(toarray):
+    x = np.arange(9).reshape(3, 3)
+    y = toarray(x + 1)
+
+    msg = "Can only compare two sparse matrices, not a sparse matrix and an array"
+    with pytest.raises(ValueError, match=msg):
+        _allclose_dense_sparse(x, y)
+
+
+def test_deprecate_positional_args_warns_for_function():
+    @_deprecate_positional_args
+    def f1(a, b, *, c=1, d=1):
+        pass
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3 as keyword args"):
+        f1(1, 2, 3)
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3, d=4 as keyword args"):
+        f1(1, 2, 3, 4)
+
+    @_deprecate_positional_args
+    def f2(a=1, *, b=1, c=1, d=1):
+        pass
+
+    with pytest.warns(FutureWarning, match=r"Pass b=2 as keyword args"):
+        f2(1, 2)
+
+    # The * is place before a keyword only argument without a default value
+    @_deprecate_positional_args
+    def f3(a, *, b, c=1, d=1):
+        pass
+
+    with pytest.warns(FutureWarning, match=r"Pass b=2 as keyword args"):
+        f3(1, 2)
+
+
+def test_deprecate_positional_args_warns_for_function_version():
+    @_deprecate_positional_args(version="1.1")
+    def f1(a, *, b):
+        pass
+
+    with pytest.warns(
+        FutureWarning, match=r"From version 1.1 passing these as positional"
+    ):
+        f1(1, 2)
+
+
+def test_deprecate_positional_args_warns_for_class():
+    class A1:
+        @_deprecate_positional_args
+        def __init__(self, a, b, *, c=1, d=1):
+            pass
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3 as keyword args"):
+        A1(1, 2, 3)
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3, d=4 as keyword args"):
+        A1(1, 2, 3, 4)
+
+    class A2:
+        @_deprecate_positional_args
+        def __init__(self, a=1, b=1, *, c=1, d=1):
+            pass
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3 as keyword args"):
+        A2(1, 2, 3)
+
+    with pytest.warns(FutureWarning, match=r"Pass c=3, d=4 as keyword args"):
+        A2(1, 2, 3, 4)
+
+
+@pytest.mark.parametrize("indices", [None, [1, 3]])
+def test_check_method_params(indices):
+    X = np.random.randn(4, 2)
+    _params = {
+        "list": [1, 2, 3, 4],
+        "array": np.array([1, 2, 3, 4]),
+        "sparse-col": sp.csc_matrix([1, 2, 3, 4]).T,
+        "sparse-row": sp.csc_matrix([1, 2, 3, 4]),
+        "scalar-int": 1,
+        "scalar-str": "xxx",
+        "None": None,
+    }
+    result = _check_method_params(X, params=_params, indices=indices)
+    indices_ = indices if indices is not None else list(range(X.shape[0]))
+
+    for key in ["sparse-row", "scalar-int", "scalar-str", "None"]:
+        assert result[key] is _params[key]
+
+    assert result["list"] == _safe_indexing(_params["list"], indices_)
+    assert_array_equal(result["array"], _safe_indexing(_params["array"], indices_))
+    assert_allclose_dense_sparse(
+        result["sparse-col"], _safe_indexing(_params["sparse-col"], indices_)
+    )
+
+
+@pytest.mark.parametrize("sp_format", [True, "csr", "csc", "coo", "bsr"])
+def test_check_sparse_pandas_sp_format(sp_format):
+    # check_array converts pandas dataframe with only sparse arrays into
+    # sparse matrix
+    pd = pytest.importorskip("pandas")
+    sp_mat = _sparse_random_matrix(10, 3)
+
+    sdf = pd.DataFrame.sparse.from_spmatrix(sp_mat)
+    result = check_array(sdf, accept_sparse=sp_format)
+
+    if sp_format is True:
+        # by default pandas converts to coo when accept_sparse is True
+        sp_format = "coo"
+
+    assert sp.issparse(result)
+    assert result.format == sp_format
+    assert_allclose_dense_sparse(sp_mat, result)
+
+
+@pytest.mark.parametrize(
+    "ntype1, ntype2",
+    [
+        ("longdouble", "float16"),
+        ("float16", "float32"),
+        ("float32", "double"),
+        ("int16", "int32"),
+        ("int32", "long"),
+        ("byte", "uint16"),
+        ("ushort", "uint32"),
+        ("uint32", "uint64"),
+        ("uint8", "int8"),
+    ],
+)
+def test_check_pandas_sparse_mixed_dtypes(ntype1, ntype2):
+    """Check that pandas dataframes having sparse extension arrays with mixed dtypes
+    works."""
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame(
+        {
+            "col1": pd.arrays.SparseArray([0, 1, 0], dtype=ntype1, fill_value=0),
+            "col2": pd.arrays.SparseArray([1, 0, 1], dtype=ntype2, fill_value=0),
+        }
+    )
+    check_array(df, accept_sparse=["csr", "csc"])
+
+
+@pytest.mark.parametrize(
+    "ntype1, ntype2, expected_subtype",
+    [
+        ("double", "longdouble", np.floating),
+        ("single", "float32", np.floating),
+        ("double", "float64", np.floating),
+        ("int8", "byte", np.integer),
+        ("short", "int16", np.integer),
+        ("intc", "int32", np.integer),
+        ("intp", "long", np.integer),
+        ("int", "long", np.integer),
+        ("int64", "longlong", np.integer),
+        ("int_", "intp", np.integer),
+        ("ubyte", "uint8", np.unsignedinteger),
+        ("uint16", "ushort", np.unsignedinteger),
+        ("uintc", "uint32", np.unsignedinteger),
+        ("uint", "uint64", np.unsignedinteger),
+        ("uintp", "ulonglong", np.unsignedinteger),
+    ],
+)
+def test_check_pandas_sparse_valid(ntype1, ntype2, expected_subtype):
+    # check that we support the conversion of sparse dataframe with mixed
+    # type which can be converted safely.
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame(
+        {
+            "col1": pd.arrays.SparseArray([0, 1, 0], dtype=ntype1, fill_value=0),
+            "col2": pd.arrays.SparseArray([1, 0, 1], dtype=ntype2, fill_value=0),
+        }
+    )
+    arr = check_array(df, accept_sparse=["csr", "csc"])
+    assert np.issubdtype(arr.dtype, expected_subtype)
+
+
+@pytest.mark.parametrize(
+    "constructor_name",
+    ["list", "tuple", "array", "dataframe", "sparse_csr", "sparse_csc"],
+)
+def test_num_features(constructor_name):
+    """Check _num_features for array-likes."""
+    X = [[1, 2, 3], [4, 5, 6]]
+    X = _convert_container(X, constructor_name)
+    assert _num_features(X) == 3
+
+
+@pytest.mark.parametrize(
+    "X",
+    [
+        [1, 2, 3],
+        ["a", "b", "c"],
+        [False, True, False],
+        [1.0, 3.4, 4.0],
+        [{"a": 1}, {"b": 2}, {"c": 3}],
+    ],
+    ids=["int", "str", "bool", "float", "dict"],
+)
+@pytest.mark.parametrize("constructor_name", ["list", "tuple", "array", "series"])
+def test_num_features_errors_1d_containers(X, constructor_name):
+    X = _convert_container(X, constructor_name)
+    if constructor_name == "array":
+        expected_type_name = "numpy.ndarray"
+    elif constructor_name == "series":
+        expected_type_name = "pandas.*Series"
+    else:
+        expected_type_name = constructor_name
+    message = (
+        f"Unable to find the number of features from X of type {expected_type_name}"
+    )
+    if hasattr(X, "shape"):
+        message += re.escape(" with shape (3,)")
+    elif isinstance(X[0], str):
+        message += " where the samples are of type str"
+    elif isinstance(X[0], dict):
+        message += " where the samples are of type dict"
+    with pytest.raises(TypeError, match=message):
+        _num_features(X)
+
+
+@pytest.mark.parametrize("X", [1, "b", False, 3.0], ids=["int", "str", "bool", "float"])
+def test_num_features_errors_scalars(X):
+    msg = f"Unable to find the number of features from X of type {type(X).__qualname__}"
+    with pytest.raises(TypeError, match=msg):
+        _num_features(X)
+
+
+@pytest.mark.parametrize(
+    "names",
+    [list(range(2)), range(2), None, [["a", "b"], ["c", "d"]]],
+    ids=["list-int", "range", "default", "MultiIndex"],
+)
+def test_get_feature_names_pandas_with_ints_no_warning(names):
+    """Get feature names with pandas dataframes without warning.
+
+    Column names with consistent dtypes will not warn, such as int or MultiIndex.
+    """
+    pd = pytest.importorskip("pandas")
+    X = pd.DataFrame([[1, 2], [4, 5], [5, 6]], columns=names)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", FutureWarning)
+        names = _get_feature_names(X)
+    assert names is None
+
+
+def test_get_feature_names_pandas():
+    """Get feature names with pandas dataframes."""
+    pd = pytest.importorskip("pandas")
+    columns = [f"col_{i}" for i in range(3)]
+    X = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=columns)
+    feature_names = _get_feature_names(X)
+
+    assert_array_equal(feature_names, columns)
+
+
+@pytest.mark.parametrize(
+    "constructor_name, minversion",
+    [("pyarrow", "12.0.0"), ("dataframe", "1.5.0"), ("polars", "0.18.2")],
+)
+def test_get_feature_names_dataframe_protocol(constructor_name, minversion):
+    """Uses the dataframe exchange protocol to get feature names."""
+    data = [[1, 4, 2], [3, 3, 6]]
+    columns = ["col_0", "col_1", "col_2"]
+    df = _convert_container(
+        data, constructor_name, columns_name=columns, minversion=minversion
+    )
+    feature_names = _get_feature_names(df)
+
+    assert_array_equal(feature_names, columns)
+
+
+@pytest.mark.parametrize("constructor_name", ["pyarrow", "dataframe", "polars"])
+def test_is_pandas_df_other_libraries(constructor_name):
+    df = _convert_container([[1, 4, 2], [3, 3, 6]], constructor_name)
+    if constructor_name in ("pyarrow", "polars"):
+        assert not _is_pandas_df(df)
+    else:
+        assert _is_pandas_df(df)
+
+
+def test_is_pandas_df():
+    """Check behavior of is_pandas_df when pandas is installed."""
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame([[1, 2, 3]])
+    assert _is_pandas_df(df)
+    assert not _is_pandas_df(np.asarray([1, 2, 3]))
+    assert not _is_pandas_df(1)
+
+
+def test_is_pandas_df_pandas_not_installed(hide_available_pandas):
+    """Check _is_pandas_df when pandas is not installed."""
+
+    assert not _is_pandas_df(np.asarray([1, 2, 3]))
+    assert not _is_pandas_df(1)
+
+
+@pytest.mark.parametrize(
+    "constructor_name, minversion",
+    [
+        ("pyarrow", dependent_packages["pyarrow"][0]),
+        ("dataframe", dependent_packages["pandas"][0]),
+        ("polars", dependent_packages["polars"][0]),
+    ],
+)
+def test_is_polars_df_other_libraries(constructor_name, minversion):
+    df = _convert_container(
+        [[1, 4, 2], [3, 3, 6]],
+        constructor_name,
+        minversion=minversion,
+    )
+    if constructor_name in ("pyarrow", "dataframe"):
+        assert not _is_polars_df(df)
+    else:
+        assert _is_polars_df(df)
+
+
+def test_is_polars_df_for_duck_typed_polars_dataframe():
+    """Check _is_polars_df for object that looks like a polars dataframe"""
+
+    class NotAPolarsDataFrame:
+        def __init__(self):
+            self.columns = [1, 2, 3]
+            self.schema = "my_schema"
+
+    not_a_polars_df = NotAPolarsDataFrame()
+    assert not _is_polars_df(not_a_polars_df)
+
+
+def test_get_feature_names_numpy():
+    """Get feature names return None for numpy arrays."""
+    X = np.array([[1, 2, 3], [4, 5, 6]])
+    names = _get_feature_names(X)
+    assert names is None
+
+
+@pytest.mark.parametrize(
+    "names, dtypes",
+    [
+        (["a", 1], "['int', 'str']"),
+        (["pizza", ["a", "b"]], "['list', 'str']"),
+    ],
+    ids=["int-str", "list-str"],
+)
+def test_get_feature_names_invalid_dtypes(names, dtypes):
+    """Get feature names errors when the feature names have mixed dtypes"""
+    pd = pytest.importorskip("pandas")
+    X = pd.DataFrame([[1, 2], [4, 5], [5, 6]], columns=names)
+
+    msg = re.escape(
+        "Feature names are only supported if all input features have string names, "
+        f"but your input has {dtypes} as feature name / column name types. "
+        "If you want feature names to be stored and validated, you must convert "
+        "them all to strings, by using X.columns = X.columns.astype(str) for "
+        "example. Otherwise you can remove feature / column names from your input "
+        "data, or convert them all to a non-string data type."
+    )
+    with pytest.raises(TypeError, match=msg):
+        names = _get_feature_names(X)
+
+
+class PassthroughTransformer(BaseEstimator):
+    def fit(self, X, y=None):
+        validate_data(self, X, reset=True)
+        return self
+
+    def transform(self, X):
+        return X
+
+    def get_feature_names_out(self, input_features=None):
+        return _check_feature_names_in(self, input_features)
+
+
+def test_check_feature_names_in():
+    """Check behavior of check_feature_names_in for arrays."""
+    X = np.array([[0.0, 1.0, 2.0]])
+    est = PassthroughTransformer().fit(X)
+
+    names = est.get_feature_names_out()
+    assert_array_equal(names, ["x0", "x1", "x2"])
+
+    incorrect_len_names = ["x10", "x1"]
+    with pytest.raises(ValueError, match="input_features should have length equal to"):
+        est.get_feature_names_out(incorrect_len_names)
+
+    # remove n_feature_in_
+    del est.n_features_in_
+    with pytest.raises(ValueError, match="Unable to generate feature names"):
+        est.get_feature_names_out()
+
+
+def test_check_feature_names_in_pandas():
+    """Check behavior of check_feature_names_in for pandas dataframes."""
+    pd = pytest.importorskip("pandas")
+    names = ["a", "b", "c"]
+    df = pd.DataFrame([[0.0, 1.0, 2.0]], columns=names)
+    est = PassthroughTransformer().fit(df)
+
+    names = est.get_feature_names_out()
+    assert_array_equal(names, ["a", "b", "c"])
+
+    with pytest.raises(ValueError, match="input_features is not equal to"):
+        est.get_feature_names_out(["x1", "x2", "x3"])
+
+
+def test_check_response_method_unknown_method():
+    """Check the error message when passing an unknown response method."""
+    err_msg = (
+        "RandomForestRegressor has none of the following attributes: unknown_method."
+    )
+    with pytest.raises(AttributeError, match=err_msg):
+        _check_response_method(RandomForestRegressor(), "unknown_method")
+
+
+@pytest.mark.parametrize(
+    "response_method", ["decision_function", "predict_proba", "predict"]
+)
+def test_check_response_method_not_supported_response_method(response_method):
+    """Check the error message when a response method is not supported by the
+    estimator."""
+    err_msg = (
+        f"EstimatorWithFit has none of the following attributes: {response_method}."
+    )
+    with pytest.raises(AttributeError, match=err_msg):
+        _check_response_method(EstimatorWithFit(), response_method)
+
+
+def test_check_response_method_list_str():
+    """Check that we can pass a list of ordered method."""
+    method_implemented = ["predict_proba"]
+    my_estimator = _MockEstimatorOnOffPrediction(method_implemented)
+
+    X = "mocking_data"
+
+    # raise an error when no methods are defined
+    response_method = ["decision_function", "predict"]
+    err_msg = (
+        "_MockEstimatorOnOffPrediction has none of the following attributes: "
+        f"{', '.join(response_method)}."
+    )
+    with pytest.raises(AttributeError, match=err_msg):
+        _check_response_method(my_estimator, response_method)(X)
+
+    # check that we don't get issue when one of the method is defined
+    response_method = ["decision_function", "predict_proba"]
+    method_name_predicting = _check_response_method(my_estimator, response_method)(X)
+    assert method_name_predicting == "predict_proba"
+
+    # check the order of the methods returned
+    method_implemented = ["predict_proba", "predict"]
+    my_estimator = _MockEstimatorOnOffPrediction(method_implemented)
+    response_method = ["decision_function", "predict", "predict_proba"]
+    method_name_predicting = _check_response_method(my_estimator, response_method)(X)
+    assert method_name_predicting == "predict"
+
+
+def test_boolean_series_remains_boolean():
+    """Regression test for gh-25145"""
+    pd = importorskip("pandas")
+    res = check_array(pd.Series([True, False]), ensure_2d=False)
+    expected = np.array([True, False])
+
+    assert res.dtype == expected.dtype
+    assert_array_equal(res, expected)
+
+
+@pytest.mark.parametrize("input_values", [[0, 1, 0, 1, 0, np.nan], [0, 1, 0, 1, 0, 1]])
+def test_pandas_array_returns_ndarray(input_values):
+    """Check pandas array with extensions dtypes returns a numeric ndarray.
+
+    Non-regression test for gh-25637.
+    """
+    pd = importorskip("pandas")
+    input_series = pd.array(input_values, dtype="Int32")
+    result = check_array(
+        input_series,
+        dtype=None,
+        ensure_2d=False,
+        allow_nd=False,
+        ensure_all_finite=False,
+    )
+    assert np.issubdtype(result.dtype.kind, np.floating)
+    assert_allclose(result, input_values)
+
+
+@skip_if_array_api_compat_not_configured
+def test_check_array_array_api_has_non_finite():
+    """Checks that Array API arrays checks non-finite correctly."""
+    xp = pytest.importorskip("array_api_strict")
+
+    X_nan = xp.asarray([[xp.nan, 1, 0], [0, xp.nan, 3]], dtype=xp.float32)
+    with config_context(array_api_dispatch=True):
+        with pytest.raises(ValueError, match="Input contains NaN."):
+            check_array(X_nan)
+
+    X_inf = xp.asarray([[xp.inf, 1, 0], [0, xp.inf, 3]], dtype=xp.float32)
+    with config_context(array_api_dispatch=True):
+        with pytest.raises(ValueError, match="infinity or a value too large"):
+            check_array(X_inf)
+
+
+@pytest.mark.parametrize(
+    "extension_dtype, regular_dtype",
+    [
+        ("boolean", "bool"),
+        ("Int64", "int64"),
+        ("Float64", "float64"),
+        ("category", "object"),
+    ],
+)
+@pytest.mark.parametrize("include_object", [True, False])
+def test_check_array_multiple_extensions(
+    extension_dtype, regular_dtype, include_object
+):
+    """Check pandas extension arrays give the same result as non-extension arrays."""
+    pd = pytest.importorskip("pandas")
+    X_regular = pd.DataFrame(
+        {
+            "a": pd.Series([1, 0, 1, 0], dtype=regular_dtype),
+            "c": pd.Series([9, 8, 7, 6], dtype="int64"),
+        }
+    )
+    if include_object:
+        X_regular["b"] = pd.Series(["a", "b", "c", "d"], dtype="object")
+
+    X_extension = X_regular.assign(a=X_regular["a"].astype(extension_dtype))
+
+    X_regular_checked = check_array(X_regular, dtype=None)
+    X_extension_checked = check_array(X_extension, dtype=None)
+    assert_array_equal(X_regular_checked, X_extension_checked)
+
+
+def test_num_samples_dataframe_protocol():
+    """Use the DataFrame interchange protocol to get n_samples from polars."""
+    pl = pytest.importorskip("polars")
+
+    df = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    assert _num_samples(df) == 3
+
+
+@pytest.mark.parametrize(
+    "sparse_container",
+    CSR_CONTAINERS + CSC_CONTAINERS + COO_CONTAINERS + DIA_CONTAINERS,
+)
+@pytest.mark.parametrize("output_format", ["csr", "csc", "coo"])
+def test_check_array_dia_to_int32_indexed_csr_csc_coo(sparse_container, output_format):
+    """Check the consistency of the indices dtype with sparse matrices/arrays."""
+    X = sparse_container([[0, 1], [1, 0]], dtype=np.float64)
+
+    # Explicitly set the dtype of the indexing arrays
+    if hasattr(X, "offsets"):  # DIA matrix
+        X.offsets = X.offsets.astype(np.int32)
+    elif hasattr(X, "row") and hasattr(X, "col"):  # COO matrix
+        X.row = X.row.astype(np.int32)
+    elif hasattr(X, "indices") and hasattr(X, "indptr"):  # CSR or CSC matrix
+        X.indices = X.indices.astype(np.int32)
+        X.indptr = X.indptr.astype(np.int32)
+
+    X_checked = check_array(X, accept_sparse=output_format)
+    if output_format == "coo":
+        assert X_checked.row.dtype == np.int32
+        assert X_checked.col.dtype == np.int32
+    else:  # output_format in ["csr", "csc"]
+        assert X_checked.indices.dtype == np.int32
+        assert X_checked.indptr.dtype == np.int32
+
+
+@pytest.mark.parametrize("sequence", [[np.array(1), np.array(2)], [[1, 2], [3, 4]]])
+def test_to_object_array(sequence):
+    out = _to_object_array(sequence)
+    assert isinstance(out, np.ndarray)
+    assert out.dtype.kind == "O"
+    assert out.ndim == 1
+
+
+def test_column_or_1d():
+    EXAMPLES = [
+        ("binary", ["spam", "egg", "spam"]),
+        ("binary", [0, 1, 0, 1]),
+        ("continuous", np.arange(10) / 20.0),
+        ("multiclass", [1, 2, 3]),
+        ("multiclass", [0, 1, 2, 2, 0]),
+        ("multiclass", [[1], [2], [3]]),
+        ("multilabel-indicator", [[0, 1, 0], [0, 0, 1]]),
+        ("multiclass-multioutput", [[1, 2, 3]]),
+        ("multiclass-multioutput", [[1, 1], [2, 2], [3, 1]]),
+        ("multiclass-multioutput", [[5, 1], [4, 2], [3, 1]]),
+        ("multiclass-multioutput", [[1, 2, 3]]),
+        ("continuous-multioutput", np.arange(30).reshape((-1, 3))),
+    ]
+
+    for y_type, y in EXAMPLES:
+        if y_type in ["binary", "multiclass", "continuous"]:
+            assert_array_equal(column_or_1d(y), np.ravel(y))
+        else:
+            with pytest.raises(ValueError):
+                column_or_1d(y)
+
+
+def test__is_polars_df():
+    """Check that _is_polars_df return False for non-dataframe objects."""
+
+    class LooksLikePolars:
+        def __init__(self):
+            self.columns = ["a", "b"]
+            self.schema = ["a", "b"]
+
+    assert not _is_polars_df(LooksLikePolars())
+
+
+def test_check_array_writeable_np():
+    """Check the behavior of check_array when a writeable array is requested
+    without copy if possible, on numpy arrays.
+    """
+    X = np.random.uniform(size=(10, 10))
+
+    out = check_array(X, copy=False, force_writeable=True)
+    # X is already writeable, no copy is needed
+    assert np.may_share_memory(out, X)
+    assert out.flags.writeable
+
+    X.flags.writeable = False
+
+    out = check_array(X, copy=False, force_writeable=True)
+    # X is not writeable, a copy is made
+    assert not np.may_share_memory(out, X)
+    assert out.flags.writeable
+
+
+def test_check_array_writeable_mmap():
+    """Check the behavior of check_array when a writeable array is requested
+    without copy if possible, on a memory-map.
+
+    A common situation is when a meta-estimators run in parallel using multiprocessing
+    with joblib, which creates read-only memory-maps of large arrays.
+    """
+    X = np.random.uniform(size=(10, 10))
+
+    mmap = create_memmap_backed_data(X, mmap_mode="w+")
+    out = check_array(mmap, copy=False, force_writeable=True)
+    # mmap is already writeable, no copy is needed
+    assert np.may_share_memory(out, mmap)
+    assert out.flags.writeable
+
+    mmap = create_memmap_backed_data(X, mmap_mode="r")
+    out = check_array(mmap, copy=False, force_writeable=True)
+    # mmap is read-only, a copy is made
+    assert not np.may_share_memory(out, mmap)
+    assert out.flags.writeable
+
+
+def test_check_array_writeable_df():
+    """Check the behavior of check_array when a writeable array is requested
+    without copy if possible, on a dataframe.
+    """
+    pd = pytest.importorskip("pandas")
+
+    X = np.random.uniform(size=(10, 10))
+    df = pd.DataFrame(X, copy=False)
+
+    out = check_array(df, copy=False, force_writeable=True)
+    # df is backed by a writeable array, no copy is needed
+    assert np.may_share_memory(out, df)
+    assert out.flags.writeable
+
+    X.flags.writeable = False
+    df = pd.DataFrame(X, copy=False)
+
+    out = check_array(df, copy=False, force_writeable=True)
+    # df is backed by a read-only array, a copy is made
+    assert not np.may_share_memory(out, df)
+    assert out.flags.writeable
+
+
+@skip_if_array_api_compat_not_configured
+def test_check_array_on_sparse_inputs_with_array_api_enabled():
+    X_sp = sp.csr_array([[0, 1, 0], [1, 0, 1]])
+    with config_context(array_api_dispatch=True):
+        assert sp.issparse(check_array(X_sp, accept_sparse=True))
+
+        with pytest.raises(TypeError):
+            check_array(X_sp)
+
+
+# TODO(1.8): remove
+def test_force_all_finite_rename_warning():
+    X = np.random.uniform(size=(10, 10))
+    y = np.random.randint(1, size=(10,))
+
+    msg = "'force_all_finite' was renamed to 'ensure_all_finite'"
+
+    with pytest.warns(FutureWarning, match=msg):
+        check_array(X, force_all_finite=True)
+
+    with pytest.warns(FutureWarning, match=msg):
+        check_X_y(X, y, force_all_finite=True)
+
+    with pytest.warns(FutureWarning, match=msg):
+        as_float_array(X, force_all_finite=True)
+
+
+@pytest.mark.parametrize(
+    ["X", "estimator", "expected_error_message"],
+    [
+        (
+            np.array([[[1, 2], [3, 4]], [[1, 2], [3, 4]]]),
+            RandomForestRegressor(),
+            "Found array with dim 3, while dim <= 2 is required by "
+            "RandomForestRegressor.",
+        ),
+        (
+            np.array([[[1, 2], [3, 4]], [[1, 2], [3, 4]]]),
+            None,
+            "Found array with dim 3, while dim <= 2 is required.",
+        ),
+    ],
+)
+def test_check_array_allow_nd_errors(X, estimator, expected_error_message):
+    with pytest.raises(ValueError, match=expected_error_message):
+        check_array(X, estimator=estimator)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_weight_vector.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_weight_vector.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b19792475e06369fb26e526e2644a3285f4223f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/tests/test_weight_vector.py
@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+
+from sklearn.utils._weight_vector import (
+    WeightVector32,
+    WeightVector64,
+)
+
+
+@pytest.mark.parametrize(
+    "dtype, WeightVector",
+    [
+        (np.float32, WeightVector32),
+        (np.float64, WeightVector64),
+    ],
+)
+def test_type_invariance(dtype, WeightVector):
+    """Check the `dtype` consistency of `WeightVector`."""
+    weights = np.random.rand(100).astype(dtype)
+    average_weights = np.random.rand(100).astype(dtype)
+
+    weight_vector = WeightVector(weights, average_weights)
+
+    assert np.asarray(weight_vector.w).dtype is np.dtype(dtype)
+    assert np.asarray(weight_vector.aw).dtype is np.dtype(dtype)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/validation.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/validation.py
new file mode 100644
index 0000000000000000000000000000000000000000..86bdd07c41f1c36fcd5827cf3bb5487af7e22627
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sklearn/utils/validation.py
@@ -0,0 +1,2977 @@
+"""Functions to validate input and parameters within scikit-learn estimators."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numbers
+import operator
+import sys
+import warnings
+from collections.abc import Sequence
+from contextlib import suppress
+from functools import reduce, wraps
+from inspect import Parameter, isclass, signature
+
+import joblib
+import numpy as np
+import scipy.sparse as sp
+
+from .. import get_config as _get_config
+from ..exceptions import DataConversionWarning, NotFittedError, PositiveSpectrumWarning
+from ..utils._array_api import _asarray_with_order, _is_numpy_namespace, get_namespace
+from ..utils.deprecation import _deprecate_force_all_finite
+from ..utils.fixes import ComplexWarning, _preserve_dia_indices_dtype
+from ._isfinite import FiniteStatus, cy_isfinite
+from ._tags import get_tags
+from .fixes import _object_dtype_isnan
+
+FLOAT_DTYPES = (np.float64, np.float32, np.float16)
+
+
+# This function is not used anymore at this moment in the code base but we keep it in
+# case that we merge a new public function without kwarg only by mistake, which would
+# require a deprecation cycle to fix.
+def _deprecate_positional_args(func=None, *, version="1.3"):
+    """Decorator for methods that issues warnings for positional arguments.
+
+    Using the keyword-only argument syntax in pep 3102, arguments after the
+    * will issue a warning when passed as a positional argument.
+
+    Parameters
+    ----------
+    func : callable, default=None
+        Function to check arguments on.
+    version : callable, default="1.3"
+        The version when positional arguments will result in error.
+    """
+
+    def _inner_deprecate_positional_args(f):
+        sig = signature(f)
+        kwonly_args = []
+        all_args = []
+
+        for name, param in sig.parameters.items():
+            if param.kind == Parameter.POSITIONAL_OR_KEYWORD:
+                all_args.append(name)
+            elif param.kind == Parameter.KEYWORD_ONLY:
+                kwonly_args.append(name)
+
+        @wraps(f)
+        def inner_f(*args, **kwargs):
+            extra_args = len(args) - len(all_args)
+            if extra_args <= 0:
+                return f(*args, **kwargs)
+
+            # extra_args > 0
+            args_msg = [
+                "{}={}".format(name, arg)
+                for name, arg in zip(kwonly_args[:extra_args], args[-extra_args:])
+            ]
+            args_msg = ", ".join(args_msg)
+            warnings.warn(
+                (
+                    f"Pass {args_msg} as keyword args. From version "
+                    f"{version} passing these as positional arguments "
+                    "will result in an error"
+                ),
+                FutureWarning,
+            )
+            kwargs.update(zip(sig.parameters, args))
+            return f(**kwargs)
+
+        return inner_f
+
+    if func is not None:
+        return _inner_deprecate_positional_args(func)
+
+    return _inner_deprecate_positional_args
+
+
+def _assert_all_finite(
+    X, allow_nan=False, msg_dtype=None, estimator_name=None, input_name=""
+):
+    """Like assert_all_finite, but only for ndarray."""
+
+    xp, is_array_api = get_namespace(X)
+
+    if _get_config()["assume_finite"]:
+        return
+
+    X = xp.asarray(X)
+
+    # for object dtype data, we only check for NaNs (GH-13254)
+    if not is_array_api and X.dtype == np.dtype("object") and not allow_nan:
+        if _object_dtype_isnan(X).any():
+            raise ValueError("Input contains NaN")
+
+    # We need only consider float arrays, hence can early return for all else.
+    if not xp.isdtype(X.dtype, ("real floating", "complex floating")):
+        return
+
+    # First try an O(n) time, O(1) space solution for the common case that
+    # everything is finite; fall back to O(n) space `np.isinf/isnan` or custom
+    # Cython implementation to prevent false positives and provide a detailed
+    # error message.
+    with np.errstate(over="ignore"):
+        first_pass_isfinite = xp.isfinite(xp.sum(X))
+    if first_pass_isfinite:
+        return
+
+    _assert_all_finite_element_wise(
+        X,
+        xp=xp,
+        allow_nan=allow_nan,
+        msg_dtype=msg_dtype,
+        estimator_name=estimator_name,
+        input_name=input_name,
+    )
+
+
+def _assert_all_finite_element_wise(
+    X, *, xp, allow_nan, msg_dtype=None, estimator_name=None, input_name=""
+):
+    # Cython implementation doesn't support FP16 or complex numbers
+    use_cython = (
+        xp is np and X.data.contiguous and X.dtype.type in {np.float32, np.float64}
+    )
+    if use_cython:
+        out = cy_isfinite(X.reshape(-1), allow_nan=allow_nan)
+        has_nan_error = False if allow_nan else out == FiniteStatus.has_nan
+        has_inf = out == FiniteStatus.has_infinite
+    else:
+        has_inf = xp.any(xp.isinf(X))
+        has_nan_error = False if allow_nan else xp.any(xp.isnan(X))
+    if has_inf or has_nan_error:
+        if has_nan_error:
+            type_err = "NaN"
+        else:
+            msg_dtype = msg_dtype if msg_dtype is not None else X.dtype
+            type_err = f"infinity or a value too large for {msg_dtype!r}"
+        padded_input_name = input_name + " " if input_name else ""
+        msg_err = f"Input {padded_input_name}contains {type_err}."
+        if estimator_name and input_name == "X" and has_nan_error:
+            # Improve the error message on how to handle missing values in
+            # scikit-learn.
+            msg_err += (
+                f"\n{estimator_name} does not accept missing values"
+                " encoded as NaN natively. For supervised learning, you might want"
+                " to consider sklearn.ensemble.HistGradientBoostingClassifier and"
+                " Regressor which accept missing values encoded as NaNs natively."
+                " Alternatively, it is possible to preprocess the data, for"
+                " instance by using an imputer transformer in a pipeline or drop"
+                " samples with missing values. See"
+                " https://scikit-learn.org/stable/modules/impute.html"
+                " You can find a list of all estimators that handle NaN values"
+                " at the following page:"
+                " https://scikit-learn.org/stable/modules/impute.html"
+                "#estimators-that-handle-nan-values"
+            )
+        raise ValueError(msg_err)
+
+
+def assert_all_finite(
+    X,
+    *,
+    allow_nan=False,
+    estimator_name=None,
+    input_name="",
+):
+    """Throw a ValueError if X contains NaN or infinity.
+
+    Parameters
+    ----------
+    X : {ndarray, sparse matrix}
+        The input data.
+
+    allow_nan : bool, default=False
+        If True, do not throw error when `X` contains NaN.
+
+    estimator_name : str, default=None
+        The estimator name, used to construct the error message.
+
+    input_name : str, default=""
+        The data name used to construct the error message. In particular
+        if `input_name` is "X" and the data has NaN values and
+        allow_nan is False, the error message will link to the imputer
+        documentation.
+
+    Examples
+    --------
+    >>> from sklearn.utils import assert_all_finite
+    >>> import numpy as np
+    >>> array = np.array([1, np.inf, np.nan, 4])
+    >>> try:
+    ...     assert_all_finite(array)
+    ...     print("Test passed: Array contains only finite values.")
+    ... except ValueError:
+    ...     print("Test failed: Array contains non-finite values.")
+    Test failed: Array contains non-finite values.
+    """
+    _assert_all_finite(
+        X.data if sp.issparse(X) else X,
+        allow_nan=allow_nan,
+        estimator_name=estimator_name,
+        input_name=input_name,
+    )
+
+
+def as_float_array(
+    X, *, copy=True, force_all_finite="deprecated", ensure_all_finite=None
+):
+    """Convert an array-like to an array of floats.
+
+    The new dtype will be np.float32 or np.float64, depending on the original
+    type. The function can create a copy or modify the argument depending
+    on the argument copy.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix}
+        The input data.
+
+    copy : bool, default=True
+        If True, a copy of X will be created. If False, a copy may still be
+        returned if X's dtype is not a floating point type.
+
+    force_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in X. The
+        possibilities are:
+
+        - True: Force all values of X to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in X.
+        - 'allow-nan': accepts only np.nan and pd.NA values in X. Values cannot
+          be infinite.
+
+        .. versionadded:: 0.20
+           ``force_all_finite`` accepts the string ``'allow-nan'``.
+
+        .. versionchanged:: 0.23
+           Accepts `pd.NA` and converts it into `np.nan`
+
+        .. deprecated:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite` and will be removed
+           in 1.8.
+
+    ensure_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in X. The
+        possibilities are:
+
+        - True: Force all values of X to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in X.
+        - 'allow-nan': accepts only np.nan and pd.NA values in X. Values cannot
+          be infinite.
+
+        .. versionadded:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite`.
+
+    Returns
+    -------
+    XT : {ndarray, sparse matrix}
+        An array of type float.
+
+    Examples
+    --------
+    >>> from sklearn.utils import as_float_array
+    >>> import numpy as np
+    >>> array = np.array([0, 0, 1, 2, 2], dtype=np.int64)
+    >>> as_float_array(array)
+    array([0., 0., 1., 2., 2.])
+    """
+    ensure_all_finite = _deprecate_force_all_finite(force_all_finite, ensure_all_finite)
+
+    if isinstance(X, np.matrix) or (
+        not isinstance(X, np.ndarray) and not sp.issparse(X)
+    ):
+        return check_array(
+            X,
+            accept_sparse=["csr", "csc", "coo"],
+            dtype=np.float64,
+            copy=copy,
+            ensure_all_finite=ensure_all_finite,
+            ensure_2d=False,
+        )
+    elif sp.issparse(X) and X.dtype in [np.float32, np.float64]:
+        return X.copy() if copy else X
+    elif X.dtype in [np.float32, np.float64]:  # is numpy array
+        return X.copy("F" if X.flags["F_CONTIGUOUS"] else "C") if copy else X
+    else:
+        if X.dtype.kind in "uib" and X.dtype.itemsize <= 4:
+            return_dtype = np.float32
+        else:
+            return_dtype = np.float64
+        return X.astype(return_dtype)
+
+
+def _is_arraylike(x):
+    """Returns whether the input is array-like."""
+    if sp.issparse(x):
+        return False
+
+    return hasattr(x, "__len__") or hasattr(x, "shape") or hasattr(x, "__array__")
+
+
+def _is_arraylike_not_scalar(array):
+    """Return True if array is array-like and not a scalar"""
+    return _is_arraylike(array) and not np.isscalar(array)
+
+
+def _use_interchange_protocol(X):
+    """Use interchange protocol for non-pandas dataframes that follow the protocol.
+
+    Note: at this point we chose not to use the interchange API on pandas dataframe
+    to ensure strict behavioral backward compatibility with older versions of
+    scikit-learn.
+    """
+    return not _is_pandas_df(X) and hasattr(X, "__dataframe__")
+
+
+def _num_features(X):
+    """Return the number of features in an array-like X.
+
+    This helper function tries hard to avoid to materialize an array version
+    of X unless necessary. For instance, if X is a list of lists,
+    this function will return the length of the first element, assuming
+    that subsequent elements are all lists of the same length without
+    checking.
+    Parameters
+    ----------
+    X : array-like
+        array-like to get the number of features.
+
+    Returns
+    -------
+    features : int
+        Number of features
+    """
+    type_ = type(X)
+    if type_.__module__ == "builtins":
+        type_name = type_.__qualname__
+    else:
+        type_name = f"{type_.__module__}.{type_.__qualname__}"
+    message = f"Unable to find the number of features from X of type {type_name}"
+    if not hasattr(X, "__len__") and not hasattr(X, "shape"):
+        if not hasattr(X, "__array__"):
+            raise TypeError(message)
+        # Only convert X to a numpy array if there is no cheaper, heuristic
+        # option.
+        X = np.asarray(X)
+
+    if hasattr(X, "shape"):
+        if not hasattr(X.shape, "__len__") or len(X.shape) <= 1:
+            message += f" with shape {X.shape}"
+            raise TypeError(message)
+        return X.shape[1]
+
+    first_sample = X[0]
+
+    # Do not consider an array-like of strings or dicts to be a 2D array
+    if isinstance(first_sample, (str, bytes, dict)):
+        message += f" where the samples are of type {type(first_sample).__qualname__}"
+        raise TypeError(message)
+
+    try:
+        # If X is a list of lists, for instance, we assume that all nested
+        # lists have the same length without checking or converting to
+        # a numpy array to keep this function call as cheap as possible.
+        return len(first_sample)
+    except Exception as err:
+        raise TypeError(message) from err
+
+
+def _num_samples(x):
+    """Return number of samples in array-like x."""
+    message = "Expected sequence or array-like, got %s" % type(x)
+    if hasattr(x, "fit") and callable(x.fit):
+        # Don't get num_samples from an ensembles length!
+        raise TypeError(message)
+
+    if _use_interchange_protocol(x):
+        return x.__dataframe__().num_rows()
+
+    if not hasattr(x, "__len__") and not hasattr(x, "shape"):
+        if hasattr(x, "__array__"):
+            x = np.asarray(x)
+        else:
+            raise TypeError(message)
+
+    if hasattr(x, "shape") and x.shape is not None:
+        if len(x.shape) == 0:
+            raise TypeError(
+                "Input should have at least 1 dimension i.e. satisfy "
+                f"`len(x.shape) > 0`, got scalar `{x!r}` instead."
+            )
+        # Check that shape is returning an integer or default to len
+        # Dask dataframes may not return numeric shape[0] value
+        if isinstance(x.shape[0], numbers.Integral):
+            return x.shape[0]
+
+    try:
+        return len(x)
+    except TypeError as type_error:
+        raise TypeError(message) from type_error
+
+
+def check_memory(memory):
+    """Check that ``memory`` is joblib.Memory-like.
+
+    joblib.Memory-like means that ``memory`` can be converted into a
+    joblib.Memory instance (typically a str denoting the ``location``)
+    or has the same interface (has a ``cache`` method).
+
+    Parameters
+    ----------
+    memory : None, str or object with the joblib.Memory interface
+        - If string, the location where to create the `joblib.Memory` interface.
+        - If None, no caching is done and the Memory object is completely transparent.
+
+    Returns
+    -------
+    memory : object with the joblib.Memory interface
+        A correct joblib.Memory object.
+
+    Raises
+    ------
+    ValueError
+        If ``memory`` is not joblib.Memory-like.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_memory
+    >>> check_memory("caching_dir")
+    Memory(location=caching_dir/joblib)
+    """
+    if memory is None or isinstance(memory, str):
+        memory = joblib.Memory(location=memory, verbose=0)
+    elif not hasattr(memory, "cache"):
+        raise ValueError(
+            "'memory' should be None, a string or have the same"
+            " interface as joblib.Memory."
+            " Got memory='{}' instead.".format(memory)
+        )
+    return memory
+
+
+def check_consistent_length(*arrays):
+    """Check that all arrays have consistent first dimensions.
+
+    Checks whether all objects in arrays have the same shape or length.
+
+    Parameters
+    ----------
+    *arrays : list or tuple of input objects.
+        Objects that will be checked for consistent length.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_consistent_length
+    >>> a = [1, 2, 3]
+    >>> b = [2, 3, 4]
+    >>> check_consistent_length(a, b)
+    """
+    lengths = [_num_samples(X) for X in arrays if X is not None]
+    if len(set(lengths)) > 1:
+        raise ValueError(
+            "Found input variables with inconsistent numbers of samples: %r"
+            % [int(l) for l in lengths]
+        )
+
+
+def _make_indexable(iterable):
+    """Ensure iterable supports indexing or convert to an indexable variant.
+
+    Convert sparse matrices to csr and other non-indexable iterable to arrays.
+    Let `None` and indexable objects (e.g. pandas dataframes) pass unchanged.
+
+    Parameters
+    ----------
+    iterable : {list, dataframe, ndarray, sparse matrix} or None
+        Object to be converted to an indexable iterable.
+    """
+    if sp.issparse(iterable):
+        return iterable.tocsr()
+    elif hasattr(iterable, "__getitem__") or hasattr(iterable, "iloc"):
+        return iterable
+    elif iterable is None:
+        return iterable
+    return np.array(iterable)
+
+
+def indexable(*iterables):
+    """Make arrays indexable for cross-validation.
+
+    Checks consistent length, passes through None, and ensures that everything
+    can be indexed by converting sparse matrices to csr and converting
+    non-iterable objects to arrays.
+
+    Parameters
+    ----------
+    *iterables : {lists, dataframes, ndarrays, sparse matrices}
+        List of objects to ensure sliceability.
+
+    Returns
+    -------
+    result : list of {ndarray, sparse matrix, dataframe} or None
+        Returns a list containing indexable arrays (i.e. NumPy array,
+        sparse matrix, or dataframe) or `None`.
+
+    Examples
+    --------
+    >>> from sklearn.utils import indexable
+    >>> from scipy.sparse import csr_matrix
+    >>> import numpy as np
+    >>> iterables = [
+    ...     [1, 2, 3], np.array([2, 3, 4]), None, csr_matrix([[5], [6], [7]])
+    ... ]
+    >>> indexable(*iterables)
+    [[1, 2, 3], array([2, 3, 4]), None, <...Sparse...dtype 'int64'...shape (3, 1)>]
+    """
+
+    result = [_make_indexable(X) for X in iterables]
+    check_consistent_length(*result)
+    return result
+
+
+def _ensure_sparse_format(
+    sparse_container,
+    accept_sparse,
+    dtype,
+    copy,
+    ensure_all_finite,
+    accept_large_sparse,
+    estimator_name=None,
+    input_name="",
+):
+    """Convert a sparse container to a given format.
+
+    Checks the sparse format of `sparse_container` and converts if necessary.
+
+    Parameters
+    ----------
+    sparse_container : sparse matrix or array
+        Input to validate and convert.
+
+    accept_sparse : str, bool or list/tuple of str
+        String[s] representing allowed sparse matrix formats ('csc',
+        'csr', 'coo', 'dok', 'bsr', 'lil', 'dia'). If the input is sparse but
+        not in the allowed format, it will be converted to the first listed
+        format. True allows the input to be any format. False means
+        that a sparse matrix input will raise an error.
+
+    dtype : str, type or None
+        Data type of result. If None, the dtype of the input is preserved.
+
+    copy : bool
+        Whether a forced copy will be triggered. If copy=False, a copy might
+        be triggered by a conversion.
+
+    ensure_all_finite : bool or 'allow-nan'
+        Whether to raise an error on np.inf, np.nan, pd.NA in X. The
+        possibilities are:
+
+        - True: Force all values of X to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in X.
+        - 'allow-nan': accepts only np.nan and pd.NA values in X. Values cannot
+          be infinite.
+
+        .. versionadded:: 0.20
+           ``ensure_all_finite`` accepts the string ``'allow-nan'``.
+
+        .. versionchanged:: 0.23
+           Accepts `pd.NA` and converts it into `np.nan`
+
+
+    estimator_name : str, default=None
+        The estimator name, used to construct the error message.
+
+    input_name : str, default=""
+        The data name used to construct the error message. In particular
+        if `input_name` is "X" and the data has NaN values and
+        allow_nan is False, the error message will link to the imputer
+        documentation.
+
+    Returns
+    -------
+    sparse_container_converted : sparse matrix or array
+        Sparse container (matrix/array) that is ensured to have an allowed type.
+    """
+    if dtype is None:
+        dtype = sparse_container.dtype
+
+    changed_format = False
+    sparse_container_type_name = type(sparse_container).__name__
+
+    if isinstance(accept_sparse, str):
+        accept_sparse = [accept_sparse]
+
+    # Indices dtype validation
+    _check_large_sparse(sparse_container, accept_large_sparse)
+
+    if accept_sparse is False:
+        padded_input = " for " + input_name if input_name else ""
+        raise TypeError(
+            f"Sparse data was passed{padded_input}, but dense data is required. "
+            "Use '.toarray()' to convert to a dense numpy array."
+        )
+    elif isinstance(accept_sparse, (list, tuple)):
+        if len(accept_sparse) == 0:
+            raise ValueError(
+                "When providing 'accept_sparse' as a tuple or list, it must contain at "
+                "least one string value."
+            )
+        # ensure correct sparse format
+        if sparse_container.format not in accept_sparse:
+            # create new with correct sparse
+            sparse_container = sparse_container.asformat(accept_sparse[0])
+            changed_format = True
+    elif accept_sparse is not True:
+        # any other type
+        raise ValueError(
+            "Parameter 'accept_sparse' should be a string, boolean or list of strings."
+            f" You provided 'accept_sparse={accept_sparse}'."
+        )
+
+    if dtype != sparse_container.dtype:
+        # convert dtype
+        sparse_container = sparse_container.astype(dtype)
+    elif copy and not changed_format:
+        # force copy
+        sparse_container = sparse_container.copy()
+
+    if ensure_all_finite:
+        if not hasattr(sparse_container, "data"):
+            warnings.warn(
+                f"Can't check {sparse_container.format} sparse matrix for nan or inf.",
+                stacklevel=2,
+            )
+        else:
+            _assert_all_finite(
+                sparse_container.data,
+                allow_nan=ensure_all_finite == "allow-nan",
+                estimator_name=estimator_name,
+                input_name=input_name,
+            )
+
+    # TODO: Remove when the minimum version of SciPy supported is 1.12
+    # With SciPy sparse arrays, conversion from DIA format to COO, CSR, or BSR
+    # triggers the use of `np.int64` indices even if the data is such that it could
+    # be more efficiently represented with `np.int32` indices.
+    # https://github.com/scipy/scipy/issues/19245 Since not all scikit-learn
+    # algorithms support large indices, the following code downcasts to `np.int32`
+    # indices when it's safe to do so.
+    if changed_format:
+        # accept_sparse is specified to a specific format and a conversion occurred
+        requested_sparse_format = accept_sparse[0]
+        _preserve_dia_indices_dtype(
+            sparse_container, sparse_container_type_name, requested_sparse_format
+        )
+
+    return sparse_container
+
+
+def _ensure_no_complex_data(array):
+    if (
+        hasattr(array, "dtype")
+        and array.dtype is not None
+        and hasattr(array.dtype, "kind")
+        and array.dtype.kind == "c"
+    ):
+        raise ValueError("Complex data not supported\n{}\n".format(array))
+
+
+def _check_estimator_name(estimator):
+    if estimator is not None:
+        if isinstance(estimator, str):
+            return estimator
+        else:
+            return estimator.__class__.__name__
+    return None
+
+
+def _pandas_dtype_needs_early_conversion(pd_dtype):
+    """Return True if pandas extension pd_dtype need to be converted early."""
+    # Check these early for pandas versions without extension dtypes
+    from pandas import SparseDtype
+    from pandas.api.types import (
+        is_bool_dtype,
+        is_float_dtype,
+        is_integer_dtype,
+    )
+
+    if is_bool_dtype(pd_dtype):
+        # bool and extension booleans need early conversion because __array__
+        # converts mixed dtype dataframes into object dtypes
+        return True
+
+    if isinstance(pd_dtype, SparseDtype):
+        # Sparse arrays will be converted later in `check_array`
+        return False
+
+    try:
+        from pandas.api.types import is_extension_array_dtype
+    except ImportError:
+        return False
+
+    if isinstance(pd_dtype, SparseDtype) or not is_extension_array_dtype(pd_dtype):
+        # Sparse arrays will be converted later in `check_array`
+        # Only handle extension arrays for integer and floats
+        return False
+    elif is_float_dtype(pd_dtype):
+        # Float ndarrays can normally support nans. They need to be converted
+        # first to map pd.NA to np.nan
+        return True
+    elif is_integer_dtype(pd_dtype):
+        # XXX: Warn when converting from a high integer to a float
+        return True
+
+    return False
+
+
+def _is_extension_array_dtype(array):
+    # Pandas extension arrays have a dtype with an na_value
+    return hasattr(array, "dtype") and hasattr(array.dtype, "na_value")
+
+
+def check_array(
+    array,
+    accept_sparse=False,
+    *,
+    accept_large_sparse=True,
+    dtype="numeric",
+    order=None,
+    copy=False,
+    force_writeable=False,
+    force_all_finite="deprecated",
+    ensure_all_finite=None,
+    ensure_non_negative=False,
+    ensure_2d=True,
+    allow_nd=False,
+    ensure_min_samples=1,
+    ensure_min_features=1,
+    estimator=None,
+    input_name="",
+):
+    """Input validation on an array, list, sparse matrix or similar.
+
+    By default, the input is checked to be a non-empty 2D array containing
+    only finite values. If the dtype of the array is object, attempt
+    converting to float, raising on failure.
+
+    Parameters
+    ----------
+    array : object
+        Input object to check / convert.
+
+    accept_sparse : str, bool or list/tuple of str, default=False
+        String[s] representing allowed sparse matrix formats, such as 'csc',
+        'csr', etc. If the input is sparse but not in the allowed format,
+        it will be converted to the first listed format. True allows the input
+        to be any format. False means that a sparse matrix input will
+        raise an error.
+
+    accept_large_sparse : bool, default=True
+        If a CSR, CSC, COO or BSR sparse matrix is supplied and accepted by
+        accept_sparse, accept_large_sparse=False will cause it to be accepted
+        only if its indices are stored with a 32-bit dtype.
+
+        .. versionadded:: 0.20
+
+    dtype : 'numeric', type, list of type or None, default='numeric'
+        Data type of result. If None, the dtype of the input is preserved.
+        If "numeric", dtype is preserved unless array.dtype is object.
+        If dtype is a list of types, conversion on the first type is only
+        performed if the dtype of the input is not in the list.
+
+    order : {'F', 'C'} or None, default=None
+        Whether an array will be forced to be fortran or c-style.
+        When order is None (default), then if copy=False, nothing is ensured
+        about the memory layout of the output array; otherwise (copy=True)
+        the memory layout of the returned array is kept as close as possible
+        to the original array.
+
+    copy : bool, default=False
+        Whether a forced copy will be triggered. If copy=False, a copy might
+        be triggered by a conversion.
+
+    force_writeable : bool, default=False
+        Whether to force the output array to be writeable. If True, the returned array
+        is guaranteed to be writeable, which may require a copy. Otherwise the
+        writeability of the input array is preserved.
+
+        .. versionadded:: 1.6
+
+    force_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in array. The
+        possibilities are:
+
+        - True: Force all values of array to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in array.
+        - 'allow-nan': accepts only np.nan and pd.NA values in array. Values
+          cannot be infinite.
+
+        .. versionadded:: 0.20
+           ``force_all_finite`` accepts the string ``'allow-nan'``.
+
+        .. versionchanged:: 0.23
+           Accepts `pd.NA` and converts it into `np.nan`
+
+        .. deprecated:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite` and will be removed
+           in 1.8.
+
+    ensure_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in array. The
+        possibilities are:
+
+        - True: Force all values of array to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in array.
+        - 'allow-nan': accepts only np.nan and pd.NA values in array. Values
+          cannot be infinite.
+
+        .. versionadded:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite`.
+
+    ensure_non_negative : bool, default=False
+        Make sure the array has only non-negative values. If True, an array that
+        contains negative values will raise a ValueError.
+
+        .. versionadded:: 1.6
+
+    ensure_2d : bool, default=True
+        Whether to raise a value error if array is not 2D.
+
+    allow_nd : bool, default=False
+        Whether to allow array.ndim > 2.
+
+    ensure_min_samples : int, default=1
+        Make sure that the array has a minimum number of samples in its first
+        axis (rows for a 2D array). Setting to 0 disables this check.
+
+    ensure_min_features : int, default=1
+        Make sure that the 2D array has some minimum number of features
+        (columns). The default value of 1 rejects empty datasets.
+        This check is only enforced when the input data has effectively 2
+        dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0
+        disables this check.
+
+    estimator : str or estimator instance, default=None
+        If passed, include the name of the estimator in warning messages.
+
+    input_name : str, default=""
+        The data name used to construct the error message. In particular
+        if `input_name` is "X" and the data has NaN values and
+        allow_nan is False, the error message will link to the imputer
+        documentation.
+
+        .. versionadded:: 1.1.0
+
+    Returns
+    -------
+    array_converted : object
+        The converted and validated array.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_array
+    >>> X = [[1, 2, 3], [4, 5, 6]]
+    >>> X_checked = check_array(X)
+    >>> X_checked
+    array([[1, 2, 3], [4, 5, 6]])
+    """
+    ensure_all_finite = _deprecate_force_all_finite(force_all_finite, ensure_all_finite)
+
+    if isinstance(array, np.matrix):
+        raise TypeError(
+            "np.matrix is not supported. Please convert to a numpy array with "
+            "np.asarray. For more information see: "
+            "https://numpy.org/doc/stable/reference/generated/numpy.matrix.html"
+        )
+
+    xp, is_array_api_compliant = get_namespace(array)
+
+    # store reference to original array to check if copy is needed when
+    # function returns
+    array_orig = array
+
+    # store whether originally we wanted numeric dtype
+    dtype_numeric = isinstance(dtype, str) and dtype == "numeric"
+
+    dtype_orig = getattr(array, "dtype", None)
+    if not is_array_api_compliant and not hasattr(dtype_orig, "kind"):
+        # not a data type (e.g. a column named dtype in a pandas DataFrame)
+        dtype_orig = None
+
+    # check if the object contains several dtypes (typically a pandas
+    # DataFrame), and store them. If not, store None.
+    dtypes_orig = None
+    pandas_requires_conversion = False
+    # track if we have a Series-like object to raise a better error message
+    type_if_series = None
+    if hasattr(array, "dtypes") and hasattr(array.dtypes, "__array__"):
+        # throw warning if columns are sparse. If all columns are sparse, then
+        # array.sparse exists and sparsity will be preserved (later).
+        with suppress(ImportError):
+            from pandas import SparseDtype
+
+            def is_sparse(dtype):
+                return isinstance(dtype, SparseDtype)
+
+            if not hasattr(array, "sparse") and array.dtypes.apply(is_sparse).any():
+                warnings.warn(
+                    "pandas.DataFrame with sparse columns found."
+                    "It will be converted to a dense numpy array."
+                )
+
+        dtypes_orig = list(array.dtypes)
+        pandas_requires_conversion = any(
+            _pandas_dtype_needs_early_conversion(i) for i in dtypes_orig
+        )
+        if all(isinstance(dtype_iter, np.dtype) for dtype_iter in dtypes_orig):
+            dtype_orig = np.result_type(*dtypes_orig)
+        elif pandas_requires_conversion and any(d == object for d in dtypes_orig):
+            # Force object if any of the dtypes is an object
+            dtype_orig = object
+
+    elif (_is_extension_array_dtype(array) or hasattr(array, "iloc")) and hasattr(
+        array, "dtype"
+    ):
+        # array is a pandas series
+        type_if_series = type(array)
+        pandas_requires_conversion = _pandas_dtype_needs_early_conversion(array.dtype)
+        if isinstance(array.dtype, np.dtype):
+            dtype_orig = array.dtype
+        else:
+            # Set to None to let array.astype work out the best dtype
+            dtype_orig = None
+
+    if dtype_numeric:
+        if (
+            dtype_orig is not None
+            and hasattr(dtype_orig, "kind")
+            and dtype_orig.kind == "O"
+        ):
+            # if input is object, convert to float.
+            dtype = xp.float64
+        else:
+            dtype = None
+
+    if isinstance(dtype, (list, tuple)):
+        if dtype_orig is not None and dtype_orig in dtype:
+            # no dtype conversion required
+            dtype = None
+        else:
+            # dtype conversion required. Let's select the first element of the
+            # list of accepted types.
+            dtype = dtype[0]
+
+    if pandas_requires_conversion:
+        # pandas dataframe requires conversion earlier to handle extension dtypes with
+        # nans
+        # Use the original dtype for conversion if dtype is None
+        new_dtype = dtype_orig if dtype is None else dtype
+        array = array.astype(new_dtype)
+        # Since we converted here, we do not need to convert again later
+        dtype = None
+
+    if ensure_all_finite not in (True, False, "allow-nan"):
+        raise ValueError(
+            "ensure_all_finite should be a bool or 'allow-nan'. Got "
+            f"{ensure_all_finite!r} instead."
+        )
+
+    if dtype is not None and _is_numpy_namespace(xp):
+        # convert to dtype object to conform to Array API to be use `xp.isdtype` later
+        dtype = np.dtype(dtype)
+
+    estimator_name = _check_estimator_name(estimator)
+    context = " by %s" % estimator_name if estimator is not None else ""
+
+    # When all dataframe columns are sparse, convert to a sparse array
+    if hasattr(array, "sparse") and array.ndim > 1:
+        with suppress(ImportError):
+            from pandas import SparseDtype
+
+            def is_sparse(dtype):
+                return isinstance(dtype, SparseDtype)
+
+            if array.dtypes.apply(is_sparse).all():
+                # DataFrame.sparse only supports `to_coo`
+                array = array.sparse.to_coo()
+                if array.dtype == np.dtype("object"):
+                    unique_dtypes = set([dt.subtype.name for dt in array_orig.dtypes])
+                    if len(unique_dtypes) > 1:
+                        raise ValueError(
+                            "Pandas DataFrame with mixed sparse extension arrays "
+                            "generated a sparse matrix with object dtype which "
+                            "can not be converted to a scipy sparse matrix."
+                            "Sparse extension arrays should all have the same "
+                            "numeric type."
+                        )
+
+    if sp.issparse(array):
+        _ensure_no_complex_data(array)
+        array = _ensure_sparse_format(
+            array,
+            accept_sparse=accept_sparse,
+            dtype=dtype,
+            copy=copy,
+            ensure_all_finite=ensure_all_finite,
+            accept_large_sparse=accept_large_sparse,
+            estimator_name=estimator_name,
+            input_name=input_name,
+        )
+        if ensure_2d and array.ndim < 2:
+            raise ValueError(
+                f"Expected 2D input, got input with shape {array.shape}.\n"
+                "Reshape your data either using array.reshape(-1, 1) if "
+                "your data has a single feature or array.reshape(1, -1) "
+                "if it contains a single sample."
+            )
+    else:
+        # If np.array(..) gives ComplexWarning, then we convert the warning
+        # to an error. This is needed because specifying a non complex
+        # dtype to the function converts complex to real dtype,
+        # thereby passing the test made in the lines following the scope
+        # of warnings context manager.
+        with warnings.catch_warnings():
+            try:
+                warnings.simplefilter("error", ComplexWarning)
+                if dtype is not None and xp.isdtype(dtype, "integral"):
+                    # Conversion float -> int should not contain NaN or
+                    # inf (numpy#14412). We cannot use casting='safe' because
+                    # then conversion float -> int would be disallowed.
+                    array = _asarray_with_order(array, order=order, xp=xp)
+                    if xp.isdtype(array.dtype, ("real floating", "complex floating")):
+                        _assert_all_finite(
+                            array,
+                            allow_nan=False,
+                            msg_dtype=dtype,
+                            estimator_name=estimator_name,
+                            input_name=input_name,
+                        )
+                    array = xp.astype(array, dtype, copy=False)
+                else:
+                    array = _asarray_with_order(array, order=order, dtype=dtype, xp=xp)
+            except ComplexWarning as complex_warning:
+                raise ValueError(
+                    "Complex data not supported\n{}\n".format(array)
+                ) from complex_warning
+
+        # It is possible that the np.array(..) gave no warning. This happens
+        # when no dtype conversion happened, for example dtype = None. The
+        # result is that np.array(..) produces an array of complex dtype
+        # and we need to catch and raise exception for such cases.
+        _ensure_no_complex_data(array)
+
+        if ensure_2d:
+            # If input is scalar raise error
+            if array.ndim == 0:
+                raise ValueError(
+                    "Expected 2D array, got scalar array instead:\narray={}.\n"
+                    "Reshape your data either using array.reshape(-1, 1) if "
+                    "your data has a single feature or array.reshape(1, -1) "
+                    "if it contains a single sample.".format(array)
+                )
+            # If input is 1D raise error
+            if array.ndim == 1:
+                # If input is a Series-like object (eg. pandas Series or polars Series)
+                if type_if_series is not None:
+                    msg = (
+                        f"Expected a 2-dimensional container but got {type_if_series} "
+                        "instead. Pass a DataFrame containing a single row (i.e. "
+                        "single sample) or a single column (i.e. single feature) "
+                        "instead."
+                    )
+                else:
+                    msg = (
+                        f"Expected 2D array, got 1D array instead:\narray={array}.\n"
+                        "Reshape your data either using array.reshape(-1, 1) if "
+                        "your data has a single feature or array.reshape(1, -1) "
+                        "if it contains a single sample."
+                    )
+                raise ValueError(msg)
+
+        if dtype_numeric and hasattr(array.dtype, "kind") and array.dtype.kind in "USV":
+            raise ValueError(
+                "dtype='numeric' is not compatible with arrays of bytes/strings."
+                "Convert your data to numeric values explicitly instead."
+            )
+        if not allow_nd and array.ndim >= 3:
+            raise ValueError(
+                f"Found array with dim {array.ndim},"
+                f" while dim <= 2 is required{context}."
+            )
+
+        if ensure_all_finite:
+            _assert_all_finite(
+                array,
+                input_name=input_name,
+                estimator_name=estimator_name,
+                allow_nan=ensure_all_finite == "allow-nan",
+            )
+
+        if copy:
+            if _is_numpy_namespace(xp):
+                # only make a copy if `array` and `array_orig` may share memory`
+                if np.may_share_memory(array, array_orig):
+                    array = _asarray_with_order(
+                        array, dtype=dtype, order=order, copy=True, xp=xp
+                    )
+            else:
+                # always make a copy for non-numpy arrays
+                array = _asarray_with_order(
+                    array, dtype=dtype, order=order, copy=True, xp=xp
+                )
+
+    if ensure_min_samples > 0:
+        n_samples = _num_samples(array)
+        if n_samples < ensure_min_samples:
+            raise ValueError(
+                "Found array with %d sample(s) (shape=%s) while a"
+                " minimum of %d is required%s."
+                % (n_samples, array.shape, ensure_min_samples, context)
+            )
+
+    if ensure_min_features > 0 and array.ndim == 2:
+        n_features = array.shape[1]
+        if n_features < ensure_min_features:
+            raise ValueError(
+                "Found array with %d feature(s) (shape=%s) while"
+                " a minimum of %d is required%s."
+                % (n_features, array.shape, ensure_min_features, context)
+            )
+
+    if ensure_non_negative:
+        whom = input_name
+        if estimator_name:
+            whom += f" in {estimator_name}"
+        check_non_negative(array, whom)
+
+    if force_writeable:
+        # By default, array.copy() creates a C-ordered copy. We set order=K to
+        # preserve the order of the array.
+        copy_params = {"order": "K"} if not sp.issparse(array) else {}
+
+        array_data = array.data if sp.issparse(array) else array
+        flags = getattr(array_data, "flags", None)
+        if not getattr(flags, "writeable", True):
+            # This situation can only happen when copy=False, the array is read-only and
+            # a writeable output is requested. This is an ambiguous setting so we chose
+            # to always (except for one specific setting, see below) make a copy to
+            # ensure that the output is writeable, even if avoidable, to not overwrite
+            # the user's data by surprise.
+
+            if _is_pandas_df_or_series(array_orig):
+                try:
+                    # In pandas >= 3, np.asarray(df), called earlier in check_array,
+                    # returns a read-only intermediate array. It can be made writeable
+                    # safely without copy because if the original DataFrame was backed
+                    # by a read-only array, trying to change the flag would raise an
+                    # error, in which case we make a copy.
+                    array_data.flags.writeable = True
+                except ValueError:
+                    array = array.copy(**copy_params)
+            else:
+                array = array.copy(**copy_params)
+
+    return array
+
+
+def _check_large_sparse(X, accept_large_sparse=False):
+    """Raise a ValueError if X has 64bit indices and accept_large_sparse=False"""
+    if not accept_large_sparse:
+        supported_indices = ["int32"]
+        if X.format == "coo":
+            index_keys = ["col", "row"]
+        elif X.format in ["csr", "csc", "bsr"]:
+            index_keys = ["indices", "indptr"]
+        else:
+            return
+        for key in index_keys:
+            indices_datatype = getattr(X, key).dtype
+            if indices_datatype not in supported_indices:
+                raise ValueError(
+                    "Only sparse matrices with 32-bit integer indices are accepted."
+                    f" Got {indices_datatype} indices. Please do report a minimal"
+                    " reproducer on scikit-learn issue tracker so that support for"
+                    " your use-case can be studied by maintainers. See:"
+                    " https://scikit-learn.org/dev/developers/minimal_reproducer.html"
+                )
+
+
+def check_X_y(
+    X,
+    y,
+    accept_sparse=False,
+    *,
+    accept_large_sparse=True,
+    dtype="numeric",
+    order=None,
+    copy=False,
+    force_writeable=False,
+    force_all_finite="deprecated",
+    ensure_all_finite=None,
+    ensure_2d=True,
+    allow_nd=False,
+    multi_output=False,
+    ensure_min_samples=1,
+    ensure_min_features=1,
+    y_numeric=False,
+    estimator=None,
+):
+    """Input validation for standard estimators.
+
+    Checks X and y for consistent length, enforces X to be 2D and y 1D. By
+    default, X is checked to be non-empty and containing only finite values.
+    Standard input checks are also applied to y, such as checking that y
+    does not have np.nan or np.inf targets. For multi-label y, set
+    multi_output=True to allow 2D and sparse y. If the dtype of X is
+    object, attempt converting to float, raising on failure.
+
+    Parameters
+    ----------
+    X : {ndarray, list, sparse matrix}
+        Input data.
+
+    y : {ndarray, list, sparse matrix}
+        Labels.
+
+    accept_sparse : str, bool or list of str, default=False
+        String[s] representing allowed sparse matrix formats, such as 'csc',
+        'csr', etc. If the input is sparse but not in the allowed format,
+        it will be converted to the first listed format. True allows the input
+        to be any format. False means that a sparse matrix input will
+        raise an error.
+
+    accept_large_sparse : bool, default=True
+        If a CSR, CSC, COO or BSR sparse matrix is supplied and accepted by
+        accept_sparse, accept_large_sparse will cause it to be accepted only
+        if its indices are stored with a 32-bit dtype.
+
+        .. versionadded:: 0.20
+
+    dtype : 'numeric', type, list of type or None, default='numeric'
+        Data type of result. If None, the dtype of the input is preserved.
+        If "numeric", dtype is preserved unless array.dtype is object.
+        If dtype is a list of types, conversion on the first type is only
+        performed if the dtype of the input is not in the list.
+
+    order : {'F', 'C'}, default=None
+        Whether an array will be forced to be fortran or c-style. If
+        `None`, then the input data's order is preserved when possible.
+
+    copy : bool, default=False
+        Whether a forced copy will be triggered. If copy=False, a copy might
+        be triggered by a conversion.
+
+    force_writeable : bool, default=False
+        Whether to force the output array to be writeable. If True, the returned array
+        is guaranteed to be writeable, which may require a copy. Otherwise the
+        writeability of the input array is preserved.
+
+        .. versionadded:: 1.6
+
+    force_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in array. This parameter
+        does not influence whether y can have np.inf, np.nan, pd.NA values.
+        The possibilities are:
+
+        - True: Force all values of X to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in X.
+        - 'allow-nan': accepts only np.nan or pd.NA values in X. Values cannot
+          be infinite.
+
+        .. versionadded:: 0.20
+           ``force_all_finite`` accepts the string ``'allow-nan'``.
+
+        .. versionchanged:: 0.23
+           Accepts `pd.NA` and converts it into `np.nan`
+
+        .. deprecated:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite` and will be removed
+           in 1.8.
+
+    ensure_all_finite : bool or 'allow-nan', default=True
+        Whether to raise an error on np.inf, np.nan, pd.NA in array. This parameter
+        does not influence whether y can have np.inf, np.nan, pd.NA values.
+        The possibilities are:
+
+        - True: Force all values of X to be finite.
+        - False: accepts np.inf, np.nan, pd.NA in X.
+        - 'allow-nan': accepts only np.nan or pd.NA values in X. Values cannot
+          be infinite.
+
+        .. versionadded:: 1.6
+           `force_all_finite` was renamed to `ensure_all_finite`.
+
+    ensure_2d : bool, default=True
+        Whether to raise a value error if X is not 2D.
+
+    allow_nd : bool, default=False
+        Whether to allow X.ndim > 2.
+
+    multi_output : bool, default=False
+        Whether to allow 2D y (array or sparse matrix). If false, y will be
+        validated as a vector. y cannot have np.nan or np.inf values if
+        multi_output=True.
+
+    ensure_min_samples : int, default=1
+        Make sure that X has a minimum number of samples in its first
+        axis (rows for a 2D array).
+
+    ensure_min_features : int, default=1
+        Make sure that the 2D array has some minimum number of features
+        (columns). The default value of 1 rejects empty datasets.
+        This check is only enforced when X has effectively 2 dimensions or
+        is originally 1D and ``ensure_2d`` is True. Setting to 0 disables
+        this check.
+
+    y_numeric : bool, default=False
+        Whether to ensure that y has a numeric type. If dtype of y is object,
+        it is converted to float64. Should only be used for regression
+        algorithms.
+
+    estimator : str or estimator instance, default=None
+        If passed, include the name of the estimator in warning messages.
+
+    Returns
+    -------
+    X_converted : object
+        The converted and validated X.
+
+    y_converted : object
+        The converted and validated y.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_X_y
+    >>> X = [[1, 2], [3, 4], [5, 6]]
+    >>> y = [1, 2, 3]
+    >>> X, y = check_X_y(X, y)
+    >>> X
+    array([[1, 2],
+          [3, 4],
+          [5, 6]])
+    >>> y
+    array([1, 2, 3])
+    """
+    if y is None:
+        if estimator is None:
+            estimator_name = "estimator"
+        else:
+            estimator_name = _check_estimator_name(estimator)
+        raise ValueError(
+            f"{estimator_name} requires y to be passed, but the target y is None"
+        )
+
+    ensure_all_finite = _deprecate_force_all_finite(force_all_finite, ensure_all_finite)
+
+    X = check_array(
+        X,
+        accept_sparse=accept_sparse,
+        accept_large_sparse=accept_large_sparse,
+        dtype=dtype,
+        order=order,
+        copy=copy,
+        force_writeable=force_writeable,
+        ensure_all_finite=ensure_all_finite,
+        ensure_2d=ensure_2d,
+        allow_nd=allow_nd,
+        ensure_min_samples=ensure_min_samples,
+        ensure_min_features=ensure_min_features,
+        estimator=estimator,
+        input_name="X",
+    )
+
+    y = _check_y(y, multi_output=multi_output, y_numeric=y_numeric, estimator=estimator)
+
+    check_consistent_length(X, y)
+
+    return X, y
+
+
+def _check_y(y, multi_output=False, y_numeric=False, estimator=None):
+    """Isolated part of check_X_y dedicated to y validation"""
+    if multi_output:
+        y = check_array(
+            y,
+            accept_sparse="csr",
+            ensure_all_finite=True,
+            ensure_2d=False,
+            dtype=None,
+            input_name="y",
+            estimator=estimator,
+        )
+    else:
+        estimator_name = _check_estimator_name(estimator)
+        y = column_or_1d(y, warn=True)
+        _assert_all_finite(y, input_name="y", estimator_name=estimator_name)
+        _ensure_no_complex_data(y)
+    if y_numeric and hasattr(y.dtype, "kind") and y.dtype.kind == "O":
+        y = y.astype(np.float64)
+
+    return y
+
+
+def column_or_1d(y, *, dtype=None, warn=False, device=None):
+    """Ravel column or 1d numpy array, else raises an error.
+
+    Parameters
+    ----------
+    y : array-like
+       Input data.
+
+    dtype : data-type, default=None
+        Data type for `y`.
+
+        .. versionadded:: 1.2
+
+    warn : bool, default=False
+       To control display of warnings.
+
+    device : device, default=None
+        `device` object.
+        See the :ref:`Array API User Guide <array_api>` for more details.
+
+        .. versionadded:: 1.6
+
+    Returns
+    -------
+    y : ndarray
+       Output data.
+
+    Raises
+    ------
+    ValueError
+        If `y` is not a 1D array or a 2D array with a single row or column.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import column_or_1d
+    >>> column_or_1d([1, 1])
+    array([1, 1])
+    """
+    xp, _ = get_namespace(y)
+    y = check_array(
+        y,
+        ensure_2d=False,
+        dtype=dtype,
+        input_name="y",
+        ensure_all_finite=False,
+        ensure_min_samples=0,
+    )
+
+    shape = y.shape
+    if len(shape) == 1:
+        return _asarray_with_order(
+            xp.reshape(y, (-1,)), order="C", xp=xp, device=device
+        )
+    if len(shape) == 2 and shape[1] == 1:
+        if warn:
+            warnings.warn(
+                (
+                    "A column-vector y was passed when a 1d array was"
+                    " expected. Please change the shape of y to "
+                    "(n_samples, ), for example using ravel()."
+                ),
+                DataConversionWarning,
+                stacklevel=2,
+            )
+        return _asarray_with_order(
+            xp.reshape(y, (-1,)), order="C", xp=xp, device=device
+        )
+
+    raise ValueError(
+        "y should be a 1d array, got an array of shape {} instead.".format(shape)
+    )
+
+
+def check_random_state(seed):
+    """Turn seed into a np.random.RandomState instance.
+
+    Parameters
+    ----------
+    seed : None, int or instance of RandomState
+        If seed is None, return the RandomState singleton used by np.random.
+        If seed is an int, return a new RandomState instance seeded with seed.
+        If seed is already a RandomState instance, return it.
+        Otherwise raise ValueError.
+
+    Returns
+    -------
+    :class:`numpy:numpy.random.RandomState`
+        The random state object based on `seed` parameter.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_random_state
+    >>> check_random_state(42)
+    RandomState(MT19937) at 0x...
+    """
+    if seed is None or seed is np.random:
+        return np.random.mtrand._rand
+    if isinstance(seed, numbers.Integral):
+        return np.random.RandomState(seed)
+    if isinstance(seed, np.random.RandomState):
+        return seed
+    raise ValueError(
+        "%r cannot be used to seed a numpy.random.RandomState instance" % seed
+    )
+
+
+def has_fit_parameter(estimator, parameter):
+    """Check whether the estimator's fit method supports the given parameter.
+
+    Parameters
+    ----------
+    estimator : object
+        An estimator to inspect.
+
+    parameter : str
+        The searched parameter.
+
+    Returns
+    -------
+    is_parameter : bool
+        Whether the parameter was found to be a named parameter of the
+        estimator's fit method.
+
+    Examples
+    --------
+    >>> from sklearn.svm import SVC
+    >>> from sklearn.utils.validation import has_fit_parameter
+    >>> has_fit_parameter(SVC(), "sample_weight")
+    True
+    """
+    return (
+        # This is used during test collection in common tests. The
+        # hasattr(estimator, "fit") makes it so that we don't fail for an estimator
+        # that does not have a `fit` method during collection of checks. The right
+        # checks will fail later.
+        hasattr(estimator, "fit") and parameter in signature(estimator.fit).parameters
+    )
+
+
+def check_symmetric(array, *, tol=1e-10, raise_warning=True, raise_exception=False):
+    """Make sure that array is 2D, square and symmetric.
+
+    If the array is not symmetric, then a symmetrized version is returned.
+    Optionally, a warning or exception is raised if the matrix is not
+    symmetric.
+
+    Parameters
+    ----------
+    array : {ndarray, sparse matrix}
+        Input object to check / convert. Must be two-dimensional and square,
+        otherwise a ValueError will be raised.
+
+    tol : float, default=1e-10
+        Absolute tolerance for equivalence of arrays. Default = 1E-10.
+
+    raise_warning : bool, default=True
+        If True then raise a warning if conversion is required.
+
+    raise_exception : bool, default=False
+        If True then raise an exception if array is not symmetric.
+
+    Returns
+    -------
+    array_sym : {ndarray, sparse matrix}
+        Symmetrized version of the input array, i.e. the average of array
+        and array.transpose(). If sparse, then duplicate entries are first
+        summed and zeros are eliminated.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils.validation import check_symmetric
+    >>> symmetric_array = np.array([[0, 1, 2], [1, 0, 1], [2, 1, 0]])
+    >>> check_symmetric(symmetric_array)
+    array([[0, 1, 2],
+           [1, 0, 1],
+           [2, 1, 0]])
+    >>> from scipy.sparse import csr_matrix
+    >>> sparse_symmetric_array = csr_matrix(symmetric_array)
+    >>> check_symmetric(sparse_symmetric_array)
+    <Compressed Sparse Row sparse matrix of dtype 'int64'
+        with 6 stored elements and shape (3, 3)>
+    """
+    if (array.ndim != 2) or (array.shape[0] != array.shape[1]):
+        raise ValueError(
+            "array must be 2-dimensional and square. shape = {0}".format(array.shape)
+        )
+
+    if sp.issparse(array):
+        diff = array - array.T
+        # only csr, csc, and coo have `data` attribute
+        if diff.format not in ["csr", "csc", "coo"]:
+            diff = diff.tocsr()
+        symmetric = np.all(abs(diff.data) < tol)
+    else:
+        symmetric = np.allclose(array, array.T, atol=tol)
+
+    if not symmetric:
+        if raise_exception:
+            raise ValueError("Array must be symmetric")
+        if raise_warning:
+            warnings.warn(
+                (
+                    "Array is not symmetric, and will be converted "
+                    "to symmetric by average with its transpose."
+                ),
+                stacklevel=2,
+            )
+        if sp.issparse(array):
+            conversion = "to" + array.format
+            array = getattr(0.5 * (array + array.T), conversion)()
+        else:
+            array = 0.5 * (array + array.T)
+
+    return array
+
+
+def _is_fitted(estimator, attributes=None, all_or_any=all):
+    """Determine if an estimator is fitted
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        Estimator instance for which the check is performed.
+
+    attributes : str, list or tuple of str, default=None
+        Attribute name(s) given as string or a list/tuple of strings
+        Eg.: ``["coef_", "estimator_", ...], "coef_"``
+
+        If `None`, `estimator` is considered fitted if there exist an
+        attribute that ends with a underscore and does not start with double
+        underscore.
+
+    all_or_any : callable, {all, any}, default=all
+        Specify whether all or any of the given attributes must exist.
+
+    Returns
+    -------
+    fitted : bool
+        Whether the estimator is fitted.
+    """
+    if attributes is not None:
+        if not isinstance(attributes, (list, tuple)):
+            attributes = [attributes]
+        return all_or_any([hasattr(estimator, attr) for attr in attributes])
+
+    if hasattr(estimator, "__sklearn_is_fitted__"):
+        return estimator.__sklearn_is_fitted__()
+
+    fitted_attrs = [
+        v for v in vars(estimator) if v.endswith("_") and not v.startswith("__")
+    ]
+    return len(fitted_attrs) > 0
+
+
+def check_is_fitted(estimator, attributes=None, *, msg=None, all_or_any=all):
+    """Perform is_fitted validation for estimator.
+
+    Checks if the estimator is fitted by verifying the presence of
+    fitted attributes (ending with a trailing underscore) and otherwise
+    raises a :class:`~sklearn.exceptions.NotFittedError` with the given message.
+
+    If an estimator does not set any attributes with a trailing underscore, it
+    can define a ``__sklearn_is_fitted__`` method returning a boolean to
+    specify if the estimator is fitted or not. See
+    :ref:`sphx_glr_auto_examples_developing_estimators_sklearn_is_fitted.py`
+    for an example on how to use the API.
+
+    If no `attributes` are passed, this function will pass if an estimator is stateless.
+    An estimator can indicate it's stateless by setting the `requires_fit` tag. See
+    :ref:`estimator_tags` for more information. Note that the `requires_fit` tag
+    is ignored if `attributes` are passed.
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        Estimator instance for which the check is performed.
+
+    attributes : str, list or tuple of str, default=None
+        Attribute name(s) given as string or a list/tuple of strings
+        Eg.: ``["coef_", "estimator_", ...], "coef_"``
+
+        If `None`, `estimator` is considered fitted if there exist an
+        attribute that ends with a underscore and does not start with double
+        underscore.
+
+    msg : str, default=None
+        The default error message is, "This %(name)s instance is not fitted
+        yet. Call 'fit' with appropriate arguments before using this
+        estimator."
+
+        For custom messages if "%(name)s" is present in the message string,
+        it is substituted for the estimator name.
+
+        Eg. : "Estimator, %(name)s, must be fitted before sparsifying".
+
+    all_or_any : callable, {all, any}, default=all
+        Specify whether all or any of the given attributes must exist.
+
+    Raises
+    ------
+    TypeError
+        If the estimator is a class or not an estimator instance
+
+    NotFittedError
+        If the attributes are not found.
+
+    Examples
+    --------
+    >>> from sklearn.linear_model import LogisticRegression
+    >>> from sklearn.utils.validation import check_is_fitted
+    >>> from sklearn.exceptions import NotFittedError
+    >>> lr = LogisticRegression()
+    >>> try:
+    ...     check_is_fitted(lr)
+    ... except NotFittedError as exc:
+    ...     print(f"Model is not fitted yet.")
+    Model is not fitted yet.
+    >>> lr.fit([[1, 2], [1, 3]], [1, 0])
+    LogisticRegression()
+    >>> check_is_fitted(lr)
+    """
+    if isclass(estimator):
+        raise TypeError("{} is a class, not an instance.".format(estimator))
+    if msg is None:
+        msg = (
+            "This %(name)s instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using this estimator."
+        )
+
+    if not hasattr(estimator, "fit"):
+        raise TypeError("%s is not an estimator instance." % (estimator))
+
+    tags = get_tags(estimator)
+
+    if not tags.requires_fit and attributes is None:
+        return
+
+    if not _is_fitted(estimator, attributes, all_or_any):
+        raise NotFittedError(msg % {"name": type(estimator).__name__})
+
+
+def _estimator_has(attr, *, delegates=("estimator_", "estimator")):
+    """Check if we can delegate a method to the underlying estimator.
+
+    We check the `delegates` in the order they are passed. By default, we first check
+    the fitted estimator if available, otherwise we check the unfitted estimator.
+
+    Parameters
+    ----------
+    attr : str
+        Name of the attribute the delegate might or might not have.
+
+    delegates: tuple of str, default=("estimator_", "estimator")
+        A tuple of sub-estimator(s) to check if we can delegate the `attr` method.
+
+    Returns
+    -------
+    check : function
+        Function to check if the delegate has the attribute.
+
+    Raises
+    ------
+    ValueError
+        Raised when none of the delegates are present in the object.
+    """
+
+    def check(self):
+        for delegate in delegates:
+            # In meta estimators with multiple sub estimators,
+            # only the attribute of the first sub estimator is checked,
+            # assuming uniformity across all sub estimators.
+            if hasattr(self, delegate):
+                delegator = getattr(self, delegate)
+                if isinstance(delegator, Sequence):
+                    return getattr(delegator[0], attr)
+                else:
+                    return getattr(delegator, attr)
+
+        raise ValueError(f"None of the delegates {delegates} are present in the class.")
+
+    return check
+
+
+def check_non_negative(X, whom):
+    """
+    Check if there is any negative value in an array.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix}
+        Input data.
+
+    whom : str
+        Who passed X to this function.
+    """
+    xp, _ = get_namespace(X)
+    # avoid X.min() on sparse matrix since it also sorts the indices
+    if sp.issparse(X):
+        if X.format in ["lil", "dok"]:
+            X = X.tocsr()
+        if X.data.size == 0:
+            X_min = 0
+        else:
+            X_min = X.data.min()
+    else:
+        X_min = xp.min(X)
+
+    if X_min < 0:
+        raise ValueError(f"Negative values in data passed to {whom}.")
+
+
+def check_scalar(
+    x,
+    name,
+    target_type,
+    *,
+    min_val=None,
+    max_val=None,
+    include_boundaries="both",
+):
+    """Validate scalar parameters type and value.
+
+    Parameters
+    ----------
+    x : object
+        The scalar parameter to validate.
+
+    name : str
+        The name of the parameter to be printed in error messages.
+
+    target_type : type or tuple
+        Acceptable data types for the parameter.
+
+    min_val : float or int, default=None
+        The minimum valid value the parameter can take. If None (default) it
+        is implied that the parameter does not have a lower bound.
+
+    max_val : float or int, default=None
+        The maximum valid value the parameter can take. If None (default) it
+        is implied that the parameter does not have an upper bound.
+
+    include_boundaries : {"left", "right", "both", "neither"}, default="both"
+        Whether the interval defined by `min_val` and `max_val` should include
+        the boundaries. Possible choices are:
+
+        - `"left"`: only `min_val` is included in the valid interval.
+          It is equivalent to the interval `[ min_val, max_val )`.
+        - `"right"`: only `max_val` is included in the valid interval.
+          It is equivalent to the interval `( min_val, max_val ]`.
+        - `"both"`: `min_val` and `max_val` are included in the valid interval.
+          It is equivalent to the interval `[ min_val, max_val ]`.
+        - `"neither"`: neither `min_val` nor `max_val` are included in the
+          valid interval. It is equivalent to the interval `( min_val, max_val )`.
+
+    Returns
+    -------
+    x : numbers.Number
+        The validated number.
+
+    Raises
+    ------
+    TypeError
+        If the parameter's type does not match the desired type.
+
+    ValueError
+        If the parameter's value violates the given bounds.
+        If `min_val`, `max_val` and `include_boundaries` are inconsistent.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import check_scalar
+    >>> check_scalar(10, "x", int, min_val=1, max_val=20)
+    10
+    """
+
+    def type_name(t):
+        """Convert type into humman readable string."""
+        module = t.__module__
+        qualname = t.__qualname__
+        if module == "builtins":
+            return qualname
+        elif t == numbers.Real:
+            return "float"
+        elif t == numbers.Integral:
+            return "int"
+        return f"{module}.{qualname}"
+
+    if not isinstance(x, target_type):
+        if isinstance(target_type, tuple):
+            types_str = ", ".join(type_name(t) for t in target_type)
+            target_type_str = f"{{{types_str}}}"
+        else:
+            target_type_str = type_name(target_type)
+
+        raise TypeError(
+            f"{name} must be an instance of {target_type_str}, not"
+            f" {type(x).__qualname__}."
+        )
+
+    expected_include_boundaries = ("left", "right", "both", "neither")
+    if include_boundaries not in expected_include_boundaries:
+        raise ValueError(
+            f"Unknown value for `include_boundaries`: {include_boundaries!r}. "
+            f"Possible values are: {expected_include_boundaries}."
+        )
+
+    if max_val is None and include_boundaries == "right":
+        raise ValueError(
+            "`include_boundaries`='right' without specifying explicitly `max_val` "
+            "is inconsistent."
+        )
+
+    if min_val is None and include_boundaries == "left":
+        raise ValueError(
+            "`include_boundaries`='left' without specifying explicitly `min_val` "
+            "is inconsistent."
+        )
+
+    comparison_operator = (
+        operator.lt if include_boundaries in ("left", "both") else operator.le
+    )
+    if min_val is not None and comparison_operator(x, min_val):
+        raise ValueError(
+            f"{name} == {x}, must be"
+            f" {'>=' if include_boundaries in ('left', 'both') else '>'} {min_val}."
+        )
+
+    comparison_operator = (
+        operator.gt if include_boundaries in ("right", "both") else operator.ge
+    )
+    if max_val is not None and comparison_operator(x, max_val):
+        raise ValueError(
+            f"{name} == {x}, must be"
+            f" {'<=' if include_boundaries in ('right', 'both') else '<'} {max_val}."
+        )
+
+    return x
+
+
+def _check_psd_eigenvalues(lambdas, enable_warnings=False):
+    """Check the eigenvalues of a positive semidefinite (PSD) matrix.
+
+    Checks the provided array of PSD matrix eigenvalues for numerical or
+    conditioning issues and returns a fixed validated version. This method
+    should typically be used if the PSD matrix is user-provided (e.g. a
+    Gram matrix) or computed using a user-provided dissimilarity metric
+    (e.g. kernel function), or if the decomposition process uses approximation
+    methods (randomized SVD, etc.).
+
+    It checks for three things:
+
+    - that there are no significant imaginary parts in eigenvalues (more than
+      1e-5 times the maximum real part). If this check fails, it raises a
+      ``ValueError``. Otherwise all non-significant imaginary parts that may
+      remain are set to zero. This operation is traced with a
+      ``PositiveSpectrumWarning`` when ``enable_warnings=True``.
+
+    - that eigenvalues are not all negative. If this check fails, it raises a
+      ``ValueError``
+
+    - that there are no significant negative eigenvalues with absolute value
+      more than 1e-10 (1e-6) and more than 1e-5 (5e-3) times the largest
+      positive eigenvalue in double (simple) precision. If this check fails,
+      it raises a ``ValueError``. Otherwise all negative eigenvalues that may
+      remain are set to zero. This operation is traced with a
+      ``PositiveSpectrumWarning`` when ``enable_warnings=True``.
+
+    Finally, all the positive eigenvalues that are too small (with a value
+    smaller than the maximum eigenvalue multiplied by 1e-12 (2e-7)) are set to
+    zero. This operation is traced with a ``PositiveSpectrumWarning`` when
+    ``enable_warnings=True``.
+
+    Parameters
+    ----------
+    lambdas : array-like of shape (n_eigenvalues,)
+        Array of eigenvalues to check / fix.
+
+    enable_warnings : bool, default=False
+        When this is set to ``True``, a ``PositiveSpectrumWarning`` will be
+        raised when there are imaginary parts, negative eigenvalues, or
+        extremely small non-zero eigenvalues. Otherwise no warning will be
+        raised. In both cases, imaginary parts, negative eigenvalues, and
+        extremely small non-zero eigenvalues will be set to zero.
+
+    Returns
+    -------
+    lambdas_fixed : ndarray of shape (n_eigenvalues,)
+        A fixed validated copy of the array of eigenvalues.
+
+    Examples
+    --------
+    >>> from sklearn.utils.validation import _check_psd_eigenvalues
+    >>> _check_psd_eigenvalues([1, 2])      # nominal case
+    array([1, 2])
+    >>> _check_psd_eigenvalues([5, 5j])     # significant imag part
+    Traceback (most recent call last):
+        ...
+    ValueError: There are significant imaginary parts in eigenvalues (1
+        of the maximum real part). Either the matrix is not PSD, or there was
+        an issue while computing the eigendecomposition of the matrix.
+    >>> _check_psd_eigenvalues([5, 5e-5j])  # insignificant imag part
+    array([5., 0.])
+    >>> _check_psd_eigenvalues([-5, -1])    # all negative
+    Traceback (most recent call last):
+        ...
+    ValueError: All eigenvalues are negative (maximum is -1). Either the
+        matrix is not PSD, or there was an issue while computing the
+        eigendecomposition of the matrix.
+    >>> _check_psd_eigenvalues([5, -1])     # significant negative
+    Traceback (most recent call last):
+        ...
+    ValueError: There are significant negative eigenvalues (0.2 of the
+        maximum positive). Either the matrix is not PSD, or there was an issue
+        while computing the eigendecomposition of the matrix.
+    >>> _check_psd_eigenvalues([5, -5e-5])  # insignificant negative
+    array([5., 0.])
+    >>> _check_psd_eigenvalues([5, 4e-12])  # bad conditioning (too small)
+    array([5., 0.])
+
+    """
+
+    lambdas = np.array(lambdas)
+    is_double_precision = lambdas.dtype == np.float64
+
+    # note: the minimum value available is
+    #  - single-precision: np.finfo('float32').eps = 1.2e-07
+    #  - double-precision: np.finfo('float64').eps = 2.2e-16
+
+    # the various thresholds used for validation
+    # we may wish to change the value according to precision.
+    significant_imag_ratio = 1e-5
+    significant_neg_ratio = 1e-5 if is_double_precision else 5e-3
+    significant_neg_value = 1e-10 if is_double_precision else 1e-6
+    small_pos_ratio = 1e-12 if is_double_precision else 2e-7
+
+    # Check that there are no significant imaginary parts
+    if not np.isreal(lambdas).all():
+        max_imag_abs = np.abs(np.imag(lambdas)).max()
+        max_real_abs = np.abs(np.real(lambdas)).max()
+        if max_imag_abs > significant_imag_ratio * max_real_abs:
+            raise ValueError(
+                "There are significant imaginary parts in eigenvalues (%g "
+                "of the maximum real part). Either the matrix is not PSD, or "
+                "there was an issue while computing the eigendecomposition "
+                "of the matrix." % (max_imag_abs / max_real_abs)
+            )
+
+        # warn about imaginary parts being removed
+        if enable_warnings:
+            warnings.warn(
+                "There are imaginary parts in eigenvalues (%g "
+                "of the maximum real part). Either the matrix is not"
+                " PSD, or there was an issue while computing the "
+                "eigendecomposition of the matrix. Only the real "
+                "parts will be kept." % (max_imag_abs / max_real_abs),
+                PositiveSpectrumWarning,
+            )
+
+    # Remove all imaginary parts (even if zero)
+    lambdas = np.real(lambdas)
+
+    # Check that there are no significant negative eigenvalues
+    max_eig = lambdas.max()
+    if max_eig < 0:
+        raise ValueError(
+            "All eigenvalues are negative (maximum is %g). "
+            "Either the matrix is not PSD, or there was an "
+            "issue while computing the eigendecomposition of "
+            "the matrix." % max_eig
+        )
+
+    else:
+        min_eig = lambdas.min()
+        if (
+            min_eig < -significant_neg_ratio * max_eig
+            and min_eig < -significant_neg_value
+        ):
+            raise ValueError(
+                "There are significant negative eigenvalues (%g"
+                " of the maximum positive). Either the matrix is "
+                "not PSD, or there was an issue while computing "
+                "the eigendecomposition of the matrix." % (-min_eig / max_eig)
+            )
+        elif min_eig < 0:
+            # Remove all negative values and warn about it
+            if enable_warnings:
+                warnings.warn(
+                    "There are negative eigenvalues (%g of the "
+                    "maximum positive). Either the matrix is not "
+                    "PSD, or there was an issue while computing the"
+                    " eigendecomposition of the matrix. Negative "
+                    "eigenvalues will be replaced with 0." % (-min_eig / max_eig),
+                    PositiveSpectrumWarning,
+                )
+            lambdas[lambdas < 0] = 0
+
+    # Check for conditioning (small positive non-zeros)
+    too_small_lambdas = (0 < lambdas) & (lambdas < small_pos_ratio * max_eig)
+    if too_small_lambdas.any():
+        if enable_warnings:
+            warnings.warn(
+                "Badly conditioned PSD matrix spectrum: the largest "
+                "eigenvalue is more than %g times the smallest. "
+                "Small eigenvalues will be replaced with 0."
+                "" % (1 / small_pos_ratio),
+                PositiveSpectrumWarning,
+            )
+        lambdas[too_small_lambdas] = 0
+
+    return lambdas
+
+
+def _check_sample_weight(
+    sample_weight, X, *, dtype=None, ensure_non_negative=False, copy=False
+):
+    """Validate sample weights.
+
+    Note that passing sample_weight=None will output an array of ones.
+    Therefore, in some cases, you may want to protect the call with:
+    if sample_weight is not None:
+        sample_weight = _check_sample_weight(...)
+
+    Parameters
+    ----------
+    sample_weight : {ndarray, Number or None}, shape (n_samples,)
+        Input sample weights.
+
+    X : {ndarray, list, sparse matrix}
+        Input data.
+
+    dtype : dtype, default=None
+        dtype of the validated `sample_weight`.
+        If None, and `sample_weight` is an array:
+
+            - If `sample_weight.dtype` is one of `{np.float64, np.float32}`,
+              then the dtype is preserved.
+            - Else the output has NumPy's default dtype: `np.float64`.
+
+        If `dtype` is not `{np.float32, np.float64, None}`, then output will
+        be `np.float64`.
+
+    ensure_non_negative : bool, default=False,
+        Whether or not the weights are expected to be non-negative.
+
+        .. versionadded:: 1.0
+
+    copy : bool, default=False
+        If True, a copy of sample_weight will be created.
+
+    Returns
+    -------
+    sample_weight : ndarray of shape (n_samples,)
+        Validated sample weight. It is guaranteed to be "C" contiguous.
+    """
+    n_samples = _num_samples(X)
+
+    xp, _ = get_namespace(X)
+
+    if dtype is not None and dtype not in [xp.float32, xp.float64]:
+        dtype = xp.float64
+
+    if sample_weight is None:
+        sample_weight = xp.ones(n_samples, dtype=dtype)
+    elif isinstance(sample_weight, numbers.Number):
+        sample_weight = xp.full(n_samples, sample_weight, dtype=dtype)
+    else:
+        if dtype is None:
+            dtype = [xp.float64, xp.float32]
+        sample_weight = check_array(
+            sample_weight,
+            accept_sparse=False,
+            ensure_2d=False,
+            dtype=dtype,
+            order="C",
+            copy=copy,
+            input_name="sample_weight",
+        )
+        if sample_weight.ndim != 1:
+            raise ValueError("Sample weights must be 1D array or scalar")
+
+        if sample_weight.shape != (n_samples,):
+            raise ValueError(
+                "sample_weight.shape == {}, expected {}!".format(
+                    sample_weight.shape, (n_samples,)
+                )
+            )
+
+    if ensure_non_negative:
+        check_non_negative(sample_weight, "`sample_weight`")
+
+    return sample_weight
+
+
+def _allclose_dense_sparse(x, y, rtol=1e-7, atol=1e-9):
+    """Check allclose for sparse and dense data.
+
+    Both x and y need to be either sparse or dense, they
+    can't be mixed.
+
+    Parameters
+    ----------
+    x : {array-like, sparse matrix}
+        First array to compare.
+
+    y : {array-like, sparse matrix}
+        Second array to compare.
+
+    rtol : float, default=1e-7
+        Relative tolerance; see numpy.allclose.
+
+    atol : float, default=1e-9
+        absolute tolerance; see numpy.allclose. Note that the default here is
+        more tolerant than the default for numpy.testing.assert_allclose, where
+        atol=0.
+    """
+    if sp.issparse(x) and sp.issparse(y):
+        x = x.tocsr()
+        y = y.tocsr()
+        x.sum_duplicates()
+        y.sum_duplicates()
+        return (
+            np.array_equal(x.indices, y.indices)
+            and np.array_equal(x.indptr, y.indptr)
+            and np.allclose(x.data, y.data, rtol=rtol, atol=atol)
+        )
+    elif not sp.issparse(x) and not sp.issparse(y):
+        return np.allclose(x, y, rtol=rtol, atol=atol)
+    raise ValueError(
+        "Can only compare two sparse matrices, not a sparse matrix and an array"
+    )
+
+
+def _check_response_method(estimator, response_method):
+    """Check if `response_method` is available in estimator and return it.
+
+    .. versionadded:: 1.3
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        Classifier or regressor to check.
+
+    response_method : {"predict_proba", "predict_log_proba", "decision_function",
+            "predict"} or list of such str
+        Specifies the response method to use get prediction from an estimator
+        (i.e. :term:`predict_proba`, :term:`predict_log_proba`,
+        :term:`decision_function` or :term:`predict`). Possible choices are:
+        - if `str`, it corresponds to the name to the method to return;
+        - if a list of `str`, it provides the method names in order of
+          preference. The method returned corresponds to the first method in
+          the list and which is implemented by `estimator`.
+
+    Returns
+    -------
+    prediction_method : callable
+        Prediction method of estimator.
+
+    Raises
+    ------
+    AttributeError
+        If `response_method` is not available in `estimator`.
+    """
+    if isinstance(response_method, str):
+        list_methods = [response_method]
+    else:
+        list_methods = response_method
+
+    prediction_method = [getattr(estimator, method, None) for method in list_methods]
+    prediction_method = reduce(lambda x, y: x or y, prediction_method)
+    if prediction_method is None:
+        raise AttributeError(
+            f"{estimator.__class__.__name__} has none of the following attributes: "
+            f"{', '.join(list_methods)}."
+        )
+
+    return prediction_method
+
+
+def _check_method_params(X, params, indices=None):
+    """Check and validate the parameters passed to a specific
+    method like `fit`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data array.
+
+    params : dict
+        Dictionary containing the parameters passed to the method.
+
+    indices : array-like of shape (n_samples,), default=None
+        Indices to be selected if the parameter has the same size as `X`.
+
+    Returns
+    -------
+    method_params_validated : dict
+        Validated parameters. We ensure that the values support indexing.
+    """
+    from . import _safe_indexing
+
+    method_params_validated = {}
+    for param_key, param_value in params.items():
+        if (
+            not _is_arraylike(param_value) and not sp.issparse(param_value)
+        ) or _num_samples(param_value) != _num_samples(X):
+            # Non-indexable pass-through (for now for backward-compatibility).
+            # https://github.com/scikit-learn/scikit-learn/issues/15805
+            method_params_validated[param_key] = param_value
+        else:
+            # Any other method_params should support indexing
+            # (e.g. for cross-validation).
+            method_params_validated[param_key] = _make_indexable(param_value)
+            method_params_validated[param_key] = _safe_indexing(
+                method_params_validated[param_key], indices
+            )
+
+    return method_params_validated
+
+
+def _is_pandas_df_or_series(X):
+    """Return True if the X is a pandas dataframe or series."""
+    try:
+        pd = sys.modules["pandas"]
+    except KeyError:
+        return False
+    return isinstance(X, (pd.DataFrame, pd.Series))
+
+
+def _is_pandas_df(X):
+    """Return True if the X is a pandas dataframe."""
+    try:
+        pd = sys.modules["pandas"]
+    except KeyError:
+        return False
+    return isinstance(X, pd.DataFrame)
+
+
+def _is_pyarrow_data(X):
+    """Return True if the X is a pyarrow Table, RecordBatch, Array or ChunkedArray."""
+    try:
+        pa = sys.modules["pyarrow"]
+    except KeyError:
+        return False
+    return isinstance(X, (pa.Table, pa.RecordBatch, pa.Array, pa.ChunkedArray))
+
+
+def _is_polars_df_or_series(X):
+    """Return True if the X is a polars dataframe or series."""
+    try:
+        pl = sys.modules["polars"]
+    except KeyError:
+        return False
+    return isinstance(X, (pl.DataFrame, pl.Series))
+
+
+def _is_polars_df(X):
+    """Return True if the X is a polars dataframe."""
+    try:
+        pl = sys.modules["polars"]
+    except KeyError:
+        return False
+    return isinstance(X, pl.DataFrame)
+
+
+def _get_feature_names(X):
+    """Get feature names from X.
+
+    Support for other array containers should place its implementation here.
+
+    Parameters
+    ----------
+    X : {ndarray, dataframe} of shape (n_samples, n_features)
+        Array container to extract feature names.
+
+        - pandas dataframe : The columns will be considered to be feature
+          names. If the dataframe contains non-string feature names, `None` is
+          returned.
+        - All other array containers will return `None`.
+
+    Returns
+    -------
+    names: ndarray or None
+        Feature names of `X`. Unrecognized array containers will return `None`.
+    """
+    feature_names = None
+
+    # extract feature names for support array containers
+    if _is_pandas_df(X):
+        # Make sure we can inspect columns names from pandas, even with
+        # versions too old to expose a working implementation of
+        # __dataframe__.column_names() and avoid introducing any
+        # additional copy.
+        # TODO: remove the pandas-specific branch once the minimum supported
+        # version of pandas has a working implementation of
+        # __dataframe__.column_names() that is guaranteed to not introduce any
+        # additional copy of the data without having to impose allow_copy=False
+        # that could fail with other libraries. Note: in the longer term, we
+        # could decide to instead rely on the __dataframe_namespace__ API once
+        # adopted by our minimally supported pandas version.
+        feature_names = np.asarray(X.columns, dtype=object)
+    elif hasattr(X, "__dataframe__"):
+        df_protocol = X.__dataframe__()
+        feature_names = np.asarray(list(df_protocol.column_names()), dtype=object)
+
+    if feature_names is None or len(feature_names) == 0:
+        return
+
+    types = sorted(t.__qualname__ for t in set(type(v) for v in feature_names))
+
+    # mixed type of string and non-string is not supported
+    if len(types) > 1 and "str" in types:
+        raise TypeError(
+            "Feature names are only supported if all input features have string names, "
+            f"but your input has {types} as feature name / column name types. "
+            "If you want feature names to be stored and validated, you must convert "
+            "them all to strings, by using X.columns = X.columns.astype(str) for "
+            "example. Otherwise you can remove feature / column names from your input "
+            "data, or convert them all to a non-string data type."
+        )
+
+    # Only feature names of all strings are supported
+    if len(types) == 1 and types[0] == "str":
+        return feature_names
+
+
+def _check_feature_names_in(estimator, input_features=None, *, generate_names=True):
+    """Check `input_features` and generate names if needed.
+
+    Commonly used in :term:`get_feature_names_out`.
+
+    Parameters
+    ----------
+    input_features : array-like of str or None, default=None
+        Input features.
+
+        - If `input_features` is `None`, then `feature_names_in_` is
+          used as feature names in. If `feature_names_in_` is not defined,
+          then the following input feature names are generated:
+          `["x0", "x1", ..., "x(n_features_in_ - 1)"]`.
+        - If `input_features` is an array-like, then `input_features` must
+          match `feature_names_in_` if `feature_names_in_` is defined.
+
+    generate_names : bool, default=True
+        Whether to generate names when `input_features` is `None` and
+        `estimator.feature_names_in_` is not defined. This is useful for transformers
+        that validates `input_features` but do not require them in
+        :term:`get_feature_names_out` e.g. `PCA`.
+
+    Returns
+    -------
+    feature_names_in : ndarray of str or `None`
+        Feature names in.
+    """
+
+    feature_names_in_ = getattr(estimator, "feature_names_in_", None)
+    n_features_in_ = getattr(estimator, "n_features_in_", None)
+
+    if input_features is not None:
+        input_features = np.asarray(input_features, dtype=object)
+        if feature_names_in_ is not None and not np.array_equal(
+            feature_names_in_, input_features
+        ):
+            raise ValueError("input_features is not equal to feature_names_in_")
+
+        if n_features_in_ is not None and len(input_features) != n_features_in_:
+            raise ValueError(
+                "input_features should have length equal to number of "
+                f"features ({n_features_in_}), got {len(input_features)}"
+            )
+        return input_features
+
+    if feature_names_in_ is not None:
+        return feature_names_in_
+
+    if not generate_names:
+        return
+
+    # Generates feature names if `n_features_in_` is defined
+    if n_features_in_ is None:
+        raise ValueError("Unable to generate feature names without n_features_in_")
+
+    return np.asarray([f"x{i}" for i in range(n_features_in_)], dtype=object)
+
+
+def _generate_get_feature_names_out(estimator, n_features_out, input_features=None):
+    """Generate feature names out for estimator using the estimator name as the prefix.
+
+    The input_feature names are validated but not used. This function is useful
+    for estimators that generate their own names based on `n_features_out`, i.e. PCA.
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        Estimator producing output feature names.
+
+    n_feature_out : int
+        Number of feature names out.
+
+    input_features : array-like of str or None, default=None
+        Only used to validate feature names with `estimator.feature_names_in_`.
+
+    Returns
+    -------
+    feature_names_in : ndarray of str or `None`
+        Feature names in.
+    """
+    _check_feature_names_in(estimator, input_features, generate_names=False)
+    estimator_name = estimator.__class__.__name__.lower()
+    return np.asarray(
+        [f"{estimator_name}{i}" for i in range(n_features_out)], dtype=object
+    )
+
+
+def _check_monotonic_cst(estimator, monotonic_cst=None):
+    """Check the monotonic constraints and return the corresponding array.
+
+    This helper function should be used in the `fit` method of an estimator
+    that supports monotonic constraints and called after the estimator has
+    introspected input data to set the `n_features_in_` and optionally the
+    `feature_names_in_` attributes.
+
+    .. versionadded:: 1.2
+
+    Parameters
+    ----------
+    estimator : estimator instance
+
+    monotonic_cst : array-like of int, dict of str or None, default=None
+        Monotonic constraints for the features.
+
+        - If array-like, then it should contain only -1, 0 or 1. Each value
+            will be checked to be in [-1, 0, 1]. If a value is -1, then the
+            corresponding feature is required to be monotonically decreasing.
+        - If dict, then it the keys should be the feature names occurring in
+            `estimator.feature_names_in_` and the values should be -1, 0 or 1.
+        - If None, then an array of 0s will be allocated.
+
+    Returns
+    -------
+    monotonic_cst : ndarray of int
+        Monotonic constraints for each feature.
+    """
+    original_monotonic_cst = monotonic_cst
+    if monotonic_cst is None or isinstance(monotonic_cst, dict):
+        monotonic_cst = np.full(
+            shape=estimator.n_features_in_,
+            fill_value=0,
+            dtype=np.int8,
+        )
+        if isinstance(original_monotonic_cst, dict):
+            if not hasattr(estimator, "feature_names_in_"):
+                raise ValueError(
+                    f"{estimator.__class__.__name__} was not fitted on data "
+                    "with feature names. Pass monotonic_cst as an integer "
+                    "array instead."
+                )
+            unexpected_feature_names = list(
+                set(original_monotonic_cst) - set(estimator.feature_names_in_)
+            )
+            unexpected_feature_names.sort()  # deterministic error message
+            n_unexpeced = len(unexpected_feature_names)
+            if unexpected_feature_names:
+                if len(unexpected_feature_names) > 5:
+                    unexpected_feature_names = unexpected_feature_names[:5]
+                    unexpected_feature_names.append("...")
+                raise ValueError(
+                    f"monotonic_cst contains {n_unexpeced} unexpected feature "
+                    f"names: {unexpected_feature_names}."
+                )
+            for feature_idx, feature_name in enumerate(estimator.feature_names_in_):
+                if feature_name in original_monotonic_cst:
+                    cst = original_monotonic_cst[feature_name]
+                    if cst not in [-1, 0, 1]:
+                        raise ValueError(
+                            f"monotonic_cst['{feature_name}'] must be either "
+                            f"-1, 0 or 1. Got {cst!r}."
+                        )
+                    monotonic_cst[feature_idx] = cst
+    else:
+        unexpected_cst = np.setdiff1d(monotonic_cst, [-1, 0, 1])
+        if unexpected_cst.shape[0]:
+            raise ValueError(
+                "monotonic_cst must be an array-like of -1, 0 or 1. Observed "
+                f"values: {unexpected_cst.tolist()}."
+            )
+
+        monotonic_cst = np.asarray(monotonic_cst, dtype=np.int8)
+        if monotonic_cst.shape[0] != estimator.n_features_in_:
+            raise ValueError(
+                f"monotonic_cst has shape {monotonic_cst.shape} but the input data "
+                f"X has {estimator.n_features_in_} features."
+            )
+    return monotonic_cst
+
+
+def _check_pos_label_consistency(pos_label, y_true):
+    """Check if `pos_label` need to be specified or not.
+
+    In binary classification, we fix `pos_label=1` if the labels are in the set
+    {-1, 1} or {0, 1}. Otherwise, we raise an error asking to specify the
+    `pos_label` parameters.
+
+    Parameters
+    ----------
+    pos_label : int, float, bool, str or None
+        The positive label.
+    y_true : ndarray of shape (n_samples,)
+        The target vector.
+
+    Returns
+    -------
+    pos_label : int, float, bool or str
+        If `pos_label` can be inferred, it will be returned.
+
+    Raises
+    ------
+    ValueError
+        In the case that `y_true` does not have label in {-1, 1} or {0, 1},
+        it will raise a `ValueError`.
+    """
+    # ensure binary classification if pos_label is not specified
+    # classes.dtype.kind in ('O', 'U', 'S') is required to avoid
+    # triggering a FutureWarning by calling np.array_equal(a, b)
+    # when elements in the two arrays are not comparable.
+    if pos_label is None:
+        # Compute classes only if pos_label is not specified:
+        classes = np.unique(y_true)
+        if classes.dtype.kind in "OUS" or not (
+            np.array_equal(classes, [0, 1])
+            or np.array_equal(classes, [-1, 1])
+            or np.array_equal(classes, [0])
+            or np.array_equal(classes, [-1])
+            or np.array_equal(classes, [1])
+        ):
+            classes_repr = ", ".join([repr(c) for c in classes.tolist()])
+            raise ValueError(
+                f"y_true takes value in {{{classes_repr}}} and pos_label is not "
+                "specified: either make y_true take value in {0, 1} or "
+                "{-1, 1} or pass pos_label explicitly."
+            )
+        pos_label = 1
+
+    return pos_label
+
+
+def _to_object_array(sequence):
+    """Convert sequence to a 1-D NumPy array of object dtype.
+
+    numpy.array constructor has a similar use but it's output
+    is ambiguous. It can be 1-D NumPy array of object dtype if
+    the input is a ragged array, but if the input is a list of
+    equal length arrays, then the output is a 2D numpy.array.
+    _to_object_array solves this ambiguity by guarantying that
+    the output is a 1-D NumPy array of objects for any input.
+
+    Parameters
+    ----------
+    sequence : array-like of shape (n_elements,)
+        The sequence to be converted.
+
+    Returns
+    -------
+    out : ndarray of shape (n_elements,), dtype=object
+        The converted sequence into a 1-D NumPy array of object dtype.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils.validation import _to_object_array
+    >>> _to_object_array([np.array([0]), np.array([1])])
+    array([array([0]), array([1])], dtype=object)
+    >>> _to_object_array([np.array([0]), np.array([1, 2])])
+    array([array([0]), array([1, 2])], dtype=object)
+    >>> _to_object_array([np.array([0]), np.array([1, 2])])
+    array([array([0]), array([1, 2])], dtype=object)
+    """
+    out = np.empty(len(sequence), dtype=object)
+    out[:] = sequence
+    return out
+
+
+def _check_feature_names(estimator, X, *, reset):
+    """Set or check the `feature_names_in_` attribute of an estimator.
+
+    .. versionadded:: 1.0
+
+    .. versionchanged:: 1.6
+        Moved from :class:`~sklearn.base.BaseEstimator` to
+        :mod:`sklearn.utils.validation`.
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        The estimator to validate the input for.
+
+    X : {ndarray, dataframe} of shape (n_samples, n_features)
+        The input samples.
+
+    reset : bool
+        Whether to reset the `feature_names_in_` attribute.
+        If False, the input will be checked for consistency with
+        feature names of data provided when reset was last True.
+        .. note::
+           It is recommended to call `reset=True` in `fit` and in the first
+           call to `partial_fit`. All other methods that validate `X`
+           should set `reset=False`.
+    """
+
+    if reset:
+        feature_names_in = _get_feature_names(X)
+        if feature_names_in is not None:
+            estimator.feature_names_in_ = feature_names_in
+        elif hasattr(estimator, "feature_names_in_"):
+            # Delete the attribute when the estimator is fitted on a new dataset
+            # that has no feature names.
+            delattr(estimator, "feature_names_in_")
+        return
+
+    fitted_feature_names = getattr(estimator, "feature_names_in_", None)
+    X_feature_names = _get_feature_names(X)
+
+    if fitted_feature_names is None and X_feature_names is None:
+        # no feature names seen in fit and in X
+        return
+
+    if X_feature_names is not None and fitted_feature_names is None:
+        warnings.warn(
+            f"X has feature names, but {estimator.__class__.__name__} was fitted "
+            "without feature names"
+        )
+        return
+
+    if X_feature_names is None and fitted_feature_names is not None:
+        warnings.warn(
+            "X does not have valid feature names, but"
+            f" {estimator.__class__.__name__} was fitted with feature names"
+        )
+        return
+
+    # validate the feature names against the `feature_names_in_` attribute
+    if len(fitted_feature_names) != len(X_feature_names) or np.any(
+        fitted_feature_names != X_feature_names
+    ):
+        message = "The feature names should match those that were passed during fit.\n"
+        fitted_feature_names_set = set(fitted_feature_names)
+        X_feature_names_set = set(X_feature_names)
+
+        unexpected_names = sorted(X_feature_names_set - fitted_feature_names_set)
+        missing_names = sorted(fitted_feature_names_set - X_feature_names_set)
+
+        def add_names(names):
+            output = ""
+            max_n_names = 5
+            for i, name in enumerate(names):
+                if i >= max_n_names:
+                    output += "- ...\n"
+                    break
+                output += f"- {name}\n"
+            return output
+
+        if unexpected_names:
+            message += "Feature names unseen at fit time:\n"
+            message += add_names(unexpected_names)
+
+        if missing_names:
+            message += "Feature names seen at fit time, yet now missing:\n"
+            message += add_names(missing_names)
+
+        if not missing_names and not unexpected_names:
+            message += "Feature names must be in the same order as they were in fit.\n"
+
+        raise ValueError(message)
+
+
+def _check_n_features(estimator, X, reset):
+    """Set the `n_features_in_` attribute, or check against it on an estimator.
+
+    .. versionchanged:: 1.6
+        Moved from :class:`~sklearn.base.BaseEstimator` to
+        :mod:`~sklearn.utils.validation`.
+
+    Parameters
+    ----------
+    estimator : estimator instance
+        The estimator to validate the input for.
+
+    X : {ndarray, sparse matrix} of shape (n_samples, n_features)
+        The input samples.
+
+    reset : bool
+        If True, the `n_features_in_` attribute is set to `X.shape[1]`.
+        If False and the attribute exists, then check that it is equal to
+        `X.shape[1]`. If False and the attribute does *not* exist, then
+        the check is skipped.
+        .. note::
+           It is recommended to call reset=True in `fit` and in the first
+           call to `partial_fit`. All other methods that validate `X`
+           should set `reset=False`.
+    """
+    try:
+        n_features = _num_features(X)
+    except TypeError as e:
+        if not reset and hasattr(estimator, "n_features_in_"):
+            raise ValueError(
+                "X does not contain any features, but "
+                f"{estimator.__class__.__name__} is expecting "
+                f"{estimator.n_features_in_} features"
+            ) from e
+        # If the number of features is not defined and reset=True,
+        # then we skip this check
+        return
+
+    if reset:
+        estimator.n_features_in_ = n_features
+        return
+
+    if not hasattr(estimator, "n_features_in_"):
+        # Skip this check if the expected number of expected input features
+        # was not recorded by calling fit first. This is typically the case
+        # for stateless transformers.
+        return
+
+    if n_features != estimator.n_features_in_:
+        raise ValueError(
+            f"X has {n_features} features, but {estimator.__class__.__name__} "
+            f"is expecting {estimator.n_features_in_} features as input."
+        )
+
+
+def validate_data(
+    _estimator,
+    /,
+    X="no_validation",
+    y="no_validation",
+    reset=True,
+    validate_separately=False,
+    skip_check_array=False,
+    **check_params,
+):
+    """Validate input data and set or check feature names and counts of the input.
+
+    This helper function should be used in an estimator that requires input
+    validation. This mutates the estimator and sets the `n_features_in_` and
+    `feature_names_in_` attributes if `reset=True`.
+
+    .. versionadded:: 1.6
+
+    Parameters
+    ----------
+    _estimator : estimator instance
+        The estimator to validate the input for.
+
+    X : {array-like, sparse matrix, dataframe} of shape \
+            (n_samples, n_features), default='no validation'
+        The input samples.
+        If `'no_validation'`, no validation is performed on `X`. This is
+        useful for meta-estimator which can delegate input validation to
+        their underlying estimator(s). In that case `y` must be passed and
+        the only accepted `check_params` are `multi_output` and
+        `y_numeric`.
+
+    y : array-like of shape (n_samples,), default='no_validation'
+        The targets.
+
+        - If `None`, :func:`~sklearn.utils.check_array` is called on `X`. If
+          the estimator's `requires_y` tag is True, then an error will be raised.
+        - If `'no_validation'`, :func:`~sklearn.utils.check_array` is called
+          on `X` and the estimator's `requires_y` tag is ignored. This is a default
+          placeholder and is never meant to be explicitly set. In that case `X` must be
+          passed.
+        - Otherwise, only `y` with `_check_y` or both `X` and `y` are checked with
+          either :func:`~sklearn.utils.check_array` or
+          :func:`~sklearn.utils.check_X_y` depending on `validate_separately`.
+
+    reset : bool, default=True
+        Whether to reset the `n_features_in_` attribute.
+        If False, the input will be checked for consistency with data
+        provided when reset was last True.
+
+        .. note::
+
+           It is recommended to call `reset=True` in `fit` and in the first
+           call to `partial_fit`. All other methods that validate `X`
+           should set `reset=False`.
+
+    validate_separately : False or tuple of dicts, default=False
+        Only used if `y` is not `None`.
+        If `False`, call :func:`~sklearn.utils.check_X_y`. Else, it must be a tuple of
+        kwargs to be used for calling :func:`~sklearn.utils.check_array` on `X` and `y`
+        respectively.
+
+        `estimator=self` is automatically added to these dicts to generate
+        more informative error message in case of invalid input data.
+
+    skip_check_array : bool, default=False
+        If `True`, `X` and `y` are unchanged and only `feature_names_in_` and
+        `n_features_in_` are checked. Otherwise, :func:`~sklearn.utils.check_array`
+        is called on `X` and `y`.
+
+    **check_params : kwargs
+        Parameters passed to :func:`~sklearn.utils.check_array` or
+        :func:`~sklearn.utils.check_X_y`. Ignored if validate_separately
+        is not False.
+
+        `estimator=self` is automatically added to these params to generate
+        more informative error message in case of invalid input data.
+
+    Returns
+    -------
+    out : {ndarray, sparse matrix} or tuple of these
+        The validated input. A tuple is returned if both `X` and `y` are
+        validated.
+    """
+    _check_feature_names(_estimator, X, reset=reset)
+    tags = get_tags(_estimator)
+    if y is None and tags.target_tags.required:
+        raise ValueError(
+            f"This {_estimator.__class__.__name__} estimator "
+            "requires y to be passed, but the target y is None."
+        )
+
+    no_val_X = isinstance(X, str) and X == "no_validation"
+    no_val_y = y is None or (isinstance(y, str) and y == "no_validation")
+
+    if no_val_X and no_val_y:
+        raise ValueError("Validation should be done on X, y or both.")
+
+    default_check_params = {"estimator": _estimator}
+    check_params = {**default_check_params, **check_params}
+
+    if skip_check_array:
+        if not no_val_X and no_val_y:
+            out = X
+        elif no_val_X and not no_val_y:
+            out = y
+        else:
+            out = X, y
+    elif not no_val_X and no_val_y:
+        out = check_array(X, input_name="X", **check_params)
+    elif no_val_X and not no_val_y:
+        out = _check_y(y, **check_params)
+    else:
+        if validate_separately:
+            # We need this because some estimators validate X and y
+            # separately, and in general, separately calling check_array()
+            # on X and y isn't equivalent to just calling check_X_y()
+            # :(
+            check_X_params, check_y_params = validate_separately
+            if "estimator" not in check_X_params:
+                check_X_params = {**default_check_params, **check_X_params}
+            X = check_array(X, input_name="X", **check_X_params)
+            if "estimator" not in check_y_params:
+                check_y_params = {**default_check_params, **check_y_params}
+            y = check_array(y, input_name="y", **check_y_params)
+        else:
+            X, y = check_X_y(X, y, **check_params)
+        out = X, y
+
+    if not no_val_X and check_params.get("ensure_2d", True):
+        _check_n_features(_estimator, X, reset=reset)
+
+    return out
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/INSTALLER b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/METADATA b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..8d4be036e7c2635a4e32b003a7b4966825c6b072
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/METADATA
@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: smmap
+Version: 5.0.3
+Summary: A pure Python implementation of a sliding window memory map manager
+Home-page: https://github.com/gitpython-developers/smmap
+Author: Sebastian Thiel
+Author-email: byronimo@gmail.com
+License: BSD-3-Clause
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-python
+Dynamic: summary
+
+## Motivation
+
+When reading from many possibly large files in a fashion similar to random access, it is usually the fastest and most efficient to use memory maps.
+
+Although memory maps have many advantages, they represent a very limited system resource as every map uses one file descriptor, whose amount is limited per process. On 32 bit systems, the amount of memory you can have mapped at a time is naturally limited to theoretical 4GB of memory, which may not be enough for some applications.
+
+
+## Limitations
+
+* **System resources (file-handles) are likely to be leaked!** This is due to the library authors reliance on a deterministic `__del__()` destructor.
+* The memory access is read-only by design.
+
+
+## Overview
+
+![Python package](https://github.com/gitpython-developers/smmap/workflows/Python%20package/badge.svg)
+
+Smmap wraps an interface around mmap and tracks the mapped files as well as the amount of clients who use it. If the system runs out of resources, or if a memory limit is reached, it will automatically unload unused maps to allow continued operation.
+
+To allow processing large files even on 32 bit systems, it allows only portions of the file to be mapped. Once the user reads beyond the mapped region, smmap will automatically map the next required region, unloading unused regions using a LRU algorithm.
+
+Although the library can be used most efficiently with its native interface, a Buffer implementation is provided to hide these details behind a simple string-like interface.
+
+For performance critical 64 bit applications, a simplified version of memory mapping is provided which always maps the whole file, but still provides the benefit of unloading unused mappings on demand.
+
+
+
+## Prerequisites
+
+* Python 3.7+
+* OSX, Windows or Linux
+
+The package was tested on all of the previously mentioned configurations.
+
+## Installing smmap
+
+[![Documentation Status](https://readthedocs.org/projects/smmap/badge/?version=latest)](https://readthedocs.org/projects/smmap/?badge=latest)
+
+Its easiest to install smmap using the [pip](http://www.pip-installer.org/en/latest) program:
+
+```bash
+$ pip install smmap
+```
+
+As the command will install smmap in your respective python distribution, you will most likely need root permissions to authorize the required changes.
+
+If you have downloaded the source archive, the package can be installed by running the `setup.py` script:
+
+```bash
+$ python setup.py install
+```
+
+It is advised to have a look at the **Usage Guide** for a brief introduction on the different database implementations.
+
+
+
+## Homepage and Links
+
+The project is home on github at https://github.com/gitpython-developers/smmap .
+
+The latest source can be cloned from github as well:
+
+* git://github.com/gitpython-developers/smmap.git
+
+
+For support, please use the git-python mailing list:
+
+* http://groups.google.com/group/git-python
+
+
+Issues can be filed on github:
+
+* https://github.com/gitpython-developers/smmap/issues
+
+A link to the pypi page related to this repository:
+
+* https://pypi.org/project/smmap/
+
+
+## License Information
+
+*smmap* is licensed under the New BSD License.
+
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/RECORD b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..8375eb105ddb1d920abd135f2fa04b2994adcfb7
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/RECORD
@@ -0,0 +1,27 @@
+smmap-5.0.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+smmap-5.0.3.dist-info/METADATA,sha256=dh1i1428o477gPF7laWu9SJNgoiu35gMqZxFPblQR7k,4588
+smmap-5.0.3.dist-info/RECORD,,
+smmap-5.0.3.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+smmap-5.0.3.dist-info/licenses/LICENSE,sha256=iOnZP3CNEQsyioNDAt0dXGr72lMOdyHRXYCzUR2G8jU,1519
+smmap-5.0.3.dist-info/top_level.txt,sha256=h0Tp1UdaROCy2bjWNha1MFpwgVghxEUQsaLHbZs96Gw,6
+smmap-5.0.3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+smmap/__init__.py,sha256=9xfDzQfkot54EJaz-fU1BAjsTOLOVXpSzszfL6LV4uU,343
+smmap/__pycache__/__init__.cpython-310.pyc,,
+smmap/__pycache__/buf.cpython-310.pyc,,
+smmap/__pycache__/mman.cpython-310.pyc,,
+smmap/__pycache__/util.cpython-310.pyc,,
+smmap/buf.py,sha256=wElndUNa4Njhnes6JYmI_Xp4zwaohirLdr7eVR9XYNU,5762
+smmap/mman.py,sha256=HYxohllZqpPY4KgRF_D_lNp4fx0akZ-NQosutLDrQ60,24022
+smmap/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smmap/test/__pycache__/__init__.cpython-310.pyc,,
+smmap/test/__pycache__/lib.cpython-310.pyc,,
+smmap/test/__pycache__/test_buf.cpython-310.pyc,,
+smmap/test/__pycache__/test_mman.cpython-310.pyc,,
+smmap/test/__pycache__/test_tutorial.cpython-310.pyc,,
+smmap/test/__pycache__/test_util.cpython-310.pyc,,
+smmap/test/lib.py,sha256=jYIT4rKckHw2s7-l5lwysft1jqrwDFkjtyNLKNpu_j0,1489
+smmap/test/test_buf.py,sha256=BCg9FbusakiYNs5MUNoJSiyuTP5HcMYl65HzvpY9SNo,5439
+smmap/test/test_mman.py,sha256=o3cPg5idyYJpq32zXgDy1qtD10RA_e88-1zPYBWi4Ms,10822
+smmap/test/test_tutorial.py,sha256=ZwCphCbKAGYt_fn_CiOJ9lWwpWwpqE4-zBUp-v-t9eM,3174
+smmap/test/test_util.py,sha256=3hJyW9Km7k7XSgxxtDOkG8eVagk3lIzP4H2pR0S2ewg,3468
+smmap/util.py,sha256=_Sl3Sd2KWdd-5nmhUegFMfT6L1j5BGchRT4z53Sobug,7476
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/WHEEL b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..1ef5583317a5e59140e3f1c85c2db91aec0961e8
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/licenses/LICENSE b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..710010f1fe0311afd9823e319ff958827a419964
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/licenses/LICENSE
@@ -0,0 +1,30 @@
+Copyright (C) 2010, 2011 Sebastian Thiel and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+
+* Redistributions of source code must retain the above copyright 
+notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright 
+notice, this list of conditions and the following disclaimer in the 
+documentation and/or other materials provided with the distribution.
+
+* Neither the name of the async project nor the names of 
+its contributors may be used to endorse or promote products derived 
+from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/top_level.txt b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2765cefa1c4976ec31a903f3ffb7b2f9f92531f3
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+smmap
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/zip-safe b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/zip-safe
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap-5.0.3.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..623181034acb05e7c9168ded256bf549d98c1efa
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/__init__.py
@@ -0,0 +1,11 @@
+"""Initialize the smmap package"""
+
+__author__ = "Sebastian Thiel"
+__contact__ = "byronimo@gmail.com"
+__homepage__ = "https://github.com/gitpython-developers/smmap"
+version_info = (5, 0, 3)
+__version__ = '.'.join(str(i) for i in version_info)
+
+# make everything available in root package for convenience
+from .mman import *
+from .buf import *
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/buf.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/buf.py
new file mode 100644
index 0000000000000000000000000000000000000000..731b0644b5a269b1f941dc7cd49163e6754878a6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/buf.py
@@ -0,0 +1,143 @@
+"""Module with a simple buffer implementation using the memory manager"""
+import sys
+
+__all__ = ["SlidingWindowMapBuffer"]
+
+
+class SlidingWindowMapBuffer:
+
+    """A buffer like object which allows direct byte-wise object and slicing into
+    memory of a mapped file. The mapping is controlled by the provided cursor.
+
+    The buffer is relative, that is if you map an offset, index 0 will map to the
+    first byte at the offset you used during initialization or begin_access
+
+    **Note:** Although this type effectively hides the fact that there are mapped windows
+    underneath, it can unfortunately not be used in any non-pure python method which
+    needs a buffer or string"""
+    __slots__ = (
+        '_c',           # our cursor
+        '_size',        # our supposed size
+    )
+
+    def __init__(self, cursor=None, offset=0, size=sys.maxsize, flags=0):
+        """Initialize the instance to operate on the given cursor.
+        :param cursor: if not None, the associated cursor to the file you want to access
+            If None, you have call begin_access before using the buffer and provide a cursor
+        :param offset: absolute offset in bytes
+        :param size: the total size of the mapping. Defaults to the maximum possible size
+            From that point on, the __len__ of the buffer will be the given size or the file size.
+            If the size is larger than the mappable area, you can only access the actually available
+            area, although the length of the buffer is reported to be your given size.
+            Hence it is in your own interest to provide a proper size !
+        :param flags: Additional flags to be passed to os.open
+        :raise ValueError: if the buffer could not achieve a valid state"""
+        self._c = cursor
+        if cursor and not self.begin_access(cursor, offset, size, flags):
+            raise ValueError("Failed to allocate the buffer - probably the given offset is out of bounds")
+        # END handle offset
+
+    def __del__(self):
+        self.end_access()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.end_access()
+
+    def __len__(self):
+        return self._size
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            return self.__getslice__(i.start or 0, i.stop or self._size)
+        c = self._c
+        assert c.is_valid()
+        if i < 0:
+            i = self._size + i
+        if not c.includes_ofs(i):
+            c.use_region(i, 1)
+        # END handle region usage
+        return c.buffer()[i - c.ofs_begin()]
+
+    def __getslice__(self, i, j):
+        c = self._c
+        # fast path, slice fully included - safes a concatenate operation and
+        # should be the default
+        assert c.is_valid()
+        if i < 0:
+            i = self._size + i
+        if j == sys.maxsize:
+            j = self._size
+        if j < 0:
+            j = self._size + j
+        if (c.ofs_begin() <= i) and (j < c.ofs_end()):
+            b = c.ofs_begin()
+            return c.buffer()[i - b:j - b]
+        else:
+            l = j - i                 # total length
+            ofs = i
+            # It's fastest to keep tokens and join later, especially in py3, which was 7 times slower
+            # in the previous iteration of this code
+            md = list()
+            while l:
+                c.use_region(ofs, l)
+                assert c.is_valid()
+                d = c.buffer()[:l]
+                ofs += len(d)
+                l -= len(d)
+                # Make sure we don't keep references, as c.use_region() might attempt to free resources, but
+                # can't unless we use pure bytes
+                if hasattr(d, 'tobytes'):
+                    d = d.tobytes()
+                md.append(d)
+            # END while there are bytes to read
+            return b''.join(md)
+        # END fast or slow path
+    #{ Interface
+
+    def begin_access(self, cursor=None, offset=0, size=sys.maxsize, flags=0):
+        """Call this before the first use of this instance. The method was already
+        called by the constructor in case sufficient information was provided.
+
+        For more information no the parameters, see the __init__ method
+        :param path: if cursor is None the existing one will be used.
+        :return: True if the buffer can be used"""
+        if cursor:
+            self._c = cursor
+        # END update our cursor
+
+        # reuse existing cursors if possible
+        if self._c is not None and self._c.is_associated():
+            res = self._c.use_region(offset, size, flags).is_valid()
+            if res:
+                # if given size is too large or default, we computer a proper size
+                # If its smaller, we assume the combination between offset and size
+                # as chosen by the user is correct and use it !
+                # If not, the user is in trouble.
+                if size > self._c.file_size():
+                    size = self._c.file_size() - offset
+                # END handle size
+                self._size = size
+            # END set size
+            return res
+        # END use our cursor
+        return False
+
+    def end_access(self):
+        """Call this method once you are done using the instance. It is automatically
+        called on destruction, and should be called just in time to allow system
+        resources to be freed.
+
+        Once you called end_access, you must call begin access before reusing this instance!"""
+        self._size = 0
+        if self._c is not None:
+            self._c.unuse_region()
+        # END unuse region
+
+    def cursor(self):
+        """:return: the currently set cursor which provides access to the data"""
+        return self._c
+
+    #}END interface
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/mman.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/mman.py
new file mode 100644
index 0000000000000000000000000000000000000000..873f687fdc6f0d78ee24a6d25f7720708d48b6e5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/mman.py
@@ -0,0 +1,588 @@
+"""Module containing a memory memory manager which provides a sliding window on a number of memory mapped files"""
+from .util import (
+    MapWindow,
+    MapRegion,
+    MapRegionList,
+    is_64_bit,
+)
+
+import sys
+from functools import reduce
+
+__all__ = ["StaticWindowMapManager", "SlidingWindowMapManager", "WindowCursor"]
+#{ Utilities
+
+#}END utilities
+
+
+class WindowCursor:
+
+    """
+    Pointer into the mapped region of the memory manager, keeping the map
+    alive until it is destroyed and no other client uses it.
+
+    Cursors should not be created manually, but are instead returned by the SlidingWindowMapManager
+
+    **Note:**: The current implementation is suited for static and sliding window managers, but it also means
+    that it must be suited for the somewhat quite different sliding manager. It could be improved, but
+    I see no real need to do so."""
+    __slots__ = (
+        '_manager',  # the manager keeping all file regions
+        '_rlist',   # a regions list with regions for our file
+        '_region',  # our current class:`MapRegion` or None
+        '_ofs',     # relative offset from the actually mapped area to our start area
+        '_size'     # maximum size we should provide
+    )
+
+    def __init__(self, manager=None, regions=None):
+        self._manager = manager
+        self._rlist = regions
+        self._region = None
+        self._ofs = 0
+        self._size = 0
+
+    def __del__(self):
+        self._destroy()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._destroy()
+
+    def _destroy(self):
+        """Destruction code to decrement counters"""
+        self.unuse_region()
+
+        if self._rlist is not None:
+            # Actual client count, which doesn't include the reference kept by the manager, nor ours
+            # as we are about to be deleted
+            try:
+                if len(self._rlist) == 0:
+                    # Free all resources associated with the mapped file
+                    self._manager._fdict.pop(self._rlist.path_or_fd())
+                # END remove regions list from manager
+            except (TypeError, KeyError):
+                # sometimes, during shutdown, getrefcount is None. Its possible
+                # to re-import it, however, its probably better to just ignore
+                # this python problem (for now).
+                # The next step is to get rid of the error prone getrefcount altogether.
+                pass
+            # END exception handling
+        # END handle regions
+
+    def _copy_from(self, rhs):
+        """Copy all data from rhs into this instance, handles usage count"""
+        self._manager = rhs._manager
+        self._rlist = type(rhs._rlist)(rhs._rlist)
+        self._region = rhs._region
+        self._ofs = rhs._ofs
+        self._size = rhs._size
+
+        for region in self._rlist:
+            region.increment_client_count()
+
+        if self._region is not None:
+            self._region.increment_client_count()
+        # END handle regions
+
+    def __copy__(self):
+        """copy module interface"""
+        cpy = type(self)()
+        cpy._copy_from(self)
+        return cpy
+
+    #{ Interface
+    def assign(self, rhs):
+        """Assign rhs to this instance. This is required in order to get a real copy.
+        Alternatively, you can copy an existing instance using the copy module"""
+        self._destroy()
+        self._copy_from(rhs)
+
+    def use_region(self, offset=0, size=0, flags=0):
+        """Assure we point to a window which allows access to the given offset into the file
+
+        :param offset: absolute offset in bytes into the file
+        :param size: amount of bytes to map. If 0, all available bytes will be mapped
+        :param flags: additional flags to be given to os.open in case a file handle is initially opened
+            for mapping. Has no effect if a region can actually be reused.
+        :return: this instance - it should be queried for whether it points to a valid memory region.
+            This is not the case if the mapping failed because we reached the end of the file
+
+        **Note:**: The size actually mapped may be smaller than the given size. If that is the case,
+        either the file has reached its end, or the map was created between two existing regions"""
+        need_region = True
+        man = self._manager
+        fsize = self._rlist.file_size()
+        size = min(size or fsize, man.window_size() or fsize)   # clamp size to window size
+
+        if self._region is not None:
+            if self._region.includes_ofs(offset):
+                need_region = False
+            else:
+                self.unuse_region()
+            # END handle existing region
+        # END check existing region
+
+        # offset too large ?
+        if offset >= fsize:
+            return self
+        # END handle offset
+
+        if need_region:
+            self._region = man._obtain_region(self._rlist, offset, size, flags, False)
+            self._region.increment_client_count()
+        # END need region handling
+
+        self._ofs = offset - self._region._b
+        self._size = min(size, self._region.ofs_end() - offset)
+
+        return self
+
+    def unuse_region(self):
+        """Unuse the current region. Does nothing if we have no current region
+
+        **Note:** the cursor unuses the region automatically upon destruction. It is recommended
+        to un-use the region once you are done reading from it in persistent cursors as it
+        helps to free up resource more quickly"""
+        if self._region is not None:
+            self._region.increment_client_count(-1)
+        self._region = None
+        # note: should reset ofs and size, but we spare that for performance. Its not
+        # allowed to query information if we are not valid !
+
+    def buffer(self):
+        """Return a buffer object which allows access to our memory region from our offset
+        to the window size. Please note that it might be smaller than you requested when calling use_region()
+
+        **Note:** You can only obtain a buffer if this instance is_valid() !
+
+        **Note:** buffers should not be cached passed the duration of your access as it will
+        prevent resources from being freed even though they might not be accounted for anymore !"""
+        return memoryview(self._region.buffer())[self._ofs:self._ofs+self._size]
+
+    def map(self):
+        """
+        :return: the underlying raw memory map. Please not that the offset and size is likely to be different
+            to what you set as offset and size. Use it only if you are sure about the region it maps, which is the whole
+            file in case of StaticWindowMapManager"""
+        return self._region.map()
+
+    def is_valid(self):
+        """:return: True if we have a valid and usable region"""
+        return self._region is not None
+
+    def is_associated(self):
+        """:return: True if we are associated with a specific file already"""
+        return self._rlist is not None
+
+    def ofs_begin(self):
+        """:return: offset to the first byte pointed to by our cursor
+
+        **Note:** only if is_valid() is True"""
+        return self._region._b + self._ofs
+
+    def ofs_end(self):
+        """:return: offset to one past the last available byte"""
+        # unroll method calls for performance !
+        return self._region._b + self._ofs + self._size
+
+    def size(self):
+        """:return: amount of bytes we point to"""
+        return self._size
+
+    def region(self):
+        """:return: our mapped region, or None if nothing is mapped yet
+        :raise AssertionError: if we have no current region. This is only useful for debugging"""
+        return self._region
+
+    def includes_ofs(self, ofs):
+        """:return: True if the given absolute offset is contained in the cursors
+            current region
+
+        **Note:** cursor must be valid for this to work"""
+        # unroll methods
+        return (self._region._b + self._ofs) <= ofs < (self._region._b + self._ofs + self._size)
+
+    def file_size(self):
+        """:return: size of the underlying file"""
+        return self._rlist.file_size()
+
+    def path_or_fd(self):
+        """:return: path or file descriptor of the underlying mapped file"""
+        return self._rlist.path_or_fd()
+
+    def path(self):
+        """:return: path of the underlying mapped file
+        :raise ValueError: if attached path is not a path"""
+        if isinstance(self._rlist.path_or_fd(), int):
+            raise ValueError("Path queried although mapping was applied to a file descriptor")
+        # END handle type
+        return self._rlist.path_or_fd()
+
+    def fd(self):
+        """:return: file descriptor used to create the underlying mapping.
+
+        **Note:** it is not required to be valid anymore
+        :raise ValueError: if the mapping was not created by a file descriptor"""
+        if isinstance(self._rlist.path_or_fd(), str):
+            raise ValueError("File descriptor queried although mapping was generated from path")
+        # END handle type
+        return self._rlist.path_or_fd()
+
+    #} END interface
+
+
+class StaticWindowMapManager:
+
+    """Provides a manager which will produce single size cursors that are allowed
+    to always map the whole file.
+
+    Clients must be written to specifically know that they are accessing their data
+    through a StaticWindowMapManager, as they otherwise have to deal with their window size.
+
+    These clients would have to use a SlidingWindowMapBuffer to hide this fact.
+
+    This type will always use a maximum window size, and optimize certain methods to
+    accommodate this fact"""
+
+    __slots__ = [
+        '_fdict',           # mapping of path -> StorageHelper (of some kind
+        '_window_size',     # maximum size of a window
+        '_max_memory_size',  # maximum amount of memory we may allocate
+        '_max_handle_count',        # maximum amount of handles to keep open
+        '_memory_size',     # currently allocated memory size
+        '_handle_count',        # amount of currently allocated file handles
+    ]
+
+    #{ Configuration
+    MapRegionListCls = MapRegionList
+    MapWindowCls = MapWindow
+    MapRegionCls = MapRegion
+    WindowCursorCls = WindowCursor
+    #} END configuration
+
+    _MB_in_bytes = 1024 * 1024
+
+    def __init__(self, window_size=0, max_memory_size=0, max_open_handles=sys.maxsize):
+        """initialize the manager with the given parameters.
+        :param window_size: if -1, a default window size will be chosen depending on
+            the operating system's architecture. It will internally be quantified to a multiple of the page size
+            If 0, the window may have any size, which basically results in mapping the whole file at one
+        :param max_memory_size: maximum amount of memory we may map at once before releasing mapped regions.
+            If 0, a viable default will be set depending on the system's architecture.
+            It is a soft limit that is tried to be kept, but nothing bad happens if we have to over-allocate
+        :param max_open_handles: if not maxint, limit the amount of open file handles to the given number.
+            Otherwise the amount is only limited by the system itself. If a system or soft limit is hit,
+            the manager will free as many handles as possible"""
+        self._fdict = dict()
+        self._window_size = window_size
+        self._max_memory_size = max_memory_size
+        self._max_handle_count = max_open_handles
+        self._memory_size = 0
+        self._handle_count = 0
+
+        if window_size < 0:
+            coeff = 64
+            if is_64_bit():
+                coeff = 1024
+            # END handle arch
+            self._window_size = coeff * self._MB_in_bytes
+        # END handle max window size
+
+        if max_memory_size == 0:
+            coeff = 1024
+            if is_64_bit():
+                coeff = 8192
+            # END handle arch
+            self._max_memory_size = coeff * self._MB_in_bytes
+        # END handle max memory size
+
+    #{ Internal Methods
+
+    def _collect_lru_region(self, size):
+        """Unmap the region which was least-recently used and has no client
+        :param size: size of the region we want to map next (assuming its not already mapped partially or full
+            if 0, we try to free any available region
+        :return: Amount of freed regions
+
+        .. Note::
+            We don't raise exceptions anymore, in order to keep the system working, allowing temporary overallocation.
+            If the system runs out of memory, it will tell.
+
+        .. TODO::
+            implement a case where all unusued regions are discarded efficiently.
+            Currently its only brute force
+        """
+        num_found = 0
+        while (size == 0) or (self._memory_size + size > self._max_memory_size):
+            lru_region = None
+            lru_list = None
+            for regions in self._fdict.values():
+                for region in regions:
+                    # check client count - if it's 1, it's just us
+                    if (region.client_count() == 1 and
+                            (lru_region is None or region._uc < lru_region._uc)):
+                        lru_region = region
+                        lru_list = regions
+                    # END update lru_region
+                # END for each region
+            # END for each regions list
+
+            if lru_region is None:
+                break
+            # END handle region not found
+
+            num_found += 1
+            del(lru_list[lru_list.index(lru_region)])
+            lru_region.increment_client_count(-1)
+            self._memory_size -= lru_region.size()
+            self._handle_count -= 1
+        # END while there is more memory to free
+        return num_found
+
+    def _obtain_region(self, a, offset, size, flags, is_recursive):
+        """Utility to create a new region - for more information on the parameters,
+        see MapCursor.use_region.
+        :param a: A regions (a)rray
+        :return: The newly created region"""
+        if self._memory_size + size > self._max_memory_size:
+            self._collect_lru_region(size)
+        # END handle collection
+
+        r = None
+        if a:
+            assert len(a) == 1
+            r = a[0]
+        else:
+            try:
+                r = self.MapRegionCls(a.path_or_fd(), 0, sys.maxsize, flags)
+            except Exception:
+                # apparently we are out of system resources or hit a limit
+                # As many more operations are likely to fail in that condition (
+                # like reading a file from disk, etc) we free up as much as possible
+                # As this invalidates our insert position, we have to recurse here
+                if is_recursive:
+                    # we already tried this, and still have no success in obtaining
+                    # a mapping. This is an exception, so we propagate it
+                    raise
+                # END handle existing recursion
+                self._collect_lru_region(0)
+                return self._obtain_region(a, offset, size, flags, True)
+            # END handle exceptions
+
+            self._handle_count += 1
+            self._memory_size += r.size()
+            a.append(r)
+        # END handle array
+
+        assert r.includes_ofs(offset)
+        return r
+
+    #}END internal methods
+
+    #{ Interface
+    def make_cursor(self, path_or_fd):
+        """
+        :return: a cursor pointing to the given path or file descriptor.
+            It can be used to map new regions of the file into memory
+
+        **Note:** if a file descriptor is given, it is assumed to be open and valid,
+        but may be closed afterwards. To refer to the same file, you may reuse
+        your existing file descriptor, but keep in mind that new windows can only
+        be mapped as long as it stays valid. This is why the using actual file paths
+        are preferred unless you plan to keep the file descriptor open.
+
+        **Note:** file descriptors are problematic as they are not necessarily unique, as two
+        different files opened and closed in succession might have the same file descriptor id.
+
+        **Note:** Using file descriptors directly is faster once new windows are mapped as it
+        prevents the file to be opened again just for the purpose of mapping it."""
+        regions = self._fdict.get(path_or_fd)
+        if regions is None:
+            regions = self.MapRegionListCls(path_or_fd)
+            self._fdict[path_or_fd] = regions
+        # END obtain region for path
+        return self.WindowCursorCls(self, regions)
+
+    def collect(self):
+        """Collect all available free-to-collect mapped regions
+        :return: Amount of freed handles"""
+        return self._collect_lru_region(0)
+
+    def num_file_handles(self):
+        """:return: amount of file handles in use. Each mapped region uses one file handle"""
+        return self._handle_count
+
+    def num_open_files(self):
+        """Amount of opened files in the system"""
+        return reduce(lambda x, y: x + y, (1 for rlist in self._fdict.values() if len(rlist) > 0), 0)
+
+    def window_size(self):
+        """:return: size of each window when allocating new regions"""
+        return self._window_size
+
+    def mapped_memory_size(self):
+        """:return: amount of bytes currently mapped in total"""
+        return self._memory_size
+
+    def max_file_handles(self):
+        """:return: maximum amount of handles we may have opened"""
+        return self._max_handle_count
+
+    def max_mapped_memory_size(self):
+        """:return: maximum amount of memory we may allocate"""
+        return self._max_memory_size
+
+    #} END interface
+
+    #{ Special Purpose Interface
+
+    def force_map_handle_removal_win(self, base_path):
+        """ONLY AVAILABLE ON WINDOWS
+        On windows removing files is not allowed if anybody still has it opened.
+        If this process is ourselves, and if the whole process uses this memory
+        manager (as far as the parent framework is concerned) we can enforce
+        closing all memory maps whose path matches the given base path to
+        allow the respective operation after all.
+        The respective system must NOT access the closed memory regions anymore !
+        This really may only be used if you know that the items which keep
+        the cursors alive will not be using it anymore. They need to be recreated !
+        :return: Amount of closed handles
+
+        **Note:** does nothing on non-windows platforms"""
+        if sys.platform != 'win32':
+            return
+        # END early bailout
+
+        num_closed = 0
+        for path, rlist in self._fdict.items():
+            if path.startswith(base_path):
+                for region in rlist:
+                    region.release()
+                    num_closed += 1
+            # END path matches
+        # END for each path
+        return num_closed
+    #} END special purpose interface
+
+
+class SlidingWindowMapManager(StaticWindowMapManager):
+
+    """Maintains a list of ranges of mapped memory regions in one or more files and allows to easily
+    obtain additional regions assuring there is no overlap.
+    Once a certain memory limit is reached globally, or if there cannot be more open file handles
+    which result from each mmap call, the least recently used, and currently unused mapped regions
+    are unloaded automatically.
+
+    **Note:** currently not thread-safe !
+
+    **Note:** in the current implementation, we will automatically unload windows if we either cannot
+        create more memory maps (as the open file handles limit is hit) or if we have allocated more than
+        a safe amount of memory already, which would possibly cause memory allocations to fail as our address
+        space is full."""
+
+    __slots__ = tuple()
+
+    def __init__(self, window_size=-1, max_memory_size=0, max_open_handles=sys.maxsize):
+        """Adjusts the default window size to -1"""
+        super().__init__(window_size, max_memory_size, max_open_handles)
+
+    def _obtain_region(self, a, offset, size, flags, is_recursive):
+        # bisect to find an existing region. The c++ implementation cannot
+        # do that as it uses a linked list for regions.
+        r = None
+        lo = 0
+        hi = len(a)
+        while lo < hi:
+            mid = (lo + hi) // 2
+            ofs = a[mid]._b
+            if ofs <= offset:
+                if a[mid].includes_ofs(offset):
+                    r = a[mid]
+                    break
+                # END have region
+                lo = mid + 1
+            else:
+                hi = mid
+            # END handle position
+        # END while bisecting
+
+        if r is None:
+            window_size = self._window_size
+            left = self.MapWindowCls(0, 0)
+            mid = self.MapWindowCls(offset, size)
+            right = self.MapWindowCls(a.file_size(), 0)
+
+            # we want to honor the max memory size, and assure we have anough
+            # memory available
+            # Save calls !
+            if self._memory_size + window_size > self._max_memory_size:
+                self._collect_lru_region(window_size)
+            # END handle collection
+
+            # we assume the list remains sorted by offset
+            insert_pos = 0
+            len_regions = len(a)
+            if len_regions == 1:
+                if a[0]._b <= offset:
+                    insert_pos = 1
+                # END maintain sort
+            else:
+                # find insert position
+                insert_pos = len_regions
+                for i, region in enumerate(a):
+                    if region._b > offset:
+                        insert_pos = i
+                        break
+                    # END if insert position is correct
+                # END for each region
+            # END obtain insert pos
+
+            # adjust the actual offset and size values to create the largest
+            # possible mapping
+            if insert_pos == 0:
+                if len_regions:
+                    right = self.MapWindowCls.from_region(a[insert_pos])
+                # END adjust right side
+            else:
+                if insert_pos != len_regions:
+                    right = self.MapWindowCls.from_region(a[insert_pos])
+                # END adjust right window
+                left = self.MapWindowCls.from_region(a[insert_pos - 1])
+            # END adjust surrounding windows
+
+            mid.extend_left_to(left, window_size)
+            mid.extend_right_to(right, window_size)
+            mid.align()
+
+            # it can happen that we align beyond the end of the file
+            if mid.ofs_end() > right.ofs:
+                mid.size = right.ofs - mid.ofs
+            # END readjust size
+
+            # insert new region at the right offset to keep the order
+            try:
+                if self._handle_count >= self._max_handle_count:
+                    raise Exception
+                # END assert own imposed max file handles
+                r = self.MapRegionCls(a.path_or_fd(), mid.ofs, mid.size, flags)
+            except Exception:
+                # apparently we are out of system resources or hit a limit
+                # As many more operations are likely to fail in that condition (
+                # like reading a file from disk, etc) we free up as much as possible
+                # As this invalidates our insert position, we have to recurse here
+                if is_recursive:
+                    # we already tried this, and still have no success in obtaining
+                    # a mapping. This is an exception, so we propagate it
+                    raise
+                # END handle existing recursion
+                self._collect_lru_region(0)
+                return self._obtain_region(a, offset, size, flags, True)
+            # END handle exceptions
+
+            self._handle_count += 1
+            self._memory_size += r.size()
+            a.insert(insert_pos, r)
+        # END create new region
+        return r
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/lib.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..b15b0ec6a8eca03b9b01f0f469f8687300039df6
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/lib.py
@@ -0,0 +1,72 @@
+"""Provide base classes for the test system"""
+from unittest import TestCase
+import os
+import tempfile
+
+__all__ = ['TestBase', 'FileCreator']
+
+
+#{ Utilities
+
+class FileCreator:
+
+    """A instance which creates a temporary file with a prefix and a given size
+    and provides this info to the user.
+    Once it gets deleted, it will remove the temporary file as well."""
+    __slots__ = ("_size", "_path")
+
+    def __init__(self, size, prefix=''):
+        assert size, "Require size to be larger 0"
+
+        self._size = size
+
+        with tempfile.NamedTemporaryFile("wb", prefix=prefix, delete=False) as file:
+            self._path = file.name
+            file.seek(size - 1)
+            file.write(b'1')
+
+        assert os.path.getsize(self.path) == size
+
+    def __del__(self):
+        try:
+            os.remove(self.path)
+        except OSError:
+            pass
+        # END exception handling
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.__del__()
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def size(self):
+        return self._size
+
+#} END utilities
+
+
+class TestBase(TestCase):
+
+    """Foundation used by all tests"""
+
+    #{ Configuration
+    k_window_test_size = 1000 * 1000 * 8 + 5195
+    #} END configuration
+
+    #{ Overrides
+    @classmethod
+    def setUpAll(cls):
+        # nothing for now
+        pass
+
+    # END overrides
+
+    #{ Interface
+
+    #} END interface
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_buf.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_buf.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0a86fb643b512454c60451de56b63e171e60960
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_buf.py
@@ -0,0 +1,126 @@
+from .lib import TestBase, FileCreator
+
+from smmap.mman import (
+    SlidingWindowMapManager,
+    StaticWindowMapManager
+)
+from smmap.buf import SlidingWindowMapBuffer
+
+from random import randint
+from time import time
+import sys
+import os
+
+
+man_optimal = SlidingWindowMapManager()
+man_worst_case = SlidingWindowMapManager(
+    window_size=TestBase.k_window_test_size // 100,
+    max_memory_size=TestBase.k_window_test_size // 3,
+    max_open_handles=15)
+static_man = StaticWindowMapManager()
+
+
+class TestBuf(TestBase):
+
+    def test_basics(self):
+        with FileCreator(self.k_window_test_size, "buffer_test") as fc:
+
+            # invalid paths fail upon construction
+            c = man_optimal.make_cursor(fc.path)
+            self.assertRaises(ValueError, SlidingWindowMapBuffer, type(c)())            # invalid cursor
+            self.assertRaises(ValueError, SlidingWindowMapBuffer, c, fc.size)       # offset too large
+
+            buf = SlidingWindowMapBuffer()                                              # can create uninitialized buffers
+            assert buf.cursor() is None
+
+            # can call end access any time
+            buf.end_access()
+            buf.end_access()
+            assert len(buf) == 0
+
+            # begin access can revive it, if the offset is suitable
+            offset = 100
+            assert buf.begin_access(c, fc.size) == False
+            assert buf.begin_access(c, offset) == True
+            assert len(buf) == fc.size - offset
+            assert buf.cursor().is_valid()
+
+            # empty begin access keeps it valid on the same path, but alters the offset
+            assert buf.begin_access() == True
+            assert len(buf) == fc.size
+            assert buf.cursor().is_valid()
+
+            # simple access
+            with open(fc.path, 'rb') as fp:
+                data = fp.read()
+            assert data[offset] == buf[0]
+            assert data[offset:offset * 2] == buf[0:offset]
+
+            # negative indices, partial slices
+            assert buf[-1] == buf[len(buf) - 1]
+            assert buf[-10:] == buf[len(buf) - 10:len(buf)]
+
+            # end access makes its cursor invalid
+            buf.end_access()
+            assert not buf.cursor().is_valid()
+            assert buf.cursor().is_associated()         # but it remains associated
+
+            # an empty begin access fixes it up again
+            assert buf.begin_access() == True and buf.cursor().is_valid()
+            del(buf)        # ends access automatically
+            del(c)
+
+            assert man_optimal.num_file_handles() == 1
+
+            # PERFORMANCE
+            # blast away with random access and a full mapping - we don't want to
+            # exaggerate the manager's overhead, but measure the buffer overhead
+            # We do it once with an optimal setting, and with a worse manager which
+            # will produce small mappings only !
+            max_num_accesses = 100
+            fd = os.open(fc.path, os.O_RDONLY)
+            for item in (fc.path, fd):
+                for manager, man_id in ((man_optimal, 'optimal'),
+                                        (man_worst_case, 'worst case'),
+                                        (static_man, 'static optimal')):
+                    buf = SlidingWindowMapBuffer(manager.make_cursor(item))
+                    assert manager.num_file_handles() == 1
+                    for access_mode in range(2):    # single, multi
+                        num_accesses_left = max_num_accesses
+                        num_bytes = 0
+                        fsize = fc.size
+
+                        st = time()
+                        buf.begin_access()
+                        while num_accesses_left:
+                            num_accesses_left -= 1
+                            if access_mode:  # multi
+                                ofs_start = randint(0, fsize)
+                                ofs_end = randint(ofs_start, fsize)
+                                d = buf[ofs_start:ofs_end]
+                                assert len(d) == ofs_end - ofs_start
+                                assert d == data[ofs_start:ofs_end]
+                                num_bytes += len(d)
+                                del d
+                            else:
+                                pos = randint(0, fsize)
+                                assert buf[pos] == data[pos]
+                                num_bytes += 1
+                            # END handle mode
+                        # END handle num accesses
+
+                        buf.end_access()
+                        assert manager.num_file_handles()
+                        assert manager.collect()
+                        assert manager.num_file_handles() == 0
+                        elapsed = max(time() - st, 0.001)  # prevent zero division errors on windows
+                        mb = float(1000 * 1000)
+                        mode_str = (access_mode and "slice") or "single byte"
+                        print("%s: Made %i random %s accesses to buffer created from %s reading a total of %f mb in %f s (%f mb/s)"
+                              % (man_id, max_num_accesses, mode_str, type(item), num_bytes / mb, elapsed, (num_bytes / mb) / elapsed),
+                              file=sys.stderr)
+                    # END handle access mode
+                    del buf
+                # END for each manager
+            # END for each input
+            os.close(fd)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_mman.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_mman.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a5f4092c11e7abb6a086a87a481a9ffa0f818aa
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_mman.py
@@ -0,0 +1,224 @@
+from .lib import TestBase, FileCreator
+
+from smmap.mman import (
+    WindowCursor,
+    SlidingWindowMapManager,
+    StaticWindowMapManager
+)
+from smmap.util import align_to_mmap
+
+from random import randint
+from time import time
+import os
+import sys
+from copy import copy
+
+
+class TestMMan(TestBase):
+
+    def test_cursor(self):
+        with FileCreator(self.k_window_test_size, "cursor_test") as fc:
+            man = SlidingWindowMapManager()
+            ci = WindowCursor(man)  # invalid cursor
+            assert not ci.is_valid()
+            assert not ci.is_associated()
+            assert ci.size() == 0       # this is cached, so we can query it in invalid state
+
+            cv = man.make_cursor(fc.path)
+            assert not cv.is_valid()    # no region mapped yet
+            assert cv.is_associated()  # but it know where to map it from
+            assert cv.file_size() == fc.size
+            assert cv.path() == fc.path
+
+        # copy module
+        cio = copy(cv)
+        assert not cio.is_valid() and cio.is_associated()
+
+        # assign method
+        assert not ci.is_associated()
+        ci.assign(cv)
+        assert not ci.is_valid() and ci.is_associated()
+
+        # unuse non-existing region is fine
+        cv.unuse_region()
+        cv.unuse_region()
+
+        # destruction is fine (even multiple times)
+        cv._destroy()
+        WindowCursor(man)._destroy()
+
+    def test_memory_manager(self):
+        slide_man = SlidingWindowMapManager()
+        static_man = StaticWindowMapManager()
+
+        for man in (static_man, slide_man):
+            assert man.num_file_handles() == 0
+            assert man.num_open_files() == 0
+            winsize_cmp_val = 0
+            if isinstance(man, StaticWindowMapManager):
+                winsize_cmp_val = -1
+            # END handle window size
+            assert man.window_size() > winsize_cmp_val
+            assert man.mapped_memory_size() == 0
+            assert man.max_mapped_memory_size() > 0
+
+            # collection doesn't raise in 'any' mode
+            man._collect_lru_region(0)
+            # doesn't raise if we are within the limit
+            man._collect_lru_region(10)
+
+            # doesn't fail if we over-allocate
+            assert man._collect_lru_region(sys.maxsize) == 0
+
+            # use a region, verify most basic functionality
+            with FileCreator(self.k_window_test_size, "manager_test") as fc:
+                fd = os.open(fc.path, os.O_RDONLY)
+                try:
+                    for item in (fc.path, fd):
+                        c = man.make_cursor(item)
+                        assert c.path_or_fd() is item
+                        assert c.use_region(10, 10).is_valid()
+                        assert c.ofs_begin() == 10
+                        assert c.size() == 10
+                        with open(fc.path, 'rb') as fp:
+                            assert c.buffer()[:] == fp.read(20)[10:]
+
+                    if isinstance(item, int):
+                        self.assertRaises(ValueError, c.path)
+                    else:
+                        self.assertRaises(ValueError, c.fd)
+                    # END handle value error
+                # END for each input
+                finally:
+                    os.close(fd)
+        # END for each manasger type
+
+    def test_memman_operation(self):
+        # test more access, force it to actually unmap regions
+        with FileCreator(self.k_window_test_size, "manager_operation_test") as fc:
+            with open(fc.path, 'rb') as fp:
+                data = fp.read()
+            fd = os.open(fc.path, os.O_RDONLY)
+            try:
+                max_num_handles = 15
+                # small_size =
+                for mtype, args in ((StaticWindowMapManager, (0, fc.size // 3, max_num_handles)),
+                                    (SlidingWindowMapManager, (fc.size // 100, fc.size // 3, max_num_handles)),):
+                    for item in (fc.path, fd):
+                        assert len(data) == fc.size
+
+                        # small windows, a reasonable max memory. Not too many regions at once
+                        man = mtype(window_size=args[0], max_memory_size=args[1], max_open_handles=args[2])
+                        c = man.make_cursor(item)
+
+                        # still empty (more about that is tested in test_memory_manager()
+                        assert man.num_open_files() == 0
+                        assert man.mapped_memory_size() == 0
+
+                        base_offset = 5000
+                        # window size is 0 for static managers, hence size will be 0. We take that into consideration
+                        size = man.window_size() // 2
+                        assert c.use_region(base_offset, size).is_valid()
+                        rr = c.region()
+                        assert rr.client_count() == 2  # the manager and the cursor and us
+
+                        assert man.num_open_files() == 1
+                        assert man.num_file_handles() == 1
+                        assert man.mapped_memory_size() == rr.size()
+
+                        # assert c.size() == size        # the cursor may overallocate in its static version
+                        assert c.ofs_begin() == base_offset
+                        assert rr.ofs_begin() == 0        # it was aligned and expanded
+                        if man.window_size():
+                            # but isn't larger than the max window (aligned)
+                            assert rr.size() == align_to_mmap(man.window_size(), True)
+                        else:
+                            assert rr.size() == fc.size
+                        # END ignore static managers which dont use windows and are aligned to file boundaries
+
+                        assert c.buffer()[:] == data[base_offset:base_offset + (size or c.size())]
+
+                        # obtain second window, which spans the first part of the file - it is a still the same window
+                        nsize = (size or fc.size) - 10
+                        assert c.use_region(0, nsize).is_valid()
+                        assert c.region() == rr
+                        assert man.num_file_handles() == 1
+                        assert c.size() == nsize
+                        assert c.ofs_begin() == 0
+                        assert c.buffer()[:] == data[:nsize]
+
+                        # map some part at the end, our requested size cannot be kept
+                        overshoot = 4000
+                        base_offset = fc.size - (size or c.size()) + overshoot
+                        assert c.use_region(base_offset, size).is_valid()
+                        if man.window_size():
+                            assert man.num_file_handles() == 2
+                            assert c.size() < size
+                            assert c.region() is not rr  # old region is still available, but has not cursor ref anymore
+                            assert rr.client_count() == 1  # only held by manager
+                        else:
+                            assert c.size() < fc.size
+                        # END ignore static managers which only have one handle per file
+                        rr = c.region()
+                        assert rr.client_count() == 2  # manager + cursor
+                        assert rr.ofs_begin() < c.ofs_begin()  # it should have extended itself to the left
+                        assert rr.ofs_end() <= fc.size  # it cannot be larger than the file
+                        assert c.buffer()[:] == data[base_offset:base_offset + (size or c.size())]
+
+                        # unising a region makes the cursor invalid
+                        c.unuse_region()
+                        assert not c.is_valid()
+                        if man.window_size():
+                            # but doesn't change anything regarding the handle count - we cache it and only
+                            # remove mapped regions if we have to
+                            assert man.num_file_handles() == 2
+                        # END ignore this for static managers
+
+                        # iterate through the windows, verify data contents
+                        # this will trigger map collection after a while
+                        max_random_accesses = 5000
+                        num_random_accesses = max_random_accesses
+                        memory_read = 0
+                        st = time()
+
+                        # cache everything to get some more performance
+                        includes_ofs = c.includes_ofs
+                        max_mapped_memory_size = man.max_mapped_memory_size()
+                        max_file_handles = man.max_file_handles()
+                        mapped_memory_size = man.mapped_memory_size
+                        num_file_handles = man.num_file_handles
+                        while num_random_accesses:
+                            num_random_accesses -= 1
+                            base_offset = randint(0, fc.size - 1)
+
+                            # precondition
+                            if man.window_size():
+                                assert max_mapped_memory_size >= mapped_memory_size()
+                            # END statistics will overshoot, which is fine
+                            assert max_file_handles >= num_file_handles()
+                            assert c.use_region(base_offset, (size or c.size())).is_valid()
+                            csize = c.size()
+                            assert c.buffer()[:] == data[base_offset:base_offset + csize]
+                            memory_read += csize
+
+                            assert includes_ofs(base_offset)
+                            assert includes_ofs(base_offset + csize - 1)
+                            assert not includes_ofs(base_offset + csize)
+                        # END while we should do an access
+                        elapsed = max(time() - st, 0.001)  # prevent zero division errors on windows
+                        mb = float(1000 * 1000)
+                        print("%s: Read %i mb of memory with %i random on cursor initialized with %s accesses in %fs (%f mb/s)\n"
+                              % (mtype, memory_read / mb, max_random_accesses, type(item), elapsed, (memory_read / mb) / elapsed),
+                              file=sys.stderr)
+
+                        # an offset as large as the size doesn't work !
+                        assert not c.use_region(fc.size, size).is_valid()
+
+                        # collection - it should be able to collect all
+                        assert man.num_file_handles()
+                        assert man.collect()
+                        assert man.num_file_handles() == 0
+                    # END for each item
+                # END for each manager type
+            finally:
+                os.close(fd)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_tutorial.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_tutorial.py
new file mode 100644
index 0000000000000000000000000000000000000000..31c272abbf09361b6c5dc2077e853a8d47958458
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_tutorial.py
@@ -0,0 +1,75 @@
+from .lib import TestBase
+
+
+class TestTutorial(TestBase):
+
+    def test_example(self):
+        # Memory Managers
+        ##################
+        import smmap
+        # This instance should be globally available in your application
+        # It is configured to be well suitable for 32-bit or 64 bit applications.
+        mman = smmap.SlidingWindowMapManager()
+
+        # the manager provides much useful information about its current state
+        # like the amount of open file handles or the amount of mapped memory
+        assert mman.num_file_handles() == 0
+        assert mman.mapped_memory_size() == 0
+        # and many more ...
+
+        # Cursors
+        ##########
+        import smmap.test.lib
+        with smmap.test.lib.FileCreator(1024 * 1024 * 8, "test_file") as fc:
+            # obtain a cursor to access some file.
+            c = mman.make_cursor(fc.path)
+
+            # the cursor is now associated with the file, but not yet usable
+            assert c.is_associated()
+            assert not c.is_valid()
+
+            # before you can use the cursor, you have to specify a window you want to
+            # access. The following just says you want as much data as possible starting
+            # from offset 0.
+            # To be sure your region could be mapped, query for validity
+            assert c.use_region().is_valid()        # use_region returns self
+
+            # once a region was mapped, you must query its dimension regularly
+            # to assure you don't try to access its buffer out of its bounds
+            assert c.size()
+            c.buffer()[0]           # first byte
+            c.buffer()[1:10]            # first 9 bytes
+            c.buffer()[c.size() - 1]  # last byte
+
+            # you can query absolute offsets, and check whether an offset is included
+            # in the cursor's data.
+            assert c.ofs_begin() < c.ofs_end()
+            assert c.includes_ofs(100)
+
+            # If you are over out of bounds with one of your region requests, the
+            # cursor will be come invalid. It cannot be used in that state
+            assert not c.use_region(fc.size, 100).is_valid()
+            # map as much as possible after skipping the first 100 bytes
+            assert c.use_region(100).is_valid()
+
+            # You can explicitly free cursor resources by unusing the cursor's region
+            c.unuse_region()
+            assert not c.is_valid()
+
+            # Buffers
+            #########
+            # Create a default buffer which can operate on the whole file
+            buf = smmap.SlidingWindowMapBuffer(mman.make_cursor(fc.path))
+
+            # you can use it right away
+            assert buf.cursor().is_valid()
+
+            buf[0]  # access the first byte
+            buf[-1]  # access the last ten bytes on the file
+            buf[-10:]  # access the last ten bytes
+
+            # If you want to keep the instance between different accesses, use the
+            # dedicated methods
+            buf.end_access()
+            assert not buf.cursor().is_valid()  # you cannot use the buffer anymore
+            assert buf.begin_access(offset=10)  # start using the buffer at an offset
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_util.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6ac10f35cb0841947b17f08a49ce52176ded51b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/test/test_util.py
@@ -0,0 +1,105 @@
+from .lib import TestBase, FileCreator
+
+from smmap.util import (
+    MapWindow,
+    MapRegion,
+    MapRegionList,
+    ALLOCATIONGRANULARITY,
+    is_64_bit,
+    align_to_mmap
+)
+
+import os
+import sys
+
+
+class TestMMan(TestBase):
+
+    def test_window(self):
+        wl = MapWindow(0, 1)        # left
+        wc = MapWindow(1, 1)        # center
+        wc2 = MapWindow(10, 5)      # another center
+        wr = MapWindow(8000, 50)    # right
+
+        assert wl.ofs_end() == 1
+        assert wc.ofs_end() == 2
+        assert wr.ofs_end() == 8050
+
+        # extension does nothing if already in place
+        maxsize = 100
+        wc.extend_left_to(wl, maxsize)
+        assert wc.ofs == 1 and wc.size == 1
+        wl.extend_right_to(wc, maxsize)
+        wl.extend_right_to(wc, maxsize)
+        assert wl.ofs == 0 and wl.size == 1
+
+        # an actual left extension
+        pofs_end = wc2.ofs_end()
+        wc2.extend_left_to(wc, maxsize)
+        assert wc2.ofs == wc.ofs_end() and pofs_end == wc2.ofs_end()
+
+        # respects maxsize
+        wc.extend_right_to(wr, maxsize)
+        assert wc.ofs == 1 and wc.size == maxsize
+        wc.extend_right_to(wr, maxsize)
+        assert wc.ofs == 1 and wc.size == maxsize
+
+        # without maxsize
+        wc.extend_right_to(wr, sys.maxsize)
+        assert wc.ofs_end() == wr.ofs and wc.ofs == 1
+
+        # extend left
+        wr.extend_left_to(wc2, maxsize)
+        wr.extend_left_to(wc2, maxsize)
+        assert wr.size == maxsize
+
+        wr.extend_left_to(wc2, sys.maxsize)
+        assert wr.ofs == wc2.ofs_end()
+
+        wc.align()
+        assert wc.ofs == 0 and wc.size == align_to_mmap(wc.size, True)
+
+    def test_region(self):
+        with FileCreator(self.k_window_test_size, "window_test") as fc:
+            half_size = fc.size // 2
+            rofs = align_to_mmap(4200, False)
+            rfull = MapRegion(fc.path, 0, fc.size)
+            rhalfofs = MapRegion(fc.path, rofs, fc.size)
+            rhalfsize = MapRegion(fc.path, 0, half_size)
+
+            # offsets
+            assert rfull.ofs_begin() == 0 and rfull.size() == fc.size
+            assert rfull.ofs_end() == fc.size   # if this method works, it works always
+
+            assert rhalfofs.ofs_begin() == rofs and rhalfofs.size() == fc.size - rofs
+            assert rhalfsize.ofs_begin() == 0 and rhalfsize.size() == half_size
+
+            assert rfull.includes_ofs(0) and rfull.includes_ofs(fc.size - 1) and rfull.includes_ofs(half_size)
+            assert not rfull.includes_ofs(-1) and not rfull.includes_ofs(sys.maxsize)
+
+        # auto-refcount
+        assert rfull.client_count() == 1
+        rfull2 = rfull
+        assert rfull.client_count() == 1, "no auto-counting"
+
+        # window constructor
+        w = MapWindow.from_region(rfull)
+        assert w.ofs == rfull.ofs_begin() and w.ofs_end() == rfull.ofs_end()
+
+    def test_region_list(self):
+        with FileCreator(100, "sample_file") as fc:
+            fd = os.open(fc.path, os.O_RDONLY)
+            try:
+                for item in (fc.path, fd):
+                    ml = MapRegionList(item)
+
+                    assert len(ml) == 0
+                    assert ml.path_or_fd() == item
+                    assert ml.file_size() == fc.size
+            finally:
+                os.close(fd)
+
+    def test_util(self):
+        assert isinstance(is_64_bit(), bool)    # just call it
+        assert align_to_mmap(1, False) == 0
+        assert align_to_mmap(1, True) == ALLOCATIONGRANULARITY
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/util.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbb3872118e644ee0a920914fa5835cf2bfab44d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/smmap/util.py
@@ -0,0 +1,222 @@
+"""Module containing a memory memory manager which provides a sliding window on a number of memory mapped files"""
+import os
+import sys
+
+from mmap import mmap, ACCESS_READ
+from mmap import ALLOCATIONGRANULARITY
+
+__all__ = ["align_to_mmap", "is_64_bit",
+           "MapWindow", "MapRegion", "MapRegionList", "ALLOCATIONGRANULARITY"]
+
+#{ Utilities
+
+
+def align_to_mmap(num, round_up):
+    """
+    Align the given integer number to the closest page offset, which usually is 4096 bytes.
+
+    :param round_up: if True, the next higher multiple of page size is used, otherwise
+        the lower page_size will be used (i.e. if True, 1 becomes 4096, otherwise it becomes 0)
+    :return: num rounded to closest page"""
+    res = (num // ALLOCATIONGRANULARITY) * ALLOCATIONGRANULARITY
+    if round_up and (res != num):
+        res += ALLOCATIONGRANULARITY
+    # END handle size
+    return res
+
+
+def is_64_bit():
+    """:return: True if the system is 64 bit. Otherwise it can be assumed to be 32 bit"""
+    return sys.maxsize > (1 << 32) - 1
+
+#}END utilities
+
+
+#{ Utility Classes
+
+class MapWindow:
+
+    """Utility type which is used to snap windows towards each other, and to adjust their size"""
+    __slots__ = (
+        'ofs',      # offset into the file in bytes
+        'size'              # size of the window in bytes
+    )
+
+    def __init__(self, offset, size):
+        self.ofs = offset
+        self.size = size
+
+    def __repr__(self):
+        return "MapWindow(%i, %i)" % (self.ofs, self.size)
+
+    @classmethod
+    def from_region(cls, region):
+        """:return: new window from a region"""
+        return cls(region._b, region.size())
+
+    def ofs_end(self):
+        return self.ofs + self.size
+
+    def align(self):
+        """Assures the previous window area is contained in the new one"""
+        nofs = align_to_mmap(self.ofs, 0)
+        self.size += self.ofs - nofs    # keep size constant
+        self.ofs = nofs
+        self.size = align_to_mmap(self.size, 1)
+
+    def extend_left_to(self, window, max_size):
+        """Adjust the offset to start where the given window on our left ends if possible,
+        but don't make yourself larger than max_size.
+        The resize will assure that the new window still contains the old window area"""
+        rofs = self.ofs - window.ofs_end()
+        nsize = rofs + self.size
+        rofs -= nsize - min(nsize, max_size)
+        self.ofs -= rofs
+        self.size += rofs
+
+    def extend_right_to(self, window, max_size):
+        """Adjust the size to make our window end where the right window begins, but don't
+        get larger than max_size"""
+        self.size = min(self.size + (window.ofs - self.ofs_end()), max_size)
+
+
+class MapRegion:
+
+    """Defines a mapped region of memory, aligned to pagesizes
+
+    **Note:** deallocates used region automatically on destruction"""
+    __slots__ = [
+        '_b',   # beginning of mapping
+        '_mf',  # mapped memory chunk (as returned by mmap)
+        '_uc',  # total amount of usages
+        '_size',  # cached size of our memory map
+        '__weakref__'
+    ]
+
+    #{ Configuration
+    #} END configuration
+
+    def __init__(self, path_or_fd, ofs, size, flags=0):
+        """Initialize a region, allocate the memory map
+        :param path_or_fd: path to the file to map, or the opened file descriptor
+        :param ofs: **aligned** offset into the file to be mapped
+        :param size: if size is larger then the file on disk, the whole file will be
+            allocated the the size automatically adjusted
+        :param flags: additional flags to be given when opening the file.
+        :raise Exception: if no memory can be allocated"""
+        self._b = ofs
+        self._size = 0
+        self._uc = 0
+
+        if isinstance(path_or_fd, int):
+            fd = path_or_fd
+        else:
+            fd = os.open(path_or_fd, os.O_RDONLY | getattr(os, 'O_BINARY', 0) | flags)
+        # END handle fd
+
+        try:
+            kwargs = dict(access=ACCESS_READ, offset=ofs)
+            corrected_size = size
+            sizeofs = ofs
+
+            # have to correct size, otherwise (instead of the c version) it will
+            # bark that the size is too large ... many extra file accesses because
+            # if this ... argh !
+            actual_size = min(os.fstat(fd).st_size - sizeofs, corrected_size)
+            self._mf = mmap(fd, actual_size, **kwargs)
+            # END handle memory mode
+
+            self._size = len(self._mf)
+        finally:
+            if isinstance(path_or_fd, str):
+                os.close(fd)
+            # END only close it if we opened it
+        # END close file handle
+        # We assume the first one to use us keeps us around
+        self.increment_client_count()
+
+    def __repr__(self):
+        return "MapRegion<%i, %i>" % (self._b, self.size())
+
+    #{ Interface
+
+    def buffer(self):
+        """:return: a buffer containing the memory"""
+        return self._mf
+
+    def map(self):
+        """:return: a memory map containing the memory"""
+        return self._mf
+
+    def ofs_begin(self):
+        """:return: absolute byte offset to the first byte of the mapping"""
+        return self._b
+
+    def size(self):
+        """:return: total size of the mapped region in bytes"""
+        return self._size
+
+    def ofs_end(self):
+        """:return: Absolute offset to one byte beyond the mapping into the file"""
+        return self._b + self._size
+
+    def includes_ofs(self, ofs):
+        """:return: True if the given offset can be read in our mapped region"""
+        return self._b <= ofs < self._b + self._size
+
+    def client_count(self):
+        """:return: number of clients currently using this region"""
+        return self._uc
+
+    def increment_client_count(self, ofs = 1):
+        """Adjust the usage count by the given positive or negative offset.
+        If usage count equals 0, we will auto-release our resources
+        :return: True if we released resources, False otherwise. In the latter case, we can still be used"""
+        self._uc += ofs
+        assert self._uc > -1, "Increments must match decrements, usage counter negative: %i" % self._uc
+
+        if self.client_count() == 0:
+            self.release()
+            return True
+        else:
+            return False
+        # end handle release
+
+    def release(self):
+        """Release all resources this instance might hold. Must only be called if there usage_count() is zero"""
+        self._mf.close()
+
+    #} END interface
+
+
+class MapRegionList(list):
+
+    """List of MapRegion instances associating a path with a list of regions."""
+    __slots__ = (
+        '_path_or_fd',  # path or file descriptor which is mapped by all our regions
+        '_file_size'    # total size of the file we map
+    )
+
+    def __new__(cls, path):
+        return super().__new__(cls)
+
+    def __init__(self, path_or_fd):
+        self._path_or_fd = path_or_fd
+        self._file_size = None
+
+    def path_or_fd(self):
+        """:return: path or file descriptor we are attached to"""
+        return self._path_or_fd
+
+    def file_size(self):
+        """:return: size of file we manager"""
+        if self._file_size is None:
+            if isinstance(self._path_or_fd, str):
+                self._file_size = os.stat(self._path_or_fd).st_size
+            else:
+                self._file_size = os.fstat(self._path_or_fd).st_size
+            # END handle path type
+        # END update file size
+        return self._file_size
+
+#} END utility classes
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c67ba49409169c49ac5d34f2be365def3c30369b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/__init__.py
@@ -0,0 +1,545 @@
+"""
+SymPy is a Python library for symbolic mathematics. It aims to become a
+full-featured computer algebra system (CAS) while keeping the code as simple
+as possible in order to be comprehensible and easily extensible.  SymPy is
+written entirely in Python. It depends on mpmath, and other external libraries
+may be optionally for things like plotting support.
+
+See the webpage for more information and documentation:
+
+    https://sympy.org
+
+"""
+
+
+# Keep this in sync with setup.py/pyproject.toml
+import sys
+if sys.version_info < (3, 9):
+    raise ImportError("Python version 3.9 or above is required for SymPy.")
+del sys
+
+
+try:
+    import mpmath
+except ImportError:
+    raise ImportError("SymPy now depends on mpmath as an external library. "
+    "See https://docs.sympy.org/latest/install.html#mpmath for more information.")
+
+del mpmath
+
+from sympy.release import __version__
+from sympy.core.cache import lazy_function
+
+if 'dev' in __version__:
+    def enable_warnings():
+        import warnings
+        warnings.filterwarnings('default',   '.*',   DeprecationWarning, module='sympy.*')
+        del warnings
+    enable_warnings()
+    del enable_warnings
+
+
+def __sympy_debug():
+    # helper function so we don't import os globally
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+# Fails py2 test if using type hinting
+SYMPY_DEBUG = __sympy_debug()  # type: bool
+
+
+from .core import (sympify, SympifyError, cacheit, Basic, Atom,
+        preorder_traversal, S, Expr, AtomicExpr, UnevaluatedExpr, Symbol,
+        Wild, Dummy, symbols, var, Number, Float, Rational, Integer,
+        NumberSymbol, RealNumber, igcd, ilcm, seterr, E, I, nan, oo, pi, zoo,
+        AlgebraicNumber, comp, mod_inverse, Pow, integer_nthroot, integer_log,
+        trailing, Mul, prod, Add, Mod, Rel, Eq, Ne, Lt, Le, Gt, Ge, Equality,
+        GreaterThan, LessThan, Unequality, StrictGreaterThan, StrictLessThan,
+        vectorize, Lambda, WildFunction, Derivative, diff, FunctionClass,
+        Function, Subs, expand, PoleError, count_ops, expand_mul, expand_log,
+        expand_func, expand_trig, expand_complex, expand_multinomial, nfloat,
+        expand_power_base, expand_power_exp, arity, PrecisionExhausted, N,
+        evalf, Tuple, Dict, gcd_terms, factor_terms, factor_nc, evaluate,
+        Catalan, EulerGamma, GoldenRatio, TribonacciConstant, bottom_up, use,
+        postorder_traversal, default_sort_key, ordered, num_digits)
+
+from .logic import (to_cnf, to_dnf, to_nnf, And, Or, Not, Xor, Nand, Nor,
+        Implies, Equivalent, ITE, POSform, SOPform, simplify_logic, bool_map,
+        true, false, satisfiable)
+
+from .assumptions import (AppliedPredicate, Predicate, AssumptionsContext,
+        assuming, Q, ask, register_handler, remove_handler, refine)
+
+from .polys import (Poly, PurePoly, poly_from_expr, parallel_poly_from_expr,
+        degree, total_degree, degree_list, LC, LM, LT, pdiv, prem, pquo,
+        pexquo, div, rem, quo, exquo, half_gcdex, gcdex, invert,
+        subresultants, resultant, discriminant, cofactors, gcd_list, gcd,
+        lcm_list, lcm, terms_gcd, trunc, monic, content, primitive, compose,
+        decompose, sturm, gff_list, gff, sqf_norm, sqf_part, sqf_list, sqf,
+        factor_list, factor, intervals, refine_root, count_roots, all_roots,
+        real_roots, nroots, ground_roots, nth_power_roots_poly, cancel,
+        reduced, groebner, is_zero_dimensional, GroebnerBasis, poly,
+        symmetrize, horner, interpolate, rational_interpolate, viete, together,
+        BasePolynomialError, ExactQuotientFailed, PolynomialDivisionFailed,
+        OperationNotSupported, HeuristicGCDFailed, HomomorphismFailed,
+        IsomorphismFailed, ExtraneousFactors, EvaluationFailed,
+        RefinementFailed, CoercionFailed, NotInvertible, NotReversible,
+        NotAlgebraic, DomainError, PolynomialError, UnificationFailed,
+        GeneratorsError, GeneratorsNeeded, ComputationFailed,
+        UnivariatePolynomialError, MultivariatePolynomialError,
+        PolificationFailed, OptionError, FlagError, minpoly,
+        minimal_polynomial, primitive_element, field_isomorphism,
+        to_number_field, isolate, round_two, prime_decomp, prime_valuation,
+        galois_group, itermonomials, Monomial, lex, grlex,
+        grevlex, ilex, igrlex, igrevlex, CRootOf, rootof, RootOf,
+        ComplexRootOf, RootSum, roots, Domain, FiniteField, IntegerRing,
+        RationalField, RealField, ComplexField, PythonFiniteField,
+        GMPYFiniteField, PythonIntegerRing, GMPYIntegerRing, PythonRational,
+        GMPYRationalField, AlgebraicField, PolynomialRing, FractionField,
+        ExpressionDomain, FF_python, FF_gmpy, ZZ_python, ZZ_gmpy, QQ_python,
+        QQ_gmpy, GF, FF, ZZ, QQ, ZZ_I, QQ_I, RR, CC, EX, EXRAW,
+        construct_domain, swinnerton_dyer_poly, cyclotomic_poly,
+        symmetric_poly, random_poly, interpolating_poly, jacobi_poly,
+        chebyshevt_poly, chebyshevu_poly, hermite_poly, hermite_prob_poly,
+        legendre_poly, laguerre_poly, apart, apart_list, assemble_partfrac_list,
+        Options, ring, xring, vring, sring, field, xfield, vfield, sfield)
+
+from .series import (Order, O, limit, Limit, gruntz, series, approximants,
+        residue, EmptySequence, SeqPer, SeqFormula, sequence, SeqAdd, SeqMul,
+        fourier_series, fps, difference_delta, limit_seq)
+
+from .functions import (factorial, factorial2, rf, ff, binomial,
+        RisingFactorial, FallingFactorial, subfactorial, carmichael,
+        fibonacci, lucas, motzkin, tribonacci, harmonic, bernoulli, bell, euler,
+        catalan, genocchi, andre, partition, divisor_sigma, legendre_symbol,
+        jacobi_symbol, kronecker_symbol, mobius, primenu, primeomega,
+        totient, reduced_totient, primepi, sqrt, root, Min, Max, Id,
+        real_root, Rem, cbrt, re, im, sign, Abs, conjugate, arg, polar_lift,
+        periodic_argument, unbranched_argument, principal_branch, transpose,
+        adjoint, polarify, unpolarify, sin, cos, tan, sec, csc, cot, sinc,
+        asin, acos, atan, asec, acsc, acot, atan2, exp_polar, exp, ln, log,
+        LambertW, sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh,
+        acoth, asech, acsch, floor, ceiling, frac, Piecewise, piecewise_fold,
+        piecewise_exclusive, erf, erfc, erfi, erf2, erfinv, erfcinv, erf2inv,
+        Ei, expint, E1, li, Li, Si, Ci, Shi, Chi, fresnels, fresnelc, gamma,
+        lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma,
+        multigamma, dirichlet_eta, zeta, lerchphi, polylog, stieltjes, Eijk,
+        LeviCivita, KroneckerDelta, SingularityFunction, DiracDelta, Heaviside,
+        bspline_basis, bspline_basis_set, interpolating_spline, besselj,
+        bessely, besseli, besselk, hankel1, hankel2, jn, yn, jn_zeros, hn1,
+        hn2, airyai, airybi, airyaiprime, airybiprime, marcumq, hyper,
+        meijerg, appellf1, legendre, assoc_legendre, hermite, hermite_prob,
+        chebyshevt, chebyshevu, chebyshevu_root, chebyshevt_root, laguerre,
+        assoc_laguerre, gegenbauer, jacobi, jacobi_normalized, Ynm, Ynm_c,
+        Znm, elliptic_k, elliptic_f, elliptic_e, elliptic_pi, beta, mathieus,
+        mathieuc, mathieusprime, mathieucprime, riemann_xi, betainc, betainc_regularized)
+
+from .ntheory import (nextprime, prevprime, prime, primerange,
+        randprime, Sieve, sieve, primorial, cycle_length, composite,
+        compositepi, isprime, divisors, proper_divisors, factorint,
+        multiplicity, perfect_power, factor_cache, pollard_pm1, pollard_rho, primefactors,
+        divisor_count, proper_divisor_count,
+        factorrat,
+        mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant,
+        is_deficient, is_amicable, is_carmichael, abundance, npartitions, is_primitive_root,
+        is_quad_residue, n_order, sqrt_mod,
+        quadratic_residues, primitive_root, nthroot_mod, is_nthpow_residue,
+        sqrt_mod_iter, discrete_log, quadratic_congruence,
+        binomial_coefficients, binomial_coefficients_list,
+        multinomial_coefficients, continued_fraction_periodic,
+        continued_fraction_iterator, continued_fraction_reduce,
+        continued_fraction_convergents, continued_fraction, egyptian_fraction)
+
+from .concrete import product, Product, summation, Sum
+
+from .discrete import (fft, ifft, ntt, intt, fwht, ifwht, mobius_transform,
+        inverse_mobius_transform, convolution, covering_product,
+        intersecting_product)
+
+from .simplify import (simplify, hypersimp, hypersimilar, logcombine,
+        separatevars, posify, besselsimp, kroneckersimp, signsimp,
+        nsimplify, FU, fu, sqrtdenest, cse, epath, EPath, hyperexpand,
+        collect, rcollect, radsimp, collect_const, fraction, numer, denom,
+        trigsimp, exptrigsimp, powsimp, powdenest, combsimp, gammasimp,
+        ratsimp, ratsimpmodprime)
+
+from .sets import (Set, Interval, Union, EmptySet, FiniteSet, ProductSet,
+        Intersection, DisjointUnion, imageset, Complement, SymmetricDifference, ImageSet,
+        Range, ComplexRegion, Complexes, Reals, Contains, ConditionSet, Ordinal,
+        OmegaPower, ord0, PowerSet, Naturals, Naturals0, UniversalSet,
+        Integers, Rationals)
+
+from .solvers import (solve, solve_linear_system, solve_linear_system_LU,
+        solve_undetermined_coeffs, nsolve, solve_linear, checksol, det_quick,
+        inv_quick, check_assumptions, failing_assumptions, diophantine,
+        rsolve, rsolve_poly, rsolve_ratio, rsolve_hyper, checkodesol,
+        classify_ode, dsolve, homogeneous_order, solve_poly_system, factor_system,
+        solve_triangulated, pde_separate, pde_separate_add, pde_separate_mul,
+        pdsolve, classify_pde, checkpdesol, ode_order, reduce_inequalities,
+        reduce_abs_inequality, reduce_abs_inequalities, solve_poly_inequality,
+        solve_rational_inequalities, solve_univariate_inequality, decompogen,
+        solveset, linsolve, linear_eq_to_matrix, nonlinsolve, substitution)
+
+from .matrices import (ShapeError, NonSquareMatrixError, GramSchmidt,
+        casoratian, diag, eye, hessian, jordan_cell, list2numpy, matrix2numpy,
+        matrix_multiply_elementwise, ones, randMatrix, rot_axis1, rot_axis2,
+        rot_axis3, symarray, wronskian, zeros, MutableDenseMatrix,
+        DeferredVector, MatrixBase, Matrix, MutableMatrix,
+        MutableSparseMatrix, banded, ImmutableDenseMatrix,
+        ImmutableSparseMatrix, ImmutableMatrix, SparseMatrix, MatrixSlice,
+        BlockDiagMatrix, BlockMatrix, FunctionMatrix, Identity, Inverse,
+        MatAdd, MatMul, MatPow, MatrixExpr, MatrixSymbol, Trace, Transpose,
+        ZeroMatrix, OneMatrix, blockcut, block_collapse, matrix_symbols,
+        Adjoint, hadamard_product, HadamardProduct, HadamardPower,
+        Determinant, det, diagonalize_vector, DiagMatrix, DiagonalMatrix,
+        DiagonalOf, trace, DotProduct, kronecker_product, KroneckerProduct,
+        PermutationMatrix, MatrixPermute, Permanent, per, rot_ccw_axis1,
+        rot_ccw_axis2, rot_ccw_axis3, rot_givens)
+
+from .geometry import (Point, Point2D, Point3D, Line, Ray, Segment, Line2D,
+        Segment2D, Ray2D, Line3D, Segment3D, Ray3D, Plane, Ellipse, Circle,
+        Polygon, RegularPolygon, Triangle, rad, deg, are_similar, centroid,
+        convex_hull, idiff, intersection, closest_points, farthest_points,
+        GeometryError, Curve, Parabola)
+
+from .utilities import (flatten, group, take, subsets, variations,
+        numbered_symbols, cartes, capture, dict_merge, prefixes, postfixes,
+        sift, topological_sort, unflatten, has_dups, has_variety, reshape,
+        rotations, filldedent, lambdify,
+        threaded, xthreaded, public, memoize_property, timed)
+
+from .integrals import (integrate, Integral, line_integrate, mellin_transform,
+        inverse_mellin_transform, MellinTransform, InverseMellinTransform,
+        laplace_transform, laplace_correspondence, laplace_initial_conds,
+        inverse_laplace_transform, LaplaceTransform,
+        InverseLaplaceTransform, fourier_transform, inverse_fourier_transform,
+        FourierTransform, InverseFourierTransform, sine_transform,
+        inverse_sine_transform, SineTransform, InverseSineTransform,
+        cosine_transform, inverse_cosine_transform, CosineTransform,
+        InverseCosineTransform, hankel_transform, inverse_hankel_transform,
+        HankelTransform, InverseHankelTransform, singularityintegrate)
+
+from .tensor import (IndexedBase, Idx, Indexed, get_contraction_structure,
+        get_indices, shape, MutableDenseNDimArray, ImmutableDenseNDimArray,
+        MutableSparseNDimArray, ImmutableSparseNDimArray, NDimArray,
+        tensorproduct, tensorcontraction, tensordiagonal, derive_by_array,
+        permutedims, Array, DenseNDimArray, SparseNDimArray)
+
+from .parsing import parse_expr
+
+from .calculus import (euler_equations, singularities, is_increasing,
+        is_strictly_increasing, is_decreasing, is_strictly_decreasing,
+        is_monotonic, finite_diff_weights, apply_finite_diff,
+        differentiate_finite, periodicity, not_empty_in, AccumBounds,
+        is_convex, stationary_points, minimum, maximum)
+
+from .algebras import Quaternion
+
+from .printing import (pager_print, pretty, pretty_print, pprint,
+        pprint_use_unicode, pprint_try_use_unicode, latex, print_latex,
+        multiline_latex, mathml, print_mathml, python, print_python, pycode,
+        ccode, print_ccode, smtlib_code, glsl_code, print_glsl, cxxcode, fcode,
+        print_fcode, rcode, print_rcode, jscode, print_jscode, julia_code,
+        mathematica_code, octave_code, rust_code, print_gtk, preview, srepr,
+        print_tree, StrPrinter, sstr, sstrrepr, TableForm, dotprint,
+        maple_code, print_maple_code)
+
+test = lazy_function('sympy.testing.runtests_pytest', 'test')
+doctest = lazy_function('sympy.testing.runtests', 'doctest')
+
+# This module causes conflicts with other modules:
+# from .stats import *
+# Adds about .04-.05 seconds of import time
+# from combinatorics import *
+# This module is slow to import:
+#from physics import units
+from .plotting import plot, textplot, plot_backends, plot_implicit, plot_parametric
+from .interactive import init_session, init_printing, interactive_traversal
+
+evalf._create_evalf_table()
+
+__all__ = [
+    '__version__',
+
+    # sympy.core
+    'sympify', 'SympifyError', 'cacheit', 'Basic', 'Atom',
+    'preorder_traversal', 'S', 'Expr', 'AtomicExpr', 'UnevaluatedExpr',
+    'Symbol', 'Wild', 'Dummy', 'symbols', 'var', 'Number', 'Float',
+    'Rational', 'Integer', 'NumberSymbol', 'RealNumber', 'igcd', 'ilcm',
+    'seterr', 'E', 'I', 'nan', 'oo', 'pi', 'zoo', 'AlgebraicNumber', 'comp',
+    'mod_inverse', 'Pow', 'integer_nthroot', 'integer_log', 'trailing', 'Mul', 'prod',
+    'Add', 'Mod', 'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge', 'Equality',
+    'GreaterThan', 'LessThan', 'Unequality', 'StrictGreaterThan',
+    'StrictLessThan', 'vectorize', 'Lambda', 'WildFunction', 'Derivative',
+    'diff', 'FunctionClass', 'Function', 'Subs', 'expand', 'PoleError',
+    'count_ops', 'expand_mul', 'expand_log', 'expand_func', 'expand_trig',
+    'expand_complex', 'expand_multinomial', 'nfloat', 'expand_power_base',
+    'expand_power_exp', 'arity', 'PrecisionExhausted', 'N', 'evalf', 'Tuple',
+    'Dict', 'gcd_terms', 'factor_terms', 'factor_nc', 'evaluate', 'Catalan',
+    'EulerGamma', 'GoldenRatio', 'TribonacciConstant', 'bottom_up', 'use',
+    'postorder_traversal', 'default_sort_key', 'ordered', 'num_digits',
+
+    # sympy.logic
+    'to_cnf', 'to_dnf', 'to_nnf', 'And', 'Or', 'Not', 'Xor', 'Nand', 'Nor',
+    'Implies', 'Equivalent', 'ITE', 'POSform', 'SOPform', 'simplify_logic',
+    'bool_map', 'true', 'false', 'satisfiable',
+
+    # sympy.assumptions
+    'AppliedPredicate', 'Predicate', 'AssumptionsContext', 'assuming', 'Q',
+    'ask', 'register_handler', 'remove_handler', 'refine',
+
+    # sympy.polys
+    'Poly', 'PurePoly', 'poly_from_expr', 'parallel_poly_from_expr', 'degree',
+    'total_degree', 'degree_list', 'LC', 'LM', 'LT', 'pdiv', 'prem', 'pquo',
+    'pexquo', 'div', 'rem', 'quo', 'exquo', 'half_gcdex', 'gcdex', 'invert',
+    'subresultants', 'resultant', 'discriminant', 'cofactors', 'gcd_list',
+    'gcd', 'lcm_list', 'lcm', 'terms_gcd', 'trunc', 'monic', 'content',
+    'primitive', 'compose', 'decompose', 'sturm', 'gff_list', 'gff',
+    'sqf_norm', 'sqf_part', 'sqf_list', 'sqf', 'factor_list', 'factor',
+    'intervals', 'refine_root', 'count_roots', 'all_roots', 'real_roots',
+    'nroots', 'ground_roots', 'nth_power_roots_poly', 'cancel', 'reduced',
+    'groebner', 'is_zero_dimensional', 'GroebnerBasis', 'poly', 'symmetrize',
+    'horner', 'interpolate', 'rational_interpolate', 'viete', 'together',
+    'BasePolynomialError', 'ExactQuotientFailed', 'PolynomialDivisionFailed',
+    'OperationNotSupported', 'HeuristicGCDFailed', 'HomomorphismFailed',
+    'IsomorphismFailed', 'ExtraneousFactors', 'EvaluationFailed',
+    'RefinementFailed', 'CoercionFailed', 'NotInvertible', 'NotReversible',
+    'NotAlgebraic', 'DomainError', 'PolynomialError', 'UnificationFailed',
+    'GeneratorsError', 'GeneratorsNeeded', 'ComputationFailed',
+    'UnivariatePolynomialError', 'MultivariatePolynomialError',
+    'PolificationFailed', 'OptionError', 'FlagError', 'minpoly',
+    'minimal_polynomial', 'primitive_element', 'field_isomorphism',
+    'to_number_field', 'isolate', 'round_two', 'prime_decomp',
+    'prime_valuation', 'galois_group', 'itermonomials', 'Monomial', 'lex', 'grlex',
+    'grevlex', 'ilex', 'igrlex', 'igrevlex', 'CRootOf', 'rootof', 'RootOf',
+    'ComplexRootOf', 'RootSum', 'roots', 'Domain', 'FiniteField',
+    'IntegerRing', 'RationalField', 'RealField', 'ComplexField',
+    'PythonFiniteField', 'GMPYFiniteField', 'PythonIntegerRing',
+    'GMPYIntegerRing', 'PythonRational', 'GMPYRationalField',
+    'AlgebraicField', 'PolynomialRing', 'FractionField', 'ExpressionDomain',
+    'FF_python', 'FF_gmpy', 'ZZ_python', 'ZZ_gmpy', 'QQ_python', 'QQ_gmpy',
+    'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR', 'CC', 'EX', 'EXRAW',
+    'construct_domain', 'swinnerton_dyer_poly', 'cyclotomic_poly',
+    'symmetric_poly', 'random_poly', 'interpolating_poly', 'jacobi_poly',
+    'chebyshevt_poly', 'chebyshevu_poly', 'hermite_poly', 'hermite_prob_poly',
+    'legendre_poly', 'laguerre_poly', 'apart', 'apart_list', 'assemble_partfrac_list',
+    'Options', 'ring', 'xring', 'vring', 'sring', 'field', 'xfield', 'vfield',
+    'sfield',
+
+    # sympy.series
+    'Order', 'O', 'limit', 'Limit', 'gruntz', 'series', 'approximants',
+    'residue', 'EmptySequence', 'SeqPer', 'SeqFormula', 'sequence', 'SeqAdd',
+    'SeqMul', 'fourier_series', 'fps', 'difference_delta', 'limit_seq',
+
+    # sympy.functions
+    'factorial', 'factorial2', 'rf', 'ff', 'binomial', 'RisingFactorial',
+    'FallingFactorial', 'subfactorial', 'carmichael', 'fibonacci', 'lucas',
+    'motzkin', 'tribonacci', 'harmonic', 'bernoulli', 'bell', 'euler', 'catalan',
+    'genocchi', 'andre', 'partition',  'divisor_sigma', 'legendre_symbol', 'jacobi_symbol',
+    'kronecker_symbol', 'mobius', 'primenu', 'primeomega', 'totient', 'primepi',
+    'reduced_totient', 'sqrt', 'root', 'Min', 'Max', 'Id', 'real_root',
+    'Rem', 'cbrt', 're', 'im', 'sign', 'Abs', 'conjugate', 'arg', 'polar_lift',
+    'periodic_argument', 'unbranched_argument', 'principal_branch',
+    'transpose', 'adjoint', 'polarify', 'unpolarify', 'sin', 'cos', 'tan',
+    'sec', 'csc', 'cot', 'sinc', 'asin', 'acos', 'atan', 'asec', 'acsc',
+    'acot', 'atan2', 'exp_polar', 'exp', 'ln', 'log', 'LambertW', 'sinh',
+    'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh',
+    'acoth', 'asech', 'acsch', 'floor', 'ceiling', 'frac', 'Piecewise',
+    'piecewise_fold', 'piecewise_exclusive', 'erf', 'erfc', 'erfi', 'erf2',
+    'erfinv', 'erfcinv', 'erf2inv', 'Ei', 'expint', 'E1', 'li', 'Li', 'Si',
+    'Ci', 'Shi', 'Chi', 'fresnels', 'fresnelc', 'gamma', 'lowergamma',
+    'uppergamma', 'polygamma', 'loggamma', 'digamma', 'trigamma', 'multigamma',
+    'dirichlet_eta', 'zeta', 'lerchphi', 'polylog', 'stieltjes', 'Eijk', 'LeviCivita',
+    'KroneckerDelta', 'SingularityFunction', 'DiracDelta', 'Heaviside',
+    'bspline_basis', 'bspline_basis_set', 'interpolating_spline', 'besselj',
+    'bessely', 'besseli', 'besselk', 'hankel1', 'hankel2', 'jn', 'yn',
+    'jn_zeros', 'hn1', 'hn2', 'airyai', 'airybi', 'airyaiprime',
+    'airybiprime', 'marcumq', 'hyper', 'meijerg', 'appellf1', 'legendre',
+    'assoc_legendre', 'hermite', 'hermite_prob', 'chebyshevt', 'chebyshevu',
+    'chebyshevu_root', 'chebyshevt_root', 'laguerre', 'assoc_laguerre',
+    'gegenbauer', 'jacobi', 'jacobi_normalized', 'Ynm', 'Ynm_c', 'Znm',
+    'elliptic_k', 'elliptic_f', 'elliptic_e', 'elliptic_pi', 'beta',
+    'mathieus', 'mathieuc', 'mathieusprime', 'mathieucprime', 'riemann_xi','betainc',
+    'betainc_regularized',
+
+    # sympy.ntheory
+    'nextprime', 'prevprime', 'prime', 'primerange', 'randprime',
+    'Sieve', 'sieve', 'primorial', 'cycle_length', 'composite', 'compositepi',
+    'isprime', 'divisors', 'proper_divisors', 'factorint', 'multiplicity',
+    'perfect_power', 'pollard_pm1', 'factor_cache', 'pollard_rho', 'primefactors',
+    'divisor_count', 'proper_divisor_count',
+    'factorrat',
+    'mersenne_prime_exponent', 'is_perfect', 'is_mersenne_prime',
+    'is_abundant', 'is_deficient', 'is_amicable', 'is_carmichael', 'abundance',
+    'npartitions',
+    'is_primitive_root', 'is_quad_residue',
+    'n_order', 'sqrt_mod', 'quadratic_residues',
+    'primitive_root', 'nthroot_mod', 'is_nthpow_residue', 'sqrt_mod_iter',
+    'discrete_log', 'quadratic_congruence', 'binomial_coefficients',
+    'binomial_coefficients_list', 'multinomial_coefficients',
+    'continued_fraction_periodic', 'continued_fraction_iterator',
+    'continued_fraction_reduce', 'continued_fraction_convergents',
+    'continued_fraction', 'egyptian_fraction',
+
+    # sympy.concrete
+    'product', 'Product', 'summation', 'Sum',
+
+    # sympy.discrete
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform', 'convolution', 'covering_product',
+    'intersecting_product',
+
+    # sympy.simplify
+    'simplify', 'hypersimp', 'hypersimilar', 'logcombine', 'separatevars',
+    'posify', 'besselsimp', 'kroneckersimp', 'signsimp',
+    'nsimplify', 'FU', 'fu', 'sqrtdenest', 'cse', 'epath', 'EPath',
+    'hyperexpand', 'collect', 'rcollect', 'radsimp', 'collect_const',
+    'fraction', 'numer', 'denom', 'trigsimp', 'exptrigsimp', 'powsimp',
+    'powdenest', 'combsimp', 'gammasimp', 'ratsimp', 'ratsimpmodprime',
+
+    # sympy.sets
+    'Set', 'Interval', 'Union', 'EmptySet', 'FiniteSet', 'ProductSet',
+    'Intersection', 'imageset', 'DisjointUnion', 'Complement', 'SymmetricDifference',
+    'ImageSet', 'Range', 'ComplexRegion', 'Reals', 'Contains', 'ConditionSet',
+    'Ordinal', 'OmegaPower', 'ord0', 'PowerSet', 'Naturals',
+    'Naturals0', 'UniversalSet', 'Integers', 'Rationals', 'Complexes',
+
+    # sympy.solvers
+    'solve', 'solve_linear_system', 'solve_linear_system_LU',
+    'solve_undetermined_coeffs', 'nsolve', 'solve_linear', 'checksol',
+    'det_quick', 'inv_quick', 'check_assumptions', 'failing_assumptions',
+    'diophantine', 'rsolve', 'rsolve_poly', 'rsolve_ratio', 'rsolve_hyper',
+    'checkodesol', 'classify_ode', 'dsolve', 'homogeneous_order',
+    'solve_poly_system', 'factor_system', 'solve_triangulated', 'pde_separate',
+    'pde_separate_add', 'pde_separate_mul', 'pdsolve', 'classify_pde',
+    'checkpdesol', 'ode_order', 'reduce_inequalities',
+    'reduce_abs_inequality', 'reduce_abs_inequalities',
+    'solve_poly_inequality', 'solve_rational_inequalities',
+    'solve_univariate_inequality', 'decompogen', 'solveset', 'linsolve',
+    'linear_eq_to_matrix', 'nonlinsolve', 'substitution',
+
+    # sympy.matrices
+    'ShapeError', 'NonSquareMatrixError', 'GramSchmidt', 'casoratian', 'diag',
+    'eye', 'hessian', 'jordan_cell', 'list2numpy', 'matrix2numpy',
+    'matrix_multiply_elementwise', 'ones', 'randMatrix', 'rot_axis1',
+    'rot_axis2', 'rot_axis3', 'symarray', 'wronskian', 'zeros',
+    'MutableDenseMatrix', 'DeferredVector', 'MatrixBase', 'Matrix',
+    'MutableMatrix', 'MutableSparseMatrix', 'banded', 'ImmutableDenseMatrix',
+    'ImmutableSparseMatrix', 'ImmutableMatrix', 'SparseMatrix', 'MatrixSlice',
+    'BlockDiagMatrix', 'BlockMatrix', 'FunctionMatrix', 'Identity', 'Inverse',
+    'MatAdd', 'MatMul', 'MatPow', 'MatrixExpr', 'MatrixSymbol', 'Trace',
+    'Transpose', 'ZeroMatrix', 'OneMatrix', 'blockcut', 'block_collapse',
+    'matrix_symbols', 'Adjoint', 'hadamard_product', 'HadamardProduct',
+    'HadamardPower', 'Determinant', 'det', 'diagonalize_vector', 'DiagMatrix',
+    'DiagonalMatrix', 'DiagonalOf', 'trace', 'DotProduct',
+    'kronecker_product', 'KroneckerProduct', 'PermutationMatrix',
+    'MatrixPermute', 'Permanent', 'per', 'rot_ccw_axis1', 'rot_ccw_axis2',
+    'rot_ccw_axis3', 'rot_givens',
+
+    # sympy.geometry
+    'Point', 'Point2D', 'Point3D', 'Line', 'Ray', 'Segment', 'Line2D',
+    'Segment2D', 'Ray2D', 'Line3D', 'Segment3D', 'Ray3D', 'Plane', 'Ellipse',
+    'Circle', 'Polygon', 'RegularPolygon', 'Triangle', 'rad', 'deg',
+    'are_similar', 'centroid', 'convex_hull', 'idiff', 'intersection',
+    'closest_points', 'farthest_points', 'GeometryError', 'Curve', 'Parabola',
+
+    # sympy.utilities
+    'flatten', 'group', 'take', 'subsets', 'variations', 'numbered_symbols',
+    'cartes', 'capture', 'dict_merge', 'prefixes', 'postfixes', 'sift',
+    'topological_sort', 'unflatten', 'has_dups', 'has_variety', 'reshape',
+    'rotations', 'filldedent', 'lambdify', 'threaded', 'xthreaded',
+    'public', 'memoize_property', 'timed',
+
+    # sympy.integrals
+    'integrate', 'Integral', 'line_integrate', 'mellin_transform',
+    'inverse_mellin_transform', 'MellinTransform', 'InverseMellinTransform',
+    'laplace_transform', 'inverse_laplace_transform', 'LaplaceTransform',
+    'laplace_correspondence', 'laplace_initial_conds',
+    'InverseLaplaceTransform', 'fourier_transform',
+    'inverse_fourier_transform', 'FourierTransform',
+    'InverseFourierTransform', 'sine_transform', 'inverse_sine_transform',
+    'SineTransform', 'InverseSineTransform', 'cosine_transform',
+    'inverse_cosine_transform', 'CosineTransform', 'InverseCosineTransform',
+    'hankel_transform', 'inverse_hankel_transform', 'HankelTransform',
+    'InverseHankelTransform', 'singularityintegrate',
+
+    # sympy.tensor
+    'IndexedBase', 'Idx', 'Indexed', 'get_contraction_structure',
+    'get_indices', 'shape', 'MutableDenseNDimArray', 'ImmutableDenseNDimArray',
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'NDimArray',
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array',
+    'permutedims', 'Array', 'DenseNDimArray', 'SparseNDimArray',
+
+    # sympy.parsing
+    'parse_expr',
+
+    # sympy.calculus
+    'euler_equations', 'singularities', 'is_increasing',
+    'is_strictly_increasing', 'is_decreasing', 'is_strictly_decreasing',
+    'is_monotonic', 'finite_diff_weights', 'apply_finite_diff',
+    'differentiate_finite', 'periodicity', 'not_empty_in',
+    'AccumBounds', 'is_convex', 'stationary_points', 'minimum', 'maximum',
+
+    # sympy.algebras
+    'Quaternion',
+
+    # sympy.printing
+    'pager_print', 'pretty', 'pretty_print', 'pprint', 'pprint_use_unicode',
+    'pprint_try_use_unicode', 'latex', 'print_latex', 'multiline_latex',
+    'mathml', 'print_mathml', 'python', 'print_python', 'pycode', 'ccode',
+    'print_ccode', 'smtlib_code', 'glsl_code', 'print_glsl', 'cxxcode', 'fcode',
+    'print_fcode', 'rcode', 'print_rcode', 'jscode', 'print_jscode',
+    'julia_code', 'mathematica_code', 'octave_code', 'rust_code', 'print_gtk',
+    'preview', 'srepr', 'print_tree', 'StrPrinter', 'sstr', 'sstrrepr',
+    'TableForm', 'dotprint', 'maple_code', 'print_maple_code',
+
+    # sympy.plotting
+    'plot', 'textplot', 'plot_backends', 'plot_implicit', 'plot_parametric',
+
+    # sympy.interactive
+    'init_session', 'init_printing', 'interactive_traversal',
+
+    # sympy.testing
+    'test', 'doctest',
+]
+
+
+#===========================================================================#
+#                                                                           #
+# XXX: The names below were importable before SymPy 1.6 using               #
+#                                                                           #
+#          from sympy import *                                              #
+#                                                                           #
+# This happened implicitly because there was no __all__ defined in this     #
+# __init__.py file. Not every package is imported. The list matches what    #
+# would have been imported before. It is possible that these packages will  #
+# not be imported by a star-import from sympy in future.                    #
+#                                                                           #
+#===========================================================================#
+
+
+__all__.extend((
+    'algebras',
+    'assumptions',
+    'calculus',
+    'concrete',
+    'discrete',
+    'external',
+    'functions',
+    'geometry',
+    'interactive',
+    'multipledispatch',
+    'ntheory',
+    'parsing',
+    'plotting',
+    'polys',
+    'printing',
+    'release',
+    'strategies',
+    'tensor',
+    'utilities',
+))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/abc.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/abc.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6f7a4056e60b0d651becc0b9909bd0ab3c1723f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/abc.py
@@ -0,0 +1,111 @@
+"""
+This module exports all latin and greek letters as Symbols, so you can
+conveniently do
+
+    >>> from sympy.abc import x, y
+
+instead of the slightly more clunky-looking
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x y')
+
+Caveats
+=======
+
+1. As of the time of writing this, the names ``O``, ``S``, ``I``, ``N``,
+``E``, and ``Q`` are colliding with names defined in SymPy. If you import them
+from both ``sympy.abc`` and ``sympy``, the second import will "win".
+This is an issue only for * imports, which should only be used for short-lived
+code such as interactive sessions and throwaway scripts that do not survive
+until the next SymPy upgrade, where ``sympy`` may contain a different set of
+names.
+
+2. This module does not define symbol names on demand, i.e.
+``from sympy.abc import foo`` will be reported as an error because
+``sympy.abc`` does not contain the name ``foo``. To get a symbol named ``foo``,
+you still need to use ``Symbol('foo')`` or ``symbols('foo')``.
+You can freely mix usage of ``sympy.abc`` and ``Symbol``/``symbols``, though
+sticking with one and only one way to get the symbols does tend to make the code
+more readable.
+
+The module also defines some special names to help detect which names clash
+with the default SymPy namespace.
+
+``_clash1`` defines all the single letter variables that clash with
+SymPy objects; ``_clash2`` defines the multi-letter clashing symbols;
+and ``_clash`` is the union of both. These can be passed for ``locals``
+during sympification if one desires Symbols rather than the non-Symbol
+objects for those names.
+
+Examples
+========
+
+>>> from sympy import S
+>>> from sympy.abc import _clash1, _clash2, _clash
+>>> S("Q & C", locals=_clash1)
+C & Q
+>>> S('pi(x)', locals=_clash2)
+pi(x)
+>>> S('pi(C, Q)', locals=_clash)
+pi(C, Q)
+
+"""
+from __future__ import annotations
+from typing import Any
+
+import string
+
+from .core import Symbol, symbols
+from .core.alphabets import greeks
+from sympy.parsing.sympy_parser import null
+
+##### Symbol definitions #####
+
+# Implementation note: The easiest way to avoid typos in the symbols()
+# parameter is to copy it from the left-hand side of the assignment.
+
+a, b, c, d, e, f, g, h, i, j = symbols('a, b, c, d, e, f, g, h, i, j')
+k, l, m, n, o, p, q, r, s, t = symbols('k, l, m, n, o, p, q, r, s, t')
+u, v, w, x, y, z = symbols('u, v, w, x, y, z')
+
+A, B, C, D, E, F, G, H, I, J = symbols('A, B, C, D, E, F, G, H, I, J')
+K, L, M, N, O, P, Q, R, S, T = symbols('K, L, M, N, O, P, Q, R, S, T')
+U, V, W, X, Y, Z = symbols('U, V, W, X, Y, Z')
+
+alpha, beta, gamma, delta = symbols('alpha, beta, gamma, delta')
+epsilon, zeta, eta, theta = symbols('epsilon, zeta, eta, theta')
+iota, kappa, lamda, mu = symbols('iota, kappa, lamda, mu')
+nu, xi, omicron, pi = symbols('nu, xi, omicron, pi')
+rho, sigma, tau, upsilon = symbols('rho, sigma, tau, upsilon')
+phi, chi, psi, omega = symbols('phi, chi, psi, omega')
+
+
+##### Clashing-symbols diagnostics #####
+
+# We want to know which names in SymPy collide with those in here.
+# This is mostly for diagnosing SymPy's namespace during SymPy development.
+
+_latin = list(string.ascii_letters)
+# QOSINE should not be imported as they clash; gamma, pi and zeta clash, too
+_greek = list(greeks) # make a copy, so we can mutate it
+# Note: We import lamda since lambda is a reserved keyword in Python
+_greek.remove("lambda")
+_greek.append("lamda")
+
+ns: dict[str, Any] = {}
+exec('from sympy import *', ns)
+_clash1: dict[str, Any] = {}
+_clash2: dict[str, Any] = {}
+while ns:
+    _k, _ = ns.popitem()
+    if _k in _greek:
+        _clash2[_k] = null
+        _greek.remove(_k)
+    elif _k in _latin:
+        _clash1[_k] = null
+        _latin.remove(_k)
+_clash = {}
+_clash.update(_clash1)
+_clash.update(_clash2)
+
+del _latin, _greek, Symbol, _k, null
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..58013d2e0377a016d1a21fbf21c344ee76765189
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/__init__.py
@@ -0,0 +1,3 @@
+from .quaternion import Quaternion
+
+__all__ = ["Quaternion",]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/quaternion.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/quaternion.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bf4b363545128e50294e825461106ef9b41990d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/quaternion.py
@@ -0,0 +1,1666 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.relational import is_eq
+from sympy.functions.elementary.complexes import (conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log as ln)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.core.sympify import sympify, _sympify
+from sympy.core.expr import Expr
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.utilities.misc import as_int
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def _check_norm(elements, norm):
+    """validate if input norm is consistent"""
+    if norm is not None and norm.is_number:
+        if norm.is_positive is False:
+            raise ValueError("Input norm must be positive.")
+
+        numerical = all(i.is_number and i.is_real is True for i in elements)
+        if numerical and is_eq(norm**2, sum(i**2 for i in elements)) is False:
+            raise ValueError("Incompatible value for norm.")
+
+
+def _is_extrinsic(seq):
+    """validate seq and return True if seq is lowercase and False if uppercase"""
+    if type(seq) != str:
+        raise ValueError('Expected seq to be a string.')
+    if len(seq) != 3:
+        raise ValueError("Expected 3 axes, got `{}`.".format(seq))
+
+    intrinsic = seq.isupper()
+    extrinsic = seq.islower()
+    if not (intrinsic or extrinsic):
+        raise ValueError("seq must either be fully uppercase (for extrinsic "
+                         "rotations), or fully lowercase, for intrinsic "
+                         "rotations).")
+
+    i, j, k = seq.lower()
+    if (i == j) or (j == k):
+        raise ValueError("Consecutive axes must be different")
+
+    bad = set(seq) - set('xyzXYZ')
+    if bad:
+        raise ValueError("Expected axes from `seq` to be from "
+                         "['x', 'y', 'z'] or ['X', 'Y', 'Z'], "
+                         "got {}".format(''.join(bad)))
+
+    return extrinsic
+
+
+class Quaternion(Expr):
+    """Provides basic quaternion operations.
+    Quaternion objects can be instantiated as ``Quaternion(a, b, c, d)``
+    as in $q = a + bi + cj + dk$.
+
+    Parameters
+    ==========
+
+    norm : None or number
+        Pre-defined quaternion norm. If a value is given, Quaternion.norm
+        returns this pre-defined value instead of calculating the norm
+
+    Examples
+    ========
+
+    >>> from sympy import Quaternion
+    >>> q = Quaternion(1, 2, 3, 4)
+    >>> q
+    1 + 2*i + 3*j + 4*k
+
+    Quaternions over complex fields can be defined as:
+
+    >>> from sympy import Quaternion
+    >>> from sympy import symbols, I
+    >>> x = symbols('x')
+    >>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
+    >>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    >>> q1
+    x + x**3*i + x*j + x**2*k
+    >>> q2
+    (3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+    Defining symbolic unit quaternions:
+
+    >>> from sympy import Quaternion
+    >>> from sympy.abc import w, x, y, z
+    >>> q = Quaternion(w, x, y, z, norm=1)
+    >>> q
+    w + x*i + y*j + z*k
+    >>> q.norm()
+    1
+
+    References
+    ==========
+
+    .. [1] https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
+    .. [2] https://en.wikipedia.org/wiki/Quaternion
+
+    """
+    _op_priority = 11.0
+
+    is_commutative = False
+
+    def __new__(cls, a=0, b=0, c=0, d=0, real_field=True, norm=None):
+        a, b, c, d = map(sympify, (a, b, c, d))
+
+        if any(i.is_commutative is False for i in [a, b, c, d]):
+            raise ValueError("arguments have to be commutative")
+        obj = super().__new__(cls, a, b, c, d)
+        obj._real_field = real_field
+        obj.set_norm(norm)
+        return obj
+
+    def set_norm(self, norm):
+        """Sets norm of an already instantiated quaternion.
+
+        Parameters
+        ==========
+
+        norm : None or number
+            Pre-defined quaternion norm. If a value is given, Quaternion.norm
+            returns this pre-defined value instead of calculating the norm
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        Setting the norm:
+
+        >>> q.set_norm(1)
+        >>> q.norm()
+        1
+
+        Removing set norm:
+
+        >>> q.set_norm(None)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        """
+        norm = sympify(norm)
+        _check_norm(self.args, norm)
+        self._norm = norm
+
+    @property
+    def a(self):
+        return self.args[0]
+
+    @property
+    def b(self):
+        return self.args[1]
+
+    @property
+    def c(self):
+        return self.args[2]
+
+    @property
+    def d(self):
+        return self.args[3]
+
+    @property
+    def real_field(self):
+        return self._real_field
+
+    @property
+    def product_matrix_left(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        left. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  &-d  & c \\
+                                  c  & d  & a  &-b \\
+                                  d  &-c  & b  & a \end{bmatrix}
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(1, 0, 0, 1)
+        >>> q2 = Quaternion(a, b, c, d)
+        >>> q1.product_matrix_left
+        Matrix([
+        [1, 0,  0, -1],
+        [0, 1, -1,  0],
+        [0, 1,  1,  0],
+        [1, 0,  0,  1]])
+
+        >>> q1.product_matrix_left * q2.to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, -self.d, self.c],
+                [self.c, self.d, self.a, -self.b],
+                [self.d, -self.c, self.b, self.a]])
+
+    @property
+    def product_matrix_right(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        right. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  & d  &-c \\
+                                  c  &-d  & a  & b \\
+                                  d  & c  &-b  & a \end{bmatrix}
+
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(a, b, c, d)
+        >>> q2 = Quaternion(1, 0, 0, 1)
+        >>> q2.product_matrix_right
+        Matrix([
+        [1, 0, 0, -1],
+        [0, 1, 1, 0],
+        [0, -1, 1, 0],
+        [1, 0, 0, 1]])
+
+        Note the switched arguments: the matrix represents the quaternion on
+        the right, but is still considered as a matrix multiplication from the
+        left.
+
+        >>> q2.product_matrix_right * q1.to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, self.d, -self.c],
+                [self.c, -self.d, self.a, self.b],
+                [self.d, self.c, -self.b, self.a]])
+
+    def to_Matrix(self, vector_only=False):
+        """Returns elements of quaternion as a column vector.
+        By default, a ``Matrix`` of length 4 is returned, with the real part as the
+        first element.
+        If ``vector_only`` is ``True``, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        vector_only : bool
+            If True, only imaginary part is returned.
+            Default value: False
+
+        Returns
+        =======
+
+        Matrix
+            A column vector constructed by the elements of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q.to_Matrix()
+        Matrix([
+        [a],
+        [b],
+        [c],
+        [d]])
+
+
+        >>> q.to_Matrix(vector_only=True)
+        Matrix([
+        [b],
+        [c],
+        [d]])
+
+        """
+        if vector_only:
+            return Matrix(self.args[1:])
+        else:
+            return Matrix(self.args)
+
+    @classmethod
+    def from_Matrix(cls, elements):
+        """Returns quaternion from elements of a column vector`.
+        If vector_only is True, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        elements : Matrix, list or tuple of length 3 or 4. If length is 3,
+            assume real part is zero.
+            Default value: False
+
+        Returns
+        =======
+
+        Quaternion
+            A quaternion created from the input elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion.from_Matrix([a, b, c, d])
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q = Quaternion.from_Matrix([b, c, d])
+        >>> q
+        0 + b*i + c*j + d*k
+
+        """
+        length = len(elements)
+        if length != 3 and length != 4:
+            raise ValueError("Input elements must have length 3 or 4, got {} "
+                             "elements".format(length))
+
+        if length == 3:
+            return Quaternion(0, *elements)
+        else:
+            return Quaternion(*elements)
+
+    @classmethod
+    def from_euler(cls, angles, seq):
+        """Returns quaternion equivalent to rotation represented by the Euler
+        angles, in the sequence defined by ``seq``.
+
+        Parameters
+        ==========
+
+        angles : list, tuple or Matrix of 3 numbers
+            The Euler angles (in radians).
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the Euler angles
+            in the given sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi
+        >>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
+        >>> q
+        sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
+        >>> q
+        0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
+        >>> q
+        0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k
+
+        """
+
+        if len(angles) != 3:
+            raise ValueError("3 angles must be given.")
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get elementary basis vectors
+        ei = [1 if n == i else 0 for n in 'xyz']
+        ej = [1 if n == j else 0 for n in 'xyz']
+        ek = [1 if n == k else 0 for n in 'xyz']
+
+        # calculate distinct quaternions
+        qi = cls.from_axis_angle(ei, angles[0])
+        qj = cls.from_axis_angle(ej, angles[1])
+        qk = cls.from_axis_angle(ek, angles[2])
+
+        if extrinsic:
+            return trigsimp(qk * qj * qi)
+        else:
+            return trigsimp(qi * qj * qk)
+
+    def to_euler(self, seq, angle_addition=True, avoid_square_root=False):
+        r"""Returns Euler angles representing same rotation as the quaternion,
+        in the sequence given by ``seq``. This implements the method described
+        in [1]_.
+
+        For degenerate cases (gymbal lock cases), the third angle is
+        set to zero.
+
+        Parameters
+        ==========
+
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        angle_addition : bool
+            When True, first and third angles are given as an addition and
+            subtraction of two simpler ``atan2`` expressions. When False, the
+            first and third angles are each given by a single more complicated
+            ``atan2`` expression. This equivalent expression is given by:
+
+            .. math::
+
+                \operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) =
+                \operatorname{atan_2} (bc\pm ad, ac\mp bd)
+
+            Default value: True
+
+        avoid_square_root : bool
+            When True, the second angle is calculated with an expression based
+            on ``acos``, which is slightly more complicated but avoids a square
+            root. When False, second angle is calculated with ``atan2``, which
+            is simpler and can be better for numerical reasons (some
+            numerical implementations of ``acos`` have problems near zero).
+            Default value: False
+
+
+        Returns
+        =======
+
+        Tuple
+            The Euler angles calculated from the quaternion
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> euler = Quaternion(a, b, c, d).to_euler('zyz')
+        >>> euler
+        (-atan2(-b, c) + atan2(d, a),
+         2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
+         atan2(-b, c) + atan2(d, a))
+
+
+        References
+        ==========
+
+        .. [1] https://doi.org/10.1371/journal.pone.0276302
+
+        """
+        if self.is_zero_quaternion():
+            raise ValueError('Cannot convert a quaternion with norm 0.')
+
+        angles = [0, 0, 0]
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get index corresponding to elementary basis vectors
+        i = 'xyz'.index(i) + 1
+        j = 'xyz'.index(j) + 1
+        k = 'xyz'.index(k) + 1
+
+        if not extrinsic:
+            i, k = k, i
+
+        # check if sequence is symmetric
+        symmetric = i == k
+        if symmetric:
+            k = 6 - i - j
+
+        # parity of the permutation
+        sign = (i - j) * (j - k) * (k - i) // 2
+
+        # permutate elements
+        elements = [self.a, self.b, self.c, self.d]
+        a = elements[0]
+        b = elements[i]
+        c = elements[j]
+        d = elements[k] * sign
+
+        if not symmetric:
+            a, b, c, d = a - c, b + d, c + a, d - b
+
+        if avoid_square_root:
+            if symmetric:
+                n2 = self.norm()**2
+                angles[1] = acos((a * a + b * b - c * c - d * d) / n2)
+            else:
+                n2 = 2 * self.norm()**2
+                angles[1] = asin((c * c + d * d - a * a - b * b) / n2)
+        else:
+            angles[1] = 2 * atan2(sqrt(c * c + d * d), sqrt(a * a + b * b))
+            if not symmetric:
+                angles[1] -= S.Pi / 2
+
+        # Check for singularities in numerical cases
+        case = 0
+        if is_eq(c, S.Zero) and is_eq(d, S.Zero):
+            case = 1
+        if is_eq(a, S.Zero) and is_eq(b, S.Zero):
+            case = 2
+
+        if case == 0:
+            if angle_addition:
+                angles[0] = atan2(b, a) + atan2(d, c)
+                angles[2] = atan2(b, a) - atan2(d, c)
+            else:
+                angles[0] = atan2(b*c + a*d, a*c - b*d)
+                angles[2] = atan2(b*c - a*d, a*c + b*d)
+
+        else:  # any degenerate case
+            angles[2 * (not extrinsic)] = S.Zero
+            if case == 1:
+                angles[2 * extrinsic] = 2 * atan2(b, a)
+            else:
+                angles[2 * extrinsic] = 2 * atan2(d, c)
+                angles[2 * extrinsic] *= (-1 if extrinsic else 1)
+
+        # for Tait-Bryan angles
+        if not symmetric:
+            angles[0] *= sign
+
+        if extrinsic:
+            return tuple(angles[::-1])
+        else:
+            return tuple(angles)
+
+    @classmethod
+    def from_axis_angle(cls, vector, angle):
+        """Returns a rotation quaternion given the axis and the angle of rotation.
+
+        Parameters
+        ==========
+
+        vector : tuple of three numbers
+            The vector representation of the given axis.
+        angle : number
+            The angle by which axis is rotated (in radians).
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the given axis and the angle of rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi, sqrt
+        >>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
+        >>> q
+        1/2 + 1/2*i + 1/2*j + 1/2*k
+
+        """
+        (x, y, z) = vector
+        norm = sqrt(x**2 + y**2 + z**2)
+        (x, y, z) = (x / norm, y / norm, z / norm)
+        s = sin(angle * S.Half)
+        a = cos(angle * S.Half)
+        b = x * s
+        c = y * s
+        d = z * s
+
+        # note that this quaternion is already normalized by construction:
+        # c^2 + (s*x)^2 + (s*y)^2 + (s*z)^2 = c^2 + s^2*(x^2 + y^2 + z^2) = c^2 + s^2 * 1 = c^2 + s^2 = 1
+        # so, what we return is a normalized quaternion
+
+        return cls(a, b, c, d)
+
+    @classmethod
+    def from_rotation_matrix(cls, M):
+        """Returns the equivalent quaternion of a matrix. The quaternion will be normalized
+        only if the matrix is special orthogonal (orthogonal and det(M) = 1).
+
+        Parameters
+        ==========
+
+        M : Matrix
+            Input matrix to be converted to equivalent quaternion. M must be special
+            orthogonal (orthogonal and det(M) = 1) for the quaternion to be normalized.
+
+        Returns
+        =======
+
+        Quaternion
+            The quaternion equivalent to given matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Matrix, symbols, cos, sin, trigsimp
+        >>> x = symbols('x')
+        >>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
+        >>> q = trigsimp(Quaternion.from_rotation_matrix(M))
+        >>> q
+        sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k
+
+        """
+
+        absQ = M.det()**Rational(1, 3)
+
+        a = sqrt(absQ + M[0, 0] + M[1, 1] + M[2, 2]) / 2
+        b = sqrt(absQ + M[0, 0] - M[1, 1] - M[2, 2]) / 2
+        c = sqrt(absQ - M[0, 0] + M[1, 1] - M[2, 2]) / 2
+        d = sqrt(absQ - M[0, 0] - M[1, 1] + M[2, 2]) / 2
+
+        b = b * sign(M[2, 1] - M[1, 2])
+        c = c * sign(M[0, 2] - M[2, 0])
+        d = d * sign(M[1, 0] - M[0, 1])
+
+        return Quaternion(a, b, c, d)
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.add(other*-1)
+
+    def __mul__(self, other):
+        return self._generic_mul(self, _sympify(other))
+
+    def __rmul__(self, other):
+        return self._generic_mul(_sympify(other), self)
+
+    def __pow__(self, p):
+        return self.pow(p)
+
+    def __neg__(self):
+        return Quaternion(-self.a, -self.b, -self.c, -self.d)
+
+    def __truediv__(self, other):
+        return self * sympify(other)**-1
+
+    def __rtruediv__(self, other):
+        return sympify(other) * self**-1
+
+    def _eval_Integral(self, *args):
+        return self.integrate(*args)
+
+    def diff(self, *symbols, **kwargs):
+        kwargs.setdefault('evaluate', True)
+        return self.func(*[a.diff(*symbols, **kwargs) for a  in self.args])
+
+    def add(self, other):
+        """Adds quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion
+            The quaternion to add to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after adding self to other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.add(q2)
+        6 + 8*i + 10*j + 12*k
+        >>> q1 + 5
+        6 + 2*i + 3*j + 4*k
+        >>> x = symbols('x', real = True)
+        >>> q1.add(x)
+        (x + 1) + 2*i + 3*j + 4*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.add(2 + 3*I)
+        (5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+        """
+        q1 = self
+        q2 = sympify(other)
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return Quaternion(re(q2) + q1.a, im(q2) + q1.b, q1.c, q1.d)
+            elif q2.is_commutative:
+                return Quaternion(q1.a + q2, q1.b, q1.c, q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be added with a Quaternion.")
+
+        return Quaternion(q1.a + q2.a, q1.b + q2.b, q1.c + q2.c, q1.d
+                          + q2.d)
+
+    def mul(self, other):
+        """Multiplies quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion or symbol
+            The quaternion to multiply to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying self with other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.mul(q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> q1.mul(2)
+        2 + 4*i + 6*j + 8*k
+        >>> x = symbols('x', real = True)
+        >>> q1.mul(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.mul(2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        return self._generic_mul(self, _sympify(other))
+
+    @staticmethod
+    def _generic_mul(q1, q2):
+        """Generic multiplication.
+
+        Parameters
+        ==========
+
+        q1 : Quaternion or symbol
+        q2 : Quaternion or symbol
+
+        It is important to note that if neither q1 nor q2 is a Quaternion,
+        this function simply returns q1 * q2.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying q1 and q2
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Symbol, S
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> Quaternion._generic_mul(q1, q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> Quaternion._generic_mul(q1, S(2))
+        2 + 4*i + 6*j + 8*k
+        >>> x = Symbol('x', real = True)
+        >>> Quaternion._generic_mul(q1, x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> Quaternion._generic_mul(q3, 2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        # None is a Quaternion:
+        if not isinstance(q1, Quaternion) and not isinstance(q2, Quaternion):
+            return q1 * q2
+
+        # If q1 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q1, Quaternion):
+            if q2.real_field and q1.is_complex:
+                return Quaternion(re(q1), im(q1), 0, 0) * q2
+            elif q1.is_commutative:
+                return Quaternion(q1 * q2.a, q1 * q2.b, q1 * q2.c, q1 * q2.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return q1 * Quaternion(re(q2), im(q2), 0, 0)
+            elif q2.is_commutative:
+                return Quaternion(q2 * q1.a, q2 * q1.b, q2 * q1.c, q2 * q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If any of the quaternions has a fixed norm, pre-compute norm
+        if q1._norm is None and q2._norm is None:
+            norm = None
+        else:
+            norm = q1.norm() * q2.norm()
+
+        return Quaternion(-q1.b*q2.b - q1.c*q2.c - q1.d*q2.d + q1.a*q2.a,
+                          q1.b*q2.a + q1.c*q2.d - q1.d*q2.c + q1.a*q2.b,
+                          -q1.b*q2.d + q1.c*q2.a + q1.d*q2.b + q1.a*q2.c,
+                          q1.b*q2.c - q1.c*q2.b + q1.d*q2.a + q1.a * q2.d,
+                          norm=norm)
+
+    def _eval_conjugate(self):
+        """Returns the conjugate of the quaternion."""
+        q = self
+        return Quaternion(q.a, -q.b, -q.c, -q.d, norm=q._norm)
+
+    def norm(self):
+        """Returns the norm of the quaternion."""
+        if self._norm is None:  # check if norm is pre-defined
+            q = self
+            # trigsimp is used to simplify sin(x)^2 + cos(x)^2 (these terms
+            # arise when from_axis_angle is used).
+            return sqrt(trigsimp(q.a**2 + q.b**2 + q.c**2 + q.d**2))
+
+        return self._norm
+
+    def normalize(self):
+        """Returns the normalized form of the quaternion."""
+        q = self
+        return q * (1/q.norm())
+
+    def inverse(self):
+        """Returns the inverse of the quaternion."""
+        q = self
+        if not q.norm():
+            raise ValueError("Cannot compute inverse for a quaternion with zero norm")
+        return conjugate(q) * (1/q.norm()**2)
+
+    def pow(self, p):
+        """Finds the pth power of the quaternion.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Returns the p-th power of the current quaternion.
+            Returns the inverse if p = -1.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow(4)
+        668 + (-224)*i + (-336)*j + (-448)*k
+
+        """
+        try:
+            q, p = self, as_int(p)
+        except ValueError:
+            return NotImplemented
+
+        if p < 0:
+            q, p = q.inverse(), -p
+
+        if p == 1:
+            return q
+
+        res = Quaternion(1, 0, 0, 0)
+        while p > 0:
+            if p & 1:
+                res *= q
+            q *= q
+            p >>= 1
+
+        return res
+
+    def exp(self):
+        """Returns the exponential of $q$, given by $e^q$.
+
+        Returns
+        =======
+
+        Quaternion
+            The exponential of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.exp()
+        E*cos(sqrt(29))
+        + 2*sqrt(29)*E*sin(sqrt(29))/29*i
+        + 3*sqrt(29)*E*sin(sqrt(29))/29*j
+        + 4*sqrt(29)*E*sin(sqrt(29))/29*k
+
+        """
+        # exp(q) = e^a(cos||v|| + v/||v||*sin||v||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        a = exp(q.a) * cos(vector_norm)
+        b = exp(q.a) * sin(vector_norm) * q.b / vector_norm
+        c = exp(q.a) * sin(vector_norm) * q.c / vector_norm
+        d = exp(q.a) * sin(vector_norm) * q.d / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def log(self):
+        r"""Returns the logarithm of the quaternion, given by $\log q$.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.log()
+        log(sqrt(30))
+        + 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+        + 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+        + 4*sqrt(29)*acos(sqrt(30)/30)/29*k
+
+        """
+        # log(q) = log||q|| + v/||v||*arccos(a/||q||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        q_norm = q.norm()
+        a = ln(q_norm)
+        b = q.b * acos(q.a / q_norm) / vector_norm
+        c = q.c * acos(q.a / q_norm) / vector_norm
+        d = q.d * acos(q.a / q_norm) / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def _eval_subs(self, *args):
+        elements = [i.subs(*args) for i in self.args]
+        norm = self._norm
+        if norm is not None:
+            norm = norm.subs(*args)
+        _check_norm(elements, norm)
+        return Quaternion(*elements, norm=norm)
+
+    def _eval_evalf(self, prec):
+        """Returns the floating point approximations (decimal numbers) of the quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Floating point approximations of quaternion(self)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import sqrt
+        >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4))
+        >>> q.evalf()
+        1.00000000000000
+        + 0.707106781186547*i
+        + 0.577350269189626*j
+        + 0.500000000000000*k
+
+        """
+        nprec = prec_to_dps(prec)
+        return Quaternion(*[arg.evalf(n=nprec) for arg in self.args])
+
+    def pow_cos_sin(self, p):
+        """Computes the pth power in the cos-sin form.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The p-th power in the cos-sin form.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow_cos_sin(4)
+        900*cos(4*acos(sqrt(30)/30))
+        + 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+        + 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+        + 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k
+
+        """
+        # q = ||q||*(cos(a) + u*sin(a))
+        # q^p = ||q||^p * (cos(p*a) + u*sin(p*a))
+
+        q = self
+        (v, angle) = q.to_axis_angle()
+        q2 = Quaternion.from_axis_angle(v, p * angle)
+        return q2 * (q.norm()**p)
+
+    def integrate(self, *args):
+        """Computes integration of quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Integration of the quaternion(self) with the given variable.
+
+        Examples
+        ========
+
+        Indefinite Integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Definite integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate((x, 1, 5))
+        4 + 8*i + 12*j + 16*k
+
+        """
+        return Quaternion(integrate(self.a, *args), integrate(self.b, *args),
+                          integrate(self.c, *args), integrate(self.d, *args))
+
+    @staticmethod
+    def rotate_point(pin, r):
+        """Returns the coordinates of the point pin (a 3 tuple) after rotation.
+
+        Parameters
+        ==========
+
+        pin : tuple
+            A 3-element tuple of coordinates of a point which needs to be
+            rotated.
+        r : Quaternion or tuple
+            Axis and angle of rotation.
+
+            It's important to note that when r is a tuple, it must be of the form
+            (axis, angle)
+
+        Returns
+        =======
+
+        tuple
+            The coordinates of the point after rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+
+        """
+        if isinstance(r, tuple):
+            # if r is of the form (vector, angle)
+            q = Quaternion.from_axis_angle(r[0], r[1])
+        else:
+            # if r is a quaternion
+            q = r.normalize()
+        pout = q * Quaternion(0, pin[0], pin[1], pin[2]) * conjugate(q)
+        return (pout.b, pout.c, pout.d)
+
+    def to_axis_angle(self):
+        """Returns the axis and angle of rotation of a quaternion.
+
+        Returns
+        =======
+
+        tuple
+            Tuple of (axis, angle)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> axis
+        (sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
+        >>> angle
+        2*pi/3
+
+        """
+        q = self
+        if q.a.is_negative:
+            q = q * -1
+
+        q = q.normalize()
+        angle = trigsimp(2 * acos(q.a))
+
+        # Since quaternion is normalised, q.a is less than 1.
+        s = sqrt(1 - q.a*q.a)
+
+        x = trigsimp(q.b / s)
+        y = trigsimp(q.c / s)
+        z = trigsimp(q.d / s)
+
+        v = (x, y, z)
+        t = (v, angle)
+
+        return t
+
+    def to_rotation_matrix(self, v=None, homogeneous=True):
+        """Returns the equivalent rotation transformation matrix of the quaternion
+        which represents rotation about the origin if ``v`` is not passed.
+
+        Parameters
+        ==========
+
+        v : tuple or None
+            Default value: None
+        homogeneous : bool
+            When True, gives an expression that may be more efficient for
+            symbolic calculations but less so for direct evaluation. Both
+            formulas are mathematically equivalent.
+            Default value: True
+
+        Returns
+        =======
+
+        tuple
+            Returns the equivalent rotation transformation matrix of the quaternion
+            which represents rotation about the origin if v is not passed.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(q.to_rotation_matrix())
+        Matrix([
+        [cos(x), -sin(x), 0],
+        [sin(x),  cos(x), 0],
+        [     0,       0, 1]])
+
+        Generates a 4x4 transformation matrix (used for rotation about a point
+        other than the origin) if the point(v) is passed as an argument.
+        """
+
+        q = self
+        s = q.norm()**-2
+
+        # diagonal elements are different according to parameter normal
+        if homogeneous:
+            m00 = s*(q.a**2 + q.b**2 - q.c**2 - q.d**2)
+            m11 = s*(q.a**2 - q.b**2 + q.c**2 - q.d**2)
+            m22 = s*(q.a**2 - q.b**2 - q.c**2 + q.d**2)
+        else:
+            m00 = 1 - 2*s*(q.c**2 + q.d**2)
+            m11 = 1 - 2*s*(q.b**2 + q.d**2)
+            m22 = 1 - 2*s*(q.b**2 + q.c**2)
+
+        m01 = 2*s*(q.b*q.c - q.d*q.a)
+        m02 = 2*s*(q.b*q.d + q.c*q.a)
+
+        m10 = 2*s*(q.b*q.c + q.d*q.a)
+        m12 = 2*s*(q.c*q.d - q.b*q.a)
+
+        m20 = 2*s*(q.b*q.d - q.c*q.a)
+        m21 = 2*s*(q.c*q.d + q.b*q.a)
+
+        if not v:
+            return Matrix([[m00, m01, m02], [m10, m11, m12], [m20, m21, m22]])
+
+        else:
+            (x, y, z) = v
+
+            m03 = x - x*m00 - y*m01 - z*m02
+            m13 = y - x*m10 - y*m11 - z*m12
+            m23 = z - x*m20 - y*m21 - z*m22
+            m30 = m31 = m32 = 0
+            m33 = 1
+
+            return Matrix([[m00, m01, m02, m03], [m10, m11, m12, m13],
+                          [m20, m21, m22, m23], [m30, m31, m32, m33]])
+
+    def scalar_part(self):
+        r"""Returns scalar part($\mathbf{S}(q)$) of the quaternion q.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{S}(q) = a$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.scalar_part()
+        4
+
+        """
+
+        return self.a
+
+    def vector_part(self):
+        r"""
+        Returns $\mathbf{V}(q)$, the vector part of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{V}(q) = bi + cj + dk$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.vector_part()
+        0 + 1*i + 1*j + 1*k
+
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.vector_part()
+        0 + 8*i + 13*j + 12*k
+
+        """
+
+        return Quaternion(0, self.b, self.c, self.d)
+
+    def axis(self):
+        r"""
+        Returns $\mathbf{Ax}(q)$, the axis of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{Ax}(q)$  i.e., the versor of the vector part of that quaternion
+        equal to $\mathbf{U}[\mathbf{V}(q)]$.
+        The axis is always an imaginary unit with square equal to $-1 + 0i + 0j + 0k$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.axis()
+        0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k
+
+        See Also
+        ========
+
+        vector_part
+
+        """
+        axis = self.vector_part().normalize()
+
+        return Quaternion(0, axis.b, axis.c, axis.d)
+
+    def is_pure(self):
+        """
+        Returns true if the quaternion is pure, false if the quaternion is not pure
+        or returns none if it is unknown.
+
+        Explanation
+        ===========
+
+        A pure quaternion (also a vector quaternion) is a quaternion with scalar
+        part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 8, 13, 12)
+        >>> q.is_pure()
+        True
+
+        See Also
+        ========
+        scalar_part
+
+        """
+
+        return self.a.is_zero
+
+    def is_zero_quaternion(self):
+        """
+        Returns true if the quaternion is a zero quaternion or false if it is not a zero quaternion
+        and None if the value is unknown.
+
+        Explanation
+        ===========
+
+        A zero quaternion is a quaternion with both scalar part and
+        vector part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        False
+
+        >>> q = Quaternion(0, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        True
+
+        See Also
+        ========
+        scalar_part
+        vector_part
+
+        """
+
+        return self.norm().is_zero
+
+    def angle(self):
+        r"""
+        Returns the angle of the quaternion measured in the real-axis plane.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$ where $a$, $b$, $c$ and $d$
+        are real numbers, returns the angle of the quaternion given by
+
+        .. math::
+            \theta := 2 \operatorname{atan_2}\left(\sqrt{b^2 + c^2 + d^2}, {a}\right)
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 4, 4, 4)
+        >>> q.angle()
+        2*atan(4*sqrt(3))
+
+        """
+
+        return 2 * atan2(self.vector_part().norm(), self.scalar_part())
+
+
+    def arc_coplanar(self, other):
+        """
+        Returns True if the transformation arcs represented by the input quaternions happen in the same plane.
+
+        Explanation
+        ===========
+
+        Two quaternions are said to be coplanar (in this arc sense) when their axes are parallel.
+        The plane of a quaternion is the one normal to its axis.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the planes of the two quaternions are the same, apart from its orientation/sign.
+        False : if the planes of the two quaternions are not the same, apart from its orientation/sign.
+        None : if plane of either of the quaternion is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(1, 4, 4, 4)
+        >>> q2 = Quaternion(3, 8, 8, 8)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        True
+
+        >>> q1 = Quaternion(2, 8, 13, 12)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        False
+
+        See Also
+        ========
+
+        vector_coplanar
+        is_pure
+
+        """
+        if (self.is_zero_quaternion()) or (other.is_zero_quaternion()):
+            raise ValueError('Neither of the given quaternions can be 0')
+
+        return fuzzy_or([(self.axis() - other.axis()).is_zero_quaternion(), (self.axis() + other.axis()).is_zero_quaternion()])
+
+    @classmethod
+    def vector_coplanar(cls, q1, q2, q3):
+        r"""
+        Returns True if the axis of the pure quaternions seen as 3D vectors
+        ``q1``, ``q2``, and ``q3`` are coplanar.
+
+        Explanation
+        ===========
+
+        Three pure quaternions are vector coplanar if the quaternions seen as 3D vectors are coplanar.
+
+        Parameters
+        ==========
+
+        q1
+            A pure Quaternion.
+        q2
+            A pure Quaternion.
+        q3
+            A pure Quaternion.
+
+        Returns
+        =======
+
+        True : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar.
+        False : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are not coplanar.
+        None : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(0, 4, 4, 4)
+        >>> q2 = Quaternion(0, 8, 8, 8)
+        >>> q3 = Quaternion(0, 24, 24, 24)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        True
+
+        >>> q1 = Quaternion(0, 8, 16, 8)
+        >>> q2 = Quaternion(0, 8, 3, 12)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        False
+
+        See Also
+        ========
+
+        axis
+        is_pure
+
+        """
+
+        if fuzzy_not(q1.is_pure()) or fuzzy_not(q2.is_pure()) or fuzzy_not(q3.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        M = Matrix([[q1.b, q1.c, q1.d], [q2.b, q2.c, q2.d], [q3.b, q3.c, q3.d]]).det()
+        return M.is_zero
+
+    def parallel(self, other):
+        """
+        Returns True if the two pure quaternions seen as 3D vectors are parallel.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called parallel when their vector product is commutative which
+        implies that the quaternions seen as 3D vectors have same direction.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are parallel.
+        False : if the two pure quaternions seen as 3D vectors are not parallel.
+        None : if the two pure quaternions seen as 3D vectors are parallel is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.parallel(q1)
+        True
+
+        >>> q1 = Quaternion(0, 8, 13, 12)
+        >>> q.parallel(q1)
+        False
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The provided quaternions must be pure')
+
+        return (self*other - other*self).is_zero_quaternion()
+
+    def orthogonal(self, other):
+        """
+        Returns the orthogonality of two quaternions.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called orthogonal when their product is anti-commutative.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are orthogonal.
+        False : if the two pure quaternions seen as 3D vectors are not orthogonal.
+        None : if the two pure quaternions seen as 3D vectors are orthogonal is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.orthogonal(q1)
+        False
+
+        >>> q1 = Quaternion(0, 2, 2, 0)
+        >>> q = Quaternion(0, 2, -2, 0)
+        >>> q.orthogonal(q1)
+        True
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        return (self*other + other*self).is_zero_quaternion()
+
+    def index_vector(self):
+        r"""
+        Returns the index vector of the quaternion.
+
+        Explanation
+        ===========
+
+        The index vector is given by $\mathbf{T}(q)$, the norm (or magnitude) of
+        the quaternion $q$, multiplied by $\mathbf{Ax}(q)$, the axis of $q$.
+
+        Returns
+        =======
+
+        Quaternion: representing index vector of the provided quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.index_vector()
+        0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k
+
+        See Also
+        ========
+
+        axis
+        norm
+
+        """
+
+        return self.norm() * self.axis()
+
+    def mensor(self):
+        """
+        Returns the natural logarithm of the norm(magnitude) of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.mensor()
+        log(2*sqrt(10))
+        >>> q.norm()
+        2*sqrt(10)
+
+        See Also
+        ========
+
+        norm
+
+        """
+
+        return ln(self.norm())
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/tests/test_quaternion.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/tests/test_quaternion.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4331cd6afa05c96e8e11d59df4b7520e4810930
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/algebras/tests/test_quaternion.py
@@ -0,0 +1,437 @@
+from sympy.testing.pytest import slow
+from sympy.core.function import diff
+from sympy.core.function import expand
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, cos, sin, atan2, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify import simplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.algebras.quaternion import Quaternion
+from sympy.testing.pytest import raises
+import math
+from itertools import permutations, product
+
+w, x, y, z = symbols('w:z')
+phi = symbols('phi')
+
+def test_quaternion_construction():
+    q = Quaternion(w, x, y, z)
+    assert q + q == Quaternion(2*w, 2*x, 2*y, 2*z)
+
+    q2 = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3),
+                                    pi*Rational(2, 3))
+    assert q2 == Quaternion(S.Half, S.Half,
+                            S.Half, S.Half)
+
+    M = Matrix([[cos(phi), -sin(phi), 0], [sin(phi), cos(phi), 0], [0, 0, 1]])
+    q3 = trigsimp(Quaternion.from_rotation_matrix(M))
+    assert q3 == Quaternion(
+        sqrt(2)*sqrt(cos(phi) + 1)/2, 0, 0, sqrt(2 - 2*cos(phi))*sign(sin(phi))/2)
+
+    nc = Symbol('nc', commutative=False)
+    raises(ValueError, lambda: Quaternion(w, x, nc, z))
+
+
+def test_quaternion_construction_norm():
+    q1 = Quaternion(*symbols('a:d'))
+
+    q2 = Quaternion(w, x, y, z)
+    assert expand((q1*q2).norm()**2 - (q1.norm()**2 * q2.norm()**2)) == 0
+
+    q3 = Quaternion(w, x, y, z, norm=1)
+    assert (q1 * q3).norm() == q1.norm()
+
+
+def test_issue_25254():
+    # calculating the inverse cached the norm which caused problems
+    # when multiplying
+    p = Quaternion(1, 0, 0, 0)
+    q = Quaternion.from_axis_angle((1, 1, 1), 3 * math.pi/4)
+    qi = q.inverse()  # this operation cached the norm
+    test = q * p * qi
+    assert ((test - p).norm() < 1E-10)
+
+
+def test_to_and_from_Matrix():
+    q = Quaternion(w, x, y, z)
+    q_full = Quaternion.from_Matrix(q.to_Matrix())
+    q_vect = Quaternion.from_Matrix(q.to_Matrix(True))
+    assert (q - q_full).is_zero_quaternion()
+    assert (q.vector_part() - q_vect).is_zero_quaternion()
+
+
+def test_product_matrices():
+    q1 = Quaternion(w, x, y, z)
+    q2 = Quaternion(*(symbols("a:d")))
+    assert (q1 * q2).to_Matrix() == q1.product_matrix_left * q2.to_Matrix()
+    assert (q1 * q2).to_Matrix() == q2.product_matrix_right * q1.to_Matrix()
+
+    R1 = (q1.product_matrix_left * q1.product_matrix_right.T)[1:, 1:]
+    R2 = simplify(q1.to_rotation_matrix()*q1.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_axis_angle():
+
+    test_data = [ # axis, angle, expected_quaternion
+        ((1, 0, 0), 0, (1, 0, 0, 0)),
+        ((1, 0, 0), pi/2, (sqrt(2)/2, sqrt(2)/2, 0, 0)),
+        ((0, 1, 0), pi/2, (sqrt(2)/2, 0, sqrt(2)/2, 0)),
+        ((0, 0, 1), pi/2, (sqrt(2)/2, 0, 0, sqrt(2)/2)),
+        ((1, 0, 0), pi, (0, 1, 0, 0)),
+        ((0, 1, 0), pi, (0, 0, 1, 0)),
+        ((0, 0, 1), pi, (0, 0, 0, 1)),
+        ((1, 1, 1), pi, (0, 1/sqrt(3),1/sqrt(3),1/sqrt(3))),
+        ((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), pi*2/3, (S.Half, S.Half, S.Half, S.Half))
+    ]
+
+    for axis, angle, expected in test_data:
+        assert Quaternion.from_axis_angle(axis, angle) == Quaternion(*expected)
+
+
+def test_quaternion_axis_angle_simplification():
+    result = Quaternion.from_axis_angle((1, 2, 3), asin(4))
+    assert result.a == cos(asin(4)/2)
+    assert result.b == sqrt(14)*sin(asin(4)/2)/14
+    assert result.c == sqrt(14)*sin(asin(4)/2)/7
+    assert result.d == 3*sqrt(14)*sin(asin(4)/2)/14
+
+def test_quaternion_complex_real_addition():
+    a = symbols("a", complex=True)
+    b = symbols("b", real=True)
+    # This symbol is not complex:
+    c = symbols("c", commutative=False)
+
+    q = Quaternion(w, x, y, z)
+    assert a + q == Quaternion(w + re(a), x + im(a), y, z)
+    assert 1 + q == Quaternion(1 + w, x, y, z)
+    assert I + q == Quaternion(w, 1 + x, y, z)
+    assert b + q == Quaternion(w + b, x, y, z)
+    raises(ValueError, lambda: c + q)
+    raises(ValueError, lambda: q * c)
+    raises(ValueError, lambda: c * q)
+
+    assert -q == Quaternion(-w, -x, -y, -z)
+
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 4, 7, 8)
+
+    assert q1 + (2 + 3*I) == Quaternion(5 + 7*I, 2 + 5*I, 0, 7 + 8*I)
+    assert q2 + (2 + 3*I) == Quaternion(3, 7, 7, 8)
+    assert q1 * (2 + 3*I) == \
+    Quaternion((2 + 3*I)*(3 + 4*I), (2 + 3*I)*(2 + 5*I), 0, (2 + 3*I)*(7 + 8*I))
+    assert q2 * (2 + 3*I) == Quaternion(-10, 11, 38, -5)
+
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+    assert q1 + q0 == q1
+    assert q1 - q0 == q1
+    assert q1 - q1 == q0
+
+
+def test_quaternion_subs():
+    q = Quaternion.from_axis_angle((0, 0, 1), phi)
+    assert q.subs(phi, 0) == Quaternion(1, 0, 0, 0)
+
+
+def test_quaternion_evalf():
+    assert (Quaternion(sqrt(2), 0, 0, sqrt(3)).evalf() ==
+            Quaternion(sqrt(2).evalf(), 0, 0, sqrt(3).evalf()))
+    assert (Quaternion(1/sqrt(2), 0, 0, 1/sqrt(2)).evalf() ==
+            Quaternion((1/sqrt(2)).evalf(), 0, 0, (1/sqrt(2)).evalf()))
+
+
+def test_quaternion_functions():
+    q = Quaternion(w, x, y, z)
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+
+    assert conjugate(q) == Quaternion(w, -x, -y, -z)
+    assert q.norm() == sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.normalize() == Quaternion(w, x, y, z) / sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == Quaternion(w, -x, -y, -z) / (w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == q.pow(-1)
+    raises(ValueError, lambda: q0.inverse())
+    assert q.pow(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q**(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q1.pow(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1**(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1.pow(-0.5) == NotImplemented
+    raises(TypeError, lambda: q1**(-0.5))
+
+    assert q1.exp() == \
+    Quaternion(E * cos(sqrt(29)),
+               2 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               3 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               4 * sqrt(29) * E * sin(sqrt(29)) / 29)
+    assert q1.log() == \
+    Quaternion(log(sqrt(30)),
+               2 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               3 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               4 * sqrt(29) * acos(sqrt(30)/30) / 29)
+
+    assert q1.pow_cos_sin(2) == \
+    Quaternion(30 * cos(2 * acos(sqrt(30)/30)),
+               60 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               90 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               120 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29)
+
+    assert diff(Quaternion(x, x, x, x), x) == Quaternion(1, 1, 1, 1)
+
+    assert integrate(Quaternion(x, x, x, x), x) == \
+    Quaternion(x**2 / 2, x**2 / 2, x**2 / 2, x**2 / 2)
+
+    assert Quaternion(1, x, x**2, x**3).integrate(x) == \
+    Quaternion(x, x**2/2, x**3/3, x**4/4)
+
+    assert Quaternion(sin(x), cos(x), sin(2*x), cos(2*x)).integrate(x) == \
+    Quaternion(-cos(x), sin(x), -cos(2*x)/2, sin(2*x)/2)
+
+    assert Quaternion(x**2, y**2, z**2, x*y*z).integrate(x, y) == \
+    Quaternion(x**3*y/3, x*y**3/3, x*y*z**2, x**2*y**2*z/4)
+
+    assert Quaternion.rotate_point((1, 1, 1), q1) == (S.One / 5, 1, S(7) / 5)
+    n = Symbol('n')
+    raises(TypeError, lambda: q1**n)
+    n = Symbol('n', integer=True)
+    raises(TypeError, lambda: q1**n)
+
+    assert Quaternion(22, 23, 55, 8).scalar_part() == 22
+    assert Quaternion(w, x, y, z).scalar_part() == w
+
+    assert Quaternion(22, 23, 55, 8).vector_part() == Quaternion(0, 23, 55, 8)
+    assert Quaternion(w, x, y, z).vector_part() == Quaternion(0, x, y, z)
+
+    assert q1.axis() == Quaternion(0, 2*sqrt(29)/29, 3*sqrt(29)/29, 4*sqrt(29)/29)
+    assert q1.axis().pow(2) == Quaternion(-1, 0, 0, 0)
+    assert q0.axis().scalar_part() == 0
+    assert (q.axis() == Quaternion(0,
+                                   x/sqrt(x**2 + y**2 + z**2),
+                                   y/sqrt(x**2 + y**2 + z**2),
+                                   z/sqrt(x**2 + y**2 + z**2)))
+
+    assert q0.is_pure() is True
+    assert q1.is_pure() is False
+    assert Quaternion(0, 0, 0, 3).is_pure() is True
+    assert Quaternion(0, 2, 10, 3).is_pure() is True
+    assert Quaternion(w, 2, 10, 3).is_pure() is None
+
+    assert q1.angle() == 2*atan(sqrt(29))
+    assert q.angle() == 2*atan2(sqrt(x**2 + y**2 + z**2), w)
+
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, -2, -3, -4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 8, 12, 16)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 2, 3, 4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 7, 4, 1)) is False
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, x, y, z)) is None
+    raises(ValueError, lambda: Quaternion.arc_coplanar(q1, q0))
+
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 12, 16),
+        Quaternion(0, 4, 6, 8),
+        Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 0, 0, 0), Quaternion(0, 4, 6, 8), Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 2, 6), Quaternion(0, 1, 6, 6), Quaternion(0, 0, 3, 4)) is False
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 1, 3, 4),
+        Quaternion(0, 4, w, 6),
+        Quaternion(0, 6, 8, 1)) is None
+    raises(ValueError, lambda:
+        Quaternion.vector_coplanar(q0, Quaternion(0, 4, 6, 8), q1))
+
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 4, 6)) is True
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.parallel(q1))
+
+    assert Quaternion(0, 1, 2, 3).orthogonal(Quaternion(0, -2, 1, 0)) is True
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.orthogonal(q1))
+
+    assert q1.index_vector() == Quaternion(
+        0, 2*sqrt(870)/29,
+        3*sqrt(870)/29,
+        4*sqrt(870)/29)
+    assert Quaternion(0, 3, 9, 4).index_vector() == Quaternion(0, 3, 9, 4)
+
+    assert Quaternion(4, 3, 9, 4).mensor() == log(sqrt(122))
+    assert Quaternion(3, 3, 0, 2).mensor() == log(sqrt(22))
+
+    assert q0.is_zero_quaternion() is True
+    assert q1.is_zero_quaternion() is False
+    assert Quaternion(w, 0, 0, 0).is_zero_quaternion() is None
+
+def test_quaternion_conversions():
+    q1 = Quaternion(1, 2, 3, 4)
+
+    assert q1.to_axis_angle() == ((2 * sqrt(29)/29,
+                                   3 * sqrt(29)/29,
+                                   4 * sqrt(29)/29),
+                                   2 * acos(sqrt(30)/30))
+
+    assert (q1.to_rotation_matrix() ==
+            Matrix([[Rational(-2, 3), Rational(2, 15), Rational(11, 15)],
+                    [Rational(2, 3), Rational(-1, 3), Rational(2, 3)],
+                    [Rational(1, 3), Rational(14, 15), Rational(2, 15)]]))
+
+    assert (q1.to_rotation_matrix((1, 1, 1)) ==
+            Matrix([
+                [Rational(-2, 3), Rational(2, 15), Rational(11, 15), Rational(4, 5)],
+                [Rational(2, 3), Rational(-1, 3), Rational(2, 3), S.Zero],
+                [Rational(1, 3), Rational(14, 15), Rational(2, 15), Rational(-2, 5)],
+                [S.Zero, S.Zero, S.Zero, S.One]]))
+
+    theta = symbols("theta", real=True)
+    q2 = Quaternion(cos(theta/2), 0, 0, sin(theta/2))
+
+    assert trigsimp(q2.to_rotation_matrix()) == Matrix([
+                                               [cos(theta), -sin(theta), 0],
+                                               [sin(theta),  cos(theta), 0],
+                                               [0,           0,          1]])
+
+    assert q2.to_axis_angle() == ((0, 0, sin(theta/2)/Abs(sin(theta/2))),
+                                   2*acos(cos(theta/2)))
+
+    assert trigsimp(q2.to_rotation_matrix((1, 1, 1))) == Matrix([
+               [cos(theta), -sin(theta), 0, sin(theta) - cos(theta) + 1],
+               [sin(theta),  cos(theta), 0, -sin(theta) - cos(theta) + 1],
+               [0,           0,          1,  0],
+               [0,           0,          0,  1]])
+
+
+def test_rotation_matrix_homogeneous():
+    q = Quaternion(w, x, y, z)
+    R1 = q.to_rotation_matrix(homogeneous=True) * q.norm()**2
+    R2 = simplify(q.to_rotation_matrix(homogeneous=False) * q.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_rotation_iss1593():
+    """
+    There was a sign mistake in the definition,
+    of the rotation matrix. This tests that particular sign mistake.
+    See issue 1593 for reference.
+    See wikipedia
+    https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Quaternion-derived_rotation_matrix
+    for the correct definition
+    """
+    q = Quaternion(cos(phi/2), sin(phi/2), 0, 0)
+    assert(trigsimp(q.to_rotation_matrix()) == Matrix([
+                [1,        0,         0],
+                [0, cos(phi), -sin(phi)],
+                [0, sin(phi),  cos(phi)]]))
+
+
+def test_quaternion_multiplication():
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 2, 3, 5)
+    q3 = Quaternion(1, 1, 1, y)
+
+    assert Quaternion._generic_mul(S(4), S.One) == 4
+    assert (Quaternion._generic_mul(S(4), q1) ==
+            Quaternion(12 + 16*I, 8 + 20*I, 0, 28 + 32*I))
+    assert q2.mul(2) == Quaternion(2, 4, 6, 10)
+    assert q2.mul(q3) == Quaternion(-5*y - 4, 3*y - 2, 9 - 2*y, y + 4)
+    assert q2.mul(q3) == q2*q3
+
+    z = symbols('z', complex=True)
+    z_quat = Quaternion(re(z), im(z), 0, 0)
+    q = Quaternion(*symbols('q:4', real=True))
+
+    assert z * q == z_quat * q
+    assert q * z == q * z_quat
+
+
+def test_issue_16318():
+    #for rtruediv
+    q0 = Quaternion(0, 0, 0, 0)
+    raises(ValueError, lambda: 1/q0)
+    #for rotate_point
+    q = Quaternion(1, 2, 3, 4)
+    (axis, angle) = q.to_axis_angle()
+    assert Quaternion.rotate_point((1, 1, 1), (axis, angle)) == (S.One / 5, 1, S(7) / 5)
+    #test for to_axis_angle
+    q = Quaternion(-1, 1, 1, 1)
+    axis = (-sqrt(3)/3, -sqrt(3)/3, -sqrt(3)/3)
+    angle = 2*pi/3
+    assert (axis, angle) == q.to_axis_angle()
+
+
+@slow
+def test_to_euler():
+    q = Quaternion(w, x, y, z)
+    q_normalized = q.normalize()
+
+    seqs = ['zxy', 'zyx', 'zyz', 'zxz']
+    seqs += [seq.upper() for seq in seqs]
+
+    for seq in seqs:
+        euler_from_q = q.to_euler(seq)
+        q_back = simplify(Quaternion.from_euler(euler_from_q, seq))
+        assert q_back == q_normalized
+
+
+def test_to_euler_iss24504():
+    """
+    There was a mistake in the degenerate case testing
+    See issue 24504 for reference.
+    """
+    q = Quaternion.from_euler((phi, 0, 0), 'zyz')
+    assert trigsimp(q.to_euler('zyz'), inverse=True) == (phi, 0, 0)
+
+
+def test_to_euler_numerical_singilarities():
+
+    def test_one_case(angles, seq):
+        q = Quaternion.from_euler(angles, seq)
+        assert q.to_euler(seq) == angles
+
+    # symmetric
+    test_one_case((pi/2,  0, 0), 'zyz')
+    test_one_case((pi/2,  0, 0), 'ZYZ')
+    test_one_case((pi/2,  pi, 0), 'zyz')
+    test_one_case((pi/2,  pi, 0), 'ZYZ')
+
+    # asymmetric
+    test_one_case((pi/2,  pi/2, 0), 'zyx')
+    test_one_case((pi/2,  -pi/2, 0), 'zyx')
+    test_one_case((pi/2,  pi/2, 0), 'ZYX')
+    test_one_case((pi/2,  -pi/2, 0), 'ZYX')
+
+
+@slow
+def test_to_euler_options():
+    def test_one_case(q):
+        angles1 = Matrix(q.to_euler(seq, True, True))
+        angles2 = Matrix(q.to_euler(seq, False, False))
+        angle_errors = simplify(angles1-angles2).evalf()
+        for angle_error in angle_errors:
+            # forcing angles to set {-pi, pi}
+            angle_error = (angle_error + pi) % (2 * pi) - pi
+            assert angle_error < 10e-7
+
+    for xyz in ('xyz', 'XYZ'):
+        for seq_tuple in permutations(xyz):
+            for symmetric in (True, False):
+                if symmetric:
+                    seq = ''.join([seq_tuple[0], seq_tuple[1], seq_tuple[0]])
+                else:
+                    seq = ''.join(seq_tuple)
+
+                for elements in product([-1, 0, 1], repeat=4):
+                    q = Quaternion(*elements)
+                    if not q.is_zero_quaternion():
+                        test_one_case(q)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..af862653f3ce0eeb67f7764e16c32f3466e87024
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/__init__.py
@@ -0,0 +1,18 @@
+"""
+A module to implement logical predicates and assumption system.
+"""
+
+from .assume import (
+    AppliedPredicate, Predicate, AssumptionsContext, assuming,
+    global_assumptions
+)
+from .ask import Q, ask, register_handler, remove_handler
+from .refine import refine
+from .relation import BinaryRelation, AppliedBinaryRelation
+
+__all__ = [
+    'AppliedPredicate', 'Predicate', 'AssumptionsContext', 'assuming',
+    'global_assumptions', 'Q', 'ask', 'register_handler', 'remove_handler',
+    'refine',
+    'BinaryRelation', 'AppliedBinaryRelation'
+]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec81ec8ecce245c2a798cf9e71af1e9373292bc1
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask.py
@@ -0,0 +1,651 @@
+"""Module for querying SymPy objects about assumptions."""
+
+from sympy.assumptions.assume import (global_assumptions, Predicate,
+        AppliedPredicate)
+from sympy.assumptions.cnf import CNF, EncodedCNF, Literal
+from sympy.core import sympify
+from sympy.core.kind import BooleanKind
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.logic.inference import satisfiable
+from sympy.utilities.decorator import memoize_property
+from sympy.utilities.exceptions import (sympy_deprecation_warning,
+                                        SymPyDeprecationWarning,
+                                        ignore_warnings)
+
+
+# Memoization is necessary for the properties of AssumptionKeys to
+# ensure that only one object of Predicate objects are created.
+# This is because assumption handlers are registered on those objects.
+
+
+class AssumptionKeys:
+    """
+    This class contains all the supported keys by ``ask``.
+    It should be accessed via the instance ``sympy.Q``.
+
+    """
+
+    # DO NOT add methods or properties other than predicate keys.
+    # SAT solver checks the properties of Q and use them to compute the
+    # fact system. Non-predicate attributes will break this.
+
+    @memoize_property
+    def hermitian(self):
+        from .handlers.sets import HermitianPredicate
+        return HermitianPredicate()
+
+    @memoize_property
+    def antihermitian(self):
+        from .handlers.sets import AntihermitianPredicate
+        return AntihermitianPredicate()
+
+    @memoize_property
+    def real(self):
+        from .handlers.sets import RealPredicate
+        return RealPredicate()
+
+    @memoize_property
+    def extended_real(self):
+        from .handlers.sets import ExtendedRealPredicate
+        return ExtendedRealPredicate()
+
+    @memoize_property
+    def imaginary(self):
+        from .handlers.sets import ImaginaryPredicate
+        return ImaginaryPredicate()
+
+    @memoize_property
+    def complex(self):
+        from .handlers.sets import ComplexPredicate
+        return ComplexPredicate()
+
+    @memoize_property
+    def algebraic(self):
+        from .handlers.sets import AlgebraicPredicate
+        return AlgebraicPredicate()
+
+    @memoize_property
+    def transcendental(self):
+        from .predicates.sets import TranscendentalPredicate
+        return TranscendentalPredicate()
+
+    @memoize_property
+    def integer(self):
+        from .handlers.sets import IntegerPredicate
+        return IntegerPredicate()
+
+    @memoize_property
+    def noninteger(self):
+        from .predicates.sets import NonIntegerPredicate
+        return NonIntegerPredicate()
+
+    @memoize_property
+    def rational(self):
+        from .handlers.sets import RationalPredicate
+        return RationalPredicate()
+
+    @memoize_property
+    def irrational(self):
+        from .handlers.sets import IrrationalPredicate
+        return IrrationalPredicate()
+
+    @memoize_property
+    def finite(self):
+        from .handlers.calculus import FinitePredicate
+        return FinitePredicate()
+
+    @memoize_property
+    def infinite(self):
+        from .handlers.calculus import InfinitePredicate
+        return InfinitePredicate()
+
+    @memoize_property
+    def positive_infinite(self):
+        from .handlers.calculus import PositiveInfinitePredicate
+        return PositiveInfinitePredicate()
+
+    @memoize_property
+    def negative_infinite(self):
+        from .handlers.calculus import NegativeInfinitePredicate
+        return NegativeInfinitePredicate()
+
+    @memoize_property
+    def positive(self):
+        from .handlers.order import PositivePredicate
+        return PositivePredicate()
+
+    @memoize_property
+    def negative(self):
+        from .handlers.order import NegativePredicate
+        return NegativePredicate()
+
+    @memoize_property
+    def zero(self):
+        from .handlers.order import ZeroPredicate
+        return ZeroPredicate()
+
+    @memoize_property
+    def extended_positive(self):
+        from .handlers.order import ExtendedPositivePredicate
+        return ExtendedPositivePredicate()
+
+    @memoize_property
+    def extended_negative(self):
+        from .handlers.order import ExtendedNegativePredicate
+        return ExtendedNegativePredicate()
+
+    @memoize_property
+    def nonzero(self):
+        from .handlers.order import NonZeroPredicate
+        return NonZeroPredicate()
+
+    @memoize_property
+    def nonpositive(self):
+        from .handlers.order import NonPositivePredicate
+        return NonPositivePredicate()
+
+    @memoize_property
+    def nonnegative(self):
+        from .handlers.order import NonNegativePredicate
+        return NonNegativePredicate()
+
+    @memoize_property
+    def extended_nonzero(self):
+        from .handlers.order import ExtendedNonZeroPredicate
+        return ExtendedNonZeroPredicate()
+
+    @memoize_property
+    def extended_nonpositive(self):
+        from .handlers.order import ExtendedNonPositivePredicate
+        return ExtendedNonPositivePredicate()
+
+    @memoize_property
+    def extended_nonnegative(self):
+        from .handlers.order import ExtendedNonNegativePredicate
+        return ExtendedNonNegativePredicate()
+
+    @memoize_property
+    def even(self):
+        from .handlers.ntheory import EvenPredicate
+        return EvenPredicate()
+
+    @memoize_property
+    def odd(self):
+        from .handlers.ntheory import OddPredicate
+        return OddPredicate()
+
+    @memoize_property
+    def prime(self):
+        from .handlers.ntheory import PrimePredicate
+        return PrimePredicate()
+
+    @memoize_property
+    def composite(self):
+        from .handlers.ntheory import CompositePredicate
+        return CompositePredicate()
+
+    @memoize_property
+    def commutative(self):
+        from .handlers.common import CommutativePredicate
+        return CommutativePredicate()
+
+    @memoize_property
+    def is_true(self):
+        from .handlers.common import IsTruePredicate
+        return IsTruePredicate()
+
+    @memoize_property
+    def symmetric(self):
+        from .handlers.matrices import SymmetricPredicate
+        return SymmetricPredicate()
+
+    @memoize_property
+    def invertible(self):
+        from .handlers.matrices import InvertiblePredicate
+        return InvertiblePredicate()
+
+    @memoize_property
+    def orthogonal(self):
+        from .handlers.matrices import OrthogonalPredicate
+        return OrthogonalPredicate()
+
+    @memoize_property
+    def unitary(self):
+        from .handlers.matrices import UnitaryPredicate
+        return UnitaryPredicate()
+
+    @memoize_property
+    def positive_definite(self):
+        from .handlers.matrices import PositiveDefinitePredicate
+        return PositiveDefinitePredicate()
+
+    @memoize_property
+    def upper_triangular(self):
+        from .handlers.matrices import UpperTriangularPredicate
+        return UpperTriangularPredicate()
+
+    @memoize_property
+    def lower_triangular(self):
+        from .handlers.matrices import LowerTriangularPredicate
+        return LowerTriangularPredicate()
+
+    @memoize_property
+    def diagonal(self):
+        from .handlers.matrices import DiagonalPredicate
+        return DiagonalPredicate()
+
+    @memoize_property
+    def fullrank(self):
+        from .handlers.matrices import FullRankPredicate
+        return FullRankPredicate()
+
+    @memoize_property
+    def square(self):
+        from .handlers.matrices import SquarePredicate
+        return SquarePredicate()
+
+    @memoize_property
+    def integer_elements(self):
+        from .handlers.matrices import IntegerElementsPredicate
+        return IntegerElementsPredicate()
+
+    @memoize_property
+    def real_elements(self):
+        from .handlers.matrices import RealElementsPredicate
+        return RealElementsPredicate()
+
+    @memoize_property
+    def complex_elements(self):
+        from .handlers.matrices import ComplexElementsPredicate
+        return ComplexElementsPredicate()
+
+    @memoize_property
+    def singular(self):
+        from .predicates.matrices import SingularPredicate
+        return SingularPredicate()
+
+    @memoize_property
+    def normal(self):
+        from .predicates.matrices import NormalPredicate
+        return NormalPredicate()
+
+    @memoize_property
+    def triangular(self):
+        from .predicates.matrices import TriangularPredicate
+        return TriangularPredicate()
+
+    @memoize_property
+    def unit_triangular(self):
+        from .predicates.matrices import UnitTriangularPredicate
+        return UnitTriangularPredicate()
+
+    @memoize_property
+    def eq(self):
+        from .relation.equality import EqualityPredicate
+        return EqualityPredicate()
+
+    @memoize_property
+    def ne(self):
+        from .relation.equality import UnequalityPredicate
+        return UnequalityPredicate()
+
+    @memoize_property
+    def gt(self):
+        from .relation.equality import StrictGreaterThanPredicate
+        return StrictGreaterThanPredicate()
+
+    @memoize_property
+    def ge(self):
+        from .relation.equality import GreaterThanPredicate
+        return GreaterThanPredicate()
+
+    @memoize_property
+    def lt(self):
+        from .relation.equality import StrictLessThanPredicate
+        return StrictLessThanPredicate()
+
+    @memoize_property
+    def le(self):
+        from .relation.equality import LessThanPredicate
+        return LessThanPredicate()
+
+
+Q = AssumptionKeys()
+
+def _extract_all_facts(assump, exprs):
+    """
+    Extract all relevant assumptions from *assump* with respect to given *exprs*.
+
+    Parameters
+    ==========
+
+    assump : sympy.assumptions.cnf.CNF
+
+    exprs : tuple of expressions
+
+    Returns
+    =======
+
+    sympy.assumptions.cnf.CNF
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.ask import _extract_all_facts
+    >>> from sympy.abc import x, y
+    >>> assump = CNF.from_prop(Q.positive(x) & Q.integer(y))
+    >>> exprs = (x,)
+    >>> cnf = _extract_all_facts(assump, exprs)
+    >>> cnf.clauses
+    {frozenset({Literal(Q.positive, False)})}
+
+    """
+    facts = set()
+
+    for clause in assump.clauses:
+        args = []
+        for literal in clause:
+            if isinstance(literal.lit, AppliedPredicate) and len(literal.lit.arguments) == 1:
+                if literal.lit.arg in exprs:
+                    # Add literal if it has matching in it
+                    args.append(Literal(literal.lit.function, literal.is_Not))
+                else:
+                    # If any of the literals doesn't have matching expr don't add the whole clause.
+                    break
+            else:
+                # If any of the literals aren't unary predicate don't add the whole clause.
+                break
+
+        else:
+            if args:
+                facts.add(frozenset(args))
+    return CNF(facts)
+
+
+def ask(proposition, assumptions=True, context=global_assumptions):
+    """
+    Function to evaluate the proposition with assumptions.
+
+    Explanation
+    ===========
+
+    This function evaluates the proposition to ``True`` or ``False`` if
+    the truth value can be determined. If not, it returns ``None``.
+
+    It should be discerned from :func:`~.refine` which, when applied to a
+    proposition, simplifies the argument to symbolic ``Boolean`` instead of
+    Python built-in ``True``, ``False`` or ``None``.
+
+    **Syntax**
+
+        * ask(proposition)
+            Evaluate the *proposition* in global assumption context.
+
+        * ask(proposition, assumptions)
+            Evaluate the *proposition* with respect to *assumptions* in
+            global assumption context.
+
+    Parameters
+    ==========
+
+    proposition : Boolean
+        Proposition which will be evaluated to boolean value. If this is
+        not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``.
+
+    assumptions : Boolean, optional
+        Local assumptions to evaluate the *proposition*.
+
+    context : AssumptionsContext, optional
+        Default assumptions to evaluate the *proposition*. By default,
+        this is ``sympy.assumptions.global_assumptions`` variable.
+
+    Returns
+    =======
+
+    ``True``, ``False``, or ``None``
+
+    Raises
+    ======
+
+    TypeError : *proposition* or *assumptions* is not valid logical expression.
+
+    ValueError : assumptions are inconsistent.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi
+    >>> from sympy.abc import x, y
+    >>> ask(Q.rational(pi))
+    False
+    >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y))
+    True
+    >>> ask(Q.prime(4*x), Q.integer(x))
+    False
+
+    If the truth value cannot be determined, ``None`` will be returned.
+
+    >>> print(ask(Q.odd(3*x))) # cannot determine unless we know x
+    None
+
+    ``ValueError`` is raised if assumptions are inconsistent.
+
+    >>> ask(Q.integer(x), Q.even(x) & Q.odd(x))
+    Traceback (most recent call last):
+      ...
+    ValueError: inconsistent assumptions Q.even(x) & Q.odd(x)
+
+    Notes
+    =====
+
+    Relations in assumptions are not implemented (yet), so the following
+    will not give a meaningful result.
+
+    >>> ask(Q.positive(x), x > 0)
+
+    It is however a work in progress.
+
+    See Also
+    ========
+
+    sympy.assumptions.refine.refine : Simplification using assumptions.
+        Proposition is not reduced to ``None`` if the truth value cannot
+        be determined.
+    """
+    from sympy.assumptions.satask import satask
+    from sympy.assumptions.lra_satask import lra_satask
+    from sympy.logic.algorithms.lra_theory import UnhandledInput
+
+    proposition = sympify(proposition)
+    assumptions = sympify(assumptions)
+
+    if isinstance(proposition, Predicate) or proposition.kind is not BooleanKind:
+        raise TypeError("proposition must be a valid logical expression")
+
+    if isinstance(assumptions, Predicate) or assumptions.kind is not BooleanKind:
+        raise TypeError("assumptions must be a valid logical expression")
+
+    binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+    if isinstance(proposition, AppliedPredicate):
+        key, args = proposition.function, proposition.arguments
+    elif proposition.func in binrelpreds:
+        key, args = binrelpreds[type(proposition)], proposition.args
+    else:
+        key, args = Q.is_true, (proposition,)
+
+    # convert local and global assumptions to CNF
+    assump_cnf = CNF.from_prop(assumptions)
+    assump_cnf.extend(context)
+
+    # extract the relevant facts from assumptions with respect to args
+    local_facts = _extract_all_facts(assump_cnf, args)
+
+    # convert default facts and assumed facts to encoded CNF
+    known_facts_cnf = get_all_known_facts()
+    enc_cnf = EncodedCNF()
+    enc_cnf.from_cnf(CNF(known_facts_cnf))
+    enc_cnf.add_from_cnf(local_facts)
+
+    # check the satisfiability of given assumptions
+    if local_facts.clauses and satisfiable(enc_cnf) is False:
+        raise ValueError("inconsistent assumptions %s" % assumptions)
+
+    # quick computation for single fact
+    res = _ask_single_fact(key, local_facts)
+    if res is not None:
+        return res
+
+    # direct resolution method, no logic
+    res = key(*args)._eval_ask(assumptions)
+    if res is not None:
+        return bool(res)
+
+    # using satask (still costly)
+    res = satask(proposition, assumptions=assumptions, context=context)
+    if res is not None:
+        return res
+
+    try:
+        res = lra_satask(proposition, assumptions=assumptions, context=context)
+    except UnhandledInput:
+        return None
+
+    return res
+
+
+def _ask_single_fact(key, local_facts):
+    """
+    Compute the truth value of single predicate using assumptions.
+
+    Parameters
+    ==========
+
+    key : sympy.assumptions.assume.Predicate
+        Proposition predicate.
+
+    local_facts : sympy.assumptions.cnf.CNF
+        Local assumption in CNF form.
+
+    Returns
+    =======
+
+    ``True``, ``False`` or ``None``
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.ask import _ask_single_fact
+
+    If prerequisite of proposition is rejected by the assumption,
+    return ``False``.
+
+    >>> key, assump = Q.zero, ~Q.zero
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+    >>> key, assump = Q.zero, ~Q.even
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+
+    If assumption implies the proposition, return ``True``.
+
+    >>> key, assump = Q.even, Q.zero
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    True
+
+    If proposition rejects the assumption, return ``False``.
+
+    >>> key, assump = Q.even, Q.odd
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+    """
+    if local_facts.clauses:
+
+        known_facts_dict = get_known_facts_dict()
+
+        if len(local_facts.clauses) == 1:
+            cl, = local_facts.clauses
+            if len(cl) == 1:
+                f, = cl
+                prop_facts = known_facts_dict.get(key, None)
+                prop_req = prop_facts[0] if prop_facts is not None else set()
+                if f.is_Not and f.arg in prop_req:
+                    # the prerequisite of proposition is rejected
+                    return False
+
+        for clause in local_facts.clauses:
+            if len(clause) == 1:
+                f, = clause
+                prop_facts = known_facts_dict.get(f.arg, None) if not f.is_Not else None
+                if prop_facts is None:
+                    continue
+
+                prop_req, prop_rej = prop_facts
+                if key in prop_req:
+                    # assumption implies the proposition
+                    return True
+                elif key in prop_rej:
+                    # proposition rejects the assumption
+                    return False
+
+    return None
+
+
+def register_handler(key, handler):
+    """
+    Register a handler in the ask system. key must be a string and handler a
+    class inheriting from AskHandler.
+
+    .. deprecated:: 1.8.
+        Use multipledispatch handler instead. See :obj:`~.Predicate`.
+
+    """
+    sympy_deprecation_warning(
+        """
+        The AskHandler system is deprecated. The register_handler() function
+        should be replaced with the multipledispatch handler of Predicate.
+        """,
+        deprecated_since_version="1.8",
+        active_deprecations_target='deprecated-askhandler',
+    )
+    if isinstance(key, Predicate):
+        key = key.name.name
+    Qkey = getattr(Q, key, None)
+    if Qkey is not None:
+        Qkey.add_handler(handler)
+    else:
+        setattr(Q, key, Predicate(key, handlers=[handler]))
+
+
+def remove_handler(key, handler):
+    """
+    Removes a handler from the ask system.
+
+    .. deprecated:: 1.8.
+        Use multipledispatch handler instead. See :obj:`~.Predicate`.
+
+    """
+    sympy_deprecation_warning(
+        """
+        The AskHandler system is deprecated. The remove_handler() function
+        should be replaced with the multipledispatch handler of Predicate.
+        """,
+        deprecated_since_version="1.8",
+        active_deprecations_target='deprecated-askhandler',
+    )
+    if isinstance(key, Predicate):
+        key = key.name.name
+    # Don't show the same warning again recursively
+    with ignore_warnings(SymPyDeprecationWarning):
+        getattr(Q, key).remove_handler(handler)
+
+
+from sympy.assumptions.ask_generated import (get_all_known_facts,
+    get_known_facts_dict)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask_generated.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask_generated.py
new file mode 100644
index 0000000000000000000000000000000000000000..d90cdffc1e127d78e18f70cda13d8d5e0530d41b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/ask_generated.py
@@ -0,0 +1,352 @@
+"""
+Do NOT manually edit this file.
+Instead, run ./bin/ask_update.py.
+"""
+
+from sympy.assumptions.ask import Q
+from sympy.assumptions.cnf import Literal
+from sympy.core.cache import cacheit
+
+@cacheit
+def get_all_known_facts():
+    """
+    Known facts between unary predicates as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.algebraic, False), Literal(Q.imaginary, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.negative, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.positive, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.rational, True))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.transcendental, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.finite, False))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.imaginary, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.finite, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.complex_elements, False), Literal(Q.real_elements, True))),
+        frozenset((Literal(Q.composite, False), Literal(Q.even, True), Literal(Q.positive, True), Literal(Q.prime, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.even, False), Literal(Q.odd, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.positive, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.prime, True))),
+        frozenset((Literal(Q.diagonal, False), Literal(Q.lower_triangular, True), Literal(Q.upper_triangular, True))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.lower_triangular, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.normal, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.symmetric, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.even, False), Literal(Q.odd, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.odd, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.finite, False), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.finite, True), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.fullrank, False), Literal(Q.invertible, True))),
+        frozenset((Literal(Q.fullrank, True), Literal(Q.invertible, False), Literal(Q.square, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.negative, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.positive, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.negative, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.integer_elements, True), Literal(Q.real_elements, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.positive_definite, True))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.singular, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.singular, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.negative, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.positive, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.rational, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.zero, False))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.rational, True))),
+        frozenset((Literal(Q.lower_triangular, False), Literal(Q.triangular, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.lower_triangular, True), Literal(Q.triangular, False))),
+        frozenset((Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.rational, True), Literal(Q.zero, False))),
+        frozenset((Literal(Q.negative, True), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.normal, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.normal, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.odd, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.orthogonal, False), Literal(Q.real_elements, True), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.positive_definite, False))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.unitary, False))),
+        frozenset((Literal(Q.positive, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.positive_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.square, False), Literal(Q.symmetric, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.unit_triangular, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.upper_triangular, True)))
+    }
+
+@cacheit
+def get_all_known_matrix_facts():
+    """
+    Known facts between unary predicates for matrices as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.complex_elements, False), Literal(Q.real_elements, True))),
+        frozenset((Literal(Q.diagonal, False), Literal(Q.lower_triangular, True), Literal(Q.upper_triangular, True))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.lower_triangular, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.normal, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.symmetric, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.fullrank, False), Literal(Q.invertible, True))),
+        frozenset((Literal(Q.fullrank, True), Literal(Q.invertible, False), Literal(Q.square, True))),
+        frozenset((Literal(Q.integer_elements, True), Literal(Q.real_elements, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.positive_definite, True))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.singular, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.singular, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.lower_triangular, False), Literal(Q.triangular, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.lower_triangular, True), Literal(Q.triangular, False))),
+        frozenset((Literal(Q.normal, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.normal, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.orthogonal, False), Literal(Q.real_elements, True), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.positive_definite, False))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.unitary, False))),
+        frozenset((Literal(Q.square, False), Literal(Q.symmetric, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.unit_triangular, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.upper_triangular, True)))
+    }
+
+@cacheit
+def get_all_known_number_facts():
+    """
+    Known facts between unary predicates for numbers as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.algebraic, False), Literal(Q.imaginary, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.negative, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.positive, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.rational, True))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.transcendental, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.finite, False))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.imaginary, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.finite, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.composite, False), Literal(Q.even, True), Literal(Q.positive, True), Literal(Q.prime, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.even, False), Literal(Q.odd, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.positive, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.odd, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.odd, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.finite, False), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.finite, True), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.negative, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.positive, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.negative, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.negative, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.positive, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.rational, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.zero, False))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.rational, True))),
+        frozenset((Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.rational, True), Literal(Q.zero, False))),
+        frozenset((Literal(Q.negative, True), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.odd, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.positive, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.positive_infinite, True), Literal(Q.zero, True)))
+    }
+
+@cacheit
+def get_known_facts_dict():
+    """
+    Logical relations between unary predicates as dictionary.
+
+    Each key is a predicate, and item is two groups of predicates.
+    First group contains the predicates which are implied by the key, and
+    second group contains the predicates which are rejected by the key.
+
+    """
+    return {
+        Q.algebraic: (set([Q.algebraic, Q.commutative, Q.complex, Q.finite]),
+        set([Q.infinite, Q.negative_infinite, Q.positive_infinite,
+        Q.transcendental])),
+        Q.antihermitian: (set([Q.antihermitian]), set([])),
+        Q.commutative: (set([Q.commutative]), set([])),
+        Q.complex: (set([Q.commutative, Q.complex, Q.finite]),
+        set([Q.infinite, Q.negative_infinite, Q.positive_infinite])),
+        Q.complex_elements: (set([Q.complex_elements]), set([])),
+        Q.composite: (set([Q.algebraic, Q.commutative, Q.complex, Q.composite,
+        Q.extended_nonnegative, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonnegative, Q.nonzero, Q.positive, Q.rational,
+        Q.real]), set([Q.extended_negative, Q.extended_nonpositive,
+        Q.imaginary, Q.infinite, Q.irrational, Q.negative,
+        Q.negative_infinite, Q.nonpositive, Q.positive_infinite,
+        Q.prime, Q.transcendental, Q.zero])),
+        Q.diagonal: (set([Q.diagonal, Q.lower_triangular, Q.normal, Q.square,
+        Q.symmetric, Q.triangular, Q.upper_triangular]), set([])),
+        Q.even: (set([Q.algebraic, Q.commutative, Q.complex, Q.even,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer, Q.rational,
+        Q.real]), set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.odd, Q.positive_infinite,
+        Q.transcendental])),
+        Q.extended_negative: (set([Q.commutative, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real]),
+        set([Q.composite, Q.extended_nonnegative, Q.extended_positive,
+        Q.imaginary, Q.nonnegative, Q.positive, Q.positive_infinite,
+        Q.prime, Q.zero])),
+        Q.extended_nonnegative: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_real]), set([Q.extended_negative, Q.imaginary,
+        Q.negative, Q.negative_infinite])),
+        Q.extended_nonpositive: (set([Q.commutative, Q.extended_nonpositive,
+        Q.extended_real]), set([Q.composite, Q.extended_positive,
+        Q.imaginary, Q.positive, Q.positive_infinite, Q.prime])),
+        Q.extended_nonzero: (set([Q.commutative, Q.extended_nonzero,
+        Q.extended_real]), set([Q.imaginary, Q.zero])),
+        Q.extended_positive: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real]),
+        set([Q.extended_negative, Q.extended_nonpositive, Q.imaginary,
+        Q.negative, Q.negative_infinite, Q.nonpositive, Q.zero])),
+        Q.extended_real: (set([Q.commutative, Q.extended_real]),
+        set([Q.imaginary])),
+        Q.finite: (set([Q.commutative, Q.finite]), set([Q.infinite,
+        Q.negative_infinite, Q.positive_infinite])),
+        Q.fullrank: (set([Q.fullrank]), set([])),
+        Q.hermitian: (set([Q.hermitian]), set([])),
+        Q.imaginary: (set([Q.antihermitian, Q.commutative, Q.complex,
+        Q.finite, Q.imaginary]), set([Q.composite, Q.even,
+        Q.extended_negative, Q.extended_nonnegative,
+        Q.extended_nonpositive, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.infinite, Q.integer,
+        Q.irrational, Q.negative, Q.negative_infinite, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive,
+        Q.positive_infinite, Q.prime, Q.rational, Q.real, Q.zero])),
+        Q.infinite: (set([Q.commutative, Q.infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.finite, Q.imaginary,
+        Q.integer, Q.irrational, Q.negative, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.integer: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer, Q.rational,
+        Q.real]), set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental])),
+        Q.integer_elements: (set([Q.complex_elements, Q.integer_elements,
+        Q.real_elements]), set([])),
+        Q.invertible: (set([Q.fullrank, Q.invertible, Q.square]),
+        set([Q.singular])),
+        Q.irrational: (set([Q.commutative, Q.complex, Q.extended_nonzero,
+        Q.extended_real, Q.finite, Q.hermitian, Q.irrational,
+        Q.nonzero, Q.real]), set([Q.composite, Q.even, Q.imaginary,
+        Q.infinite, Q.integer, Q.negative_infinite, Q.odd,
+        Q.positive_infinite, Q.prime, Q.rational, Q.zero])),
+        Q.is_true: (set([Q.is_true]), set([])),
+        Q.lower_triangular: (set([Q.lower_triangular, Q.triangular]), set([])),
+        Q.negative: (set([Q.commutative, Q.complex, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real,
+        Q.finite, Q.hermitian, Q.negative, Q.nonpositive, Q.nonzero,
+        Q.real]), set([Q.composite, Q.extended_nonnegative,
+        Q.extended_positive, Q.imaginary, Q.infinite,
+        Q.negative_infinite, Q.nonnegative, Q.positive,
+        Q.positive_infinite, Q.prime, Q.zero])),
+        Q.negative_infinite: (set([Q.commutative, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real,
+        Q.infinite, Q.negative_infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.extended_nonnegative,
+        Q.extended_positive, Q.finite, Q.imaginary, Q.integer,
+        Q.irrational, Q.negative, Q.nonnegative, Q.nonpositive,
+        Q.nonzero, Q.odd, Q.positive, Q.positive_infinite, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.noninteger: (set([Q.noninteger]), set([])),
+        Q.nonnegative: (set([Q.commutative, Q.complex, Q.extended_nonnegative,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonnegative,
+        Q.real]), set([Q.extended_negative, Q.imaginary, Q.infinite,
+        Q.negative, Q.negative_infinite, Q.positive_infinite])),
+        Q.nonpositive: (set([Q.commutative, Q.complex, Q.extended_nonpositive,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonpositive,
+        Q.real]), set([Q.composite, Q.extended_positive, Q.imaginary,
+        Q.infinite, Q.negative_infinite, Q.positive,
+        Q.positive_infinite, Q.prime])),
+        Q.nonzero: (set([Q.commutative, Q.complex, Q.extended_nonzero,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonzero, Q.real]),
+        set([Q.imaginary, Q.infinite, Q.negative_infinite,
+        Q.positive_infinite, Q.zero])),
+        Q.normal: (set([Q.normal, Q.square]), set([])),
+        Q.odd: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_nonzero, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonzero, Q.odd, Q.rational, Q.real]),
+        set([Q.even, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental,
+        Q.zero])),
+        Q.orthogonal: (set([Q.fullrank, Q.invertible, Q.normal, Q.orthogonal,
+        Q.positive_definite, Q.square, Q.unitary]), set([Q.singular])),
+        Q.positive: (set([Q.commutative, Q.complex, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real,
+        Q.finite, Q.hermitian, Q.nonnegative, Q.nonzero, Q.positive,
+        Q.real]), set([Q.extended_negative, Q.extended_nonpositive,
+        Q.imaginary, Q.infinite, Q.negative, Q.negative_infinite,
+        Q.nonpositive, Q.positive_infinite, Q.zero])),
+        Q.positive_definite: (set([Q.fullrank, Q.invertible,
+        Q.positive_definite, Q.square]), set([Q.singular])),
+        Q.positive_infinite: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real,
+        Q.infinite, Q.positive_infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.extended_negative,
+        Q.extended_nonpositive, Q.finite, Q.imaginary, Q.integer,
+        Q.irrational, Q.negative, Q.negative_infinite, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.prime: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_nonnegative, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonnegative, Q.nonzero, Q.positive, Q.prime,
+        Q.rational, Q.real]), set([Q.composite, Q.extended_negative,
+        Q.extended_nonpositive, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative, Q.negative_infinite, Q.nonpositive,
+        Q.positive_infinite, Q.transcendental, Q.zero])),
+        Q.rational: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_real, Q.finite, Q.hermitian, Q.rational, Q.real]),
+        set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental])),
+        Q.real: (set([Q.commutative, Q.complex, Q.extended_real, Q.finite,
+        Q.hermitian, Q.real]), set([Q.imaginary, Q.infinite,
+        Q.negative_infinite, Q.positive_infinite])),
+        Q.real_elements: (set([Q.complex_elements, Q.real_elements]), set([])),
+        Q.singular: (set([Q.singular]), set([Q.invertible, Q.orthogonal,
+        Q.positive_definite, Q.unitary])),
+        Q.square: (set([Q.square]), set([])),
+        Q.symmetric: (set([Q.square, Q.symmetric]), set([])),
+        Q.transcendental: (set([Q.commutative, Q.complex, Q.finite,
+        Q.transcendental]), set([Q.algebraic, Q.composite, Q.even,
+        Q.infinite, Q.integer, Q.negative_infinite, Q.odd,
+        Q.positive_infinite, Q.prime, Q.rational, Q.zero])),
+        Q.triangular: (set([Q.triangular]), set([])),
+        Q.unit_triangular: (set([Q.triangular, Q.unit_triangular]), set([])),
+        Q.unitary: (set([Q.fullrank, Q.invertible, Q.normal, Q.square,
+        Q.unitary]), set([Q.singular])),
+        Q.upper_triangular: (set([Q.triangular, Q.upper_triangular]), set([])),
+        Q.zero: (set([Q.algebraic, Q.commutative, Q.complex, Q.even,
+        Q.extended_nonnegative, Q.extended_nonpositive,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer,
+        Q.nonnegative, Q.nonpositive, Q.rational, Q.real, Q.zero]),
+        set([Q.composite, Q.extended_negative, Q.extended_nonzero,
+        Q.extended_positive, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative, Q.negative_infinite, Q.nonzero, Q.odd, Q.positive,
+        Q.positive_infinite, Q.prime, Q.transcendental])),
+    }
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/assume.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/assume.py
new file mode 100644
index 0000000000000000000000000000000000000000..743195a865a1d39389d471b95728ca79834ed019
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/assume.py
@@ -0,0 +1,485 @@
+"""A module which implements predicates and assumption context."""
+
+from contextlib import contextmanager
+import inspect
+from sympy.core.symbol import Str
+from sympy.core.sympify import _sympify
+from sympy.logic.boolalg import Boolean, false, true
+from sympy.multipledispatch.dispatcher import Dispatcher, str_signature
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.source import get_class
+
+
+class AssumptionsContext(set):
+    """
+    Set containing default assumptions which are applied to the ``ask()``
+    function.
+
+    Explanation
+    ===========
+
+    This is used to represent global assumptions, but you can also use this
+    class to create your own local assumptions contexts. It is basically a thin
+    wrapper to Python's set, so see its documentation for advanced usage.
+
+    Examples
+    ========
+
+    The default assumption context is ``global_assumptions``, which is initially empty:
+
+    >>> from sympy import ask, Q
+    >>> from sympy.assumptions import global_assumptions
+    >>> global_assumptions
+    AssumptionsContext()
+
+    You can add default assumptions:
+
+    >>> from sympy.abc import x
+    >>> global_assumptions.add(Q.real(x))
+    >>> global_assumptions
+    AssumptionsContext({Q.real(x)})
+    >>> ask(Q.real(x))
+    True
+
+    And remove them:
+
+    >>> global_assumptions.remove(Q.real(x))
+    >>> print(ask(Q.real(x)))
+    None
+
+    The ``clear()`` method removes every assumption:
+
+    >>> global_assumptions.add(Q.positive(x))
+    >>> global_assumptions
+    AssumptionsContext({Q.positive(x)})
+    >>> global_assumptions.clear()
+    >>> global_assumptions
+    AssumptionsContext()
+
+    See Also
+    ========
+
+    assuming
+
+    """
+
+    def add(self, *assumptions):
+        """Add assumptions."""
+        for a in assumptions:
+            super().add(a)
+
+    def _sympystr(self, printer):
+        if not self:
+            return "%s()" % self.__class__.__name__
+        return "{}({})".format(self.__class__.__name__, printer._print_set(self))
+
+global_assumptions = AssumptionsContext()
+
+
+class AppliedPredicate(Boolean):
+    """
+    The class of expressions resulting from applying ``Predicate`` to
+    the arguments. ``AppliedPredicate`` merely wraps its argument and
+    remain unevaluated. To evaluate it, use the ``ask()`` function.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> Q.integer(1)
+    Q.integer(1)
+
+    The ``function`` attribute returns the predicate, and the ``arguments``
+    attribute returns the tuple of arguments.
+
+    >>> type(Q.integer(1))
+    <class 'sympy.assumptions.assume.AppliedPredicate'>
+    >>> Q.integer(1).function
+    Q.integer
+    >>> Q.integer(1).arguments
+    (1,)
+
+    Applied predicates can be evaluated to a boolean value with ``ask``:
+
+    >>> ask(Q.integer(1))
+    True
+
+    """
+    __slots__ = ()
+
+    def __new__(cls, predicate, *args):
+        if not isinstance(predicate, Predicate):
+            raise TypeError("%s is not a Predicate." % predicate)
+        args = map(_sympify, args)
+        return super().__new__(cls, predicate, *args)
+
+    @property
+    def arg(self):
+        """
+        Return the expression used by this assumption.
+
+        Examples
+        ========
+
+        >>> from sympy import Q, Symbol
+        >>> x = Symbol('x')
+        >>> a = Q.integer(x + 1)
+        >>> a.arg
+        x + 1
+
+        """
+        # Will be deprecated
+        args = self._args
+        if len(args) == 2:
+            # backwards compatibility
+            return args[1]
+        raise TypeError("'arg' property is allowed only for unary predicates.")
+
+    @property
+    def function(self):
+        """
+        Return the predicate.
+        """
+        # Will be changed to self.args[0] after args overriding is removed
+        return self._args[0]
+
+    @property
+    def arguments(self):
+        """
+        Return the arguments which are applied to the predicate.
+        """
+        # Will be changed to self.args[1:] after args overriding is removed
+        return self._args[1:]
+
+    def _eval_ask(self, assumptions):
+        return self.function.eval(self.arguments, assumptions)
+
+    @property
+    def binary_symbols(self):
+        from .ask import Q
+        if self.function == Q.is_true:
+            i = self.arguments[0]
+            if i.is_Boolean or i.is_Symbol:
+                return i.binary_symbols
+        if self.function in (Q.eq, Q.ne):
+            if true in self.arguments or false in self.arguments:
+                if self.arguments[0].is_Symbol:
+                    return {self.arguments[0]}
+                elif self.arguments[1].is_Symbol:
+                    return {self.arguments[1]}
+        return set()
+
+
+class PredicateMeta(type):
+    def __new__(cls, clsname, bases, dct):
+        # If handler is not defined, assign empty dispatcher.
+        if "handler" not in dct:
+            name = f"Ask{clsname.capitalize()}Handler"
+            handler = Dispatcher(name, doc="Handler for key %s" % name)
+            dct["handler"] = handler
+
+        dct["_orig_doc"] = dct.get("__doc__", "")
+
+        return super().__new__(cls, clsname, bases, dct)
+
+    @property
+    def __doc__(cls):
+        handler = cls.handler
+        doc = cls._orig_doc
+        if cls is not Predicate and handler is not None:
+            doc += "Handler\n"
+            doc += "    =======\n\n"
+
+            # Append the handler's doc without breaking sphinx documentation.
+            docs = ["    Multiply dispatched method: %s" % handler.name]
+            if handler.doc:
+                for line in handler.doc.splitlines():
+                    if not line:
+                        continue
+                    docs.append("    %s" % line)
+            other = []
+            for sig in handler.ordering[::-1]:
+                func = handler.funcs[sig]
+                if func.__doc__:
+                    s = '    Inputs: <%s>' % str_signature(sig)
+                    lines = []
+                    for line in func.__doc__.splitlines():
+                        lines.append("    %s" % line)
+                    s += "\n".join(lines)
+                    docs.append(s)
+                else:
+                    other.append(str_signature(sig))
+            if other:
+                othersig = "    Other signatures:"
+                for line in other:
+                    othersig += "\n        * %s" % line
+                docs.append(othersig)
+
+            doc += '\n\n'.join(docs)
+
+        return doc
+
+
+class Predicate(Boolean, metaclass=PredicateMeta):
+    """
+    Base class for mathematical predicates. It also serves as a
+    constructor for undefined predicate objects.
+
+    Explanation
+    ===========
+
+    Predicate is a function that returns a boolean value [1].
+
+    Predicate function is object, and it is instance of predicate class.
+    When a predicate is applied to arguments, ``AppliedPredicate``
+    instance is returned. This merely wraps the argument and remain
+    unevaluated. To obtain the truth value of applied predicate, use the
+    function ``ask``.
+
+    Evaluation of predicate is done by multiple dispatching. You can
+    register new handler to the predicate to support new types.
+
+    Every predicate in SymPy can be accessed via the property of ``Q``.
+    For example, ``Q.even`` returns the predicate which checks if the
+    argument is even number.
+
+    To define a predicate which can be evaluated, you must subclass this
+    class, make an instance of it, and register it to ``Q``. After then,
+    dispatch the handler by argument types.
+
+    If you directly construct predicate using this class, you will get
+    ``UndefinedPredicate`` which cannot be dispatched. This is useful
+    when you are building boolean expressions which do not need to be
+    evaluated.
+
+    Examples
+    ========
+
+    Applying and evaluating to boolean value:
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.prime(7))
+    True
+
+    You can define a new predicate by subclassing and dispatching. Here,
+    we define a predicate for sexy primes [2] as an example.
+
+    >>> from sympy import Predicate, Integer
+    >>> class SexyPrimePredicate(Predicate):
+    ...     name = "sexyprime"
+    >>> Q.sexyprime = SexyPrimePredicate()
+    >>> @Q.sexyprime.register(Integer, Integer)
+    ... def _(int1, int2, assumptions):
+    ...     args = sorted([int1, int2])
+    ...     if not all(ask(Q.prime(a), assumptions) for a in args):
+    ...         return False
+    ...     return args[1] - args[0] == 6
+    >>> ask(Q.sexyprime(5, 11))
+    True
+
+    Direct constructing returns ``UndefinedPredicate``, which can be
+    applied but cannot be dispatched.
+
+    >>> from sympy import Predicate, Integer
+    >>> Q.P = Predicate("P")
+    >>> type(Q.P)
+    <class 'sympy.assumptions.assume.UndefinedPredicate'>
+    >>> Q.P(1)
+    Q.P(1)
+    >>> Q.P.register(Integer)(lambda expr, assump: True)
+    Traceback (most recent call last):
+      ...
+    TypeError: <class 'sympy.assumptions.assume.UndefinedPredicate'> cannot be dispatched.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Predicate_%28mathematical_logic%29
+    .. [2] https://en.wikipedia.org/wiki/Sexy_prime
+
+    """
+
+    is_Atom = True
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Predicate:
+            return UndefinedPredicate(*args, **kwargs)
+        obj = super().__new__(cls, *args)
+        return obj
+
+    @property
+    def name(self):
+        # May be overridden
+        return type(self).__name__
+
+    @classmethod
+    def register(cls, *types, **kwargs):
+        """
+        Register the signature to the handler.
+        """
+        if cls.handler is None:
+            raise TypeError("%s cannot be dispatched." % type(cls))
+        return cls.handler.register(*types, **kwargs)
+
+    @classmethod
+    def register_many(cls, *types, **kwargs):
+        """
+        Register multiple signatures to same handler.
+        """
+        def _(func):
+            for t in types:
+                if not is_sequence(t):
+                    t = (t,)  # for convenience, allow passing `type` to mean `(type,)`
+                cls.register(*t, **kwargs)(func)
+        return _
+
+    def __call__(self, *args):
+        return AppliedPredicate(self, *args)
+
+    def eval(self, args, assumptions=True):
+        """
+        Evaluate ``self(*args)`` under the given assumptions.
+
+        This uses only direct resolution methods, not logical inference.
+        """
+        result = None
+        try:
+            result = self.handler(*args, assumptions=assumptions)
+        except NotImplementedError:
+            pass
+        return result
+
+    def _eval_refine(self, assumptions):
+        # When Predicate is no longer Boolean, delete this method
+        return self
+
+
+class UndefinedPredicate(Predicate):
+    """
+    Predicate without handler.
+
+    Explanation
+    ===========
+
+    This predicate is generated by using ``Predicate`` directly for
+    construction. It does not have a handler, and evaluating this with
+    arguments is done by SAT solver.
+
+    Examples
+    ========
+
+    >>> from sympy import Predicate, Q
+    >>> Q.P = Predicate('P')
+    >>> Q.P.func
+    <class 'sympy.assumptions.assume.UndefinedPredicate'>
+    >>> Q.P.name
+    Str('P')
+
+    """
+
+    handler = None
+
+    def __new__(cls, name, handlers=None):
+        # "handlers" parameter supports old design
+        if not isinstance(name, Str):
+            name = Str(name)
+        obj = super(Boolean, cls).__new__(cls, name)
+        obj.handlers = handlers or []
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    def _hashable_content(self):
+        return (self.name,)
+
+    def __getnewargs__(self):
+        return (self.name,)
+
+    def __call__(self, expr):
+        return AppliedPredicate(self, expr)
+
+    def add_handler(self, handler):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Predicate.add_handler()
+            should be replaced with the multipledispatch handler of Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        self.handlers.append(handler)
+
+    def remove_handler(self, handler):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Predicate.remove_handler()
+            should be replaced with the multipledispatch handler of Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        self.handlers.remove(handler)
+
+    def eval(self, args, assumptions=True):
+        # Support for deprecated design
+        # When old design is removed, this will always return None
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Evaluating UndefinedPredicate
+            objects should be replaced with the multipledispatch handler of
+            Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+            stacklevel=5,
+        )
+        expr, = args
+        res, _res = None, None
+        mro = inspect.getmro(type(expr))
+        for handler in self.handlers:
+            cls = get_class(handler)
+            for subclass in mro:
+                eval_ = getattr(cls, subclass.__name__, None)
+                if eval_ is None:
+                    continue
+                res = eval_(expr, assumptions)
+                # Do not stop if value returned is None
+                # Try to check for higher classes
+                if res is None:
+                    continue
+                if _res is None:
+                    _res = res
+                else:
+                    # only check consistency if both resolutors have concluded
+                    if _res != res:
+                        raise ValueError('incompatible resolutors')
+                break
+        return res
+
+
+@contextmanager
+def assuming(*assumptions):
+    """
+    Context manager for assumptions.
+
+    Examples
+    ========
+
+    >>> from sympy import assuming, Q, ask
+    >>> from sympy.abc import x, y
+    >>> print(ask(Q.integer(x + y)))
+    None
+    >>> with assuming(Q.integer(x), Q.integer(y)):
+    ...     print(ask(Q.integer(x + y)))
+    True
+    """
+    old_global_assumptions = global_assumptions.copy()
+    global_assumptions.update(assumptions)
+    try:
+        yield
+    finally:
+        global_assumptions.clear()
+        global_assumptions.update(old_global_assumptions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/cnf.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/cnf.py
new file mode 100644
index 0000000000000000000000000000000000000000..a95d27bed6eeb64c42f4edd9d49bd8e5753069e5
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/cnf.py
@@ -0,0 +1,445 @@
+"""
+The classes used here are for the internal use of assumptions system
+only and should not be used anywhere else as these do not possess the
+signatures common to SymPy objects. For general use of logic constructs
+please refer to sympy.logic classes And, Or, Not, etc.
+"""
+from itertools import combinations, product, zip_longest
+from sympy.assumptions.assume import AppliedPredicate, Predicate
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.core.singleton import S
+from sympy.logic.boolalg import Or, And, Not, Xnor
+from sympy.logic.boolalg import (Equivalent, ITE, Implies, Nand, Nor, Xor)
+
+
+class Literal:
+    """
+    The smallest element of a CNF object.
+
+    Parameters
+    ==========
+
+    lit : Boolean expression
+
+    is_Not : bool
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import Literal
+    >>> from sympy.abc import x
+    >>> Literal(Q.even(x))
+    Literal(Q.even(x), False)
+    >>> Literal(~Q.even(x))
+    Literal(Q.even(x), True)
+    """
+
+    def __new__(cls, lit, is_Not=False):
+        if isinstance(lit, Not):
+            lit = lit.args[0]
+            is_Not = True
+        elif isinstance(lit, (AND, OR, Literal)):
+            return ~lit if is_Not else lit
+        obj = super().__new__(cls)
+        obj.lit = lit
+        obj.is_Not = is_Not
+        return obj
+
+    @property
+    def arg(self):
+        return self.lit
+
+    def rcall(self, expr):
+        if callable(self.lit):
+            lit = self.lit(expr)
+        else:
+            lit = self.lit.apply(expr)
+        return type(self)(lit, self.is_Not)
+
+    def __invert__(self):
+        is_Not = not self.is_Not
+        return Literal(self.lit, is_Not)
+
+    def __str__(self):
+        return '{}({}, {})'.format(type(self).__name__, self.lit, self.is_Not)
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        return self.arg == other.arg and self.is_Not == other.is_Not
+
+    def __hash__(self):
+        h = hash((type(self).__name__, self.arg, self.is_Not))
+        return h
+
+
+class OR:
+    """
+    A low-level implementation for Or
+    """
+    def __init__(self, *args):
+        self._args = args
+
+    @property
+    def args(self):
+        return sorted(self._args, key=str)
+
+    def rcall(self, expr):
+        return type(self)(*[arg.rcall(expr)
+                            for arg in self._args
+                            ])
+
+    def __invert__(self):
+        return AND(*[~arg for arg in self._args])
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(self, other):
+        return self.args == other.args
+
+    def __str__(self):
+        s = '(' + ' | '.join([str(arg) for arg in self.args]) + ')'
+        return s
+
+    __repr__ = __str__
+
+
+class AND:
+    """
+    A low-level implementation for And
+    """
+    def __init__(self, *args):
+        self._args = args
+
+    def __invert__(self):
+        return OR(*[~arg for arg in self._args])
+
+    @property
+    def args(self):
+        return sorted(self._args, key=str)
+
+    def rcall(self, expr):
+        return type(self)(*[arg.rcall(expr)
+                            for arg in self._args
+                            ])
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(self, other):
+        return self.args == other.args
+
+    def __str__(self):
+        s = '('+' & '.join([str(arg) for arg in self.args])+')'
+        return s
+
+    __repr__ = __str__
+
+
+def to_NNF(expr, composite_map=None):
+    """
+    Generates the Negation Normal Form of any boolean expression in terms
+    of AND, OR, and Literal objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Eq
+    >>> from sympy.assumptions.cnf import to_NNF
+    >>> from sympy.abc import x, y
+    >>> expr = Q.even(x) & ~Q.positive(x)
+    >>> to_NNF(expr)
+    (Literal(Q.even(x), False) & Literal(Q.positive(x), True))
+
+    Supported boolean objects are converted to corresponding predicates.
+
+    >>> to_NNF(Eq(x, y))
+    Literal(Q.eq(x, y), False)
+
+    If ``composite_map`` argument is given, ``to_NNF`` decomposes the
+    specified predicate into a combination of primitive predicates.
+
+    >>> cmap = {Q.nonpositive: Q.negative | Q.zero}
+    >>> to_NNF(Q.nonpositive, cmap)
+    (Literal(Q.negative, False) | Literal(Q.zero, False))
+    >>> to_NNF(Q.nonpositive(x), cmap)
+    (Literal(Q.negative(x), False) | Literal(Q.zero(x), False))
+    """
+    from sympy.assumptions.ask import Q
+
+    if composite_map is None:
+        composite_map = {}
+
+
+    binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+    if type(expr) in binrelpreds:
+        pred = binrelpreds[type(expr)]
+        expr = pred(*expr.args)
+
+    if isinstance(expr, Not):
+        arg = expr.args[0]
+        tmp = to_NNF(arg, composite_map)  # Strategy: negate the NNF of expr
+        return ~tmp
+
+    if isinstance(expr, Or):
+        return OR(*[to_NNF(x, composite_map) for x in Or.make_args(expr)])
+
+    if isinstance(expr, And):
+        return AND(*[to_NNF(x, composite_map) for x in And.make_args(expr)])
+
+    if isinstance(expr, Nand):
+        tmp = AND(*[to_NNF(x, composite_map) for x in expr.args])
+        return ~tmp
+
+    if isinstance(expr, Nor):
+        tmp = OR(*[to_NNF(x, composite_map) for x in expr.args])
+        return ~tmp
+
+    if isinstance(expr, Xor):
+        cnfs = []
+        for i in range(0, len(expr.args) + 1, 2):
+            for neg in combinations(expr.args, i):
+                clause = [~to_NNF(s, composite_map) if s in neg else to_NNF(s, composite_map)
+                          for s in expr.args]
+                cnfs.append(OR(*clause))
+        return AND(*cnfs)
+
+    if isinstance(expr, Xnor):
+        cnfs = []
+        for i in range(0, len(expr.args) + 1, 2):
+            for neg in combinations(expr.args, i):
+                clause = [~to_NNF(s, composite_map) if s in neg else to_NNF(s, composite_map)
+                          for s in expr.args]
+                cnfs.append(OR(*clause))
+        return ~AND(*cnfs)
+
+    if isinstance(expr, Implies):
+        L, R = to_NNF(expr.args[0], composite_map), to_NNF(expr.args[1], composite_map)
+        return OR(~L, R)
+
+    if isinstance(expr, Equivalent):
+        cnfs = []
+        for a, b in zip_longest(expr.args, expr.args[1:], fillvalue=expr.args[0]):
+            a = to_NNF(a, composite_map)
+            b = to_NNF(b, composite_map)
+            cnfs.append(OR(~a, b))
+        return AND(*cnfs)
+
+    if isinstance(expr, ITE):
+        L = to_NNF(expr.args[0], composite_map)
+        M = to_NNF(expr.args[1], composite_map)
+        R = to_NNF(expr.args[2], composite_map)
+        return AND(OR(~L, M), OR(L, R))
+
+    if isinstance(expr, AppliedPredicate):
+        pred, args = expr.function, expr.arguments
+        newpred = composite_map.get(pred, None)
+        if newpred is not None:
+            return to_NNF(newpred.rcall(*args), composite_map)
+
+    if isinstance(expr, Predicate):
+        newpred = composite_map.get(expr, None)
+        if newpred is not None:
+            return to_NNF(newpred, composite_map)
+
+    return Literal(expr)
+
+
+def distribute_AND_over_OR(expr):
+    """
+    Distributes AND over OR in the NNF expression.
+    Returns the result( Conjunctive Normal Form of expression)
+    as a CNF object.
+    """
+    if not isinstance(expr, (AND, OR)):
+        tmp = set()
+        tmp.add(frozenset((expr,)))
+        return CNF(tmp)
+
+    if isinstance(expr, OR):
+        return CNF.all_or(*[distribute_AND_over_OR(arg)
+                            for arg in expr._args])
+
+    if isinstance(expr, AND):
+        return CNF.all_and(*[distribute_AND_over_OR(arg)
+                             for arg in expr._args])
+
+
+class CNF:
+    """
+    Class to represent CNF of a Boolean expression.
+    Consists of set of clauses, which themselves are stored as
+    frozenset of Literal objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.abc import x
+    >>> cnf = CNF.from_prop(Q.real(x) & ~Q.zero(x))
+    >>> cnf.clauses
+    {frozenset({Literal(Q.zero(x), True)}),
+    frozenset({Literal(Q.negative(x), False),
+    Literal(Q.positive(x), False), Literal(Q.zero(x), False)})}
+    """
+    def __init__(self, clauses=None):
+        if not clauses:
+            clauses = set()
+        self.clauses = clauses
+
+    def add(self, prop):
+        clauses = CNF.to_CNF(prop).clauses
+        self.add_clauses(clauses)
+
+    def __str__(self):
+        s = ' & '.join(
+            ['(' + ' | '.join([str(lit) for lit in clause]) +')'
+            for clause in self.clauses]
+        )
+        return s
+
+    def extend(self, props):
+        for p in props:
+            self.add(p)
+        return self
+
+    def copy(self):
+        return CNF(set(self.clauses))
+
+    def add_clauses(self, clauses):
+        self.clauses |= clauses
+
+    @classmethod
+    def from_prop(cls, prop):
+        res = cls()
+        res.add(prop)
+        return res
+
+    def __iand__(self, other):
+        self.add_clauses(other.clauses)
+        return self
+
+    def all_predicates(self):
+        predicates = set()
+        for c in self.clauses:
+            predicates |= {arg.lit for arg in c}
+        return predicates
+
+    def _or(self, cnf):
+        clauses = set()
+        for a, b in product(self.clauses, cnf.clauses):
+            tmp = set(a)
+            tmp.update(b)
+            clauses.add(frozenset(tmp))
+        return CNF(clauses)
+
+    def _and(self, cnf):
+        clauses = self.clauses.union(cnf.clauses)
+        return CNF(clauses)
+
+    def _not(self):
+        clss = list(self.clauses)
+        ll = {frozenset((~x,)) for x in clss[-1]}
+        ll = CNF(ll)
+
+        for rest in clss[:-1]:
+            p = {frozenset((~x,)) for x in rest}
+            ll = ll._or(CNF(p))
+        return ll
+
+    def rcall(self, expr):
+        clause_list = []
+        for clause in self.clauses:
+            lits = [arg.rcall(expr) for arg in clause]
+            clause_list.append(OR(*lits))
+        expr = AND(*clause_list)
+        return distribute_AND_over_OR(expr)
+
+    @classmethod
+    def all_or(cls, *cnfs):
+        b = cnfs[0].copy()
+        for rest in cnfs[1:]:
+            b = b._or(rest)
+        return b
+
+    @classmethod
+    def all_and(cls, *cnfs):
+        b = cnfs[0].copy()
+        for rest in cnfs[1:]:
+            b = b._and(rest)
+        return b
+
+    @classmethod
+    def to_CNF(cls, expr):
+        from sympy.assumptions.facts import get_composite_predicates
+        expr = to_NNF(expr, get_composite_predicates())
+        expr = distribute_AND_over_OR(expr)
+        return expr
+
+    @classmethod
+    def CNF_to_cnf(cls, cnf):
+        """
+        Converts CNF object to SymPy's boolean expression
+        retaining the form of expression.
+        """
+        def remove_literal(arg):
+            return Not(arg.lit) if arg.is_Not else arg.lit
+
+        return And(*(Or(*(remove_literal(arg) for arg in clause)) for clause in cnf.clauses))
+
+
+class EncodedCNF:
+    """
+    Class for encoding the CNF expression.
+    """
+    def __init__(self, data=None, encoding=None):
+        if not data and not encoding:
+            data = []
+            encoding = {}
+        self.data = data
+        self.encoding = encoding
+        self._symbols = list(encoding.keys())
+
+    def from_cnf(self, cnf):
+        self._symbols = list(cnf.all_predicates())
+        n = len(self._symbols)
+        self.encoding = dict(zip(self._symbols, range(1, n + 1)))
+        self.data = [self.encode(clause) for clause in cnf.clauses]
+
+    @property
+    def symbols(self):
+        return self._symbols
+
+    @property
+    def variables(self):
+        return range(1, len(self._symbols) + 1)
+
+    def copy(self):
+        new_data = [set(clause) for clause in self.data]
+        return EncodedCNF(new_data, dict(self.encoding))
+
+    def add_prop(self, prop):
+        cnf = CNF.from_prop(prop)
+        self.add_from_cnf(cnf)
+
+    def add_from_cnf(self, cnf):
+        clauses = [self.encode(clause) for clause in cnf.clauses]
+        self.data += clauses
+
+    def encode_arg(self, arg):
+        literal = arg.lit
+        value = self.encoding.get(literal, None)
+        if value is None:
+            n = len(self._symbols)
+            self._symbols.append(literal)
+            value = self.encoding[literal] = n + 1
+        if arg.is_Not:
+            return -value
+        else:
+            return value
+
+    def encode(self, clause):
+        return {self.encode_arg(arg) if not arg.lit == S.false else 0 for arg in clause}
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/facts.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/facts.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ff268677cf74e252ac6c3bc3eecbea08b9414d0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/facts.py
@@ -0,0 +1,270 @@
+"""
+Known facts in assumptions module.
+
+This module defines the facts between unary predicates in ``get_known_facts()``,
+and supports functions to generate the contents in
+``sympy.assumptions.ask_generated`` file.
+"""
+
+from sympy.assumptions.ask import Q
+from sympy.assumptions.assume import AppliedPredicate
+from sympy.core.cache import cacheit
+from sympy.core.symbol import Symbol
+from sympy.logic.boolalg import (to_cnf, And, Not, Implies, Equivalent,
+    Exclusive,)
+from sympy.logic.inference import satisfiable
+
+
+@cacheit
+def get_composite_predicates():
+    # To reduce the complexity of sat solver, these predicates are
+    # transformed into the combination of primitive predicates.
+    return {
+        Q.real : Q.negative | Q.zero | Q.positive,
+        Q.integer : Q.even | Q.odd,
+        Q.nonpositive : Q.negative | Q.zero,
+        Q.nonzero : Q.negative | Q.positive,
+        Q.nonnegative : Q.zero | Q.positive,
+        Q.extended_real : Q.negative_infinite | Q.negative | Q.zero | Q.positive | Q.positive_infinite,
+        Q.extended_positive: Q.positive | Q.positive_infinite,
+        Q.extended_negative: Q.negative | Q.negative_infinite,
+        Q.extended_nonzero: Q.negative_infinite | Q.negative | Q.positive | Q.positive_infinite,
+        Q.extended_nonpositive: Q.negative_infinite | Q.negative | Q.zero,
+        Q.extended_nonnegative: Q.zero | Q.positive | Q.positive_infinite,
+        Q.complex : Q.algebraic | Q.transcendental
+    }
+
+
+@cacheit
+def get_known_facts(x=None):
+    """
+    Facts between unary predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        get_number_facts(x),
+        get_matrix_facts(x)
+    )
+    return fact
+
+
+@cacheit
+def get_number_facts(x = None):
+    """
+    Facts between unary number predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        # primitive predicates for extended real exclude each other.
+        Exclusive(Q.negative_infinite(x), Q.negative(x), Q.zero(x),
+            Q.positive(x), Q.positive_infinite(x)),
+
+        # build complex plane
+        Exclusive(Q.real(x), Q.imaginary(x)),
+        Implies(Q.real(x) | Q.imaginary(x), Q.complex(x)),
+
+        # other subsets of complex
+        Exclusive(Q.transcendental(x), Q.algebraic(x)),
+        Equivalent(Q.real(x), Q.rational(x) | Q.irrational(x)),
+        Exclusive(Q.irrational(x), Q.rational(x)),
+        Implies(Q.rational(x), Q.algebraic(x)),
+
+        # integers
+        Exclusive(Q.even(x), Q.odd(x)),
+        Implies(Q.integer(x), Q.rational(x)),
+        Implies(Q.zero(x), Q.even(x)),
+        Exclusive(Q.composite(x), Q.prime(x)),
+        Implies(Q.composite(x) | Q.prime(x), Q.integer(x) & Q.positive(x)),
+        Implies(Q.even(x) & Q.positive(x) & ~Q.prime(x), Q.composite(x)),
+
+        # hermitian and antihermitian
+        Implies(Q.real(x), Q.hermitian(x)),
+        Implies(Q.imaginary(x), Q.antihermitian(x)),
+        Implies(Q.zero(x), Q.hermitian(x) | Q.antihermitian(x)),
+
+        # define finity and infinity, and build extended real line
+        Exclusive(Q.infinite(x), Q.finite(x)),
+        Implies(Q.complex(x), Q.finite(x)),
+        Implies(Q.negative_infinite(x) | Q.positive_infinite(x), Q.infinite(x)),
+
+        # commutativity
+        Implies(Q.finite(x) | Q.infinite(x), Q.commutative(x)),
+    )
+    return fact
+
+
+@cacheit
+def get_matrix_facts(x = None):
+    """
+    Facts between unary matrix predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        # matrices
+        Implies(Q.orthogonal(x), Q.positive_definite(x)),
+        Implies(Q.orthogonal(x), Q.unitary(x)),
+        Implies(Q.unitary(x) & Q.real_elements(x), Q.orthogonal(x)),
+        Implies(Q.unitary(x), Q.normal(x)),
+        Implies(Q.unitary(x), Q.invertible(x)),
+        Implies(Q.normal(x), Q.square(x)),
+        Implies(Q.diagonal(x), Q.normal(x)),
+        Implies(Q.positive_definite(x), Q.invertible(x)),
+        Implies(Q.diagonal(x), Q.upper_triangular(x)),
+        Implies(Q.diagonal(x), Q.lower_triangular(x)),
+        Implies(Q.lower_triangular(x), Q.triangular(x)),
+        Implies(Q.upper_triangular(x), Q.triangular(x)),
+        Implies(Q.triangular(x), Q.upper_triangular(x) | Q.lower_triangular(x)),
+        Implies(Q.upper_triangular(x) & Q.lower_triangular(x), Q.diagonal(x)),
+        Implies(Q.diagonal(x), Q.symmetric(x)),
+        Implies(Q.unit_triangular(x), Q.triangular(x)),
+        Implies(Q.invertible(x), Q.fullrank(x)),
+        Implies(Q.invertible(x), Q.square(x)),
+        Implies(Q.symmetric(x), Q.square(x)),
+        Implies(Q.fullrank(x) & Q.square(x), Q.invertible(x)),
+        Equivalent(Q.invertible(x), ~Q.singular(x)),
+        Implies(Q.integer_elements(x), Q.real_elements(x)),
+        Implies(Q.real_elements(x), Q.complex_elements(x)),
+    )
+    return fact
+
+
+
+def generate_known_facts_dict(keys, fact):
+    """
+    Computes and returns a dictionary which contains the relations between
+    unary predicates.
+
+    Each key is a predicate, and item is two groups of predicates.
+    First group contains the predicates which are implied by the key, and
+    second group contains the predicates which are rejected by the key.
+
+    All predicates in *keys* and *fact* must be unary and have same placeholder
+    symbol.
+
+    Parameters
+    ==========
+
+    keys : list of AppliedPredicate instances.
+
+    fact : Fact between predicates in conjugated normal form.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, And, Implies
+    >>> from sympy.assumptions.facts import generate_known_facts_dict
+    >>> from sympy.abc import x
+    >>> keys = [Q.even(x), Q.odd(x), Q.zero(x)]
+    >>> fact = And(Implies(Q.even(x), ~Q.odd(x)),
+    ...     Implies(Q.zero(x), Q.even(x)))
+    >>> generate_known_facts_dict(keys, fact)
+    {Q.even: ({Q.even}, {Q.odd}),
+     Q.odd: ({Q.odd}, {Q.even, Q.zero}),
+     Q.zero: ({Q.even, Q.zero}, {Q.odd})}
+    """
+    fact_cnf = to_cnf(fact)
+    mapping = single_fact_lookup(keys, fact_cnf)
+
+    ret = {}
+    for key, value in mapping.items():
+        implied = set()
+        rejected = set()
+        for expr in value:
+            if isinstance(expr, AppliedPredicate):
+                implied.add(expr.function)
+            elif isinstance(expr, Not):
+                pred = expr.args[0]
+                rejected.add(pred.function)
+        ret[key.function] = (implied, rejected)
+    return ret
+
+
+@cacheit
+def get_known_facts_keys():
+    """
+    Return every unary predicates registered to ``Q``.
+
+    This function is used to generate the keys for
+    ``generate_known_facts_dict``.
+
+    """
+    # exclude polyadic predicates
+    exclude = {Q.eq, Q.ne, Q.gt, Q.lt, Q.ge, Q.le}
+
+    result = []
+    for attr in Q.__class__.__dict__:
+        if attr.startswith('__'):
+            continue
+        pred = getattr(Q, attr)
+        if pred in exclude:
+            continue
+        result.append(pred)
+    return result
+
+
+def single_fact_lookup(known_facts_keys, known_facts_cnf):
+    # Return the dictionary for quick lookup of single fact
+    mapping = {}
+    for key in known_facts_keys:
+        mapping[key] = {key}
+        for other_key in known_facts_keys:
+            if other_key != key:
+                if ask_full_inference(other_key, key, known_facts_cnf):
+                    mapping[key].add(other_key)
+                if ask_full_inference(~other_key, key, known_facts_cnf):
+                    mapping[key].add(~other_key)
+    return mapping
+
+
+def ask_full_inference(proposition, assumptions, known_facts_cnf):
+    """
+    Method for inferring properties about objects.
+
+    """
+    if not satisfiable(And(known_facts_cnf, assumptions, proposition)):
+        return False
+    if not satisfiable(And(known_facts_cnf, assumptions, Not(proposition))):
+        return True
+    return None
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fbe618eb8b43e252ac8fb0baf1eeee22bf347cc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/__init__.py
@@ -0,0 +1,13 @@
+"""
+Multipledispatch handlers for ``Predicate`` are implemented here.
+Handlers in this module are not directly imported to other modules in
+order to avoid circular import problem.
+"""
+
+from .common import (AskHandler, CommonHandler,
+    test_closed_group)
+
+__all__ = [
+    'AskHandler', 'CommonHandler',
+    'test_closed_group'
+]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/calculus.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2b9c43ccea216988a25aa671ea23bc81d2209ff
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/calculus.py
@@ -0,0 +1,273 @@
+"""
+This module contains query handlers responsible for calculus queries:
+infinitesimal, finite, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Expr, Add, Mul, Pow, Symbol
+from sympy.core.numbers import (NegativeInfinity, GoldenRatio,
+    Infinity, Exp1, ComplexInfinity, ImaginaryUnit, NaN, Number, Pi, E,
+    TribonacciConstant)
+from sympy.functions import cos, exp, log, sign, sin
+from sympy.logic.boolalg import conjuncts
+
+from ..predicates.calculus import (FinitePredicate, InfinitePredicate,
+    PositiveInfinitePredicate, NegativeInfinitePredicate)
+
+
+# FinitePredicate
+
+
+@FinitePredicate.register(Symbol)
+def _(expr, assumptions):
+    """
+    Handles Symbol.
+    """
+    if expr.is_finite is not None:
+        return expr.is_finite
+    if Q.finite(expr) in conjuncts(assumptions):
+        return True
+    return None
+
+@FinitePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +-------+-----+-----------+-----------+
+    |       |     |           |           |
+    |       |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |   |   |   |   |   |   |
+    |       |     |'+'|'-'|'x'|'+'|'-'|'x'|
+    |       |     |   |   |   |   |   |   |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   B   |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    |   |'+'|     | U | ? | ? | U | ? | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    | U |'-'|     | ? | U | ? | ? | U | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |           |           |
+    |   |'x'|     |     ?     |     ?     |
+    |   |   |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   ?   |     |           |     ?     |
+    |       |     |           |           |
+    +-------+-----+-----------+---+---+---+
+
+        * 'B' = Bounded
+
+        * 'U' = Unbounded
+
+        * '?' = unknown boundedness
+
+        * '+' = positive sign
+
+        * '-' = negative sign
+
+        * 'x' = sign unknown
+
+        * All Bounded -> True
+
+        * 1 Unbounded and the rest Bounded -> False
+
+        * >1 Unbounded, all with same known sign -> False
+
+        * Any Unknown and unknown sign -> None
+
+        * Else -> None
+
+    When the signs are not the same you can have an undefined
+    result as in oo - oo, hence 'bounded' is also undefined.
+    """
+    sign = -1  # sign of unknown or infinite
+    result = True
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            continue
+        s = ask(Q.extended_positive(arg), assumptions)
+        # if there has been more than one sign or if the sign of this arg
+        # is None and Bounded is None or there was already
+        # an unknown sign, return None
+        if sign != -1 and s != sign or \
+                s is None and None in (_bounded, sign):
+            return None
+        else:
+            sign = s
+        # once False, do not change
+        if result is not False:
+            result = _bounded
+    return result
+
+@FinitePredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +---+---+---+--------+
+    |   |   |   |        |
+    |   | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    |   |   |   | s | /s |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | B | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    | U |   | U | U | ?  |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | ? |   |   |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+
+        * B = Bounded
+
+        * U = Unbounded
+
+        * ? = unknown boundedness
+
+        * s = signed (hence nonzero)
+
+        * /s = not signed
+    """
+    result = True
+    possible_zero = False
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            if ask(Q.zero(arg), assumptions) is not False:
+                if result is False:
+                    return None
+                possible_zero = True
+        elif _bounded is None:
+            if result is None:
+                return None
+            if ask(Q.extended_nonzero(arg), assumptions) is None:
+                return None
+            if result is not False:
+                result = None
+        else:
+            if possible_zero:
+                return None
+            result = False
+    return result
+
+@FinitePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Unbounded ** NonZero -> Unbounded
+
+    * Bounded ** Bounded -> Bounded
+
+    * Abs()<=1 ** Positive -> Bounded
+
+    * Abs()>=1 ** Negative -> Bounded
+
+    * Otherwise unknown
+    """
+    if expr.base == E:
+        return ask(Q.finite(expr.exp), assumptions)
+
+    base_bounded = ask(Q.finite(expr.base), assumptions)
+    exp_bounded = ask(Q.finite(expr.exp), assumptions)
+    if base_bounded is None and exp_bounded is None:  # Common Case
+        return None
+    if base_bounded is False and ask(Q.extended_nonzero(expr.exp), assumptions):
+        return False
+    if base_bounded and exp_bounded:
+        is_base_zero = ask(Q.zero(expr.base),assumptions)
+        is_exp_negative = ask(Q.negative(expr.exp),assumptions)
+        if is_base_zero is True and is_exp_negative is True:
+            return False
+        if is_base_zero is not False and is_exp_negative is not False:
+            return None
+        return True
+    if (abs(expr.base) <= 1) == True and ask(Q.extended_positive(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and ask(Q.extended_negative(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and exp_bounded is False:
+        return False
+    return None
+
+@FinitePredicate.register(exp)
+def _(expr, assumptions):
+    return ask(Q.finite(expr.exp), assumptions)
+
+@FinitePredicate.register(log)
+def _(expr, assumptions):
+    # After complex -> finite fact is registered to new assumption system,
+    # querying Q.infinite may be removed.
+    if ask(Q.infinite(expr.args[0]), assumptions):
+        return False
+    return ask(~Q.zero(expr.args[0]), assumptions)
+
+@FinitePredicate.register_many(cos, sin, Number, Pi, Exp1, GoldenRatio,
+    TribonacciConstant, ImaginaryUnit, sign)
+def _(expr, assumptions):
+    return True
+
+@FinitePredicate.register_many(ComplexInfinity, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@FinitePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# InfinitePredicate
+
+
+@InfinitePredicate.register(Expr)
+def _(expr, assumptions):
+    is_finite = Q.finite(expr)._eval_ask(assumptions)
+    if is_finite is None:
+        return None
+    return not is_finite
+
+
+# PositiveInfinitePredicate
+
+
+@PositiveInfinitePredicate.register(Infinity)
+def _(expr, assumptions):
+    return True
+
+
+@PositiveInfinitePredicate.register_many(NegativeInfinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False
+
+
+# NegativeInfinitePredicate
+
+
+@NegativeInfinitePredicate.register(NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+
+@NegativeInfinitePredicate.register_many(Infinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/common.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6e9f6f321be461c09b16c03b9cec5708404d21a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/common.py
@@ -0,0 +1,164 @@
+"""
+This module defines base class for handlers and some core handlers:
+``Q.commutative`` and ``Q.is_true``.
+"""
+
+from sympy.assumptions import Q, ask, AppliedPredicate
+from sympy.core import Basic, Symbol
+from sympy.core.logic import _fuzzy_group, fuzzy_and, fuzzy_or
+from sympy.core.numbers import NaN, Number
+from sympy.logic.boolalg import (And, BooleanTrue, BooleanFalse, conjuncts,
+    Equivalent, Implies, Not, Or)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from ..predicates.common import CommutativePredicate, IsTruePredicate
+
+
+class AskHandler:
+    """Base class that all Ask Handlers must inherit."""
+    def __new__(cls, *args, **kwargs):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. The AskHandler class should
+            be replaced with the multipledispatch handler of Predicate
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        return super().__new__(cls, *args, **kwargs)
+
+
+class CommonHandler(AskHandler):
+    # Deprecated
+    """Defines some useful methods common to most Handlers. """
+
+    @staticmethod
+    def AlwaysTrue(expr, assumptions):
+        return True
+
+    @staticmethod
+    def AlwaysFalse(expr, assumptions):
+        return False
+
+    @staticmethod
+    def AlwaysNone(expr, assumptions):
+        return None
+
+    NaN = AlwaysFalse
+
+
+# CommutativePredicate
+
+@CommutativePredicate.register(Symbol)
+def _(expr, assumptions):
+    """Objects are expected to be commutative unless otherwise stated"""
+    assumps = conjuncts(assumptions)
+    if expr.is_commutative is not None:
+        return expr.is_commutative and not ~Q.commutative(expr) in assumps
+    if Q.commutative(expr) in assumps:
+        return True
+    elif ~Q.commutative(expr) in assumps:
+        return False
+    return True
+
+@CommutativePredicate.register(Basic)
+def _(expr, assumptions):
+    for arg in expr.args:
+        if not ask(Q.commutative(arg), assumptions):
+            return False
+    return True
+
+@CommutativePredicate.register(Number)
+def _(expr, assumptions):
+    return True
+
+@CommutativePredicate.register(NaN)
+def _(expr, assumptions):
+    return True
+
+
+# IsTruePredicate
+
+@IsTruePredicate.register(bool)
+def _(expr, assumptions):
+    return expr
+
+@IsTruePredicate.register(BooleanTrue)
+def _(expr, assumptions):
+    return True
+
+@IsTruePredicate.register(BooleanFalse)
+def _(expr, assumptions):
+    return False
+
+@IsTruePredicate.register(AppliedPredicate)
+def _(expr, assumptions):
+    return ask(expr, assumptions)
+
+@IsTruePredicate.register(Not)
+def _(expr, assumptions):
+    arg = expr.args[0]
+    if arg.is_Symbol:
+        # symbol used as abstract boolean object
+        return None
+    value = ask(arg, assumptions=assumptions)
+    if value in (True, False):
+        return not value
+    else:
+        return None
+
+@IsTruePredicate.register(Or)
+def _(expr, assumptions):
+    result = False
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is True:
+            return True
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(And)
+def _(expr, assumptions):
+    result = True
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is False:
+            return False
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(Implies)
+def _(expr, assumptions):
+    p, q = expr.args
+    return ask(~p | q, assumptions=assumptions)
+
+@IsTruePredicate.register(Equivalent)
+def _(expr, assumptions):
+    p, q = expr.args
+    pt = ask(p, assumptions=assumptions)
+    if pt is None:
+        return None
+    qt = ask(q, assumptions=assumptions)
+    if qt is None:
+        return None
+    return pt == qt
+
+
+#### Helper methods
+def test_closed_group(expr, assumptions, key):
+    """
+    Test for membership in a group with respect
+    to the current operation.
+    """
+    return _fuzzy_group(
+        (ask(key(a), assumptions) for a in expr.args), quick_exit=True)
+
+def ask_all(*queries, assumptions):
+    return fuzzy_and(
+        (ask(query, assumptions) for query in queries))
+
+def ask_any(*queries, assumptions):
+    return fuzzy_or(
+        (ask(query, assumptions) for query in queries))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/matrices.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b20385360136629ea037eb7238c45b70ba57fd2
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/matrices.py
@@ -0,0 +1,716 @@
+"""
+This module contains query handlers responsible for Matrices queries:
+Square, Symmetric, Invertible etc.
+"""
+
+from sympy.logic.boolalg import conjuncts
+from sympy.assumptions import Q, ask
+from sympy.assumptions.handlers import test_closed_group
+from sympy.matrices import MatrixBase
+from sympy.matrices.expressions import (BlockMatrix, BlockDiagMatrix, Determinant,
+    DiagMatrix, DiagonalMatrix, HadamardProduct, Identity, Inverse, MatAdd, MatMul,
+    MatPow, MatrixExpr, MatrixSlice, MatrixSymbol, OneMatrix, Trace, Transpose,
+    ZeroMatrix)
+from sympy.matrices.expressions.blockmatrix import reblock_2x2
+from sympy.matrices.expressions.factorizations import Factorization
+from sympy.matrices.expressions.fourier import DFT
+from sympy.core.logic import fuzzy_and
+from sympy.utilities.iterables import sift
+from sympy.core import Basic
+
+from ..predicates.matrices import (SquarePredicate, SymmetricPredicate,
+    InvertiblePredicate, OrthogonalPredicate, UnitaryPredicate,
+    FullRankPredicate, PositiveDefinitePredicate, UpperTriangularPredicate,
+    LowerTriangularPredicate, DiagonalPredicate, IntegerElementsPredicate,
+    RealElementsPredicate, ComplexElementsPredicate)
+
+
+def _Factorization(predicate, expr, assumptions):
+    if predicate in expr.predicates:
+        return True
+
+
+# SquarePredicate
+
+@SquarePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    return expr.shape[0] == expr.shape[1]
+
+
+# SymmetricPredicate
+
+@SymmetricPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.symmetric(arg), assumptions) for arg in mmul.args):
+        return True
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if len(mmul.args) >= 2 and mmul.args[0] == mmul.args[-1].T:
+        if len(mmul.args) == 2:
+            return True
+        return ask(Q.symmetric(MatMul(*mmul.args[1:-1])), assumptions)
+
+@SymmetricPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.symmetric(base), assumptions)
+    return None
+
+@SymmetricPredicate.register(MatAdd)
+def _(expr, assumptions):
+    return all(ask(Q.symmetric(arg), assumptions) for arg in expr.args)
+
+@SymmetricPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if Q.symmetric(expr) in conjuncts(assumptions):
+        return True
+
+@SymmetricPredicate.register_many(OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return ask(Q.square(expr), assumptions)
+
+@SymmetricPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.symmetric(expr.arg), assumptions)
+
+@SymmetricPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.symmetric(expr.parent), assumptions)
+
+@SymmetricPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+
+# InvertiblePredicate
+
+@InvertiblePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.invertible(arg), assumptions) for arg in mmul.args):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@InvertiblePredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.invertible(base), assumptions)
+    return None
+
+@InvertiblePredicate.register(MatAdd)
+def _(expr, assumptions):
+    return None
+
+@InvertiblePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.invertible(expr) in conjuncts(assumptions):
+        return True
+
+@InvertiblePredicate.register_many(Identity, Inverse)
+def _(expr, assumptions):
+    return True
+
+@InvertiblePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@InvertiblePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@InvertiblePredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.invertible(expr.arg), assumptions)
+
+@InvertiblePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.invertible(expr.parent), assumptions)
+
+@InvertiblePredicate.register(MatrixBase)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return expr.rank() == expr.rows
+
+@InvertiblePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return None
+
+@InvertiblePredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if expr.blockshape == (1, 1):
+        return ask(Q.invertible(expr.blocks[0, 0]), assumptions)
+    expr = reblock_2x2(expr)
+    if expr.blockshape == (2, 2):
+        [[A, B], [C, D]] = expr.blocks.tolist()
+        if ask(Q.invertible(A), assumptions) == True:
+            invertible = ask(Q.invertible(D - C * A.I * B), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(B), assumptions) == True:
+            invertible = ask(Q.invertible(C - D * B.I * A), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(C), assumptions) == True:
+            invertible = ask(Q.invertible(B - A * C.I * D), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(D), assumptions) == True:
+            invertible = ask(Q.invertible(A - B * D.I * C), assumptions)
+            if invertible is not None:
+                return invertible
+    return None
+
+@InvertiblePredicate.register(BlockDiagMatrix)
+def _(expr, assumptions):
+    if expr.rowblocksizes != expr.colblocksizes:
+        return None
+    return fuzzy_and([ask(Q.invertible(a), assumptions) for a in expr.diag])
+
+
+# OrthogonalPredicate
+
+@OrthogonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.orthogonal(arg), assumptions) for arg in mmul.args) and
+            factor == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@OrthogonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.orthogonal(base), assumptions)
+    return None
+
+@OrthogonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if (len(expr.args) == 1 and
+            ask(Q.orthogonal(expr.args[0]), assumptions)):
+        return True
+
+@OrthogonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.orthogonal(expr) in conjuncts(assumptions):
+        return True
+
+@OrthogonalPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@OrthogonalPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@OrthogonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.orthogonal(expr.arg), assumptions)
+
+@OrthogonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.orthogonal(expr.parent), assumptions)
+
+@OrthogonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.orthogonal, expr, assumptions)
+
+
+# UnitaryPredicate
+
+@UnitaryPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.unitary(arg), assumptions) for arg in mmul.args) and
+            abs(factor) == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@UnitaryPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.unitary(base), assumptions)
+    return None
+
+@UnitaryPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.unitary(expr) in conjuncts(assumptions):
+        return True
+
+@UnitaryPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.unitary(expr.arg), assumptions)
+
+@UnitaryPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.unitary(expr.parent), assumptions)
+
+@UnitaryPredicate.register_many(DFT, Identity)
+def _(expr, assumptions):
+    return True
+
+@UnitaryPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@UnitaryPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.unitary, expr, assumptions)
+
+
+# FullRankPredicate
+
+@FullRankPredicate.register(MatMul)
+def _(expr, assumptions):
+    if all(ask(Q.fullrank(arg), assumptions) for arg in expr.args):
+        return True
+
+@FullRankPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp and ask(~Q.negative(exp), assumptions):
+        return ask(Q.fullrank(base), assumptions)
+    return None
+
+@FullRankPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@FullRankPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@FullRankPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@FullRankPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.fullrank(expr.arg), assumptions)
+
+@FullRankPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if ask(Q.orthogonal(expr.parent), assumptions):
+        return True
+
+
+# PositiveDefinitePredicate
+
+@PositiveDefinitePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.positive_definite(arg), assumptions)
+            for arg in mmul.args) and factor > 0):
+        return True
+    if (len(mmul.args) >= 2
+            and mmul.args[0] == mmul.args[-1].T
+            and ask(Q.fullrank(mmul.args[0]), assumptions)):
+        return ask(Q.positive_definite(
+            MatMul(*mmul.args[1:-1])), assumptions)
+
+@PositiveDefinitePredicate.register(MatPow)
+def _(expr, assumptions):
+    # a power of a positive definite matrix is positive definite
+    if ask(Q.positive_definite(expr.args[0]), assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.positive_definite(arg), assumptions)
+            for arg in expr.args):
+        return True
+
+@PositiveDefinitePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.positive_definite(expr) in conjuncts(assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@PositiveDefinitePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@PositiveDefinitePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@PositiveDefinitePredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.positive_definite(expr.arg), assumptions)
+
+@PositiveDefinitePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.positive_definite(expr.parent), assumptions)
+
+
+# UpperTriangularPredicate
+
+@UpperTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.upper_triangular(m), assumptions) for m in matrices):
+        return True
+
+@UpperTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.upper_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@UpperTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.upper_triangular(base), assumptions)
+    return None
+
+@UpperTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.upper_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@UpperTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@UpperTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@UpperTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.upper_triangular(expr.parent), assumptions)
+
+@UpperTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.upper_triangular, expr, assumptions)
+
+# LowerTriangularPredicate
+
+@LowerTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.lower_triangular(m), assumptions) for m in matrices):
+        return True
+
+@LowerTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.lower_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@LowerTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.lower_triangular(base), assumptions)
+    return None
+
+@LowerTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.lower_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@LowerTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@LowerTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@LowerTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.lower_triangular(expr.parent), assumptions)
+
+@LowerTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.lower_triangular, expr, assumptions)
+
+
+# DiagonalPredicate
+
+def _is_empty_or_1x1(expr):
+    return expr.shape in ((0, 0), (1, 1))
+
+@DiagonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.diagonal(m), assumptions) for m in matrices):
+        return True
+
+@DiagonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.diagonal(base), assumptions)
+    return None
+
+@DiagonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.diagonal(arg), assumptions) for arg in expr.args):
+        return True
+
+@DiagonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if Q.diagonal(expr) in conjuncts(assumptions):
+        return True
+
+@DiagonalPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@DiagonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.diagonal(expr.arg), assumptions)
+
+@DiagonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.diagonal(expr.parent), assumptions)
+
+@DiagonalPredicate.register_many(DiagonalMatrix, DiagMatrix, Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@DiagonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.diagonal, expr, assumptions)
+
+
+# IntegerElementsPredicate
+
+def BM_elements(predicate, expr, assumptions):
+    """ Block Matrix elements. """
+    return all(ask(predicate(b), assumptions) for b in expr.blocks)
+
+def MS_elements(predicate, expr, assumptions):
+    """ Matrix Slice elements. """
+    return ask(predicate(expr.parent), assumptions)
+
+def MatMul_elements(matrix_predicate, scalar_predicate, expr, assumptions):
+    d = sift(expr.args, lambda x: isinstance(x, MatrixExpr))
+    factors, matrices = d[False], d[True]
+    return fuzzy_and([
+        test_closed_group(Basic(*factors), assumptions, scalar_predicate),
+        test_closed_group(Basic(*matrices), assumptions, matrix_predicate)])
+
+
+@IntegerElementsPredicate.register_many(Determinant, HadamardProduct, MatAdd,
+    Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.integer_elements)
+
+@IntegerElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.integer_elements(base), assumptions)
+    return None
+
+@IntegerElementsPredicate.register_many(Identity, OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@IntegerElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.integer_elements, Q.integer, expr, assumptions)
+
+@IntegerElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.integer_elements, expr, assumptions)
+
+@IntegerElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.integer_elements, expr, assumptions)
+
+
+# RealElementsPredicate
+
+@RealElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.real_elements)
+
+@RealElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.real_elements(base), assumptions)
+    return None
+
+@RealElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.real_elements, Q.real, expr, assumptions)
+
+@RealElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.real_elements, expr, assumptions)
+
+@RealElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.real_elements, expr, assumptions)
+
+
+# ComplexElementsPredicate
+
+@ComplexElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    Inverse, MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex_elements)
+
+@ComplexElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.complex_elements(base), assumptions)
+    return None
+
+@ComplexElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.complex_elements, Q.complex, expr, assumptions)
+
+@ComplexElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(DFT)
+def _(expr, assumptions):
+    return True
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/ntheory.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfe63ba6467ea6863c6112c5e35bb3a78191a23e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/ntheory.py
@@ -0,0 +1,279 @@
+"""
+Handlers for keys related to number theory: prime, even, odd, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Float, Mul, Pow, S
+from sympy.core.numbers import (ImaginaryUnit, Infinity, Integer, NaN,
+    NegativeInfinity, NumberSymbol, Rational, int_valued)
+from sympy.functions import Abs, im, re
+from sympy.ntheory import isprime
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.ntheory import (PrimePredicate, CompositePredicate,
+    EvenPredicate, OddPredicate)
+
+
+# PrimePredicate
+
+def _PrimePredicate_number(expr, assumptions):
+    # helper method
+    exact = not expr.atoms(Float)
+    try:
+        i = int(expr.round())
+        if (expr - i).equals(0) is False:
+            raise TypeError
+    except TypeError:
+        return False
+    if exact:
+        return isprime(i)
+    # when not exact, we won't give a True or False
+    # since the number represents an approximate value
+
+@PrimePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_prime
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PrimePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            return None
+    for arg in expr.args:
+        if arg.is_number and arg.is_composite:
+            return False
+
+@PrimePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Integer**Integer     -> !Prime
+    """
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions) and \
+            ask(Q.integer(expr.base), assumptions):
+        prime_base = ask(Q.prime(expr.base), assumptions)
+        if prime_base is False:
+            return False
+        is_exp_one = ask(Q.eq(expr.exp, 1), assumptions)
+        if is_exp_one is False:
+            return False
+        if prime_base is True and is_exp_one is True:
+            return True
+
+@PrimePredicate.register(Integer)
+def _(expr, assumptions):
+    return isprime(expr)
+
+@PrimePredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PrimePredicate.register(Float)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# CompositePredicate
+
+@CompositePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_composite
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@CompositePredicate.register(Basic)
+def _(expr, assumptions):
+    _positive = ask(Q.positive(expr), assumptions)
+    if _positive:
+        _integer = ask(Q.integer(expr), assumptions)
+        if _integer:
+            _prime = ask(Q.prime(expr), assumptions)
+            if _prime is None:
+                return
+            # Positive integer which is not prime is not
+            # necessarily composite
+            _is_one = ask(Q.eq(expr, 1), assumptions)
+            if _is_one:
+                return False
+            if _is_one is None:
+                return None
+            return not _prime
+        else:
+            return _integer
+    else:
+        return _positive
+
+
+# EvenPredicate
+
+def _EvenPredicate_number(expr, assumptions):
+    # helper method
+    if isinstance(expr, (float, Float)):
+        if int_valued(expr):
+            return None
+        return False
+    try:
+        i = int(expr.round())
+    except TypeError:
+        return False
+    if not (expr - i).equals(0):
+        return False
+    return i % 2 == 0
+
+@EvenPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_even
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@EvenPredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Even * Integer    -> Even
+    Even * Odd        -> Even
+    Integer * Odd     -> ?
+    Odd * Odd         -> Odd
+    Even * Even       -> Even
+    Integer * Integer -> Even if Integer + Integer = Odd
+    otherwise         -> ?
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    even, odd, irrational, acc = False, 0, False, 1
+    for arg in expr.args:
+        # check for all integers and at least one even
+        if ask(Q.integer(arg), assumptions):
+            if ask(Q.even(arg), assumptions):
+                even = True
+            elif ask(Q.odd(arg), assumptions):
+                odd += 1
+            elif not even and acc != 1:
+                if ask(Q.odd(acc + arg), assumptions):
+                    even = True
+        elif ask(Q.irrational(arg), assumptions):
+            # one irrational makes the result False
+            # two makes it undefined
+            if irrational:
+                break
+            irrational = True
+        else:
+            break
+        acc = arg
+    else:
+        if irrational:
+            return False
+        if even:
+            return True
+        if odd == len(expr.args):
+            return False
+
+@EvenPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Even + Odd  -> Odd
+    Even + Even -> Even
+    Odd  + Odd  -> Even
+
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    _result = True
+    for arg in expr.args:
+        if ask(Q.even(arg), assumptions):
+            pass
+        elif ask(Q.odd(arg), assumptions):
+            _result = not _result
+        else:
+            break
+    else:
+        return _result
+
+@EvenPredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions):
+        if ask(Q.positive(expr.exp), assumptions):
+            return ask(Q.even(expr.base), assumptions)
+        elif ask(~Q.negative(expr.exp) & Q.odd(expr.base), assumptions):
+            return False
+        elif expr.base is S.NegativeOne:
+            return False
+
+@EvenPredicate.register(Integer)
+def _(expr, assumptions):
+    return not bool(expr.p & 1)
+
+@EvenPredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@EvenPredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(re)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(im)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return True
+
+@EvenPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# OddPredicate
+
+@OddPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_odd
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@OddPredicate.register(Basic)
+def _(expr, assumptions):
+    _integer = ask(Q.integer(expr), assumptions)
+    if _integer:
+        _even = ask(Q.even(expr), assumptions)
+        if _even is None:
+            return None
+        return not _even
+    return _integer
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/order.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/order.py
new file mode 100644
index 0000000000000000000000000000000000000000..24a8bae7f30777f62a1bec0579d58b9875143679
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/order.py
@@ -0,0 +1,440 @@
+"""
+Handlers related to order relations: positive, negative, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.logic import fuzzy_not, fuzzy_and, fuzzy_or
+from sympy.core.numbers import E, ImaginaryUnit, NaN, I, pi
+from sympy.functions import Abs, acos, acot, asin, atan, exp, factorial, log
+from sympy.matrices import Determinant, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.order import (NegativePredicate, NonNegativePredicate,
+    NonZeroPredicate, ZeroPredicate, NonPositivePredicate, PositivePredicate,
+    ExtendedNegativePredicate, ExtendedNonNegativePredicate,
+    ExtendedNonPositivePredicate, ExtendedNonZeroPredicate,
+    ExtendedPositivePredicate,)
+
+
+# NegativePredicate
+
+def _NegativePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+
+    if r == S.NaN or i == S.NaN:
+        return None
+
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r < 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r < 0
+
+@NegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+@NegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_negative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NegativePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Positive + Positive -> Positive,
+    Negative + Negative -> Negative
+    """
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonpos = 0
+    for arg in expr.args:
+        if ask(Q.negative(arg), assumptions) is not True:
+            if ask(Q.positive(arg), assumptions) is False:
+                nonpos += 1
+            else:
+                break
+    else:
+        if nonpos < len(expr.args):
+            return True
+
+@NegativePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    result = None
+    for arg in expr.args:
+        if result is None:
+            result = False
+        if ask(Q.negative(arg), assumptions):
+            result = not result
+        elif ask(Q.positive(arg), assumptions):
+            pass
+        else:
+            return
+    return result
+
+@NegativePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Real ** Even -> NonNegative
+    Real ** Odd  -> same_as_base
+    NonNegative ** Positive -> NonNegative
+    """
+    if expr.base == E:
+        # Exponential is always positive:
+        if ask(Q.real(expr.exp), assumptions):
+            return False
+        return
+
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            if ask(Q.real(expr.exp), assumptions):
+                return False
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        if ask(Q.odd(expr.exp), assumptions):
+            return ask(Q.negative(expr.base), assumptions)
+
+@NegativePredicate.register_many(Abs, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@NegativePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return False
+    raise MDNotImplementedError
+
+
+# NonNegativePredicate
+
+@NonNegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notnegative = fuzzy_not(_NegativePredicate_number(expr, assumptions))
+        if notnegative:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notnegative
+
+@NonNegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonnegative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+
+# NonZeroPredicate
+
+@NonZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonzero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    if ask(Q.real(expr)) is False:
+        return False
+    if expr.is_number:
+        # if there are no symbols just evalf
+        i = expr.evalf(2)
+        def nonz(i):
+            if i._prec != 1:
+                return i != 0
+        return fuzzy_or(nonz(i) for i in i.as_real_imag())
+
+@NonZeroPredicate.register(Add)
+def _(expr, assumptions):
+    if all(ask(Q.positive(x), assumptions) for x in expr.args) \
+            or all(ask(Q.negative(x), assumptions) for x in expr.args):
+        return True
+
+@NonZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    for arg in expr.args:
+        result = ask(Q.nonzero(arg), assumptions)
+        if result:
+            continue
+        return result
+    return True
+
+@NonZeroPredicate.register(Pow)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.base), assumptions)
+
+@NonZeroPredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.args[0]), assumptions)
+
+@NonZeroPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ZeroPredicate
+
+@ZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_zero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    return fuzzy_and([fuzzy_not(ask(Q.nonzero(expr), assumptions)),
+        ask(Q.real(expr), assumptions)])
+
+@ZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    # TODO: This should be deducible from the nonzero handler
+    return fuzzy_or(ask(Q.zero(arg), assumptions) for arg in expr.args)
+
+
+# NonPositivePredicate
+
+@NonPositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonpositive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonPositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notpositive = fuzzy_not(_PositivePredicate_number(expr, assumptions))
+        if notpositive:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notpositive
+
+
+# PositivePredicate
+
+def _PositivePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r > 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r > 0
+
+@PositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_positive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+@PositivePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions):
+            continue
+        elif ask(Q.negative(arg), assumptions):
+            result = result ^ True
+        else:
+            return
+    return result
+
+@PositivePredicate.register(Add)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonneg = 0
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions) is not True:
+            if ask(Q.negative(arg), assumptions) is False:
+                nonneg += 1
+            else:
+                break
+    else:
+        if nonneg < len(expr.args):
+            return True
+
+@PositivePredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+        if ask(Q.imaginary(expr.exp), assumptions):
+            return ask(Q.even(expr.exp/(I*pi)), assumptions)
+        return
+
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    if ask(Q.positive(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+    if ask(Q.negative(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return True
+        if ask(Q.odd(expr.exp), assumptions):
+            return False
+
+@PositivePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return True
+    if ask(Q.imaginary(expr.exp), assumptions):
+        return ask(Q.even(expr.exp/(I*pi)), assumptions)
+
+@PositivePredicate.register(log)
+def _(expr, assumptions):
+    r = ask(Q.real(expr.args[0]), assumptions)
+    if r is not True:
+        return r
+    if ask(Q.positive(expr.args[0] - 1), assumptions):
+        return True
+    if ask(Q.negative(expr.args[0] - 1), assumptions):
+        return False
+
+@PositivePredicate.register(factorial)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.integer(x) & Q.positive(x), assumptions):
+            return True
+
+@PositivePredicate.register(ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PositivePredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr), assumptions)
+
+@PositivePredicate.register(Trace)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(Determinant)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(MatrixElement)
+def _(expr, assumptions):
+    if (expr.i == expr.j
+            and ask(Q.positive_definite(expr.parent), assumptions)):
+        return True
+
+@PositivePredicate.register(atan)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@PositivePredicate.register(asin)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.positive(x) & Q.nonpositive(x - 1), assumptions):
+        return True
+    if ask(Q.negative(x) & Q.nonnegative(x + 1), assumptions):
+        return False
+
+@PositivePredicate.register(acos)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.nonpositive(x - 1) & Q.nonnegative(x + 1), assumptions):
+        return True
+
+@PositivePredicate.register(acot)
+def _(expr, assumptions):
+    return ask(Q.real(expr.args[0]), assumptions)
+
+@PositivePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ExtendedNegativePredicate
+
+@ExtendedNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative(expr) | Q.negative_infinite(expr), assumptions)
+
+
+# ExtendedPositivePredicate
+
+@ExtendedPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.positive(expr) | Q.positive_infinite(expr), assumptions)
+
+
+# ExtendedNonZeroPredicate
+
+@ExtendedNonZeroPredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)
+
+
+# ExtendedNonPositivePredicate
+
+@ExtendedNonPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.zero(expr),
+        assumptions)
+
+
+# ExtendedNonNegativePredicate
+
+@ExtendedNonNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.zero(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/sets.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/sets.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a13ed9bf99c5b0ffc4f32fd55cb60c2c15ab836
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/handlers/sets.py
@@ -0,0 +1,816 @@
+"""
+Handlers for predicates related to set membership: integer, rational, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.numbers import (AlgebraicNumber, ComplexInfinity, Exp1, Float,
+    GoldenRatio, ImaginaryUnit, Infinity, Integer, NaN, NegativeInfinity,
+    Number, NumberSymbol, Pi, pi, Rational, TribonacciConstant, E)
+from sympy.core.logic import fuzzy_bool
+from sympy.functions import (Abs, acos, acot, asin, atan, cos, cot, exp, im,
+    log, re, sin, tan)
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.functions.elementary.complexes import conjugate
+from sympy.matrices import Determinant, MatrixBase, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from .common import test_closed_group, ask_all, ask_any
+from ..predicates.sets import (IntegerPredicate, RationalPredicate,
+    IrrationalPredicate, RealPredicate, ExtendedRealPredicate,
+    HermitianPredicate, ComplexPredicate, ImaginaryPredicate,
+    AntihermitianPredicate, AlgebraicPredicate)
+
+
+# IntegerPredicate
+
+def _IntegerPredicate_number(expr, assumptions):
+    # helper function
+        try:
+            i = int(expr.round())
+            if not (expr - i).equals(0):
+                raise TypeError
+            return True
+        except TypeError:
+            return False
+
+@IntegerPredicate.register_many(int, Integer) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@IntegerPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+        NegativeInfinity, Pi, Rational, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@IntegerPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_integer
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IntegerPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Integer + Integer       -> Integer
+    * Integer + !Integer      -> !Integer
+    * !Integer + !Integer -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.integer)
+
+@IntegerPredicate.register(Pow)
+def _(expr,assumptions):
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    if ask_all(~Q.zero(expr.base), Q.finite(expr.base), Q.zero(expr.exp), assumptions=assumptions):
+        return True
+    if ask_all(Q.integer(expr.base), Q.integer(expr.exp), assumptions=assumptions):
+        if ask_any(Q.positive(expr.exp), Q.nonnegative(expr.exp) & ~Q.zero(expr.base), Q.zero(expr.base-1), Q.zero(expr.base+1), assumptions=assumptions):
+            return True
+
+@IntegerPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Integer*Integer      -> Integer
+    * Integer*Irrational   -> !Integer
+    * Odd/Even             -> !Integer
+    * Integer*Rational     -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    _output = True
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            if arg.is_Rational:
+                if arg.q == 2:
+                    return ask(Q.even(2*expr), assumptions)
+                if ~(arg.q & 1):
+                    return None
+            elif ask(Q.irrational(arg), assumptions):
+                if _output:
+                    _output = False
+                else:
+                    return
+            else:
+                return
+
+    return _output
+
+@IntegerPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.integer(expr.args[0]), assumptions):
+        return True
+
+@IntegerPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.integer_elements(expr.args[0]), assumptions)
+
+
+# RationalPredicate
+
+@RationalPredicate.register(Rational)
+def _(expr, assumptions):
+    return True
+
+@RationalPredicate.register(Float)
+def _(expr, assumptions):
+    return None
+
+@RationalPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+    NegativeInfinity, Pi, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@RationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_rational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RationalPredicate.register_many(Add, Mul)
+def _(expr, assumptions):
+    """
+    * Rational + Rational     -> Rational
+    * Rational + !Rational    -> !Rational
+    * !Rational + !Rational   -> ?
+    """
+    if expr.is_number:
+        if expr.as_real_imag()[1]:
+            return False
+    return test_closed_group(expr, assumptions, Q.rational)
+
+@RationalPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Rational ** Integer      -> Rational
+    * Irrational ** Rational   -> Irrational
+    * Rational ** Irrational   -> ?
+    """
+    if expr.base == E:
+        x = expr.exp
+        if ask(Q.rational(x), assumptions):
+            return ask(Q.zero(x), assumptions)
+        return
+
+    is_exp_integer = ask(Q.integer(expr.exp), assumptions)
+    if is_exp_integer:
+        is_base_rational = ask(Q.rational(expr.base),assumptions)
+        if is_base_rational:
+            is_base_zero = ask(Q.zero(expr.base),assumptions)
+            if is_base_zero is False:
+                return True
+            if is_base_zero and ask(Q.positive(expr.exp)):
+                return True
+        if ask(Q.algebraic(expr.base),assumptions) is False:
+            return ask(Q.zero(expr.exp), assumptions)
+        if ask(Q.irrational(expr.base),assumptions) and ask(Q.eq(expr.exp,-1)):
+            return False
+        return
+    elif ask(Q.rational(expr.exp), assumptions):
+        if ask(Q.prime(expr.base), assumptions) and is_exp_integer is False:
+            return False
+        if ask(Q.zero(expr.base)) and ask(Q.positive(expr.exp)):
+            return True
+        if ask(Q.eq(expr.base,1)):
+            return True
+
+@RationalPredicate.register_many(asin, atan, cos, sin, tan)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register(exp)
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register_many(acot, cot)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return False
+
+@RationalPredicate.register_many(acos, log)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)
+
+
+# IrrationalPredicate
+
+@IrrationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_irrational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IrrationalPredicate.register(Basic)
+def _(expr, assumptions):
+    _real = ask(Q.real(expr), assumptions)
+    if _real:
+        _rational = ask(Q.rational(expr), assumptions)
+        if _rational is None:
+            return None
+        return not _rational
+    else:
+        return _real
+
+
+# RealPredicate
+
+def _RealPredicate_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    i = expr.as_real_imag()[1].evalf(2)
+    if i._prec != 1:
+        return not i
+    # allow None to be returned if we couldn't show for sure
+    # that i was 0
+
+@RealPredicate.register_many(Abs, Exp1, Float, GoldenRatio, im, Pi, Rational,
+    re, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@RealPredicate.register_many(ImaginaryUnit, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@RealPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_real
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RealPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Real + Real              -> Real
+    * Real + (Complex & !Real) -> !Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.real)
+
+@RealPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Real*Real               -> Real
+    * Real*Imaginary          -> !Real
+    * Imaginary*Imaginary     -> Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.real(arg), assumptions):
+            pass
+        elif ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        else:
+            break
+    else:
+        return result
+
+@RealPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Real**Integer              -> Real
+    * Positive**Real             -> Real
+    * Negative**Real             -> ?
+    * Real**(Integer/Even)       -> Real if base is nonnegative
+    * Real**(Integer/Odd)        -> Real
+    * Imaginary**(Integer/Even)  -> Real
+    * Imaginary**(Integer/Odd)   -> not Real
+    * Imaginary**Real            -> ? since Real could be 0 (giving real)
+                                    or 1 (giving imaginary)
+    * b**Imaginary               -> Real if log(b) is imaginary and b != 0
+                                    and exponent != integer multiple of
+                                    I*pi/log(b)
+    * Real**Real                 -> ? e.g. sqrt(-1) is imaginary and
+                                    sqrt(2) is not
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+
+    if expr.base == E:
+        return ask(
+            Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+        )
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return True
+        # If the i = (exp's arg)/(I*pi) is an integer or half-integer
+        # multiple of I*pi then 2*i will be an integer. In addition,
+        # exp(i*I*pi) = (-1)**i so the overall realness of the expr
+        # can be determined by replacing exp(i*I*pi) with (-1)**i.
+        i = expr.base.exp/I/pi
+        if ask(Q.integer(2*i), assumptions):
+            return ask(Q.real((S.NegativeOne**i)**expr.exp), assumptions)
+        return
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return not odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real, log(I) is imag;
+            # (2*I)**i -> complex, log(2*I) is not imag
+            return imlog
+
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            if ask(Q.zero(expr.base), assumptions) is not False:
+                if ask(Q.positive(expr.exp), assumptions):
+                    return True
+                return
+            if expr.exp.is_Rational and \
+                    ask(Q.even(expr.exp.q), assumptions):
+                return ask(Q.positive(expr.base), assumptions)
+            elif ask(Q.integer(expr.exp), assumptions):
+                return True
+            elif ask(Q.positive(expr.base), assumptions):
+                return True
+
+@RealPredicate.register_many(cos, sin)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+            return True
+
+@RealPredicate.register(exp)
+def _(expr, assumptions):
+    return ask(
+        Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+    )
+
+@RealPredicate.register(log)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@RealPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.real_elements(expr.args[0]), assumptions)
+
+
+# ExtendedRealPredicate
+
+@ExtendedRealPredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative_infinite(expr)
+               | Q.negative(expr)
+               | Q.zero(expr)
+               | Q.positive(expr)
+               | Q.positive_infinite(expr),
+            assumptions)
+
+@ExtendedRealPredicate.register_many(Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+@ExtendedRealPredicate.register_many(Add, Mul, Pow) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.extended_real)
+
+
+# HermitianPredicate
+
+@HermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    return ask(Q.real(expr), assumptions)
+
+@HermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian + Hermitian  -> Hermitian
+    * Hermitian + !Hermitian -> !Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.hermitian)
+
+@HermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> Hermitian
+    * Hermitian*Antihermitian     -> !Hermitian
+    * Antihermitian*Antihermitian -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = True
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@HermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if expr.base == E:
+        if ask(Q.hermitian(expr.exp), assumptions):
+            return True
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register_many(cos, sin) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.args[0]), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.exp), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# ComplexPredicate
+
+@ComplexPredicate.register_many(Abs, cos, exp, im, ImaginaryUnit, log, Number, # type:ignore
+    NumberSymbol, re, sin)
+def _(expr, assumptions):
+    return True
+
+@ComplexPredicate.register_many(Infinity, NegativeInfinity) # type:ignore
+def _(expr, assumptions):
+    return False
+
+@ComplexPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_complex
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ComplexPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        return True
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register_many(Determinant, MatrixElement, Trace) # type:ignore
+def _(expr, assumptions):
+    return ask(Q.complex_elements(expr.args[0]), assumptions)
+
+@ComplexPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# ImaginaryPredicate
+
+def _Imaginary_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    r = expr.as_real_imag()[0].evalf(2)
+    if r._prec != 1:
+        return not r
+    # allow None to be returned if we couldn't show for sure
+    # that r was 0
+
+@ImaginaryPredicate.register(ImaginaryUnit) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@ImaginaryPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_imaginary
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ImaginaryPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary + Imaginary -> Imaginary
+    * Imaginary + Complex   -> ?
+    * Imaginary + Real      -> !Imaginary
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            pass
+        elif ask(Q.real(arg), assumptions):
+            reals += 1
+        else:
+            break
+    else:
+        if reals == 0:
+            return True
+        if reals in (1, len(expr.args)):
+            # two reals could sum 0 thus giving an imaginary
+            return False
+
+@ImaginaryPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    * Real*Imaginary      -> Imaginary
+    * Imaginary*Imaginary -> Real
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+    result = False
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.real(arg), assumptions):
+            break
+    else:
+        if reals == len(expr.args):
+            return False
+        return result
+
+@ImaginaryPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary**Odd        -> Imaginary
+    * Imaginary**Even       -> Real
+    * b**Imaginary          -> !Imaginary if exponent is an integer
+                               multiple of I*pi/log(b)
+    * Imaginary**Real       -> ?
+    * Positive**Real        -> Real
+    * Negative**Integer     -> Real
+    * Negative**(Integer/2) -> Imaginary
+    * Negative**Real        -> not Imaginary if exponent is not Rational
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    if expr.base == E:
+        a = expr.exp/I/pi
+        return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return False
+            i = expr.base.exp/I/pi
+            if ask(Q.integer(2*i), assumptions):
+                return ask(Q.imaginary((S.NegativeOne**i)**expr.exp), assumptions)
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real; (2*I)**i -> complex ==> not imaginary
+            return False
+
+    if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            return False
+        else:
+            rat = ask(Q.rational(expr.exp), assumptions)
+            if not rat:
+                return rat
+            if ask(Q.integer(expr.exp), assumptions):
+                return False
+            else:
+                half = ask(Q.integer(2*expr.exp), assumptions)
+                if half:
+                    return ask(Q.negative(expr.base), assumptions)
+                return half
+
+@ImaginaryPredicate.register(log) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        if ask(Q.positive(expr.args[0]), assumptions):
+            return False
+        return
+    # XXX it should be enough to do
+    # return ask(Q.nonpositive(expr.args[0]), assumptions)
+    # but ask(Q.nonpositive(exp(x)), Q.imaginary(x)) -> None;
+    # it should return True since exp(x) will be either 0 or complex
+    if expr.args[0].func == exp or (expr.args[0].is_Pow and expr.args[0].base == E):
+        if expr.args[0].exp in [I, -I]:
+            return True
+    im = ask(Q.imaginary(expr.args[0]), assumptions)
+    if im is False:
+        return False
+
+@ImaginaryPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    a = expr.exp/I/pi
+    return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+@ImaginaryPredicate.register_many(Number, NumberSymbol) # type:ignore
+def _(expr, assumptions):
+    return not (expr.as_real_imag()[1] == 0)
+
+@ImaginaryPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# AntihermitianPredicate
+
+@AntihermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    if ask(Q.zero(expr), assumptions):
+        return True
+    return ask(Q.imaginary(expr), assumptions)
+
+@AntihermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Antihermitian + Antihermitian  -> Antihermitian
+    * Antihermitian + !Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.antihermitian)
+
+@AntihermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> !Antihermitian
+    * Hermitian*Antihermitian     -> Antihermitian
+    * Antihermitian*Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = False
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@AntihermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer  -> !Antihermitian
+    * Antihermitian**Even -> !Antihermitian
+    * Antihermitian**Odd  -> Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return False
+    elif ask(Q.antihermitian(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        elif ask(Q.odd(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@AntihermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], -conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# AlgebraicPredicate
+
+@AlgebraicPredicate.register_many(AlgebraicNumber, Float, GoldenRatio, # type:ignore
+    ImaginaryUnit, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@AlgebraicPredicate.register_many(ComplexInfinity, Exp1, Infinity, # type:ignore
+    NegativeInfinity, Pi)
+def _(expr, assumptions):
+    return False
+
+@AlgebraicPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.algebraic)
+
+@AlgebraicPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.algebraic(expr.exp), assumptions):
+            return ask(~Q.nonzero(expr.exp), assumptions)
+        return
+    if expr.base == pi:
+        if ask(Q.integer(expr.exp), assumptions) and ask(Q.positive(expr.exp), assumptions):
+            return False
+        return
+    exp_rational = ask(Q.rational(expr.exp), assumptions)
+    base_algebraic = ask(Q.algebraic(expr.base), assumptions)
+    exp_algebraic = ask(Q.algebraic(expr.exp),assumptions)
+    if base_algebraic and exp_algebraic:
+        if exp_rational:
+            return True
+        # Check based on the Gelfond-Schneider theorem:
+        # If the base is algebraic and not equal to 0 or 1, and the exponent
+        # is irrational,then the result is transcendental.
+        if ask(Q.ne(expr.base,0) & Q.ne(expr.base,1)) and exp_rational is False:
+            return False
+
+@AlgebraicPredicate.register(Rational) # type:ignore
+def _(expr, assumptions):
+    return expr.q != 0
+
+@AlgebraicPredicate.register_many(asin, atan, cos, sin, tan) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register_many(acot, cot) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return False
+
+@AlgebraicPredicate.register_many(acos, log) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/lra_satask.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/lra_satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..53afe3e5abe99109ec01a47f19f1a8a4c99c5628
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/lra_satask.py
@@ -0,0 +1,286 @@
+from sympy.assumptions.assume import global_assumptions
+from sympy.assumptions.cnf import CNF, EncodedCNF
+from sympy.assumptions.ask import Q
+from sympy.logic.inference import satisfiable
+from sympy.logic.algorithms.lra_theory import UnhandledInput, ALLOWED_PRED
+from sympy.matrices.kind import MatrixKind
+from sympy.core.kind import NumberKind
+from sympy.assumptions.assume import AppliedPredicate
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+
+
+def lra_satask(proposition, assumptions=True, context=global_assumptions):
+    """
+    Function to evaluate the proposition with assumptions using SAT algorithm
+    in conjunction with an Linear Real Arithmetic theory solver.
+
+    Used to handle inequalities. Should eventually be depreciated and combined
+    into satask, but infinity handling and other things need to be implemented
+    before that can happen.
+    """
+    props = CNF.from_prop(proposition)
+    _props = CNF.from_prop(~proposition)
+
+    cnf = CNF.from_prop(assumptions)
+    assumptions = EncodedCNF()
+    assumptions.from_cnf(cnf)
+
+    context_cnf = CNF()
+    if context:
+        context_cnf = context_cnf.extend(context)
+
+    assumptions.add_from_cnf(context_cnf)
+
+    return check_satisfiability(props, _props, assumptions)
+
+# Some predicates such as Q.prime can't be handled by lra_satask.
+# For example, (x > 0) & (x < 1) & Q.prime(x) is unsat but lra_satask would think it was sat.
+# WHITE_LIST is a list of predicates that can always be handled.
+WHITE_LIST = ALLOWED_PRED | {Q.positive, Q.negative, Q.zero, Q.nonzero, Q.nonpositive, Q.nonnegative,
+                                            Q.extended_positive, Q.extended_negative, Q.extended_nonpositive,
+                                            Q.extended_negative, Q.extended_nonzero, Q.negative_infinite,
+                                            Q.positive_infinite}
+
+
+def check_satisfiability(prop, _prop, factbase):
+    sat_true = factbase.copy()
+    sat_false = factbase.copy()
+    sat_true.add_from_cnf(prop)
+    sat_false.add_from_cnf(_prop)
+
+    all_pred, all_exprs = get_all_pred_and_expr_from_enc_cnf(sat_true)
+
+    for pred in all_pred:
+        if pred.function not in WHITE_LIST and pred.function != Q.ne:
+            raise UnhandledInput(f"LRASolver: {pred} is an unhandled predicate")
+    for expr in all_exprs:
+        if expr.kind == MatrixKind(NumberKind):
+            raise UnhandledInput(f"LRASolver: {expr} is of MatrixKind")
+        if expr == S.NaN:
+            raise UnhandledInput("LRASolver: nan")
+
+    # convert old assumptions into predicates and add them to sat_true and sat_false
+    # also check for unhandled predicates
+    for assm in extract_pred_from_old_assum(all_exprs):
+        n = len(sat_true.encoding)
+        if assm not in sat_true.encoding:
+            sat_true.encoding[assm] = n+1
+        sat_true.data.append([sat_true.encoding[assm]])
+
+        n = len(sat_false.encoding)
+        if assm not in sat_false.encoding:
+            sat_false.encoding[assm] = n+1
+        sat_false.data.append([sat_false.encoding[assm]])
+
+
+    sat_true = _preprocess(sat_true)
+    sat_false = _preprocess(sat_false)
+
+    can_be_true = satisfiable(sat_true, use_lra_theory=True) is not False
+    can_be_false = satisfiable(sat_false, use_lra_theory=True) is not False
+
+    if can_be_true and can_be_false:
+        return None
+
+    if can_be_true and not can_be_false:
+        return True
+
+    if not can_be_true and can_be_false:
+        return False
+
+    if not can_be_true and not can_be_false:
+        raise ValueError("Inconsistent assumptions")
+
+
+def _preprocess(enc_cnf):
+    """
+    Returns an encoded cnf with only Q.eq, Q.gt, Q.lt,
+    Q.ge, and Q.le predicate.
+
+    Converts every unequality into a disjunction of strict
+    inequalities. For example, x != 3 would become
+    x < 3 OR x > 3.
+
+    Also converts all negated Q.ne predicates into
+    equalities.
+    """
+
+    # loops through each literal in each clause
+    # to construct a new, preprocessed encodedCNF
+
+    enc_cnf = enc_cnf.copy()
+    cur_enc = 1
+    rev_encoding = {value: key for key, value in enc_cnf.encoding.items()}
+
+    new_encoding = {}
+    new_data = []
+    for clause in enc_cnf.data:
+        new_clause = []
+        for lit in clause:
+            if lit == 0:
+                new_clause.append(lit)
+                new_encoding[lit] = False
+                continue
+            prop = rev_encoding[abs(lit)]
+            negated = lit < 0
+            sign = (lit > 0) - (lit < 0)
+
+            prop = _pred_to_binrel(prop)
+
+            if not isinstance(prop, AppliedPredicate):
+                if prop not in new_encoding:
+                    new_encoding[prop] = cur_enc
+                    cur_enc += 1
+                lit = new_encoding[prop]
+                new_clause.append(sign*lit)
+                continue
+
+
+            if negated and prop.function == Q.eq:
+                negated = False
+                prop = Q.ne(*prop.arguments)
+
+            if prop.function == Q.ne:
+                arg1, arg2 = prop.arguments
+                if negated:
+                    new_prop = Q.eq(arg1, arg2)
+                    if new_prop not in new_encoding:
+                        new_encoding[new_prop] = cur_enc
+                        cur_enc += 1
+
+                    new_enc = new_encoding[new_prop]
+                    new_clause.append(new_enc)
+                    continue
+                else:
+                    new_props = (Q.gt(arg1, arg2), Q.lt(arg1, arg2))
+                    for new_prop in new_props:
+                        if new_prop not in new_encoding:
+                            new_encoding[new_prop] = cur_enc
+                            cur_enc += 1
+
+                        new_enc = new_encoding[new_prop]
+                        new_clause.append(new_enc)
+                    continue
+
+            if prop.function == Q.eq and negated:
+                assert False
+
+            if prop not in new_encoding:
+                new_encoding[prop] = cur_enc
+                cur_enc += 1
+            new_clause.append(new_encoding[prop]*sign)
+        new_data.append(new_clause)
+
+    assert len(new_encoding) >= cur_enc - 1
+
+    enc_cnf = EncodedCNF(new_data, new_encoding)
+    return enc_cnf
+
+
+def _pred_to_binrel(pred):
+    if not isinstance(pred, AppliedPredicate):
+        return pred
+
+    if pred.function in pred_to_pos_neg_zero:
+        f = pred_to_pos_neg_zero[pred.function]
+        if f is False:
+            return False
+        pred = f(pred.arguments[0])
+
+    if pred.function == Q.positive:
+        pred = Q.gt(pred.arguments[0], 0)
+    elif pred.function == Q.negative:
+        pred = Q.lt(pred.arguments[0], 0)
+    elif pred.function == Q.zero:
+        pred = Q.eq(pred.arguments[0], 0)
+    elif pred.function == Q.nonpositive:
+        pred = Q.le(pred.arguments[0], 0)
+    elif pred.function == Q.nonnegative:
+        pred = Q.ge(pred.arguments[0], 0)
+    elif pred.function == Q.nonzero:
+        pred = Q.ne(pred.arguments[0], 0)
+
+    return pred
+
+pred_to_pos_neg_zero = {
+    Q.extended_positive: Q.positive,
+    Q.extended_negative: Q.negative,
+    Q.extended_nonpositive: Q.nonpositive,
+    Q.extended_negative: Q.negative,
+    Q.extended_nonzero: Q.nonzero,
+    Q.negative_infinite: False,
+    Q.positive_infinite: False
+}
+
+def get_all_pred_and_expr_from_enc_cnf(enc_cnf):
+    all_exprs = set()
+    all_pred = set()
+    for pred in enc_cnf.encoding.keys():
+        if isinstance(pred, AppliedPredicate):
+            all_pred.add(pred)
+            all_exprs.update(pred.arguments)
+
+    return all_pred, all_exprs
+
+def extract_pred_from_old_assum(all_exprs):
+    """
+    Returns a list of relevant new assumption predicate
+    based on any old assumptions.
+
+    Raises an UnhandledInput exception if any of the assumptions are
+    unhandled.
+
+    Ignored predicate:
+    - commutative
+    - complex
+    - algebraic
+    - transcendental
+    - extended_real
+    - real
+    - all matrix predicate
+    - rational
+    - irrational
+
+    Example
+    =======
+    >>> from sympy.assumptions.lra_satask import extract_pred_from_old_assum
+    >>> from sympy import symbols
+    >>> x, y = symbols("x y", positive=True)
+    >>> extract_pred_from_old_assum([x, y, 2])
+    [Q.positive(x), Q.positive(y)]
+    """
+    ret = []
+    for expr in all_exprs:
+        if not hasattr(expr, "free_symbols"):
+            continue
+        if len(expr.free_symbols) == 0:
+            continue
+
+        if expr.is_real is not True:
+            raise UnhandledInput(f"LRASolver: {expr} must be real")
+        # test for I times imaginary variable; such expressions are considered real
+        if isinstance(expr, Mul) and any(arg.is_real is not True for arg in expr.args):
+            raise UnhandledInput(f"LRASolver: {expr} must be real")
+
+        if expr.is_integer == True and expr.is_zero != True:
+            raise UnhandledInput(f"LRASolver: {expr} is an integer")
+        if expr.is_integer == False:
+            raise UnhandledInput(f"LRASolver: {expr} can't be an integer")
+        if expr.is_rational == False:
+            raise UnhandledInput(f"LRASolver: {expr} is irational")
+
+        if expr.is_zero:
+            ret.append(Q.zero(expr))
+        elif expr.is_positive:
+            ret.append(Q.positive(expr))
+        elif expr.is_negative:
+            ret.append(Q.negative(expr))
+        elif expr.is_nonzero:
+            ret.append(Q.nonzero(expr))
+        elif expr.is_nonpositive:
+            ret.append(Q.nonpositive(expr))
+        elif expr.is_nonnegative:
+            ret.append(Q.nonnegative(expr))
+
+    return ret
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e294544bfdce13633ecff762ff42861aa12719f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/__init__.py
@@ -0,0 +1,5 @@
+"""
+Module to implement predicate classes.
+
+Class of every predicate registered to ``Q`` is defined here.
+"""
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/calculus.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..f300703788683c07649ee3a0afd6e9d4eabd4567
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/calculus.py
@@ -0,0 +1,82 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class FinitePredicate(Predicate):
+    """
+    Finite number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.finite(x)`` is true if ``x`` is a number but neither an infinity
+    nor a ``NaN``. In other words, ``ask(Q.finite(x))`` is true for all
+    numerical ``x`` having a bounded absolute value.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S, oo, I, zoo
+    >>> from sympy.abc import x
+    >>> ask(Q.finite(oo))
+    False
+    >>> ask(Q.finite(-oo))
+    False
+    >>> ask(Q.finite(zoo))
+    False
+    >>> ask(Q.finite(1))
+    True
+    >>> ask(Q.finite(2 + 3*I))
+    True
+    >>> ask(Q.finite(x), Q.positive(x))
+    True
+    >>> print(ask(Q.finite(S.NaN)))
+    None
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Finite
+
+    """
+    name = 'finite'
+    handler = Dispatcher(
+        "FiniteHandler",
+        doc=("Handler for Q.finite. Test that an expression is bounded respect"
+        " to all its variables.")
+    )
+
+
+class InfinitePredicate(Predicate):
+    """
+    Infinite number predicate.
+
+    ``Q.infinite(x)`` is true iff the absolute value of ``x`` is
+    infinity.
+
+    """
+    # TODO: Add examples
+    name = 'infinite'
+    handler = Dispatcher(
+        "InfiniteHandler",
+        doc="""Handler for Q.infinite key."""
+    )
+
+
+class PositiveInfinitePredicate(Predicate):
+    """
+    Positive infinity predicate.
+
+    ``Q.positive_infinite(x)`` is true iff ``x`` is positive infinity ``oo``.
+    """
+    name = 'positive_infinite'
+    handler = Dispatcher("PositiveInfiniteHandler")
+
+
+class NegativeInfinitePredicate(Predicate):
+    """
+    Negative infinity predicate.
+
+    ``Q.negative_infinite(x)`` is true iff ``x`` is negative infinity ``-oo``.
+    """
+    name = 'negative_infinite'
+    handler = Dispatcher("NegativeInfiniteHandler")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/common.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..a53892747131b03636abeb8f563c4f76cf3e281e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/common.py
@@ -0,0 +1,81 @@
+from sympy.assumptions import Predicate, AppliedPredicate, Q
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.multipledispatch import Dispatcher
+
+
+class CommutativePredicate(Predicate):
+    """
+    Commutative predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other
+    object with respect to multiplication operation.
+
+    """
+    # TODO: Add examples
+    name = 'commutative'
+    handler = Dispatcher("CommutativeHandler", doc="Handler for key 'commutative'.")
+
+
+binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+
+class IsTruePredicate(Predicate):
+    """
+    Generic predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.is_true(x))`` is true iff ``x`` is true. This only makes
+    sense if ``x`` is a boolean object.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> from sympy.abc import x, y
+    >>> ask(Q.is_true(True))
+    True
+
+    Wrapping another applied predicate just returns the applied predicate.
+
+    >>> Q.is_true(Q.even(x))
+    Q.even(x)
+
+    Wrapping binary relation classes in SymPy core returns applied binary
+    relational predicates.
+
+    >>> from sympy import Eq, Gt
+    >>> Q.is_true(Eq(x, y))
+    Q.eq(x, y)
+    >>> Q.is_true(Gt(x, y))
+    Q.gt(x, y)
+
+    Notes
+    =====
+
+    This class is designed to wrap the boolean objects so that they can
+    behave as if they are applied predicates. Consequently, wrapping another
+    applied predicate is unnecessary and thus it just returns the argument.
+    Also, binary relation classes in SymPy core have binary predicates to
+    represent themselves and thus wrapping them with ``Q.is_true`` converts them
+    to these applied predicates.
+
+    """
+    name = 'is_true'
+    handler = Dispatcher(
+        "IsTrueHandler",
+        doc="Wrapper allowing to query the truth value of a boolean expression."
+    )
+
+    def __call__(self, arg):
+        # No need to wrap another predicate
+        if isinstance(arg, AppliedPredicate):
+            return arg
+        # Convert relational predicates instead of wrapping them
+        if getattr(arg, "is_Relational", False):
+            pred = binrelpreds[type(arg)]
+            return pred(*arg.args)
+        return super().__call__(arg)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/matrices.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..151e78c4ff345800e1d2f17973fb0591b8d379d2
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/matrices.py
@@ -0,0 +1,511 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class SquarePredicate(Predicate):
+    """
+    Square matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.square(x)`` is true iff ``x`` is a square matrix. A square matrix
+    is a matrix with the same number of rows and columns.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('X', 2, 3)
+    >>> ask(Q.square(X))
+    True
+    >>> ask(Q.square(Y))
+    False
+    >>> ask(Q.square(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.square(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_matrix
+
+    """
+    name = 'square'
+    handler = Dispatcher("SquareHandler", doc="Handler for Q.square.")
+
+
+class SymmetricPredicate(Predicate):
+    """
+    Symmetric matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.symmetric(x)`` is true iff ``x`` is a square matrix and is equal to
+    its transpose. Every square diagonal matrix is a symmetric matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(Y))
+    False
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_matrix
+
+    """
+    # TODO: Add handlers to make these keys work with
+    # actual matrices and add more examples in the docstring.
+    name = 'symmetric'
+    handler = Dispatcher("SymmetricHandler", doc="Handler for Q.symmetric.")
+
+
+class InvertiblePredicate(Predicate):
+    """
+    Invertible matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.invertible(x)`` is true iff ``x`` is an invertible matrix.
+    A square matrix is called invertible only if its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.invertible(X*Y), Q.invertible(X))
+    False
+    >>> ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z))
+    True
+    >>> ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Invertible_matrix
+
+    """
+    name = 'invertible'
+    handler = Dispatcher("InvertibleHandler", doc="Handler for Q.invertible.")
+
+
+class OrthogonalPredicate(Predicate):
+    """
+    Orthogonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.orthogonal(x)`` is true iff ``x`` is an orthogonal matrix.
+    A square matrix ``M`` is an orthogonal matrix if it satisfies
+    ``M^TM = MM^T = I`` where ``M^T`` is the transpose matrix of
+    ``M`` and ``I`` is an identity matrix. Note that an orthogonal
+    matrix is necessarily invertible.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.orthogonal(Y))
+    False
+    >>> ask(Q.orthogonal(X*Z*X), Q.orthogonal(X) & Q.orthogonal(Z))
+    True
+    >>> ask(Q.orthogonal(Identity(3)))
+    True
+    >>> ask(Q.invertible(X), Q.orthogonal(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Orthogonal_matrix
+
+    """
+    name = 'orthogonal'
+    handler = Dispatcher("OrthogonalHandler", doc="Handler for key 'orthogonal'.")
+
+
+class UnitaryPredicate(Predicate):
+    """
+    Unitary matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.unitary(x)`` is true iff ``x`` is a unitary matrix.
+    Unitary matrix is an analogue to orthogonal matrix. A square
+    matrix ``M`` with complex elements is unitary if :math:``M^TM = MM^T= I``
+    where :math:``M^T`` is the conjugate transpose matrix of ``M``.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.unitary(Y))
+    False
+    >>> ask(Q.unitary(X*Z*X), Q.unitary(X) & Q.unitary(Z))
+    True
+    >>> ask(Q.unitary(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Unitary_matrix
+
+    """
+    name = 'unitary'
+    handler = Dispatcher("UnitaryHandler", doc="Handler for key 'unitary'.")
+
+
+class FullRankPredicate(Predicate):
+    """
+    Fullrank matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.fullrank(x)`` is true iff ``x`` is a full rank matrix.
+    A matrix is full rank if all rows and columns of the matrix
+    are linearly independent. A square matrix is full rank iff
+    its determinant is nonzero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.fullrank(X.T), Q.fullrank(X))
+    True
+    >>> ask(Q.fullrank(ZeroMatrix(3, 3)))
+    False
+    >>> ask(Q.fullrank(Identity(3)))
+    True
+
+    """
+    name = 'fullrank'
+    handler = Dispatcher("FullRankHandler", doc="Handler for key 'fullrank'.")
+
+
+class PositiveDefinitePredicate(Predicate):
+    r"""
+    Positive definite matrix predicate.
+
+    Explanation
+    ===========
+
+    If $M$ is a :math:`n \times n` symmetric real matrix, it is said
+    to be positive definite if :math:`Z^TMZ` is positive for
+    every non-zero column vector $Z$ of $n$ real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.positive_definite(Y))
+    False
+    >>> ask(Q.positive_definite(Identity(3)))
+    True
+    >>> ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+    ...     Q.positive_definite(Z))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Positive-definite_matrix
+
+    """
+    name = "positive_definite"
+    handler = Dispatcher("PositiveDefiniteHandler", doc="Handler for key 'positive_definite'.")
+
+
+class UpperTriangularPredicate(Predicate):
+    """
+    Upper triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called upper triangular matrix if :math:`M_{ij}=0`
+    for :math:`i<j`.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.upper_triangular(Identity(3)))
+    True
+    >>> ask(Q.upper_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/UpperTriangularMatrix.html
+
+    """
+    name = "upper_triangular"
+    handler = Dispatcher("UpperTriangularHandler", doc="Handler for key 'upper_triangular'.")
+
+
+class LowerTriangularPredicate(Predicate):
+    """
+    Lower triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called lower triangular matrix if :math:`M_{ij}=0`
+    for :math:`i>j`.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.lower_triangular(Identity(3)))
+    True
+    >>> ask(Q.lower_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/LowerTriangularMatrix.html
+
+    """
+    name = "lower_triangular"
+    handler = Dispatcher("LowerTriangularHandler", doc="Handler for key 'lower_triangular'.")
+
+
+class DiagonalPredicate(Predicate):
+    """
+    Diagonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.diagonal(x)`` is true iff ``x`` is a diagonal matrix. A diagonal
+    matrix is a matrix in which the entries outside the main diagonal
+    are all zero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.diagonal(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.diagonal(X), Q.lower_triangular(X) &
+    ...     Q.upper_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Diagonal_matrix
+
+    """
+    name = "diagonal"
+    handler = Dispatcher("DiagonalHandler", doc="Handler for key 'diagonal'.")
+
+
+class IntegerElementsPredicate(Predicate):
+    """
+    Integer elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer_elements(x)`` is true iff all the elements of ``x``
+    are integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    True
+
+    """
+    name = "integer_elements"
+    handler = Dispatcher("IntegerElementsHandler", doc="Handler for key 'integer_elements'.")
+
+
+class RealElementsPredicate(Predicate):
+    """
+    Real elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real_elements(x)`` is true iff all the elements of ``x``
+    are real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.real(X[1, 2]), Q.real_elements(X))
+    True
+
+    """
+    name = "real_elements"
+    handler = Dispatcher("RealElementsHandler", doc="Handler for key 'real_elements'.")
+
+
+class ComplexElementsPredicate(Predicate):
+    """
+    Complex elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex_elements(x)`` is true iff all the elements of ``x``
+    are complex numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    True
+    >>> ask(Q.complex_elements(X), Q.integer_elements(X))
+    True
+
+    """
+    name = "complex_elements"
+    handler = Dispatcher("ComplexElementsHandler", doc="Handler for key 'complex_elements'.")
+
+
+class SingularPredicate(Predicate):
+    """
+    Singular matrix predicate.
+
+    A matrix is singular iff the value of its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.singular(X), Q.invertible(X))
+    False
+    >>> ask(Q.singular(X), ~Q.invertible(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/SingularMatrix.html
+
+    """
+    name = "singular"
+    handler = Dispatcher("SingularHandler", doc="Predicate fore key 'singular'.")
+
+
+class NormalPredicate(Predicate):
+    """
+    Normal matrix predicate.
+
+    A matrix is normal if it commutes with its conjugate transpose.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.normal(X), Q.unitary(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Normal_matrix
+
+    """
+    name = "normal"
+    handler = Dispatcher("NormalHandler", doc="Predicate fore key 'normal'.")
+
+
+class TriangularPredicate(Predicate):
+    """
+    Triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.triangular(X)`` is true if ``X`` is one that is either lower
+    triangular or upper triangular.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.upper_triangular(X))
+    True
+    >>> ask(Q.triangular(X), Q.lower_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Triangular_matrix
+
+    """
+    name = "triangular"
+    handler = Dispatcher("TriangularHandler", doc="Predicate fore key 'triangular'.")
+
+
+class UnitTriangularPredicate(Predicate):
+    """
+    Unit triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A unit triangular matrix is a triangular matrix with 1s
+    on the diagonal.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.unit_triangular(X))
+    True
+
+    """
+    name = "unit_triangular"
+    handler = Dispatcher("UnitTriangularHandler", doc="Predicate fore key 'unit_triangular'.")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/ntheory.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c598e0ed1bd4a1170aa28044f9ae6de2fa1a1e0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/ntheory.py
@@ -0,0 +1,126 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class PrimePredicate(Predicate):
+    """
+    Prime number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.prime(x))`` is true iff ``x`` is a natural number greater
+    than 1 that has no positive divisors other than ``1`` and the
+    number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.prime(0))
+    False
+    >>> ask(Q.prime(1))
+    False
+    >>> ask(Q.prime(2))
+    True
+    >>> ask(Q.prime(20))
+    False
+    >>> ask(Q.prime(-3))
+    False
+
+    """
+    name = 'prime'
+    handler = Dispatcher(
+        "PrimeHandler",
+        doc=("Handler for key 'prime'. Test that an expression represents a prime"
+        " number. When the expression is an exact number, the result (when True)"
+        " is subject to the limitations of isprime() which is used to return the "
+        "result.")
+    )
+
+
+class CompositePredicate(Predicate):
+    """
+    Composite number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.composite(x))`` is true iff ``x`` is a positive integer and has
+    at least one positive divisor other than ``1`` and the number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.composite(0))
+    False
+    >>> ask(Q.composite(1))
+    False
+    >>> ask(Q.composite(2))
+    False
+    >>> ask(Q.composite(20))
+    True
+
+    """
+    name = 'composite'
+    handler = Dispatcher("CompositeHandler", doc="Handler for key 'composite'.")
+
+
+class EvenPredicate(Predicate):
+    """
+    Even number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.even(x))`` is true iff ``x`` belongs to the set of even
+    integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.even(0))
+    True
+    >>> ask(Q.even(2))
+    True
+    >>> ask(Q.even(3))
+    False
+    >>> ask(Q.even(pi))
+    False
+
+    """
+    name = 'even'
+    handler = Dispatcher("EvenHandler", doc="Handler for key 'even'.")
+
+
+class OddPredicate(Predicate):
+    """
+    Odd number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.odd(x))`` is true iff ``x`` belongs to the set of odd numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.odd(0))
+    False
+    >>> ask(Q.odd(2))
+    False
+    >>> ask(Q.odd(3))
+    True
+    >>> ask(Q.odd(pi))
+    False
+
+    """
+    name = 'odd'
+    handler = Dispatcher(
+        "OddHandler",
+        doc=("Handler for key 'odd'. Test that an expression represents an odd"
+        " number.")
+    )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/order.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/order.py
new file mode 100644
index 0000000000000000000000000000000000000000..86bfb2ae49789efd5b0df99e2cfc63984e956dd0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/order.py
@@ -0,0 +1,390 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class NegativePredicate(Predicate):
+    r"""
+    Negative number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is,
+    it is in the interval :math:`(-\infty, 0)`.  Note in particular that negative
+    infinity is not negative.
+
+    A few important facts about negative numbers:
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.negative(-1))
+    True
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(~Q.negative(I))
+    True
+
+    """
+    name = 'negative'
+    handler = Dispatcher(
+        "NegativeHandler",
+        doc=("Handler for Q.negative. Test that an expression is strictly less"
+        " than zero.")
+    )
+
+
+class NonNegativePredicate(Predicate):
+    """
+    Nonnegative real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonnegative(x))`` is true iff ``x`` belongs to the set of
+    positive numbers including zero.
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.nonnegative(1))
+    True
+    >>> ask(Q.nonnegative(0))
+    True
+    >>> ask(Q.nonnegative(-1))
+    False
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(Q.nonnegative(-I))
+    False
+
+    """
+    name = 'nonnegative'
+    handler = Dispatcher(
+        "NonNegativeHandler",
+        doc=("Handler for Q.nonnegative.")
+    )
+
+
+class NonZeroPredicate(Predicate):
+    """
+    Nonzero real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonzero(x))`` is true iff ``x`` is real and ``x`` is not zero.  Note in
+    particular that ``Q.nonzero(x)`` is false if ``x`` is not real.  Use
+    ``~Q.zero(x)`` if you want the negation of being zero without any real
+    assumptions.
+
+    A few important facts about nonzero numbers:
+
+    - ``Q.nonzero`` is logically equivalent to ``Q.positive | Q.negative``.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I, oo
+    >>> x = symbols('x')
+    >>> print(ask(Q.nonzero(x), ~Q.zero(x)))
+    None
+    >>> ask(Q.nonzero(x), Q.positive(x))
+    True
+    >>> ask(Q.nonzero(x), Q.zero(x))
+    False
+    >>> ask(Q.nonzero(0))
+    False
+    >>> ask(Q.nonzero(I))
+    False
+    >>> ask(~Q.zero(I))
+    True
+    >>> ask(Q.nonzero(oo))
+    False
+
+    """
+    name = 'nonzero'
+    handler = Dispatcher(
+        "NonZeroHandler",
+        doc=("Handler for key 'nonzero'. Test that an expression is not identically"
+        " zero.")
+    )
+
+
+class ZeroPredicate(Predicate):
+    """
+    Zero number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.zero(x))`` is true iff the value of ``x`` is zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, symbols
+    >>> x, y = symbols('x, y')
+    >>> ask(Q.zero(0))
+    True
+    >>> ask(Q.zero(1/oo))
+    True
+    >>> print(ask(Q.zero(0*oo)))
+    None
+    >>> ask(Q.zero(1))
+    False
+    >>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y))
+    True
+
+    """
+    name = 'zero'
+    handler = Dispatcher(
+        "ZeroHandler",
+        doc="Handler for key 'zero'."
+    )
+
+
+class NonPositivePredicate(Predicate):
+    """
+    Nonpositive real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonpositive(x))`` is true iff ``x`` belongs to the set of
+    negative numbers including zero.
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+
+    >>> ask(Q.nonpositive(-1))
+    True
+    >>> ask(Q.nonpositive(0))
+    True
+    >>> ask(Q.nonpositive(1))
+    False
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(Q.nonpositive(-I))
+    False
+
+    """
+    name = 'nonpositive'
+    handler = Dispatcher(
+        "NonPositiveHandler",
+        doc="Handler for key 'nonpositive'."
+    )
+
+
+class PositivePredicate(Predicate):
+    r"""
+    Positive real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.positive(x)`` is true iff ``x`` is real and `x > 0`, that is if ``x``
+    is in the interval `(0, \infty)`.  In particular, infinity is not
+    positive.
+
+    A few important facts about positive numbers:
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.positive(1))
+    True
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(~Q.positive(I))
+    True
+
+    """
+    name = 'positive'
+    handler = Dispatcher(
+        "PositiveHandler",
+        doc=("Handler for key 'positive'. Test that an expression is strictly"
+        " greater than zero.")
+    )
+
+
+class ExtendedPositivePredicate(Predicate):
+    r"""
+    Positive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_positive(x)`` is true iff ``x`` is extended real and
+    `x > 0`, that is if ``x`` is in the interval `(0, \infty]`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_positive(1))
+    True
+    >>> ask(Q.extended_positive(oo))
+    True
+    >>> ask(Q.extended_positive(I))
+    False
+
+    """
+    name = 'extended_positive'
+    handler = Dispatcher("ExtendedPositiveHandler")
+
+
+class ExtendedNegativePredicate(Predicate):
+    r"""
+    Negative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_negative(x)`` is true iff ``x`` is extended real and
+    `x < 0`, that is if ``x`` is in the interval `[-\infty, 0)`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_negative(-1))
+    True
+    >>> ask(Q.extended_negative(-oo))
+    True
+    >>> ask(Q.extended_negative(-I))
+    False
+
+    """
+    name = 'extended_negative'
+    handler = Dispatcher("ExtendedNegativeHandler")
+
+
+class ExtendedNonZeroPredicate(Predicate):
+    """
+    Nonzero extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonzero(x))`` is true iff ``x`` is extended real and
+    ``x`` is not zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonzero(-1))
+    True
+    >>> ask(Q.extended_nonzero(oo))
+    True
+    >>> ask(Q.extended_nonzero(I))
+    False
+
+    """
+    name = 'extended_nonzero'
+    handler = Dispatcher("ExtendedNonZeroHandler")
+
+
+class ExtendedNonPositivePredicate(Predicate):
+    """
+    Nonpositive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonpositive(x))`` is true iff ``x`` is extended real and
+    ``x`` is not positive.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonpositive(-1))
+    True
+    >>> ask(Q.extended_nonpositive(oo))
+    False
+    >>> ask(Q.extended_nonpositive(0))
+    True
+    >>> ask(Q.extended_nonpositive(I))
+    False
+
+    """
+    name = 'extended_nonpositive'
+    handler = Dispatcher("ExtendedNonPositiveHandler")
+
+
+class ExtendedNonNegativePredicate(Predicate):
+    """
+    Nonnegative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonnegative(x))`` is true iff ``x`` is extended real and
+    ``x`` is not negative.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonnegative(-1))
+    False
+    >>> ask(Q.extended_nonnegative(oo))
+    True
+    >>> ask(Q.extended_nonnegative(0))
+    True
+    >>> ask(Q.extended_nonnegative(I))
+    False
+
+    """
+    name = 'extended_nonnegative'
+    handler = Dispatcher("ExtendedNonNegativeHandler")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/sets.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/sets.py
new file mode 100644
index 0000000000000000000000000000000000000000..18261cee2d9de65df14a31a56b2cd22328328ed0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/predicates/sets.py
@@ -0,0 +1,399 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class IntegerPredicate(Predicate):
+    """
+    Integer predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer(x)`` is true iff ``x`` belongs to the set of integer
+    numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S
+    >>> ask(Q.integer(5))
+    True
+    >>> ask(Q.integer(S(1)/2))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Integer
+
+    """
+    name = 'integer'
+    handler = Dispatcher(
+        "IntegerHandler",
+        doc=("Handler for Q.integer.\n\n"
+        "Test that an expression belongs to the field of integer numbers.")
+    )
+
+
+class NonIntegerPredicate(Predicate):
+    """
+    Non-integer extended real predicate.
+    """
+    name = 'noninteger'
+    handler = Dispatcher(
+        "NonIntegerHandler",
+        doc=("Handler for Q.noninteger.\n\n"
+        "Test that an expression is a non-integer extended real number.")
+    )
+
+
+class RationalPredicate(Predicate):
+    """
+    Rational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.rational(x)`` is true iff ``x`` belongs to the set of
+    rational numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S
+    >>> ask(Q.rational(0))
+    True
+    >>> ask(Q.rational(S(1)/2))
+    True
+    >>> ask(Q.rational(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Rational_number
+
+    """
+    name = 'rational'
+    handler = Dispatcher(
+        "RationalHandler",
+        doc=("Handler for Q.rational.\n\n"
+        "Test that an expression belongs to the field of rational numbers.")
+    )
+
+
+class IrrationalPredicate(Predicate):
+    """
+    Irrational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.irrational(x)`` is true iff ``x``  is any real number that
+    cannot be expressed as a ratio of integers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S, I
+    >>> ask(Q.irrational(0))
+    False
+    >>> ask(Q.irrational(S(1)/2))
+    False
+    >>> ask(Q.irrational(pi))
+    True
+    >>> ask(Q.irrational(I))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Irrational_number
+
+    """
+    name = 'irrational'
+    handler = Dispatcher(
+        "IrrationalHandler",
+        doc=("Handler for Q.irrational.\n\n"
+        "Test that an expression is irrational numbers.")
+    )
+
+
+class RealPredicate(Predicate):
+    r"""
+    Real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real(x)`` is true iff ``x`` is a real number, i.e., it is in the
+    interval `(-\infty, \infty)`.  Note that, in particular the
+    infinities are not real. Use ``Q.extended_real`` if you want to
+    consider those as well.
+
+    A few important facts about reals:
+
+    - Every real number is positive, negative, or zero.  Furthermore,
+        because these sets are pairwise disjoint, each real number is
+        exactly one of those three.
+
+    - Every real number is also complex.
+
+    - Every real number is finite.
+
+    - Every real number is either rational or irrational.
+
+    - Every real number is either algebraic or transcendental.
+
+    - The facts ``Q.negative``, ``Q.zero``, ``Q.positive``,
+        ``Q.nonnegative``, ``Q.nonpositive``, ``Q.nonzero``,
+        ``Q.integer``, ``Q.rational``, and ``Q.irrational`` all imply
+        ``Q.real``, as do all facts that imply those facts.
+
+    - The facts ``Q.algebraic``, and ``Q.transcendental`` do not imply
+        ``Q.real``; they imply ``Q.complex``. An algebraic or
+        transcendental number may or may not be real.
+
+    - The "non" facts (i.e., ``Q.nonnegative``, ``Q.nonzero``,
+        ``Q.nonpositive`` and ``Q.noninteger``) are not equivalent to
+        not the fact, but rather, not the fact *and* ``Q.real``.
+        For example, ``Q.nonnegative`` means ``~Q.negative & Q.real``.
+        So for example, ``I`` is not nonnegative, nonzero, or
+        nonpositive.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols
+    >>> x = symbols('x')
+    >>> ask(Q.real(x), Q.positive(x))
+    True
+    >>> ask(Q.real(0))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Real_number
+
+    """
+    name = 'real'
+    handler = Dispatcher(
+        "RealHandler",
+        doc=("Handler for Q.real.\n\n"
+        "Test that an expression belongs to the field of real numbers.")
+    )
+
+
+class ExtendedRealPredicate(Predicate):
+    r"""
+    Extended real predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_real(x)`` is true iff ``x`` is a real number or
+    `\{-\infty, \infty\}`.
+
+    See documentation of ``Q.real`` for more information about related
+    facts.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, I
+    >>> ask(Q.extended_real(1))
+    True
+    >>> ask(Q.extended_real(I))
+    False
+    >>> ask(Q.extended_real(oo))
+    True
+
+    """
+    name = 'extended_real'
+    handler = Dispatcher(
+        "ExtendedRealHandler",
+        doc=("Handler for Q.extended_real.\n\n"
+        "Test that an expression belongs to the field of extended real\n"
+        "numbers, that is real numbers union {Infinity, -Infinity}.")
+    )
+
+
+class HermitianPredicate(Predicate):
+    """
+    Hermitian predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.hermitian(x))`` is true iff ``x`` belongs to the set of
+    Hermitian operators.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'hermitian'
+    handler = Dispatcher(
+        "HermitianHandler",
+        doc=("Handler for Q.hermitian.\n\n"
+        "Test that an expression belongs to the field of Hermitian operators.")
+    )
+
+
+class ComplexPredicate(Predicate):
+    """
+    Complex number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex(x)`` is true iff ``x`` belongs to the set of complex
+    numbers. Note that every complex number is finite.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Symbol, ask, I, oo
+    >>> x = Symbol('x')
+    >>> ask(Q.complex(0))
+    True
+    >>> ask(Q.complex(2 + 3*I))
+    True
+    >>> ask(Q.complex(oo))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_number
+
+    """
+    name = 'complex'
+    handler = Dispatcher(
+        "ComplexHandler",
+        doc=("Handler for Q.complex.\n\n"
+        "Test that an expression belongs to the field of complex numbers.")
+    )
+
+
+class ImaginaryPredicate(Predicate):
+    """
+    Imaginary number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.imaginary(x)`` is true iff ``x`` can be written as a real
+    number multiplied by the imaginary unit ``I``. Please note that ``0``
+    is not considered to be an imaginary number.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.imaginary(3*I))
+    True
+    >>> ask(Q.imaginary(2 + 3*I))
+    False
+    >>> ask(Q.imaginary(0))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Imaginary_number
+
+    """
+    name = 'imaginary'
+    handler = Dispatcher(
+        "ImaginaryHandler",
+        doc=("Handler for Q.imaginary.\n\n"
+        "Test that an expression belongs to the field of imaginary numbers,\n"
+        "that is, numbers in the form x*I, where x is real.")
+    )
+
+
+class AntihermitianPredicate(Predicate):
+    """
+    Antihermitian predicate.
+
+    Explanation
+    ===========
+
+    ``Q.antihermitian(x)`` is true iff ``x`` belongs to the field of
+    antihermitian operators, i.e., operators in the form ``x*I``, where
+    ``x`` is Hermitian.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'antihermitian'
+    handler = Dispatcher(
+        "AntiHermitianHandler",
+        doc=("Handler for Q.antihermitian.\n\n"
+        "Test that an expression belongs to the field of anti-Hermitian\n"
+        "operators, that is, operators in the form x*I, where x is Hermitian.")
+    )
+
+
+class AlgebraicPredicate(Predicate):
+    r"""
+    Algebraic number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.algebraic(x)`` is true iff ``x`` belongs to the set of
+    algebraic numbers. ``x`` is algebraic if there is some polynomial
+    in ``p(x)\in \mathbb\{Q\}[x]`` such that ``p(x) = 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, sqrt, I, pi
+    >>> ask(Q.algebraic(sqrt(2)))
+    True
+    >>> ask(Q.algebraic(I))
+    True
+    >>> ask(Q.algebraic(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Algebraic_number
+
+    """
+    name = 'algebraic'
+    AlgebraicHandler = Dispatcher(
+        "AlgebraicHandler",
+        doc="""Handler for Q.algebraic key."""
+    )
+
+
+class TranscendentalPredicate(Predicate):
+    """
+    Transcedental number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.transcendental(x)`` is true iff ``x`` belongs to the set of
+    transcendental numbers. A transcendental number is a real
+    or complex number that is not algebraic.
+
+    """
+    # TODO: Add examples
+    name = 'transcendental'
+    handler = Dispatcher(
+        "Transcendental",
+        doc="""Handler for Q.transcendental key."""
+    )
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/refine.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/refine.py
new file mode 100644
index 0000000000000000000000000000000000000000..c36a4e1cdb40f1b59a96f60a3b36182b587920fa
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/refine.py
@@ -0,0 +1,405 @@
+from __future__ import annotations
+from typing import Callable
+
+from sympy.core import S, Add, Expr, Basic, Mul, Pow, Rational
+from sympy.core.logic import fuzzy_not
+from sympy.logic.boolalg import Boolean
+
+from sympy.assumptions import ask, Q  # type: ignore
+
+
+def refine(expr, assumptions=True):
+    """
+    Simplify an expression using assumptions.
+
+    Explanation
+    ===========
+
+    Unlike :func:`~.simplify` which performs structural simplification
+    without any assumption, this function transforms the expression into
+    the form which is only valid under certain assumptions. Note that
+    ``simplify()`` is generally not done in refining process.
+
+    Refining boolean expression involves reducing it to ``S.true`` or
+    ``S.false``. Unlike :func:`~.ask`, the expression will not be reduced
+    if the truth value cannot be determined.
+
+    Examples
+    ========
+
+    >>> from sympy import refine, sqrt, Q
+    >>> from sympy.abc import x
+    >>> refine(sqrt(x**2), Q.real(x))
+    Abs(x)
+    >>> refine(sqrt(x**2), Q.positive(x))
+    x
+
+    >>> refine(Q.real(x), Q.positive(x))
+    True
+    >>> refine(Q.positive(x), Q.real(x))
+    Q.positive(x)
+
+    See Also
+    ========
+
+    sympy.simplify.simplify.simplify : Structural simplification without assumptions.
+    sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
+    """
+    if not isinstance(expr, Basic):
+        return expr
+
+    if not expr.is_Atom:
+        args = [refine(arg, assumptions) for arg in expr.args]
+        # TODO: this will probably not work with Integral or Polynomial
+        expr = expr.func(*args)
+    if hasattr(expr, '_eval_refine'):
+        ref_expr = expr._eval_refine(assumptions)
+        if ref_expr is not None:
+            return ref_expr
+    name = expr.__class__.__name__
+    handler = handlers_dict.get(name, None)
+    if handler is None:
+        return expr
+    new_expr = handler(expr, assumptions)
+    if (new_expr is None) or (expr == new_expr):
+        return expr
+    if not isinstance(new_expr, Expr):
+        return new_expr
+    return refine(new_expr, assumptions)
+
+
+def refine_abs(expr, assumptions):
+    """
+    Handler for the absolute value.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Abs
+    >>> from sympy.assumptions.refine import refine_abs
+    >>> from sympy.abc import x
+    >>> refine_abs(Abs(x), Q.real(x))
+    >>> refine_abs(Abs(x), Q.positive(x))
+    x
+    >>> refine_abs(Abs(x), Q.negative(x))
+    -x
+
+    """
+    from sympy.functions.elementary.complexes import Abs
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions) and \
+            fuzzy_not(ask(Q.negative(arg), assumptions)):
+        # if it's nonnegative
+        return arg
+    if ask(Q.negative(arg), assumptions):
+        return -arg
+    # arg is Mul
+    if isinstance(arg, Mul):
+        r = [refine(abs(a), assumptions) for a in arg.args]
+        non_abs = []
+        in_abs = []
+        for i in r:
+            if isinstance(i, Abs):
+                in_abs.append(i.args[0])
+            else:
+                non_abs.append(i)
+        return Mul(*non_abs) * Abs(Mul(*in_abs))
+
+
+def refine_Pow(expr, assumptions):
+    """
+    Handler for instances of Pow.
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.refine import refine_Pow
+    >>> from sympy.abc import x,y,z
+    >>> refine_Pow((-1)**x, Q.real(x))
+    >>> refine_Pow((-1)**x, Q.even(x))
+    1
+    >>> refine_Pow((-1)**x, Q.odd(x))
+    -1
+
+    For powers of -1, even parts of the exponent can be simplified:
+
+    >>> refine_Pow((-1)**(x+y), Q.even(x))
+    (-1)**y
+    >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z))
+    (-1)**y
+    >>> refine_Pow((-1)**(x+y+2), Q.odd(x))
+    (-1)**(y + 1)
+    >>> refine_Pow((-1)**(x+3), True)
+    (-1)**(x + 1)
+
+    """
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.functions import sign
+    if isinstance(expr.base, Abs):
+        if ask(Q.real(expr.base.args[0]), assumptions) and \
+                ask(Q.even(expr.exp), assumptions):
+            return expr.base.args[0] ** expr.exp
+    if ask(Q.real(expr.base), assumptions):
+        if expr.base.is_number:
+            if ask(Q.even(expr.exp), assumptions):
+                return abs(expr.base) ** expr.exp
+            if ask(Q.odd(expr.exp), assumptions):
+                return sign(expr.base) * abs(expr.base) ** expr.exp
+        if isinstance(expr.exp, Rational):
+            if isinstance(expr.base, Pow):
+                return abs(expr.base.base) ** (expr.base.exp * expr.exp)
+
+        if expr.base is S.NegativeOne:
+            if expr.exp.is_Add:
+
+                old = expr
+
+                # For powers of (-1) we can remove
+                #  - even terms
+                #  - pairs of odd terms
+                #  - a single odd term + 1
+                #  - A numerical constant N can be replaced with mod(N,2)
+
+                coeff, terms = expr.exp.as_coeff_add()
+                terms = set(terms)
+                even_terms = set()
+                odd_terms = set()
+                initial_number_of_terms = len(terms)
+
+                for t in terms:
+                    if ask(Q.even(t), assumptions):
+                        even_terms.add(t)
+                    elif ask(Q.odd(t), assumptions):
+                        odd_terms.add(t)
+
+                terms -= even_terms
+                if len(odd_terms) % 2:
+                    terms -= odd_terms
+                    new_coeff = (coeff + S.One) % 2
+                else:
+                    terms -= odd_terms
+                    new_coeff = coeff % 2
+
+                if new_coeff != coeff or len(terms) < initial_number_of_terms:
+                    terms.add(new_coeff)
+                    expr = expr.base**(Add(*terms))
+
+                # Handle (-1)**((-1)**n/2 + m/2)
+                e2 = 2*expr.exp
+                if ask(Q.even(e2), assumptions):
+                    if e2.could_extract_minus_sign():
+                        e2 *= expr.base
+                if e2.is_Add:
+                    i, p = e2.as_two_terms()
+                    if p.is_Pow and p.base is S.NegativeOne:
+                        if ask(Q.integer(p.exp), assumptions):
+                            i = (i + 1)/2
+                            if ask(Q.even(i), assumptions):
+                                return expr.base**p.exp
+                            elif ask(Q.odd(i), assumptions):
+                                return expr.base**(p.exp + 1)
+                            else:
+                                return expr.base**(p.exp + i)
+
+                if old != expr:
+                    return expr
+
+
+def refine_atan2(expr, assumptions):
+    """
+    Handler for the atan2 function.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, atan2
+    >>> from sympy.assumptions.refine import refine_atan2
+    >>> from sympy.abc import x, y
+    >>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x))
+    atan(y/x)
+    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x))
+    atan(y/x) - pi
+    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x))
+    atan(y/x) + pi
+    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
+    pi
+    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
+    pi/2
+    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
+    -pi/2
+    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
+    nan
+    """
+    from sympy.functions.elementary.trigonometric import atan
+    y, x = expr.args
+    if ask(Q.real(y) & Q.positive(x), assumptions):
+        return atan(y / x)
+    elif ask(Q.negative(y) & Q.negative(x), assumptions):
+        return atan(y / x) - S.Pi
+    elif ask(Q.positive(y) & Q.negative(x), assumptions):
+        return atan(y / x) + S.Pi
+    elif ask(Q.zero(y) & Q.negative(x), assumptions):
+        return S.Pi
+    elif ask(Q.positive(y) & Q.zero(x), assumptions):
+        return S.Pi/2
+    elif ask(Q.negative(y) & Q.zero(x), assumptions):
+        return -S.Pi/2
+    elif ask(Q.zero(y) & Q.zero(x), assumptions):
+        return S.NaN
+    else:
+        return expr
+
+
+def refine_re(expr, assumptions):
+    """
+    Handler for real part.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_re
+    >>> from sympy import Q, re
+    >>> from sympy.abc import x
+    >>> refine_re(re(x), Q.real(x))
+    x
+    >>> refine_re(re(x), Q.imaginary(x))
+    0
+    """
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions):
+        return arg
+    if ask(Q.imaginary(arg), assumptions):
+        return S.Zero
+    return _refine_reim(expr, assumptions)
+
+
+def refine_im(expr, assumptions):
+    """
+    Handler for imaginary part.
+
+    Explanation
+    ===========
+
+    >>> from sympy.assumptions.refine import refine_im
+    >>> from sympy import Q, im
+    >>> from sympy.abc import x
+    >>> refine_im(im(x), Q.real(x))
+    0
+    >>> refine_im(im(x), Q.imaginary(x))
+    -I*x
+    """
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions):
+        return S.Zero
+    if ask(Q.imaginary(arg), assumptions):
+        return - S.ImaginaryUnit * arg
+    return _refine_reim(expr, assumptions)
+
+def refine_arg(expr, assumptions):
+    """
+    Handler for complex argument
+
+    Explanation
+    ===========
+
+    >>> from sympy.assumptions.refine import refine_arg
+    >>> from sympy import Q, arg
+    >>> from sympy.abc import x
+    >>> refine_arg(arg(x), Q.positive(x))
+    0
+    >>> refine_arg(arg(x), Q.negative(x))
+    pi
+    """
+    rg = expr.args[0]
+    if ask(Q.positive(rg), assumptions):
+        return S.Zero
+    if ask(Q.negative(rg), assumptions):
+        return S.Pi
+    return None
+
+
+def _refine_reim(expr, assumptions):
+    # Helper function for refine_re & refine_im
+    expanded = expr.expand(complex = True)
+    if expanded != expr:
+        refined = refine(expanded, assumptions)
+        if refined != expanded:
+            return refined
+    # Best to leave the expression as is
+    return None
+
+
+def refine_sign(expr, assumptions):
+    """
+    Handler for sign.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_sign
+    >>> from sympy import Symbol, Q, sign, im
+    >>> x = Symbol('x', real = True)
+    >>> expr = sign(x)
+    >>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
+    1
+    >>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
+    -1
+    >>> refine_sign(expr, Q.zero(x))
+    0
+    >>> y = Symbol('y', imaginary = True)
+    >>> expr = sign(y)
+    >>> refine_sign(expr, Q.positive(im(y)))
+    I
+    >>> refine_sign(expr, Q.negative(im(y)))
+    -I
+    """
+    arg = expr.args[0]
+    if ask(Q.zero(arg), assumptions):
+        return S.Zero
+    if ask(Q.real(arg)):
+        if ask(Q.positive(arg), assumptions):
+            return S.One
+        if ask(Q.negative(arg), assumptions):
+            return S.NegativeOne
+    if ask(Q.imaginary(arg)):
+        arg_re, arg_im = arg.as_real_imag()
+        if ask(Q.positive(arg_im), assumptions):
+            return S.ImaginaryUnit
+        if ask(Q.negative(arg_im), assumptions):
+            return -S.ImaginaryUnit
+    return expr
+
+
+def refine_matrixelement(expr, assumptions):
+    """
+    Handler for symmetric part.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_matrixelement
+    >>> from sympy import MatrixSymbol, Q
+    >>> X = MatrixSymbol('X', 3, 3)
+    >>> refine_matrixelement(X[0, 1], Q.symmetric(X))
+    X[0, 1]
+    >>> refine_matrixelement(X[1, 0], Q.symmetric(X))
+    X[0, 1]
+    """
+    from sympy.matrices.expressions.matexpr import MatrixElement
+    matrix, i, j = expr.args
+    if ask(Q.symmetric(matrix), assumptions):
+        if (i - j).could_extract_minus_sign():
+            return expr
+        return MatrixElement(matrix, j, i)
+
+handlers_dict: dict[str, Callable[[Expr, Boolean], Expr]] = {
+    'Abs': refine_abs,
+    'Pow': refine_Pow,
+    'atan2': refine_atan2,
+    're': refine_re,
+    'im': refine_im,
+    'arg': refine_arg,
+    'sign': refine_sign,
+    'MatrixElement': refine_matrixelement
+}
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..04f5ed37893766feec941614691a9177f14e4027
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/__init__.py
@@ -0,0 +1,13 @@
+"""
+A module to implement finitary relations [1] as predicate.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Finitary_relation
+
+"""
+
+__all__ = ['BinaryRelation', 'AppliedBinaryRelation']
+
+from .binrel import BinaryRelation, AppliedBinaryRelation
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/binrel.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/binrel.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b4eba05bcce40f1a05483a30136b6ccd891c42f
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/binrel.py
@@ -0,0 +1,212 @@
+"""
+General binary relations.
+"""
+from typing import Optional
+
+from sympy.core.singleton import S
+from sympy.assumptions import AppliedPredicate, ask, Predicate, Q  # type: ignore
+from sympy.core.kind import BooleanKind
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.logic.boolalg import conjuncts, Not
+
+__all__ = ["BinaryRelation", "AppliedBinaryRelation"]
+
+
+class BinaryRelation(Predicate):
+    """
+    Base class for all binary relational predicates.
+
+    Explanation
+    ===========
+
+    Binary relation takes two arguments and returns ``AppliedBinaryRelation``
+    instance. To evaluate it to boolean value, use :obj:`~.ask()` or
+    :obj:`~.refine()` function.
+
+    You can add support for new types by registering the handler to dispatcher.
+    See :obj:`~.Predicate()` for more information about predicate dispatching.
+
+    Examples
+    ========
+
+    Applying and evaluating to boolean value:
+
+    >>> from sympy import Q, ask, sin, cos
+    >>> from sympy.abc import x
+    >>> Q.eq(sin(x)**2+cos(x)**2, 1)
+    Q.eq(sin(x)**2 + cos(x)**2, 1)
+    >>> ask(_)
+    True
+
+    You can define a new binary relation by subclassing and dispatching.
+    Here, we define a relation $R$ such that $x R y$ returns true if
+    $x = y + 1$.
+
+    >>> from sympy import ask, Number, Q
+    >>> from sympy.assumptions import BinaryRelation
+    >>> class MyRel(BinaryRelation):
+    ...     name = "R"
+    ...     is_reflexive = False
+    >>> Q.R = MyRel()
+    >>> @Q.R.register(Number, Number)
+    ... def _(n1, n2, assumptions):
+    ...     return ask(Q.zero(n1 - n2 - 1), assumptions)
+    >>> Q.R(2, 1)
+    Q.R(2, 1)
+
+    Now, we can use ``ask()`` to evaluate it to boolean value.
+
+    >>> ask(Q.R(2, 1))
+    True
+    >>> ask(Q.R(1, 2))
+    False
+
+    ``Q.R`` returns ``False`` with minimum cost if two arguments have same
+    structure because it is antireflexive relation [1] by
+    ``is_reflexive = False``.
+
+    >>> ask(Q.R(x, x))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Reflexive_relation
+    """
+
+    is_reflexive: Optional[bool] = None
+    is_symmetric: Optional[bool] = None
+
+    def __call__(self, *args):
+        if not len(args) == 2:
+            raise ValueError("Binary relation takes two arguments, but got %s." % len(args))
+        return AppliedBinaryRelation(self, *args)
+
+    @property
+    def reversed(self):
+        if self.is_symmetric:
+            return self
+        return None
+
+    @property
+    def negated(self):
+        return None
+
+    def _compare_reflexive(self, lhs, rhs):
+        # quick exit for structurally same arguments
+        # do not check != here because it cannot catch the
+        # equivalent arguments with different structures.
+
+        # reflexivity does not hold to NaN
+        if lhs is S.NaN or rhs is S.NaN:
+            return None
+
+        reflexive = self.is_reflexive
+        if reflexive is None:
+            pass
+        elif reflexive and (lhs == rhs):
+            return True
+        elif not reflexive and (lhs == rhs):
+            return False
+        return None
+
+    def eval(self, args, assumptions=True):
+        # quick exit for structurally same arguments
+        ret = self._compare_reflexive(*args)
+        if ret is not None:
+            return ret
+
+        # don't perform simplify on args here. (done by AppliedBinaryRelation._eval_ask)
+        # evaluate by multipledispatch
+        lhs, rhs = args
+        ret = self.handler(lhs, rhs, assumptions=assumptions)
+        if ret is not None:
+            return ret
+
+        # check reversed order if the relation is reflexive
+        if self.is_reflexive:
+            types = (type(lhs), type(rhs))
+            if self.handler.dispatch(*types) is not self.handler.dispatch(*reversed(types)):
+                ret = self.handler(rhs, lhs, assumptions=assumptions)
+
+        return ret
+
+
+class AppliedBinaryRelation(AppliedPredicate):
+    """
+    The class of expressions resulting from applying ``BinaryRelation``
+    to the arguments.
+
+    """
+
+    @property
+    def lhs(self):
+        """The left-hand side of the relation."""
+        return self.arguments[0]
+
+    @property
+    def rhs(self):
+        """The right-hand side of the relation."""
+        return self.arguments[1]
+
+    @property
+    def reversed(self):
+        """
+        Try to return the relationship with sides reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        return revfunc(self.rhs, self.lhs)
+
+    @property
+    def reversedsign(self):
+        """
+        Try to return the relationship with signs reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        if not any(side.kind is BooleanKind for side in self.arguments):
+            return revfunc(-self.lhs, -self.rhs)
+        return self
+
+    @property
+    def negated(self):
+        neg_rel = self.function.negated
+        if neg_rel is None:
+            return Not(self, evaluate=False)
+        return neg_rel(*self.arguments)
+
+    def _eval_ask(self, assumptions):
+        conj_assumps = set()
+        binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+        for a in conjuncts(assumptions):
+            if a.func in binrelpreds:
+                conj_assumps.add(binrelpreds[type(a)](*a.args))
+            else:
+                conj_assumps.add(a)
+
+        # After CNF in assumptions module is modified to take polyadic
+        # predicate, this will be removed
+        if any(rel in conj_assumps for rel in (self, self.reversed)):
+            return True
+        neg_rels = (self.negated, self.reversed.negated, Not(self, evaluate=False),
+            Not(self.reversed, evaluate=False))
+        if any(rel in conj_assumps for rel in neg_rels):
+            return False
+
+        # evaluation using multipledispatching
+        ret = self.function.eval(self.arguments, assumptions)
+        if ret is not None:
+            return ret
+
+        # simplify the args and try again
+        args = tuple(a.simplify() for a in self.arguments)
+        return self.function.eval(args, assumptions)
+
+    def __bool__(self):
+        ret = ask(self)
+        if ret is None:
+            raise TypeError("Cannot determine truth value of %s" % self)
+        return ret
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/equality.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..d467cea2da706de2cbbc9875f93c7f8e324a9088
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/relation/equality.py
@@ -0,0 +1,302 @@
+"""
+Module for mathematical equality [1] and inequalities [2].
+
+The purpose of this module is to provide the instances which represent the
+binary predicates in order to combine the relationals into logical inference
+system. Objects such as ``Q.eq``, ``Q.lt`` should remain internal to
+assumptions module, and user must use the classes such as :obj:`~.Eq()`,
+:obj:`~.Lt()` instead to construct the relational expressions.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Equality_(mathematics)
+.. [2] https://en.wikipedia.org/wiki/Inequality_(mathematics)
+"""
+from sympy.assumptions import Q
+from sympy.core.relational import is_eq, is_neq, is_gt, is_ge, is_lt, is_le
+
+from .binrel import BinaryRelation
+
+__all__ = ['EqualityPredicate', 'UnequalityPredicate', 'StrictGreaterThanPredicate',
+    'GreaterThanPredicate', 'StrictLessThanPredicate', 'LessThanPredicate']
+
+
+class EqualityPredicate(BinaryRelation):
+    """
+    Binary predicate for $=$.
+
+    The purpose of this class is to provide the instance which represent
+    the equality predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Eq()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_eq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.eq(0, 0)
+    Q.eq(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Eq
+
+    """
+    is_reflexive = True
+    is_symmetric = True
+
+    name = 'eq'
+    handler = None  # Do not allow dispatching by this predicate
+
+    @property
+    def negated(self):
+        return Q.ne
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_eq is None
+            assumptions = None
+        return is_eq(*args, assumptions)
+
+
+class UnequalityPredicate(BinaryRelation):
+    r"""
+    Binary predicate for $\neq$.
+
+    The purpose of this class is to provide the instance which represent
+    the inequation predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ne()` instead to construct the inequation expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_neq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ne(0, 0)
+    Q.ne(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Ne
+
+    """
+    is_reflexive = False
+    is_symmetric = True
+
+    name = 'ne'
+    handler = None
+
+    @property
+    def negated(self):
+        return Q.eq
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_neq is None
+            assumptions = None
+        return is_neq(*args, assumptions)
+
+
+class StrictGreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Gt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_gt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.gt(0, 0)
+    Q.gt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Gt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'gt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.lt
+
+    @property
+    def negated(self):
+        return Q.le
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_gt is None
+            assumptions = None
+        return is_gt(*args, assumptions)
+
+
+class GreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>=$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ge()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_ge`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ge(0, 0)
+    Q.ge(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Ge
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'ge'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.le
+
+    @property
+    def negated(self):
+        return Q.lt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_ge is None
+            assumptions = None
+        return is_ge(*args, assumptions)
+
+
+class StrictLessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Lt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_lt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.lt(0, 0)
+    Q.lt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Lt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'lt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.gt
+
+    @property
+    def negated(self):
+        return Q.ge
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_lt is None
+            assumptions = None
+        return is_lt(*args, assumptions)
+
+
+class LessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<=$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Le()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_le`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.le(0, 0)
+    Q.le(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Le
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'le'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.ge
+
+    @property
+    def negated(self):
+        return Q.gt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_le is None
+            assumptions = None
+        return is_le(*args, assumptions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/satask.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffc13f6d3bc3fb7f573c8d5d0564b780440c1a8c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/satask.py
@@ -0,0 +1,369 @@
+"""
+Module to evaluate the proposition with assumptions using SAT algorithm.
+"""
+
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.kind import NumberKind, UndefinedKind
+from sympy.assumptions.ask_generated import get_all_known_matrix_facts, get_all_known_number_facts
+from sympy.assumptions.assume import global_assumptions, AppliedPredicate
+from sympy.assumptions.sathandlers import class_fact_registry
+from sympy.core import oo
+from sympy.logic.inference import satisfiable
+from sympy.assumptions.cnf import CNF, EncodedCNF
+from sympy.matrices.kind import MatrixKind
+
+
+def satask(proposition, assumptions=True, context=global_assumptions,
+        use_known_facts=True, iterations=oo):
+    """
+    Function to evaluate the proposition with assumptions using SAT algorithm.
+
+    This function extracts every fact relevant to the expressions composing
+    proposition and assumptions. For example, if a predicate containing
+    ``Abs(x)`` is proposed, then ``Q.zero(Abs(x)) | Q.positive(Abs(x))``
+    will be found and passed to SAT solver because ``Q.nonnegative`` is
+    registered as a fact for ``Abs``.
+
+    Proposition is evaluated to ``True`` or ``False`` if the truth value can be
+    determined. If not, ``None`` is returned.
+
+    Parameters
+    ==========
+
+    proposition : Any boolean expression.
+        Proposition which will be evaluated to boolean value.
+
+    assumptions : Any boolean expression, optional.
+        Local assumptions to evaluate the *proposition*.
+
+    context : AssumptionsContext, optional.
+        Default assumptions to evaluate the *proposition*. By default,
+        this is ``sympy.assumptions.global_assumptions`` variable.
+
+    use_known_facts : bool, optional.
+        If ``True``, facts from ``sympy.assumptions.ask_generated``
+        module are passed to SAT solver as well.
+
+    iterations : int, optional.
+        Number of times that relevant facts are recursively extracted.
+        Default is infinite times until no new fact is found.
+
+    Returns
+    =======
+
+    ``True``, ``False``, or ``None``
+
+    Examples
+    ========
+
+    >>> from sympy import Abs, Q
+    >>> from sympy.assumptions.satask import satask
+    >>> from sympy.abc import x
+    >>> satask(Q.zero(Abs(x)), Q.zero(x))
+    True
+
+    """
+    props = CNF.from_prop(proposition)
+    _props = CNF.from_prop(~proposition)
+
+    assumptions = CNF.from_prop(assumptions)
+
+    context_cnf = CNF()
+    if context:
+        context_cnf = context_cnf.extend(context)
+
+    sat = get_all_relevant_facts(props, assumptions, context_cnf,
+        use_known_facts=use_known_facts, iterations=iterations)
+    sat.add_from_cnf(assumptions)
+    if context:
+        sat.add_from_cnf(context_cnf)
+
+    return check_satisfiability(props, _props, sat)
+
+
+def check_satisfiability(prop, _prop, factbase):
+    sat_true = factbase.copy()
+    sat_false = factbase.copy()
+    sat_true.add_from_cnf(prop)
+    sat_false.add_from_cnf(_prop)
+    can_be_true = satisfiable(sat_true)
+    can_be_false = satisfiable(sat_false)
+
+    if can_be_true and can_be_false:
+        return None
+
+    if can_be_true and not can_be_false:
+        return True
+
+    if not can_be_true and can_be_false:
+        return False
+
+    if not can_be_true and not can_be_false:
+        # TODO: Run additional checks to see which combination of the
+        # assumptions, global_assumptions, and relevant_facts are
+        # inconsistent.
+        raise ValueError("Inconsistent assumptions")
+
+
+def extract_predargs(proposition, assumptions=None, context=None):
+    """
+    Extract every expression in the argument of predicates from *proposition*,
+    *assumptions* and *context*.
+
+    Parameters
+    ==========
+
+    proposition : sympy.assumptions.cnf.CNF
+
+    assumptions : sympy.assumptions.cnf.CNF, optional.
+
+    context : sympy.assumptions.cnf.CNF, optional.
+        CNF generated from assumptions context.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Abs
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.satask import extract_predargs
+    >>> from sympy.abc import x, y
+    >>> props = CNF.from_prop(Q.zero(Abs(x*y)))
+    >>> assump = CNF.from_prop(Q.zero(x) & Q.zero(y))
+    >>> extract_predargs(props, assump)
+    {x, y, Abs(x*y)}
+
+    """
+    req_keys = find_symbols(proposition)
+    keys = proposition.all_predicates()
+    # XXX: We need this since True/False are not Basic
+    lkeys = set()
+    if assumptions:
+        lkeys |= assumptions.all_predicates()
+    if context:
+        lkeys |= context.all_predicates()
+
+    lkeys = lkeys - {S.true, S.false}
+    tmp_keys = None
+    while tmp_keys != set():
+        tmp = set()
+        for l in lkeys:
+            syms = find_symbols(l)
+            if (syms & req_keys) != set():
+                tmp |= syms
+        tmp_keys = tmp - req_keys
+        req_keys |= tmp_keys
+    keys |= {l for l in lkeys if find_symbols(l) & req_keys != set()}
+
+    exprs = set()
+    for key in keys:
+        if isinstance(key, AppliedPredicate):
+            exprs |= set(key.arguments)
+        else:
+            exprs.add(key)
+    return exprs
+
+def find_symbols(pred):
+    """
+    Find every :obj:`~.Symbol` in *pred*.
+
+    Parameters
+    ==========
+
+    pred : sympy.assumptions.cnf.CNF, or any Expr.
+
+    """
+    if isinstance(pred, CNF):
+        symbols = set()
+        for a in pred.all_predicates():
+            symbols |= find_symbols(a)
+        return symbols
+    return pred.atoms(Symbol)
+
+
+def get_relevant_clsfacts(exprs, relevant_facts=None):
+    """
+    Extract relevant facts from the items in *exprs*. Facts are defined in
+    ``assumptions.sathandlers`` module.
+
+    This function is recursively called by ``get_all_relevant_facts()``.
+
+    Parameters
+    ==========
+
+    exprs : set
+        Expressions whose relevant facts are searched.
+
+    relevant_facts : sympy.assumptions.cnf.CNF, optional.
+        Pre-discovered relevant facts.
+
+    Returns
+    =======
+
+    exprs : set
+        Candidates for next relevant fact searching.
+
+    relevant_facts : sympy.assumptions.cnf.CNF
+        Updated relevant facts.
+
+    Examples
+    ========
+
+    Here, we will see how facts relevant to ``Abs(x*y)`` are recursively
+    extracted. On the first run, set containing the expression is passed
+    without pre-discovered relevant facts. The result is a set containing
+    candidates for next run, and ``CNF()`` instance containing facts
+    which are relevant to ``Abs`` and its argument.
+
+    >>> from sympy import Abs
+    >>> from sympy.assumptions.satask import get_relevant_clsfacts
+    >>> from sympy.abc import x, y
+    >>> exprs = {Abs(x*y)}
+    >>> exprs, facts = get_relevant_clsfacts(exprs)
+    >>> exprs
+    {x*y}
+    >>> facts.clauses #doctest: +SKIP
+    {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
+    frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
+    frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False),
+                Literal(Q.odd(Abs(x*y)), False),
+                Literal(Q.odd(x*y), True)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False),
+                Literal(Q.even(x*y), True),
+                Literal(Q.odd(Abs(x*y)), False)}),
+    frozenset({Literal(Q.positive(Abs(x*y)), False),
+                Literal(Q.zero(Abs(x*y)), False)})}
+
+    We pass the first run's results to the second run, and get the expressions
+    for next run and updated facts.
+
+    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
+    >>> exprs
+    {x, y}
+
+    On final run, no more candidate is returned thus we know that all
+    relevant facts are successfully retrieved.
+
+    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
+    >>> exprs
+    set()
+
+    """
+    if not relevant_facts:
+        relevant_facts = CNF()
+
+    newexprs = set()
+    for expr in exprs:
+        for fact in class_fact_registry(expr):
+            newfact = CNF.to_CNF(fact)
+            relevant_facts = relevant_facts._and(newfact)
+            for key in newfact.all_predicates():
+                if isinstance(key, AppliedPredicate):
+                    newexprs |= set(key.arguments)
+
+    return newexprs - exprs, relevant_facts
+
+
+def get_all_relevant_facts(proposition, assumptions, context,
+        use_known_facts=True, iterations=oo):
+    """
+    Extract all relevant facts from *proposition* and *assumptions*.
+
+    This function extracts the facts by recursively calling
+    ``get_relevant_clsfacts()``. Extracted facts are converted to
+    ``EncodedCNF`` and returned.
+
+    Parameters
+    ==========
+
+    proposition : sympy.assumptions.cnf.CNF
+        CNF generated from proposition expression.
+
+    assumptions : sympy.assumptions.cnf.CNF
+        CNF generated from assumption expression.
+
+    context : sympy.assumptions.cnf.CNF
+        CNF generated from assumptions context.
+
+    use_known_facts : bool, optional.
+        If ``True``, facts from ``sympy.assumptions.ask_generated``
+        module are encoded as well.
+
+    iterations : int, optional.
+        Number of times that relevant facts are recursively extracted.
+        Default is infinite times until no new fact is found.
+
+    Returns
+    =======
+
+    sympy.assumptions.cnf.EncodedCNF
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.satask import get_all_relevant_facts
+    >>> from sympy.abc import x, y
+    >>> props = CNF.from_prop(Q.nonzero(x*y))
+    >>> assump = CNF.from_prop(Q.nonzero(x))
+    >>> context = CNF.from_prop(Q.nonzero(y))
+    >>> get_all_relevant_facts(props, assump, context) #doctest: +SKIP
+    <sympy.assumptions.cnf.EncodedCNF at 0x7f09faa6ccd0>
+
+    """
+    # The relevant facts might introduce new keys, e.g., Q.zero(x*y) will
+    # introduce the keys Q.zero(x) and Q.zero(y), so we need to run it until
+    # we stop getting new things. Hopefully this strategy won't lead to an
+    # infinite loop in the future.
+    i = 0
+    relevant_facts = CNF()
+    all_exprs = set()
+    while True:
+        if i == 0:
+            exprs = extract_predargs(proposition, assumptions, context)
+        all_exprs |= exprs
+        exprs, relevant_facts = get_relevant_clsfacts(exprs, relevant_facts)
+        i += 1
+        if i >= iterations:
+            break
+        if not exprs:
+            break
+
+    if use_known_facts:
+        known_facts_CNF = CNF()
+
+        if any(expr.kind == MatrixKind(NumberKind) for expr in all_exprs):
+            known_facts_CNF.add_clauses(get_all_known_matrix_facts())
+        # check for undefinedKind since kind system isn't fully implemented
+        if any(((expr.kind == NumberKind) or (expr.kind == UndefinedKind)) for expr in all_exprs):
+            known_facts_CNF.add_clauses(get_all_known_number_facts())
+
+        kf_encoded = EncodedCNF()
+        kf_encoded.from_cnf(known_facts_CNF)
+
+        def translate_literal(lit, delta):
+            if lit > 0:
+                return lit + delta
+            else:
+                return lit - delta
+
+        def translate_data(data, delta):
+            return [{translate_literal(i, delta) for i in clause} for clause in data]
+        data = []
+        symbols = []
+        n_lit = len(kf_encoded.symbols)
+        for i, expr in enumerate(all_exprs):
+            symbols += [pred(expr) for pred in kf_encoded.symbols]
+            data += translate_data(kf_encoded.data, i * n_lit)
+
+        encoding = dict(list(zip(symbols, range(1, len(symbols)+1))))
+        ctx = EncodedCNF(data, encoding)
+    else:
+        ctx = EncodedCNF()
+
+    ctx.add_from_cnf(relevant_facts)
+
+    return ctx
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/sathandlers.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/sathandlers.py
new file mode 100644
index 0000000000000000000000000000000000000000..a11199eb0e547187ab280c18196c0259c178e004
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/sathandlers.py
@@ -0,0 +1,322 @@
+from collections import defaultdict
+
+from sympy.assumptions.ask import Q
+from sympy.core import (Add, Mul, Pow, Number, NumberSymbol, Symbol)
+from sympy.core.numbers import ImaginaryUnit
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic.boolalg import (Equivalent, And, Or, Implies)
+from sympy.matrices.expressions import MatMul
+
+# APIs here may be subject to change
+
+
+### Helper functions ###
+
+def allargs(symbol, fact, expr):
+    """
+    Apply all arguments of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import allargs
+    >>> from sympy.abc import x, y
+    >>> allargs(x, Q.negative(x) | Q.positive(x), x*y)
+    (Q.negative(x) | Q.positive(x)) & (Q.negative(y) | Q.positive(y))
+
+    """
+    return And(*[fact.subs(symbol, arg) for arg in expr.args])
+
+
+def anyarg(symbol, fact, expr):
+    """
+    Apply any argument of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import anyarg
+    >>> from sympy.abc import x, y
+    >>> anyarg(x, Q.negative(x) & Q.positive(x), x*y)
+    (Q.negative(x) & Q.positive(x)) | (Q.negative(y) & Q.positive(y))
+
+    """
+    return Or(*[fact.subs(symbol, arg) for arg in expr.args])
+
+
+def exactlyonearg(symbol, fact, expr):
+    """
+    Apply exactly one argument of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import exactlyonearg
+    >>> from sympy.abc import x, y
+    >>> exactlyonearg(x, Q.positive(x), x*y)
+    (Q.positive(x) & ~Q.positive(y)) | (Q.positive(y) & ~Q.positive(x))
+
+    """
+    pred_args = [fact.subs(symbol, arg) for arg in expr.args]
+    res = Or(*[And(pred_args[i], *[~lit for lit in pred_args[:i] +
+        pred_args[i+1:]]) for i in range(len(pred_args))])
+    return res
+
+
+### Fact registry ###
+
+class ClassFactRegistry:
+    """
+    Register handlers against classes.
+
+    Explanation
+    ===========
+
+    ``register`` method registers the handler function for a class. Here,
+    handler function should return a single fact. ``multiregister`` method
+    registers the handler function for multiple classes. Here, handler function
+    should return a container of multiple facts.
+
+    ``registry(expr)`` returns a set of facts for *expr*.
+
+    Examples
+    ========
+
+    Here, we register the facts for ``Abs``.
+
+    >>> from sympy import Abs, Equivalent, Q
+    >>> from sympy.assumptions.sathandlers import ClassFactRegistry
+    >>> reg = ClassFactRegistry()
+    >>> @reg.register(Abs)
+    ... def f1(expr):
+    ...     return Q.nonnegative(expr)
+    >>> @reg.register(Abs)
+    ... def f2(expr):
+    ...     arg = expr.args[0]
+    ...     return Equivalent(~Q.zero(arg), ~Q.zero(expr))
+
+    Calling the registry with expression returns the defined facts for the
+    expression.
+
+    >>> from sympy.abc import x
+    >>> reg(Abs(x))
+    {Q.nonnegative(Abs(x)), Equivalent(~Q.zero(x), ~Q.zero(Abs(x)))}
+
+    Multiple facts can be registered at once by ``multiregister`` method.
+
+    >>> reg2 = ClassFactRegistry()
+    >>> @reg2.multiregister(Abs)
+    ... def _(expr):
+    ...     arg = expr.args[0]
+    ...     return [Q.even(arg) >> Q.even(expr), Q.odd(arg) >> Q.odd(expr)]
+    >>> reg2(Abs(x))
+    {Implies(Q.even(x), Q.even(Abs(x))), Implies(Q.odd(x), Q.odd(Abs(x)))}
+
+    """
+    def __init__(self):
+        self.singlefacts = defaultdict(frozenset)
+        self.multifacts = defaultdict(frozenset)
+
+    def register(self, cls):
+        def _(func):
+            self.singlefacts[cls] |= {func}
+            return func
+        return _
+
+    def multiregister(self, *classes):
+        def _(func):
+            for cls in classes:
+                self.multifacts[cls] |= {func}
+            return func
+        return _
+
+    def __getitem__(self, key):
+        ret1 = self.singlefacts[key]
+        for k in self.singlefacts:
+            if issubclass(key, k):
+                ret1 |= self.singlefacts[k]
+
+        ret2 = self.multifacts[key]
+        for k in self.multifacts:
+            if issubclass(key, k):
+                ret2 |= self.multifacts[k]
+
+        return ret1, ret2
+
+    def __call__(self, expr):
+        ret = set()
+
+        handlers1, handlers2 = self[type(expr)]
+
+        ret.update(h(expr) for h in handlers1)
+        for h in handlers2:
+            ret.update(h(expr))
+        return ret
+
+class_fact_registry = ClassFactRegistry()
+
+
+
+### Class fact registration ###
+
+x = Symbol('x')
+
+## Abs ##
+
+@class_fact_registry.multiregister(Abs)
+def _(expr):
+    arg = expr.args[0]
+    return [Q.nonnegative(expr),
+            Equivalent(~Q.zero(arg), ~Q.zero(expr)),
+            Q.even(arg) >> Q.even(expr),
+            Q.odd(arg) >> Q.odd(expr),
+            Q.integer(arg) >> Q.integer(expr),
+            ]
+
+
+### Add ##
+
+@class_fact_registry.multiregister(Add)
+def _(expr):
+    return [allargs(x, Q.positive(x), expr) >> Q.positive(expr),
+            allargs(x, Q.negative(x), expr) >> Q.negative(expr),
+            allargs(x, Q.real(x), expr) >> Q.real(expr),
+            allargs(x, Q.rational(x), expr) >> Q.rational(expr),
+            allargs(x, Q.integer(x), expr) >> Q.integer(expr),
+            exactlyonearg(x, ~Q.integer(x), expr) >> ~Q.integer(expr),
+            ]
+
+@class_fact_registry.register(Add)
+def _(expr):
+    allargs_real = allargs(x, Q.real(x), expr)
+    onearg_irrational = exactlyonearg(x, Q.irrational(x), expr)
+    return Implies(allargs_real, Implies(onearg_irrational, Q.irrational(expr)))
+
+
+### Mul ###
+
+@class_fact_registry.multiregister(Mul)
+def _(expr):
+    return [Equivalent(Q.zero(expr), anyarg(x, Q.zero(x), expr)),
+            allargs(x, Q.positive(x), expr) >> Q.positive(expr),
+            allargs(x, Q.real(x), expr) >> Q.real(expr),
+            allargs(x, Q.rational(x), expr) >> Q.rational(expr),
+            allargs(x, Q.integer(x), expr) >> Q.integer(expr),
+            exactlyonearg(x, ~Q.rational(x), expr) >> ~Q.integer(expr),
+            allargs(x, Q.commutative(x), expr) >> Q.commutative(expr),
+            ]
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # Implicitly assumes Mul has more than one arg
+    # Would be allargs(x, Q.prime(x) | Q.composite(x)) except 1 is composite
+    # More advanced prime assumptions will require inequalities, as 1 provides
+    # a corner case.
+    allargs_prime = allargs(x, Q.prime(x), expr)
+    return Implies(allargs_prime, ~Q.prime(expr))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # General Case: Odd number of imaginary args implies mul is imaginary(To be implemented)
+    allargs_imag_or_real = allargs(x, Q.imaginary(x) | Q.real(x), expr)
+    onearg_imaginary = exactlyonearg(x, Q.imaginary(x), expr)
+    return Implies(allargs_imag_or_real, Implies(onearg_imaginary, Q.imaginary(expr)))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    allargs_real = allargs(x, Q.real(x), expr)
+    onearg_irrational = exactlyonearg(x, Q.irrational(x), expr)
+    return Implies(allargs_real, Implies(onearg_irrational, Q.irrational(expr)))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # Including the integer qualification means we don't need to add any facts
+    # for odd, since the assumptions already know that every integer is
+    # exactly one of even or odd.
+    allargs_integer = allargs(x, Q.integer(x), expr)
+    anyarg_even = anyarg(x, Q.even(x), expr)
+    return Implies(allargs_integer, Equivalent(anyarg_even, Q.even(expr)))
+
+
+### MatMul ###
+
+@class_fact_registry.register(MatMul)
+def _(expr):
+    allargs_square = allargs(x, Q.square(x), expr)
+    allargs_invertible = allargs(x, Q.invertible(x), expr)
+    return Implies(allargs_square, Equivalent(Q.invertible(expr), allargs_invertible))
+
+
+### Pow ###
+
+@class_fact_registry.multiregister(Pow)
+def _(expr):
+    base, exp = expr.base, expr.exp
+    return [
+        (Q.real(base) & Q.even(exp) & Q.nonnegative(exp)) >> Q.nonnegative(expr),
+        (Q.nonnegative(base) & Q.odd(exp) & Q.nonnegative(exp)) >> Q.nonnegative(expr),
+        (Q.nonpositive(base) & Q.odd(exp) & Q.nonnegative(exp)) >> Q.nonpositive(expr),
+        Equivalent(Q.zero(expr), Q.zero(base) & Q.positive(exp))
+    ]
+
+
+### Numbers ###
+
+_old_assump_getters = {
+    Q.positive: lambda o: o.is_positive,
+    Q.zero: lambda o: o.is_zero,
+    Q.negative: lambda o: o.is_negative,
+    Q.rational: lambda o: o.is_rational,
+    Q.irrational: lambda o: o.is_irrational,
+    Q.even: lambda o: o.is_even,
+    Q.odd: lambda o: o.is_odd,
+    Q.imaginary: lambda o: o.is_imaginary,
+    Q.prime: lambda o: o.is_prime,
+    Q.composite: lambda o: o.is_composite,
+}
+
+@class_fact_registry.multiregister(Number, NumberSymbol, ImaginaryUnit)
+def _(expr):
+    ret = []
+    for p, getter in _old_assump_getters.items():
+        pred = p(expr)
+        prop = getter(expr)
+        if prop is not None:
+            ret.append(Equivalent(pred, prop))
+    return ret
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_assumptions_2.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_assumptions_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..493fe4a7ed70301754ad2cfe181c5acf30433768
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_assumptions_2.py
@@ -0,0 +1,35 @@
+"""
+rename this to test_assumptions.py when the old assumptions system is deleted
+"""
+from sympy.abc import x, y
+from sympy.assumptions.assume import global_assumptions
+from sympy.assumptions.ask import Q
+from sympy.printing import pretty
+
+
+def test_equal():
+    """Test for equality"""
+    assert Q.positive(x) == Q.positive(x)
+    assert Q.positive(x) != ~Q.positive(x)
+    assert ~Q.positive(x) == ~Q.positive(x)
+
+
+def test_pretty():
+    assert pretty(Q.positive(x)) == "Q.positive(x)"
+    assert pretty(
+        {Q.positive, Q.integer}) == "{Q.integer, Q.positive}"
+
+
+def test_global():
+    """Test for global assumptions"""
+    global_assumptions.add(x > 0)
+    assert (x > 0) in global_assumptions
+    global_assumptions.remove(x > 0)
+    assert not (x > 0) in global_assumptions
+    # same with multiple of assumptions
+    global_assumptions.add(x > 0, y > 0)
+    assert (x > 0) in global_assumptions
+    assert (y > 0) in global_assumptions
+    global_assumptions.clear()
+    assert not (x > 0) in global_assumptions
+    assert not (y > 0) in global_assumptions
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_context.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_context.py
new file mode 100644
index 0000000000000000000000000000000000000000..be162f1c69492218ff90ea69492925d7779567a4
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_context.py
@@ -0,0 +1,39 @@
+from sympy.assumptions import ask, Q
+from sympy.assumptions.assume import assuming, global_assumptions
+from sympy.abc import x, y
+
+def test_assuming():
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+    assert not ask(Q.integer(x))
+
+def test_assuming_nested():
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+        with assuming(Q.integer(y)):
+            assert ask(Q.integer(x))
+            assert ask(Q.integer(y))
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+
+def test_finally():
+    try:
+        with assuming(Q.integer(x)):
+            1/0
+    except ZeroDivisionError:
+        pass
+    assert not ask(Q.integer(x))
+
+def test_remove_safe():
+    global_assumptions.add(Q.integer(x))
+    with assuming():
+        assert ask(Q.integer(x))
+        global_assumptions.remove(Q.integer(x))
+        assert not ask(Q.integer(x))
+    assert ask(Q.integer(x))
+    global_assumptions.clear() # for the benefit of other tests
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_matrices.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bfa990f080eebe4d6dd5bfdd733ce1a19adf329
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_matrices.py
@@ -0,0 +1,283 @@
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.symbol import Symbol
+from sympy.matrices.expressions.diagonal import (DiagMatrix, DiagonalMatrix)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import (MatrixSymbol, Identity, ZeroMatrix,
+        OneMatrix, Trace, MatrixSlice, Determinant, BlockMatrix, BlockDiagMatrix)
+from sympy.matrices.expressions.factorizations import LofLU
+from sympy.testing.pytest import XFAIL
+
+X = MatrixSymbol('X', 2, 2)
+Y = MatrixSymbol('Y', 2, 3)
+Z = MatrixSymbol('Z', 2, 2)
+A1x1 = MatrixSymbol('A1x1', 1, 1)
+B1x1 = MatrixSymbol('B1x1', 1, 1)
+C0x0 = MatrixSymbol('C0x0', 0, 0)
+V1 = MatrixSymbol('V1', 2, 1)
+V2 = MatrixSymbol('V2', 2, 1)
+
+def test_square():
+    assert ask(Q.square(X))
+    assert not ask(Q.square(Y))
+    assert ask(Q.square(Y*Y.T))
+
+def test_invertible():
+    assert ask(Q.invertible(X), Q.invertible(X))
+    assert ask(Q.invertible(Y)) is False
+    assert ask(Q.invertible(X*Y), Q.invertible(X)) is False
+    assert ask(Q.invertible(X*Z), Q.invertible(X)) is None
+    assert ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z)) is True
+    assert ask(Q.invertible(X.T)) is None
+    assert ask(Q.invertible(X.T), Q.invertible(X)) is True
+    assert ask(Q.invertible(X.I)) is True
+    assert ask(Q.invertible(Identity(3))) is True
+    assert ask(Q.invertible(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(OneMatrix(1, 1))) is True
+    assert ask(Q.invertible(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+
+def test_singular():
+    assert ask(Q.singular(X)) is None
+    assert ask(Q.singular(X), Q.invertible(X)) is False
+    assert ask(Q.singular(X), ~Q.invertible(X)) is True
+
+@XFAIL
+def test_invertible_fullrank():
+    assert ask(Q.invertible(X), Q.fullrank(X)) is True
+
+
+def test_invertible_BlockMatrix():
+    assert ask(Q.invertible(BlockMatrix([Identity(3)]))) == True
+    assert ask(Q.invertible(BlockMatrix([ZeroMatrix(3, 3)]))) == False
+
+    X = Matrix([[1, 2, 3], [3, 5, 4]])
+    Y = Matrix([[4, 2, 7], [2, 3, 5]])
+    # non-invertible A block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.ones(3, 3), Y.T],
+        [X, Matrix.eye(2)],
+    ]))) == True
+    # non-invertible B block
+    assert ask(Q.invertible(BlockMatrix([
+        [Y.T, Matrix.ones(3, 3)],
+        [Matrix.eye(2), X],
+    ]))) == True
+    # non-invertible C block
+    assert ask(Q.invertible(BlockMatrix([
+        [X, Matrix.eye(2)],
+        [Matrix.ones(3, 3), Y.T],
+    ]))) == True
+    # non-invertible D block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.eye(2), X],
+        [Y.T, Matrix.ones(3, 3)],
+    ]))) == True
+
+
+def test_invertible_BlockDiagMatrix():
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), Identity(5)))) == True
+    assert ask(Q.invertible(BlockDiagMatrix(ZeroMatrix(3, 3), Identity(5)))) == False
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), OneMatrix(5, 5)))) == False
+
+
+def test_symmetric():
+    assert ask(Q.symmetric(X), Q.symmetric(X))
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X)) is None
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(Y)) is False
+    assert ask(Q.symmetric(Y*Y.T)) is True
+    assert ask(Q.symmetric(Y.T*X*Y)) is None
+    assert ask(Q.symmetric(Y.T*X*Y), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(X**10), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(A1x1)) is True
+    assert ask(Q.symmetric(A1x1 + B1x1)) is True
+    assert ask(Q.symmetric(A1x1 * B1x1)) is True
+    assert ask(Q.symmetric(V1.T*V1)) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2))) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2) + A1x1)) is True
+    assert ask(Q.symmetric(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.symmetric(Identity(3))) is True
+    assert ask(Q.symmetric(ZeroMatrix(3, 3))) is True
+    assert ask(Q.symmetric(OneMatrix(3, 3))) is True
+
+def _test_orthogonal_unitary(predicate):
+    assert ask(predicate(X), predicate(X))
+    assert ask(predicate(X.T), predicate(X)) is True
+    assert ask(predicate(X.I), predicate(X)) is True
+    assert ask(predicate(X**2), predicate(X))
+    assert ask(predicate(Y)) is False
+    assert ask(predicate(X)) is None
+    assert ask(predicate(X), ~Q.invertible(X)) is False
+    assert ask(predicate(X*Z*X), predicate(X) & predicate(Z)) is True
+    assert ask(predicate(Identity(3))) is True
+    assert ask(predicate(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), predicate(X))
+    assert not ask(predicate(X + Z), predicate(X) & predicate(Z))
+
+def test_orthogonal():
+    _test_orthogonal_unitary(Q.orthogonal)
+
+def test_unitary():
+    _test_orthogonal_unitary(Q.unitary)
+    assert ask(Q.unitary(X), Q.orthogonal(X))
+
+def test_fullrank():
+    assert ask(Q.fullrank(X), Q.fullrank(X))
+    assert ask(Q.fullrank(X**2), Q.fullrank(X))
+    assert ask(Q.fullrank(X.T), Q.fullrank(X)) is True
+    assert ask(Q.fullrank(X)) is None
+    assert ask(Q.fullrank(Y)) is None
+    assert ask(Q.fullrank(X*Z), Q.fullrank(X) & Q.fullrank(Z)) is True
+    assert ask(Q.fullrank(Identity(3))) is True
+    assert ask(Q.fullrank(ZeroMatrix(3, 3))) is False
+    assert ask(Q.fullrank(OneMatrix(1, 1))) is True
+    assert ask(Q.fullrank(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), ~Q.fullrank(X)) == False
+
+
+def test_positive_definite():
+    assert ask(Q.positive_definite(X), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X.T), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(X.I), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(Y)) is False
+    assert ask(Q.positive_definite(X)) is None
+    assert ask(Q.positive_definite(X**3), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X*Z*X),
+            Q.positive_definite(X) & Q.positive_definite(Z)) is True
+    assert ask(Q.positive_definite(X), Q.orthogonal(X))
+    assert ask(Q.positive_definite(Y.T*X*Y),
+            Q.positive_definite(X) & Q.fullrank(Y)) is True
+    assert not ask(Q.positive_definite(Y.T*X*Y), Q.positive_definite(X))
+    assert ask(Q.positive_definite(Identity(3))) is True
+    assert ask(Q.positive_definite(ZeroMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(OneMatrix(1, 1))) is True
+    assert ask(Q.positive_definite(OneMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+            Q.positive_definite(Z)) is True
+    assert not ask(Q.positive_definite(-X), Q.positive_definite(X))
+    assert ask(Q.positive(X[1, 1]), Q.positive_definite(X))
+
+def test_triangular():
+    assert ask(Q.upper_triangular(X + Z.T + Identity(2)), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.upper_triangular(X*Z.T), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.lower_triangular(Identity(3))) is True
+    assert ask(Q.lower_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.upper_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.lower_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.upper_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.lower_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.upper_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.triangular(X), Q.unit_triangular(X))
+    assert ask(Q.upper_triangular(X**3), Q.upper_triangular(X))
+    assert ask(Q.lower_triangular(X**3), Q.lower_triangular(X))
+
+
+def test_diagonal():
+    assert ask(Q.diagonal(X + Z.T + Identity(2)), Q.diagonal(X) &
+               Q.diagonal(Z)) is True
+    assert ask(Q.diagonal(ZeroMatrix(3, 3)))
+    assert ask(Q.diagonal(OneMatrix(1, 1))) is True
+    assert ask(Q.diagonal(OneMatrix(3, 3))) is False
+    assert ask(Q.lower_triangular(X) & Q.upper_triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(X), Q.lower_triangular(X) & Q.upper_triangular(X))
+    assert ask(Q.symmetric(X), Q.diagonal(X))
+    assert ask(Q.triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(C0x0))
+    assert ask(Q.diagonal(A1x1))
+    assert ask(Q.diagonal(A1x1 + B1x1))
+    assert ask(Q.diagonal(A1x1*B1x1))
+    assert ask(Q.diagonal(V1.T*V2))
+    assert ask(Q.diagonal(V1.T*(X + Z)*V1))
+    assert ask(Q.diagonal(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.diagonal(V1.T*(V1 + V2))) is True
+    assert ask(Q.diagonal(X**3), Q.diagonal(X))
+    assert ask(Q.diagonal(Identity(3)))
+    assert ask(Q.diagonal(DiagMatrix(V1)))
+    assert ask(Q.diagonal(DiagonalMatrix(X)))
+
+
+def test_non_atoms():
+    assert ask(Q.real(Trace(X)), Q.positive(Trace(X)))
+
+@XFAIL
+def test_non_trivial_implies():
+    X = MatrixSymbol('X', 3, 3)
+    Y = MatrixSymbol('Y', 3, 3)
+    assert ask(Q.lower_triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+    assert ask(Q.triangular(X), Q.lower_triangular(X)) is True
+    assert ask(Q.triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+
+def test_MatrixSlice():
+    X = MatrixSymbol('X', 4, 4)
+    B = MatrixSlice(X, (1, 3), (1, 3))
+    C = MatrixSlice(X, (0, 3), (1, 3))
+    assert ask(Q.symmetric(B), Q.symmetric(X))
+    assert ask(Q.invertible(B), Q.invertible(X))
+    assert ask(Q.diagonal(B), Q.diagonal(X))
+    assert ask(Q.orthogonal(B), Q.orthogonal(X))
+    assert ask(Q.upper_triangular(B), Q.upper_triangular(X))
+
+    assert not ask(Q.symmetric(C), Q.symmetric(X))
+    assert not ask(Q.invertible(C), Q.invertible(X))
+    assert not ask(Q.diagonal(C), Q.diagonal(X))
+    assert not ask(Q.orthogonal(C), Q.orthogonal(X))
+    assert not ask(Q.upper_triangular(C), Q.upper_triangular(X))
+
+def test_det_trace_positive():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.positive(Trace(X)), Q.positive_definite(X))
+    assert ask(Q.positive(Determinant(X)), Q.positive_definite(X))
+
+def test_field_assumptions():
+    X = MatrixSymbol('X', 4, 4)
+    Y = MatrixSymbol('Y', 4, 4)
+    assert ask(Q.real_elements(X), Q.real_elements(X))
+    assert not ask(Q.integer_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X**2), Q.real_elements(X))
+    assert ask(Q.real_elements(X**2), Q.integer_elements(X))
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X)) is None
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X) & Q.real_elements(Y))
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    assert ask(Q.real_elements(HadamardProduct(X, Y)),
+                    Q.real_elements(X) & Q.real_elements(Y))
+    assert ask(Q.complex_elements(X+Y), Q.real_elements(X) & Q.complex_elements(Y))
+
+    assert ask(Q.real_elements(X.T), Q.real_elements(X))
+    assert ask(Q.real_elements(X.I), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(Trace(X)), Q.real_elements(X))
+    assert ask(Q.integer_elements(Determinant(X)), Q.integer_elements(X))
+    assert not ask(Q.integer_elements(X.I), Q.integer_elements(X))
+    alpha = Symbol('alpha')
+    assert ask(Q.real_elements(alpha*X), Q.real_elements(X) & Q.real(alpha))
+    assert ask(Q.real_elements(LofLU(X)), Q.real_elements(X))
+    e = Symbol('e', integer=True, negative=True)
+    assert ask(Q.real_elements(X**e), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(X**e), Q.real_elements(X)) is None
+
+def test_matrix_element_sets():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.real(X[1, 2]), Q.real_elements(X))
+    assert ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    assert ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    assert ask(Q.integer_elements(Identity(3)))
+    assert ask(Q.integer_elements(ZeroMatrix(3, 3)))
+    assert ask(Q.integer_elements(OneMatrix(3, 3)))
+    from sympy.matrices.expressions.fourier import DFT
+    assert ask(Q.complex_elements(DFT(3)))
+
+
+def test_matrix_element_sets_slices_blocks():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.integer_elements(X[:, 3]), Q.integer_elements(X))
+    assert ask(Q.integer_elements(BlockMatrix([[X], [X]])),
+                        Q.integer_elements(X))
+
+def test_matrix_element_sets_determinant_trace():
+    assert ask(Q.integer(Determinant(X)), Q.integer_elements(X))
+    assert ask(Q.integer(Trace(X)), Q.integer_elements(X))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_query.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_query.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1ae1f1e482e5c9d19e3dcce3f37ad46b6821817
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_query.py
@@ -0,0 +1,2541 @@
+from sympy.abc import t, w, x, y, z, n, k, m, p, i
+from sympy.assumptions import (ask, AssumptionsContext, Q, register_handler,
+        remove_handler)
+from sympy.assumptions.assume import assuming, global_assumptions, Predicate
+from sympy.assumptions.cnf import CNF, Literal
+from sympy.assumptions.facts import (single_fact_lookup,
+    get_known_facts, generate_known_facts_dict, get_known_facts_keys)
+from sympy.assumptions.handlers import AskHandler
+from sympy.assumptions.ask_generated import (get_all_known_facts,
+    get_known_facts_dict)
+from sympy.core.add import Add
+from sympy.core.numbers import (I, Integer, Rational, oo, zoo, pi)
+from sympy.core.singleton import S
+from sympy.core.power import Pow
+from sympy.core.symbol import Str, symbols, Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (Abs, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (
+    acos, acot, asin, atan, cos, cot, sin, tan)
+from sympy.logic.boolalg import Equivalent, Implies, Xor, And, to_cnf
+from sympy.matrices import Matrix, SparseMatrix
+from sympy.testing.pytest import (XFAIL, slow, raises, warns_deprecated_sympy,
+    _both_exp_pow)
+import math
+
+
+def test_int_1():
+    z = 1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_int_11():
+    z = 11
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is True
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_int_12():
+    z = 12
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is True
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is True
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_float_1():
+    z = 1.0
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is None
+    assert ask(Q.rational(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is None
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is None
+    assert ask(Q.odd(z)) is None
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is None
+    assert ask(Q.composite(z)) is None
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = 7.2123
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is None
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    # test for issue #12168
+    assert ask(Q.rational(math.pi)) is None
+
+
+def test_zero_0():
+    z = Integer(0)
+    assert ask(Q.nonzero(z)) is False
+    assert ask(Q.zero(z)) is True
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is True
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is True
+
+
+def test_negativeone():
+    z = Integer(-1)
+    assert ask(Q.nonzero(z)) is True
+    assert ask(Q.zero(z)) is False
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is True
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_infinity():
+    assert ask(Q.commutative(oo)) is True
+    assert ask(Q.integer(oo)) is False
+    assert ask(Q.rational(oo)) is False
+    assert ask(Q.algebraic(oo)) is False
+    assert ask(Q.real(oo)) is False
+    assert ask(Q.extended_real(oo)) is True
+    assert ask(Q.complex(oo)) is False
+    assert ask(Q.irrational(oo)) is False
+    assert ask(Q.imaginary(oo)) is False
+    assert ask(Q.positive(oo)) is False
+    assert ask(Q.extended_positive(oo)) is True
+    assert ask(Q.negative(oo)) is False
+    assert ask(Q.even(oo)) is False
+    assert ask(Q.odd(oo)) is False
+    assert ask(Q.finite(oo)) is False
+    assert ask(Q.infinite(oo)) is True
+    assert ask(Q.prime(oo)) is False
+    assert ask(Q.composite(oo)) is False
+    assert ask(Q.hermitian(oo)) is False
+    assert ask(Q.antihermitian(oo)) is False
+    assert ask(Q.positive_infinite(oo)) is True
+    assert ask(Q.negative_infinite(oo)) is False
+
+
+def test_neg_infinity():
+    mm = S.NegativeInfinity
+    assert ask(Q.commutative(mm)) is True
+    assert ask(Q.integer(mm)) is False
+    assert ask(Q.rational(mm)) is False
+    assert ask(Q.algebraic(mm)) is False
+    assert ask(Q.real(mm)) is False
+    assert ask(Q.extended_real(mm)) is True
+    assert ask(Q.complex(mm)) is False
+    assert ask(Q.irrational(mm)) is False
+    assert ask(Q.imaginary(mm)) is False
+    assert ask(Q.positive(mm)) is False
+    assert ask(Q.negative(mm)) is False
+    assert ask(Q.extended_negative(mm)) is True
+    assert ask(Q.even(mm)) is False
+    assert ask(Q.odd(mm)) is False
+    assert ask(Q.finite(mm)) is False
+    assert ask(Q.infinite(oo)) is True
+    assert ask(Q.prime(mm)) is False
+    assert ask(Q.composite(mm)) is False
+    assert ask(Q.hermitian(mm)) is False
+    assert ask(Q.antihermitian(mm)) is False
+    assert ask(Q.positive_infinite(-oo)) is False
+    assert ask(Q.negative_infinite(-oo)) is True
+
+
+def test_complex_infinity():
+    assert ask(Q.commutative(zoo)) is True
+    assert ask(Q.integer(zoo)) is False
+    assert ask(Q.rational(zoo)) is False
+    assert ask(Q.algebraic(zoo)) is False
+    assert ask(Q.real(zoo)) is False
+    assert ask(Q.extended_real(zoo)) is False
+    assert ask(Q.complex(zoo)) is False
+    assert ask(Q.irrational(zoo)) is False
+    assert ask(Q.imaginary(zoo)) is False
+    assert ask(Q.positive(zoo)) is False
+    assert ask(Q.negative(zoo)) is False
+    assert ask(Q.zero(zoo)) is False
+    assert ask(Q.nonzero(zoo)) is False
+    assert ask(Q.even(zoo)) is False
+    assert ask(Q.odd(zoo)) is False
+    assert ask(Q.finite(zoo)) is False
+    assert ask(Q.infinite(zoo)) is True
+    assert ask(Q.prime(zoo)) is False
+    assert ask(Q.composite(zoo)) is False
+    assert ask(Q.hermitian(zoo)) is False
+    assert ask(Q.antihermitian(zoo)) is False
+    assert ask(Q.positive_infinite(zoo)) is False
+    assert ask(Q.negative_infinite(zoo)) is False
+
+
+def test_nan():
+    nan = S.NaN
+    assert ask(Q.commutative(nan)) is True
+    assert ask(Q.integer(nan)) is None
+    assert ask(Q.rational(nan)) is None
+    assert ask(Q.algebraic(nan)) is None
+    assert ask(Q.real(nan)) is None
+    assert ask(Q.extended_real(nan)) is None
+    assert ask(Q.complex(nan)) is None
+    assert ask(Q.irrational(nan)) is None
+    assert ask(Q.imaginary(nan)) is None
+    assert ask(Q.positive(nan)) is None
+    assert ask(Q.nonzero(nan)) is None
+    assert ask(Q.zero(nan)) is None
+    assert ask(Q.even(nan)) is None
+    assert ask(Q.odd(nan)) is None
+    assert ask(Q.finite(nan)) is None
+    assert ask(Q.infinite(nan)) is None
+    assert ask(Q.prime(nan)) is None
+    assert ask(Q.composite(nan)) is None
+    assert ask(Q.hermitian(nan)) is None
+    assert ask(Q.antihermitian(nan)) is None
+
+
+def test_Rational_number():
+    r = Rational(3, 4)
+    assert ask(Q.commutative(r)) is True
+    assert ask(Q.integer(r)) is False
+    assert ask(Q.rational(r)) is True
+    assert ask(Q.real(r)) is True
+    assert ask(Q.complex(r)) is True
+    assert ask(Q.irrational(r)) is False
+    assert ask(Q.imaginary(r)) is False
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+    assert ask(Q.even(r)) is False
+    assert ask(Q.odd(r)) is False
+    assert ask(Q.finite(r)) is True
+    assert ask(Q.prime(r)) is False
+    assert ask(Q.composite(r)) is False
+    assert ask(Q.hermitian(r)) is True
+    assert ask(Q.antihermitian(r)) is False
+
+    r = Rational(1, 4)
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+
+    r = Rational(5, 4)
+    assert ask(Q.negative(r)) is False
+    assert ask(Q.positive(r)) is True
+
+    r = Rational(5, 3)
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+
+    r = Rational(-3, 4)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+    r = Rational(-1, 4)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+    r = Rational(-5, 4)
+    assert ask(Q.negative(r)) is True
+    assert ask(Q.positive(r)) is False
+
+    r = Rational(-5, 3)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+
+def test_sqrt_2():
+    z = sqrt(2)
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_pi():
+    z = S.Pi
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = S.Pi + 1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = 2*S.Pi
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = S.Pi ** 2
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = (1 + S.Pi) ** 2
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_E():
+    z = S.Exp1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_GoldenRatio():
+    z = S.GoldenRatio
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_TribonacciConstant():
+    z = S.TribonacciConstant
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_I():
+    z = I
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is True
+
+    z = 1 + I
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is False
+
+    z = I*(1 + I)
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is False
+
+    z = I**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (-I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (3*I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (1)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (-1)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (1+I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(I+3)
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(I+2)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (I)**(2)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (I)**(3)
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.real(z)) is False
+
+    z = (3)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(0)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+def test_bounded():
+    x, y, z = symbols('x,y,z')
+    a = x + y
+    x, y = a.args
+    assert ask(Q.finite(a), Q.positive_infinite(y)) is None
+    assert ask(Q.finite(x)) is None
+    assert ask(Q.finite(x), Q.finite(x)) is True
+    assert ask(Q.finite(x), Q.finite(y)) is None
+    assert ask(Q.finite(x), Q.complex(x)) is True
+    assert ask(Q.finite(x), Q.extended_real(x)) is None
+
+    assert ask(Q.finite(x + 1)) is None
+    assert ask(Q.finite(x + 1), Q.finite(x)) is True
+    a = x + y
+    x, y = a.args
+    # B + B
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.finite(y)
+        & ~Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y) & ~Q.positive(x)
+        & ~Q.positive(y)) is True
+    # B + U
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & ~Q.positive(y)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x) & ~Q.finite(y)
+        & ~Q.positive(y)) is False
+    # B + ?
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.positive(x)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & ~Q.positive(y)) is None
+    # U + U
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x) & ~Q.finite(y)
+        & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.extended_positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.extended_positive(x) & ~Q.extended_positive(y)) is False
+    # U + ?
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.finite(y) & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x) & ~Q.finite(y)
+        & ~Q.extended_positive(y)) is False
+    # ? + ?
+    assert ask(Q.finite(a)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)) is None
+    assert ask(Q.finite(a), Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & ~Q.extended_positive(y)) is None
+
+    x, y, z = symbols('x,y,z')
+    a = x + y + z
+    x, y, z = a.args
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.negative(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_positive(y)
+        & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.negative_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) &
+         Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x)) is None
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y)& Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(z)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a)) is None
+    assert ask(Q.finite(a), Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+
+    assert ask(Q.finite(2*x)) is None
+    assert ask(Q.finite(2*x), Q.finite(x)) is True
+
+    x, y, z = symbols('x,y,z')
+    a = x*y
+    x, y = a.args
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y) &~Q.zero(y)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a)) is None
+    a = x*y*z
+    x, y, z = a.args
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & Q.finite(y)
+        & ~Q.zero(y) & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y) & ~Q.zero(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.zero(x) & Q.finite(y)
+        & ~Q.zero(y) & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(y) & Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(y) & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(z) & Q.extended_nonzero(x)
+        & Q.extended_nonzero(y) & Q.extended_nonzero(z)) is None
+    assert ask(Q.finite(a), Q.extended_nonzero(x) & ~Q.finite(y)
+        & Q.extended_nonzero(y) & ~Q.finite(z)
+        & Q.extended_nonzero(z)) is False
+
+    x, y, z = symbols('x,y,z')
+    assert ask(Q.finite(x**2)) is None
+    assert ask(Q.finite(2**x)) is None
+    assert ask(Q.finite(2**x), Q.finite(x)) is True
+    assert ask(Q.finite(x**x)) is None
+    assert ask(Q.finite(S.Half ** x)) is None
+    assert ask(Q.finite(S.Half ** x), Q.extended_positive(x)) is True
+    assert ask(Q.finite(S.Half ** x), Q.extended_negative(x)) is None
+    assert ask(Q.finite(2**x), Q.extended_negative(x)) is True
+    assert ask(Q.finite(sqrt(x))) is None
+    assert ask(Q.finite(2**x), ~Q.finite(x)) is False
+    assert ask(Q.finite(x**2), ~Q.finite(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27707
+    assert ask(Q.finite(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.finite(x**y), Q.real(x) & Q.negative(y)) is None
+    assert ask(Q.finite(x**y), Q.zero(x) & Q.negative(y)) is False
+    assert ask(Q.finite(x**y), Q.real(x) & Q.positive(y)) is True
+    assert ask(Q.finite(x**y), Q.nonzero(x) & Q.real(y)) is True
+    assert ask(Q.finite(x**y), Q.nonzero(x) & Q.negative(y)) is True
+    assert ask(Q.finite(x**y), Q.zero(x) & Q.positive(y)) is True
+
+    # sign function
+    assert ask(Q.finite(sign(x))) is True
+    assert ask(Q.finite(sign(x)), ~Q.finite(x)) is True
+
+    # exponential functions
+    assert ask(Q.finite(log(x))) is None
+    assert ask(Q.finite(log(x)), Q.finite(x)) is None
+    assert ask(Q.finite(log(x)), ~Q.zero(x)) is True
+    assert ask(Q.finite(log(x)), Q.infinite(x)) is False
+    assert ask(Q.finite(log(x)), Q.zero(x)) is False
+    assert ask(Q.finite(exp(x))) is None
+    assert ask(Q.finite(exp(x)), Q.finite(x)) is True
+    assert ask(Q.finite(exp(2))) is True
+
+    # trigonometric functions
+    assert ask(Q.finite(sin(x))) is True
+    assert ask(Q.finite(sin(x)), ~Q.finite(x)) is True
+    assert ask(Q.finite(cos(x))) is True
+    assert ask(Q.finite(cos(x)), ~Q.finite(x)) is True
+    assert ask(Q.finite(2*sin(x))) is True
+    assert ask(Q.finite(sin(x)**2)) is True
+    assert ask(Q.finite(cos(x)**2)) is True
+    assert ask(Q.finite(cos(x) + sin(x))) is True
+
+
+def test_unbounded():
+    assert ask(Q.infinite(I * oo)) is True
+    assert ask(Q.infinite(1 + I*oo)) is True
+    assert ask(Q.infinite(3 * (I * oo))) is True
+    assert ask(Q.infinite(-I * oo)) is True
+    assert ask(Q.infinite(1 + zoo)) is True
+    assert ask(Q.infinite(I * zoo)) is True
+    assert ask(Q.infinite(x / y), Q.infinite(x) & Q.finite(y) & ~Q.zero(y)) is True
+    assert ask(Q.infinite(I * oo - I * oo)) is None
+    assert ask(Q.infinite(x * I * oo)) is None
+    assert ask(Q.infinite(1 / x), Q.finite(x) & ~Q.zero(x)) is False
+    assert ask(Q.infinite(1 / (I * oo))) is False
+
+
+def test_issue_27441():
+    # https://github.com/sympy/sympy/issues/27441
+    assert ask(Q.composite(y), Q.integer(y) & Q.positive(y) & ~Q.prime(y)) is None
+
+
+def test_issue_27447():
+    x,y,z = symbols('x y z')
+    a = x*y
+    assert ask(Q.finite(a), Q.finite(x)  & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)  & Q.finite(y)) is None
+
+    a = x*y*z
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z) ) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z)) is None
+
+
+@XFAIL
+def test_issue_27662_xfail():
+    assert ask(Q.finite(x*y), ~Q.finite(x)
+        & Q.zero(y)) is None
+
+
+@XFAIL
+def test_bounded_xfail():
+    """We need to support relations in ask for this to work"""
+    assert ask(Q.finite(sin(x)**x)) is True
+    assert ask(Q.finite(cos(x)**x)) is True
+
+
+def test_commutative():
+    """By default objects are Q.commutative that is why it returns True
+    for both key=True and key=False"""
+    assert ask(Q.commutative(x)) is True
+    assert ask(Q.commutative(x), ~Q.commutative(x)) is False
+    assert ask(Q.commutative(x), Q.complex(x)) is True
+    assert ask(Q.commutative(x), Q.imaginary(x)) is True
+    assert ask(Q.commutative(x), Q.real(x)) is True
+    assert ask(Q.commutative(x), Q.positive(x)) is True
+    assert ask(Q.commutative(x), ~Q.commutative(y)) is True
+
+    assert ask(Q.commutative(2*x)) is True
+    assert ask(Q.commutative(2*x), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(x + 1)) is True
+    assert ask(Q.commutative(x + 1), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(x**2)) is True
+    assert ask(Q.commutative(x**2), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(log(x))) is True
+
+
+@_both_exp_pow
+def test_complex():
+    assert ask(Q.complex(x)) is None
+    assert ask(Q.complex(x), Q.complex(x)) is True
+    assert ask(Q.complex(x), Q.complex(y)) is None
+    assert ask(Q.complex(x), ~Q.complex(x)) is False
+    assert ask(Q.complex(x), Q.real(x)) is True
+    assert ask(Q.complex(x), ~Q.real(x)) is None
+    assert ask(Q.complex(x), Q.rational(x)) is True
+    assert ask(Q.complex(x), Q.irrational(x)) is True
+    assert ask(Q.complex(x), Q.positive(x)) is True
+    assert ask(Q.complex(x), Q.imaginary(x)) is True
+    assert ask(Q.complex(x), Q.algebraic(x)) is True
+
+    # a+b
+    assert ask(Q.complex(x + 1), Q.complex(x)) is True
+    assert ask(Q.complex(x + 1), Q.real(x)) is True
+    assert ask(Q.complex(x + 1), Q.rational(x)) is True
+    assert ask(Q.complex(x + 1), Q.irrational(x)) is True
+    assert ask(Q.complex(x + 1), Q.imaginary(x)) is True
+    assert ask(Q.complex(x + 1), Q.integer(x)) is True
+    assert ask(Q.complex(x + 1), Q.even(x)) is True
+    assert ask(Q.complex(x + 1), Q.odd(x)) is True
+    assert ask(Q.complex(x + y), Q.complex(x) & Q.complex(y)) is True
+    assert ask(Q.complex(x + y), Q.real(x) & Q.imaginary(y)) is True
+
+    # a*x +b
+    assert ask(Q.complex(2*x + 1), Q.complex(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.real(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.positive(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.rational(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.irrational(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.imaginary(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.integer(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.even(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.odd(x)) is True
+
+    # x**2
+    assert ask(Q.complex(x**2), Q.complex(x)) is True
+    assert ask(Q.complex(x**2), Q.real(x)) is True
+    assert ask(Q.complex(x**2), Q.positive(x)) is True
+    assert ask(Q.complex(x**2), Q.rational(x)) is True
+    assert ask(Q.complex(x**2), Q.irrational(x)) is True
+    assert ask(Q.complex(x**2), Q.imaginary(x)) is True
+    assert ask(Q.complex(x**2), Q.integer(x)) is True
+    assert ask(Q.complex(x**2), Q.even(x)) is True
+    assert ask(Q.complex(x**2), Q.odd(x)) is True
+
+    # 2**x
+    assert ask(Q.complex(2**x), Q.complex(x)) is True
+    assert ask(Q.complex(2**x), Q.real(x)) is True
+    assert ask(Q.complex(2**x), Q.positive(x)) is True
+    assert ask(Q.complex(2**x), Q.rational(x)) is True
+    assert ask(Q.complex(2**x), Q.irrational(x)) is True
+    assert ask(Q.complex(2**x), Q.imaginary(x)) is True
+    assert ask(Q.complex(2**x), Q.integer(x)) is True
+    assert ask(Q.complex(2**x), Q.even(x)) is True
+    assert ask(Q.complex(2**x), Q.odd(x)) is True
+    assert ask(Q.complex(x**y), Q.complex(x) & Q.complex(y)) is True
+
+    # trigonometric expressions
+    assert ask(Q.complex(sin(x))) is True
+    assert ask(Q.complex(sin(2*x + 1))) is True
+    assert ask(Q.complex(cos(x))) is True
+    assert ask(Q.complex(cos(2*x + 1))) is True
+
+    # exponential
+    assert ask(Q.complex(exp(x))) is True
+    assert ask(Q.complex(exp(x))) is True
+
+    # Q.complexes
+    assert ask(Q.complex(Abs(x))) is True
+    assert ask(Q.complex(re(x))) is True
+    assert ask(Q.complex(im(x))) is True
+
+
+def test_even_query():
+    assert ask(Q.even(x)) is None
+    assert ask(Q.even(x), Q.integer(x)) is None
+    assert ask(Q.even(x), ~Q.integer(x)) is False
+    assert ask(Q.even(x), Q.rational(x)) is None
+    assert ask(Q.even(x), Q.positive(x)) is None
+
+    assert ask(Q.even(2*x)) is None
+    assert ask(Q.even(2*x), Q.integer(x)) is True
+    assert ask(Q.even(2*x), Q.even(x)) is True
+    assert ask(Q.even(2*x), Q.irrational(x)) is False
+    assert ask(Q.even(2*x), Q.odd(x)) is True
+    assert ask(Q.even(2*x), ~Q.integer(x)) is None
+    assert ask(Q.even(3*x), Q.integer(x)) is None
+    assert ask(Q.even(3*x), Q.even(x)) is True
+    assert ask(Q.even(3*x), Q.odd(x)) is False
+
+    assert ask(Q.even(x + 1), Q.odd(x)) is True
+    assert ask(Q.even(x + 1), Q.even(x)) is False
+    assert ask(Q.even(x + 2), Q.odd(x)) is False
+    assert ask(Q.even(x + 2), Q.even(x)) is True
+    assert ask(Q.even(7 - x), Q.odd(x)) is True
+    assert ask(Q.even(7 + x), Q.odd(x)) is True
+    assert ask(Q.even(x + y), Q.odd(x) & Q.odd(y)) is True
+    assert ask(Q.even(x + y), Q.odd(x) & Q.even(y)) is False
+    assert ask(Q.even(x + y), Q.even(x) & Q.even(y)) is True
+
+    assert ask(Q.even(2*x + 1), Q.integer(x)) is False
+    assert ask(Q.even(2*x*y), Q.rational(x) & Q.rational(x)) is None
+    assert ask(Q.even(2*x*y), Q.irrational(x) & Q.irrational(x)) is None
+
+    assert ask(Q.even(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) is True
+    assert ask(Q.even(x + y + z + t),
+        Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) is None
+
+    assert ask(Q.even(Abs(x)), Q.even(x)) is True
+    assert ask(Q.even(Abs(x)), ~Q.even(x)) is None
+    assert ask(Q.even(re(x)), Q.even(x)) is True
+    assert ask(Q.even(re(x)), ~Q.even(x)) is None
+    assert ask(Q.even(im(x)), Q.even(x)) is True
+    assert ask(Q.even(im(x)), Q.real(x)) is True
+
+    assert ask(Q.even((-1)**n), Q.integer(n)) is False
+
+    assert ask(Q.even(k**2), Q.even(k)) is True
+    assert ask(Q.even(n**2), Q.odd(n)) is False
+    assert ask(Q.even(2**k), Q.even(k)) is None
+    assert ask(Q.even(x**2)) is None
+
+    assert ask(Q.even(k**m), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(n**m), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is False
+
+    assert ask(Q.even(k**p), Q.even(k) & Q.integer(p) & Q.positive(p)) is True
+    assert ask(Q.even(n**p), Q.odd(n) & Q.integer(p) & Q.positive(p)) is False
+
+    assert ask(Q.even(m**k), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(p**k), Q.even(k) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.even(m**n), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(p**n), Q.odd(n) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.even(k**x), Q.even(k)) is None
+    assert ask(Q.even(n**x), Q.odd(n)) is None
+
+    assert ask(Q.even(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.even(x*x), Q.integer(x)) is None
+    assert ask(Q.even(x*(x + y)), Q.integer(x) & Q.odd(y)) is True
+    assert ask(Q.even(x*(x + y)), Q.integer(x) & Q.even(y)) is None
+
+
+@XFAIL
+def test_evenness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    assert ask(Q.even(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is True
+    assert ask(Q.even(y*x*(x + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is True
+
+
+def test_evenness_in_ternary_integer_product_with_even():
+    assert ask(Q.even(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.even(z)) is None
+
+
+def test_extended_real():
+    assert ask(Q.extended_real(x), Q.positive_infinite(x)) is True
+    assert ask(Q.extended_real(x), Q.positive(x)) is True
+    assert ask(Q.extended_real(x), Q.zero(x)) is True
+    assert ask(Q.extended_real(x), Q.negative(x)) is True
+    assert ask(Q.extended_real(x), Q.negative_infinite(x)) is True
+
+    assert ask(Q.extended_real(-x), Q.positive(x)) is True
+    assert ask(Q.extended_real(-x), Q.negative(x)) is True
+
+    assert ask(Q.extended_real(x + S.Infinity), Q.real(x)) is True
+
+    assert ask(Q.extended_real(x), Q.infinite(x)) is None
+
+
+@_both_exp_pow
+def test_rational():
+    assert ask(Q.rational(x), Q.integer(x)) is True
+    assert ask(Q.rational(x), Q.irrational(x)) is False
+    assert ask(Q.rational(x), Q.real(x)) is None
+    assert ask(Q.rational(x), Q.positive(x)) is None
+    assert ask(Q.rational(x), Q.negative(x)) is None
+    assert ask(Q.rational(x), Q.nonzero(x)) is None
+    assert ask(Q.rational(x), ~Q.algebraic(x)) is False
+
+    assert ask(Q.rational(2*x), Q.rational(x)) is True
+    assert ask(Q.rational(2*x), Q.integer(x)) is True
+    assert ask(Q.rational(2*x), Q.even(x)) is True
+    assert ask(Q.rational(2*x), Q.odd(x)) is True
+    assert ask(Q.rational(2*x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(x/2), Q.rational(x)) is True
+    assert ask(Q.rational(x/2), Q.integer(x)) is True
+    assert ask(Q.rational(x/2), Q.even(x)) is True
+    assert ask(Q.rational(x/2), Q.odd(x)) is True
+    assert ask(Q.rational(x/2), Q.irrational(x)) is False
+
+    assert ask(Q.rational(1/x), Q.rational(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.integer(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.even(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.odd(x)) is True
+    assert ask(Q.rational(1/x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(2/x), Q.rational(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.integer(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.even(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.odd(x)) is True
+    assert ask(Q.rational(2/x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(x), ~Q.algebraic(x)) is False
+
+    # with multiple symbols
+    assert ask(Q.rational(x*y), Q.irrational(x) & Q.irrational(y)) is None
+    assert ask(Q.rational(y/x), Q.rational(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.integer(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.even(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.odd(x) & Q.rational(y)) is True
+    assert ask(Q.rational(y/x), Q.irrational(x) & Q.rational(y) & Q.nonzero(y)) is False
+
+    for f in [exp, sin, tan, asin, atan, cos]:
+        assert ask(Q.rational(f(7))) is False
+        assert ask(Q.rational(f(7, evaluate=False))) is False
+        assert ask(Q.rational(f(0, evaluate=False))) is True
+        assert ask(Q.rational(f(x)), Q.rational(x)) is None
+        assert ask(Q.rational(f(x)), Q.rational(x) & Q.nonzero(x)) is False
+
+    for g in [log, acos]:
+        assert ask(Q.rational(g(7))) is False
+        assert ask(Q.rational(g(7, evaluate=False))) is False
+        assert ask(Q.rational(g(1, evaluate=False))) is True
+        assert ask(Q.rational(g(x)), Q.rational(x)) is None
+        assert ask(Q.rational(g(x)), Q.rational(x) & Q.nonzero(x - 1)) is False
+
+    for h in [cot, acot]:
+        assert ask(Q.rational(h(7))) is False
+        assert ask(Q.rational(h(7, evaluate=False))) is False
+        assert ask(Q.rational(h(x)), Q.rational(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27442
+    assert ask(Q.rational(x**y),Q.irrational(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.prime(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.eq(x,0) & Q.integer(y)) is None
+    assert ask(Q.rational(x**y),Q.eq(x,1) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.eq(x,-1) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y), Q.prime(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y), ~Q.rational(x) & Q.integer(y) ) is None
+    assert ask(Q.rational(Pow(-1, x, evaluate=False), Q.rational(x))) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q. algebraic(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q. algebraic(x) & ~Q.zero(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q.algebraic(x) & Q.complex(x) & ~Q.real(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q.algebraic(x) & Q.complex(x)) is None
+
+
+def test_hermitian():
+    assert ask(Q.hermitian(x)) is None
+    assert ask(Q.hermitian(x), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x), Q.imaginary(x)) is False
+    assert ask(Q.hermitian(x), Q.prime(x)) is True
+    assert ask(Q.hermitian(x), Q.real(x)) is True
+    assert ask(Q.hermitian(x), Q.zero(x)) is True
+
+    assert ask(Q.hermitian(x + 1), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x + 1), Q.complex(x)) is None
+    assert ask(Q.hermitian(x + 1), Q.hermitian(x)) is True
+    assert ask(Q.hermitian(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.hermitian(x + 1), Q.real(x)) is True
+    assert ask(Q.hermitian(x + I), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x + I), Q.complex(x)) is None
+    assert ask(Q.hermitian(x + I), Q.hermitian(x)) is False
+    assert ask(Q.hermitian(x + I), Q.imaginary(x)) is None
+    assert ask(Q.hermitian(x + I), Q.real(x)) is False
+    assert ask(
+        Q.hermitian(x + y), Q.antihermitian(x) & Q.antihermitian(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.complex(y)) is None
+    assert ask(
+        Q.hermitian(x + y), Q.antihermitian(x) & Q.hermitian(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.imaginary(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.real(y)) is None
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.hermitian(y)) is True
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.imaginary(y)) is False
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.real(y)) is True
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.imaginary(y)) is None
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.hermitian(x + y), Q.real(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.real(x) & Q.real(y)) is True
+
+    assert ask(Q.hermitian(I*x), Q.antihermitian(x)) is True
+    assert ask(Q.hermitian(I*x), Q.complex(x)) is None
+    assert ask(Q.hermitian(I*x), Q.hermitian(x)) is False
+    assert ask(Q.hermitian(I*x), Q.imaginary(x)) is True
+    assert ask(Q.hermitian(I*x), Q.real(x)) is False
+    assert ask(Q.hermitian(x*y), Q.hermitian(x) & Q.real(y)) is True
+
+    assert ask(
+        Q.hermitian(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert ask(Q.hermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is False
+    assert ask(Q.hermitian(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is None
+    assert ask(Q.hermitian(x + y + z),
+        Q.imaginary(x) & Q.imaginary(y) & Q.imaginary(z)) is None
+
+    assert ask(Q.antihermitian(x)) is None
+    assert ask(Q.antihermitian(x), Q.real(x)) is False
+    assert ask(Q.antihermitian(x), Q.prime(x)) is False
+
+    assert ask(Q.antihermitian(x + 1), Q.antihermitian(x)) is False
+    assert ask(Q.antihermitian(x + 1), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x + 1), Q.hermitian(x)) is None
+    assert ask(Q.antihermitian(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.antihermitian(x + 1), Q.real(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.antihermitian(x)) is True
+    assert ask(Q.antihermitian(x + I), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.hermitian(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.imaginary(x)) is True
+    assert ask(Q.antihermitian(x + I), Q.real(x)) is False
+    assert ask(Q.antihermitian(x), Q.zero(x)) is True
+
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.antihermitian(y)
+    ) is True
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.complex(y)) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.hermitian(y)) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.imaginary(y)) is True
+    assert ask(Q.antihermitian(x + y), Q.antihermitian(x) & Q.real(y)
+        ) is False
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.hermitian(y)
+        ) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.hermitian(x) & Q.imaginary(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.real(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.imaginary(y)) is True
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.antihermitian(x + y), Q.real(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.real(x) & Q.real(y)) is None
+
+    assert ask(Q.antihermitian(I*x), Q.real(x)) is True
+    assert ask(Q.antihermitian(I*x), Q.antihermitian(x)) is False
+    assert ask(Q.antihermitian(I*x), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x*y), Q.antihermitian(x) & Q.real(y)) is True
+
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.real(z)) is None
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is None
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is False
+    assert ask(Q.antihermitian(x + y + z),
+        Q.imaginary(x) & Q.imaginary(y) & Q.imaginary(z)) is True
+
+
+@_both_exp_pow
+def test_imaginary():
+    assert ask(Q.imaginary(x)) is None
+    assert ask(Q.imaginary(x), Q.real(x)) is False
+    assert ask(Q.imaginary(x), Q.prime(x)) is False
+
+    assert ask(Q.imaginary(x + 1), Q.real(x)) is False
+    assert ask(Q.imaginary(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x + I), Q.real(x)) is False
+    assert ask(Q.imaginary(x + I), Q.imaginary(x)) is True
+    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.imaginary(y)) is True
+    assert ask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x + y), Q.complex(x) & Q.real(y)) is None
+    assert ask(
+        Q.imaginary(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is False
+    assert ask(Q.imaginary(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is None
+    assert ask(Q.imaginary(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is False
+
+    assert ask(Q.imaginary(I*x), Q.real(x)) is True
+    assert ask(Q.imaginary(I*x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(I*x), Q.complex(x)) is None
+    assert ask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) is True
+    assert ask(Q.imaginary(x*y), Q.real(x) & Q.real(y)) is False
+
+    assert ask(Q.imaginary(I**x), Q.negative(x)) is None
+    assert ask(Q.imaginary(I**x), Q.positive(x)) is None
+    assert ask(Q.imaginary(I**x), Q.even(x)) is False
+    assert ask(Q.imaginary(I**x), Q.odd(x)) is True
+    assert ask(Q.imaginary(I**x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary((2*I)**x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x**0), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.integer(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(y) & Q.integer(x)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.odd(y)) is True
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.rational(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.even(y)) is False
+
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.integer(y)) is False
+    assert ask(Q.imaginary(x**y), Q.positive(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.real(y) & ~Q.rational(y)) is False
+    assert ask(Q.imaginary(x**y), Q.integer(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y) & Q.integer(2*y)) is True
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y) & ~Q.integer(2*y)) is False
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.rational(y) & ~Q.integer(2*y)) is False
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.rational(y) & Q.integer(2*y)) is None
+
+    # logarithm
+    assert ask(Q.imaginary(log(I))) is True
+    assert ask(Q.imaginary(log(2*I))) is False
+    assert ask(Q.imaginary(log(I + 1))) is False
+    assert ask(Q.imaginary(log(x)), Q.complex(x)) is None
+    assert ask(Q.imaginary(log(x)), Q.imaginary(x)) is None
+    assert ask(Q.imaginary(log(x)), Q.positive(x)) is False
+    assert ask(Q.imaginary(log(exp(x))), Q.complex(x)) is None
+    assert ask(Q.imaginary(log(exp(x))), Q.imaginary(x)) is None  # zoo/I/a+I*b
+    assert ask(Q.imaginary(log(exp(I)))) is True
+
+    # exponential
+    assert ask(Q.imaginary(exp(x)**x), Q.imaginary(x)) is False
+    eq = Pow(exp(pi*I*x, evaluate=False), x, evaluate=False)
+    assert ask(Q.imaginary(eq), Q.even(x)) is False
+    eq = Pow(exp(pi*I*x/2, evaluate=False), x, evaluate=False)
+    assert ask(Q.imaginary(eq), Q.odd(x)) is True
+    assert ask(Q.imaginary(exp(3*I*pi*x)**x), Q.integer(x)) is False
+    assert ask(Q.imaginary(exp(2*pi*I, evaluate=False))) is False
+    assert ask(Q.imaginary(exp(pi*I/2, evaluate=False))) is True
+
+    # issue 7886
+    assert ask(Q.imaginary(Pow(x, Rational(1, 4))), Q.real(x) & Q.negative(x)) is False
+
+
+def test_integer():
+    assert ask(Q.integer(x)) is None
+    assert ask(Q.integer(x), Q.integer(x)) is True
+    assert ask(Q.integer(x), ~Q.integer(x)) is False
+    assert ask(Q.integer(x), ~Q.real(x)) is False
+    assert ask(Q.integer(x), ~Q.positive(x)) is None
+    assert ask(Q.integer(x), Q.even(x) | Q.odd(x)) is True
+
+    assert ask(Q.integer(2*x), Q.integer(x)) is True
+    assert ask(Q.integer(2*x), Q.even(x)) is True
+    assert ask(Q.integer(2*x), Q.prime(x)) is True
+    assert ask(Q.integer(2*x), Q.rational(x)) is None
+    assert ask(Q.integer(2*x), Q.real(x)) is None
+    assert ask(Q.integer(sqrt(2)*x), Q.integer(x)) is False
+    assert ask(Q.integer(sqrt(2)*x), Q.irrational(x)) is None
+
+    assert ask(Q.integer(x/2), Q.odd(x)) is False
+    assert ask(Q.integer(x/2), Q.even(x)) is True
+    assert ask(Q.integer(x/3), Q.odd(x)) is None
+    assert ask(Q.integer(x/3), Q.even(x)) is None
+
+    # https://github.com/sympy/sympy/issues/7286
+    assert ask(Q.integer(Abs(x)),Q.integer(x)) is True
+    assert ask(Q.integer(Abs(-x)),Q.integer(x)) is True
+    assert ask(Q.integer(Abs(x)), ~Q.integer(x)) is None
+    assert ask(Q.integer(Abs(x)),Q.complex(x)) is None
+    assert ask(Q.integer(Abs(x+I*y)),Q.real(x) & Q.real(y)) is None
+
+    # https://github.com/sympy/sympy/issues/27739
+    assert ask(Q.integer(x/y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.integer(1/x), Q.integer(x)) is None
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.integer(sqrt(5))) is False
+    assert ask(Q.integer(x**y), Q.nonzero(x) & Q.zero(y)) is True
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(-1**x), Q.integer(x)) is True
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(x**y), Q.zero(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(pi**x), Q.zero(x)) is True
+    assert ask(Q.integer(x**y), Q.imaginary(x) & Q.zero(y)) is True
+
+
+def test_negative():
+    assert ask(Q.negative(x), Q.negative(x)) is True
+    assert ask(Q.negative(x), Q.positive(x)) is False
+    assert ask(Q.negative(x), ~Q.real(x)) is False
+    assert ask(Q.negative(x), Q.prime(x)) is False
+    assert ask(Q.negative(x), ~Q.prime(x)) is None
+
+    assert ask(Q.negative(-x), Q.positive(x)) is True
+    assert ask(Q.negative(-x), ~Q.positive(x)) is None
+    assert ask(Q.negative(-x), Q.negative(x)) is False
+    assert ask(Q.negative(-x), Q.positive(x)) is True
+
+    assert ask(Q.negative(x - 1), Q.negative(x)) is True
+    assert ask(Q.negative(x + y)) is None
+    assert ask(Q.negative(x + y), Q.negative(x)) is None
+    assert ask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) is True
+    assert ask(Q.negative(x + y), Q.negative(x) & Q.nonpositive(y)) is True
+    assert ask(Q.negative(2 + I)) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.negative(cos(I)**2 + sin(I)**2 - 1)) is None
+    assert ask(Q.negative(-I + I*(cos(2)**2 + sin(2)**2))) is None
+
+    assert ask(Q.negative(x**2)) is None
+    assert ask(Q.negative(x**2), Q.real(x)) is False
+    assert ask(Q.negative(x**1.4), Q.real(x)) is None
+
+    assert ask(Q.negative(x**I), Q.positive(x)) is None
+
+    assert ask(Q.negative(x*y)) is None
+    assert ask(Q.negative(x*y), Q.positive(x) & Q.positive(y)) is False
+    assert ask(Q.negative(x*y), Q.positive(x) & Q.negative(y)) is True
+    assert ask(Q.negative(x*y), Q.complex(x) & Q.complex(y)) is None
+
+    assert ask(Q.negative(x**y)) is None
+    assert ask(Q.negative(x**y), Q.negative(x) & Q.even(y)) is False
+    assert ask(Q.negative(x**y), Q.negative(x) & Q.odd(y)) is True
+    assert ask(Q.negative(x**y), Q.positive(x) & Q.integer(y)) is False
+
+    assert ask(Q.negative(Abs(x))) is False
+
+
+def test_nonzero():
+    assert ask(Q.nonzero(x)) is None
+    assert ask(Q.nonzero(x), Q.real(x)) is None
+    assert ask(Q.nonzero(x), Q.positive(x)) is True
+    assert ask(Q.nonzero(x), Q.negative(x)) is True
+    assert ask(Q.nonzero(x), Q.negative(x) | Q.positive(x)) is True
+
+    assert ask(Q.nonzero(x + y)) is None
+    assert ask(Q.nonzero(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.nonzero(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.nonzero(x + y), Q.negative(x) & Q.negative(y)) is True
+
+    assert ask(Q.nonzero(2*x)) is None
+    assert ask(Q.nonzero(2*x), Q.positive(x)) is True
+    assert ask(Q.nonzero(2*x), Q.negative(x)) is True
+    assert ask(Q.nonzero(x*y), Q.nonzero(x)) is None
+    assert ask(Q.nonzero(x*y), Q.nonzero(x) & Q.nonzero(y)) is True
+
+    assert ask(Q.nonzero(x**y), Q.nonzero(x)) is True
+
+    assert ask(Q.nonzero(Abs(x))) is None
+    assert ask(Q.nonzero(Abs(x)), Q.nonzero(x)) is True
+
+    assert ask(Q.nonzero(log(exp(2*I)))) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.nonzero(cos(1)**2 + sin(1)**2 - 1)) is None
+
+
+def test_zero():
+    assert ask(Q.zero(x)) is None
+    assert ask(Q.zero(x), Q.real(x)) is None
+    assert ask(Q.zero(x), Q.positive(x)) is False
+    assert ask(Q.zero(x), Q.negative(x)) is False
+    assert ask(Q.zero(x), Q.negative(x) | Q.positive(x)) is False
+
+    assert ask(Q.zero(x), Q.nonnegative(x) & Q.nonpositive(x)) is True
+
+    assert ask(Q.zero(x + y)) is None
+    assert ask(Q.zero(x + y), Q.positive(x) & Q.positive(y)) is False
+    assert ask(Q.zero(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.zero(x + y), Q.negative(x) & Q.negative(y)) is False
+
+    assert ask(Q.zero(2*x)) is None
+    assert ask(Q.zero(2*x), Q.positive(x)) is False
+    assert ask(Q.zero(2*x), Q.negative(x)) is False
+    assert ask(Q.zero(x*y), Q.nonzero(x)) is None
+
+    assert ask(Q.zero(Abs(x))) is None
+    assert ask(Q.zero(Abs(x)), Q.zero(x)) is True
+
+    assert ask(Q.integer(x), Q.zero(x)) is True
+    assert ask(Q.even(x), Q.zero(x)) is True
+    assert ask(Q.odd(x), Q.zero(x)) is False
+    assert ask(Q.zero(x), Q.even(x)) is None
+    assert ask(Q.zero(x), Q.odd(x)) is False
+    assert ask(Q.zero(x) | Q.zero(y), Q.zero(x*y)) is True
+
+
+def test_odd_query():
+    assert ask(Q.odd(x)) is None
+    assert ask(Q.odd(x), Q.odd(x)) is True
+    assert ask(Q.odd(x), Q.integer(x)) is None
+    assert ask(Q.odd(x), ~Q.integer(x)) is False
+    assert ask(Q.odd(x), Q.rational(x)) is None
+    assert ask(Q.odd(x), Q.positive(x)) is None
+
+    assert ask(Q.odd(-x), Q.odd(x)) is True
+
+    assert ask(Q.odd(2*x)) is None
+    assert ask(Q.odd(2*x), Q.integer(x)) is False
+    assert ask(Q.odd(2*x), Q.odd(x)) is False
+    assert ask(Q.odd(2*x), Q.irrational(x)) is False
+    assert ask(Q.odd(2*x), ~Q.integer(x)) is None
+    assert ask(Q.odd(3*x), Q.integer(x)) is None
+
+    assert ask(Q.odd(x/3), Q.odd(x)) is None
+    assert ask(Q.odd(x/3), Q.even(x)) is None
+
+    assert ask(Q.odd(x + 1), Q.even(x)) is True
+    assert ask(Q.odd(x + 2), Q.even(x)) is False
+    assert ask(Q.odd(x + 2), Q.odd(x)) is True
+    assert ask(Q.odd(3 - x), Q.odd(x)) is False
+    assert ask(Q.odd(3 - x), Q.even(x)) is True
+    assert ask(Q.odd(3 + x), Q.odd(x)) is False
+    assert ask(Q.odd(3 + x), Q.even(x)) is True
+    assert ask(Q.odd(x + y), Q.odd(x) & Q.odd(y)) is False
+    assert ask(Q.odd(x + y), Q.odd(x) & Q.even(y)) is True
+    assert ask(Q.odd(x - y), Q.even(x) & Q.odd(y)) is True
+    assert ask(Q.odd(x - y), Q.odd(x) & Q.odd(y)) is False
+
+    assert ask(Q.odd(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) is False
+    assert ask(Q.odd(x + y + z + t),
+        Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) is None
+
+    assert ask(Q.odd(2*x + 1), Q.integer(x)) is True
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.odd(y)) is True
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.even(y)) is False
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.odd(x*y), Q.odd(x) & Q.even(y)) is False
+    assert ask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+    assert ask(Q.odd(2*x*y), Q.rational(x) & Q.rational(x)) is None
+    assert ask(Q.odd(2*x*y), Q.irrational(x) & Q.irrational(x)) is None
+
+    assert ask(Q.odd(Abs(x)), Q.odd(x)) is True
+
+    assert ask(Q.odd((-1)**n), Q.integer(n)) is True
+
+    assert ask(Q.odd(k**2), Q.even(k)) is False
+    assert ask(Q.odd(n**2), Q.odd(n)) is True
+    assert ask(Q.odd(3**k), Q.even(k)) is None
+
+    assert ask(Q.odd(k**m), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(n**m), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is True
+
+    assert ask(Q.odd(k**p), Q.even(k) & Q.integer(p) & Q.positive(p)) is False
+    assert ask(Q.odd(n**p), Q.odd(n) & Q.integer(p) & Q.positive(p)) is True
+
+    assert ask(Q.odd(m**k), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(p**k), Q.even(k) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.odd(m**n), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(p**n), Q.odd(n) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.odd(k**x), Q.even(k)) is None
+    assert ask(Q.odd(n**x), Q.odd(n)) is None
+
+    assert ask(Q.odd(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.odd(x*x), Q.integer(x)) is None
+    assert ask(Q.odd(x*(x + y)), Q.integer(x) & Q.odd(y)) is False
+    assert ask(Q.odd(x*(x + y)), Q.integer(x) & Q.even(y)) is None
+
+
+@XFAIL
+def test_oddness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    assert ask(Q.odd(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is False
+    assert ask(Q.odd(y*x*(x + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is False
+
+
+def test_oddness_in_ternary_integer_product_with_even():
+    assert ask(Q.odd(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.even(z)) is None
+
+
+def test_prime():
+    assert ask(Q.prime(x), Q.prime(x)) is True
+    assert ask(Q.prime(x), ~Q.prime(x)) is False
+    assert ask(Q.prime(x), Q.integer(x)) is None
+    assert ask(Q.prime(x), ~Q.integer(x)) is False
+
+    assert ask(Q.prime(2*x), Q.integer(x)) is None
+    assert ask(Q.prime(x*y)) is None
+    assert ask(Q.prime(x*y), Q.prime(x)) is None
+    assert ask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.prime(4*x), Q.integer(x)) is False
+    assert ask(Q.prime(4*x)) is None
+
+    assert ask(Q.prime(x**2), Q.integer(x)) is False
+    assert ask(Q.prime(x**2), Q.prime(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27446
+    assert ask(Q.prime(4**x), Q.integer(x)) is False
+    assert ask(Q.prime(p**x), Q.prime(p) & Q.integer(x) & Q.ne(x, 1)) is False
+    assert ask(Q.prime(n**x), Q.integer(x) & Q.composite(n)) is False
+    assert ask(Q.prime(x**y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.prime(2**x), Q.integer(x)) is None
+    assert ask(Q.prime(p**x), Q.prime(p) & Q.integer(x)) is None
+
+    # Ideally, these should return True since the base is prime and the exponent is one,
+    # but currently, they return None.
+    assert ask(Q.prime(x**y), Q.prime(x) & Q.eq(y,1)) is None
+    assert ask(Q.prime(x**y), Q.prime(x) & Q.integer(y) & Q.gt(y,0) & Q.lt(y,2)) is None
+
+    assert ask(Q.prime(Pow(x,1, evaluate=False)), Q.prime(x)) is True
+
+
+@_both_exp_pow
+def test_positive():
+    assert ask(Q.positive(cos(I) ** 2 + sin(I) ** 2 - 1)) is None
+    assert ask(Q.positive(x), Q.positive(x)) is True
+    assert ask(Q.positive(x), Q.negative(x)) is False
+    assert ask(Q.positive(x), Q.nonzero(x)) is None
+
+    assert ask(Q.positive(-x), Q.positive(x)) is False
+    assert ask(Q.positive(-x), Q.negative(x)) is True
+
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.nonnegative(y)) is True
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.imaginary(y)) is False
+
+    assert ask(Q.positive(2*x), Q.positive(x)) is True
+    assumptions = Q.positive(x) & Q.negative(y) & Q.negative(z) & Q.positive(w)
+    assert ask(Q.positive(x*y*z)) is None
+    assert ask(Q.positive(x*y*z), assumptions) is True
+    assert ask(Q.positive(-x*y*z), assumptions) is False
+
+    assert ask(Q.positive(x**I), Q.positive(x)) is None
+
+    assert ask(Q.positive(x**2), Q.positive(x)) is True
+    assert ask(Q.positive(x**2), Q.negative(x)) is True
+    assert ask(Q.positive(x**3), Q.negative(x)) is False
+    assert ask(Q.positive(1/(1 + x**2)), Q.real(x)) is True
+    assert ask(Q.positive(2**I)) is False
+    assert ask(Q.positive(2 + I)) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.positive(cos(I)**2 + sin(I)**2 - 1)) is None
+    assert ask(Q.positive(-I + I*(cos(2)**2 + sin(2)**2))) is None
+
+    #exponential
+    assert ask(Q.positive(exp(x)), Q.real(x)) is True
+    assert ask(~Q.negative(exp(x)), Q.real(x)) is True
+    assert ask(Q.positive(x + exp(x)), Q.real(x)) is None
+    assert ask(Q.positive(exp(x)), Q.imaginary(x)) is None
+    assert ask(Q.positive(exp(2*pi*I, evaluate=False)), Q.imaginary(x)) is True
+    assert ask(Q.negative(exp(pi*I, evaluate=False)), Q.imaginary(x)) is True
+    assert ask(Q.positive(exp(x*pi*I)), Q.even(x)) is True
+    assert ask(Q.positive(exp(x*pi*I)), Q.odd(x)) is False
+    assert ask(Q.positive(exp(x*pi*I)), Q.real(x)) is None
+
+    # logarithm
+    assert ask(Q.positive(log(x)), Q.imaginary(x)) is False
+    assert ask(Q.positive(log(x)), Q.negative(x)) is False
+    assert ask(Q.positive(log(x)), Q.positive(x)) is None
+    assert ask(Q.positive(log(x + 2)), Q.positive(x)) is True
+
+    # factorial
+    assert ask(Q.positive(factorial(x)), Q.integer(x) & Q.positive(x))
+    assert ask(Q.positive(factorial(x)), Q.integer(x)) is None
+
+    #absolute value
+    assert ask(Q.positive(Abs(x))) is None  # Abs(0) = 0
+    assert ask(Q.positive(Abs(x)), Q.positive(x)) is True
+
+
+def test_nonpositive():
+    assert ask(Q.nonpositive(-1))
+    assert ask(Q.nonpositive(0))
+    assert ask(Q.nonpositive(1)) is False
+    assert ask(~Q.positive(x), Q.nonpositive(x))
+    assert ask(Q.nonpositive(x), Q.positive(x)) is False
+    assert ask(Q.nonpositive(sqrt(-1))) is False
+    assert ask(Q.nonpositive(x), Q.imaginary(x)) is False
+
+
+def test_nonnegative():
+    assert ask(Q.nonnegative(-1)) is False
+    assert ask(Q.nonnegative(0))
+    assert ask(Q.nonnegative(1))
+    assert ask(~Q.negative(x), Q.nonnegative(x))
+    assert ask(Q.nonnegative(x), Q.negative(x)) is False
+    assert ask(Q.nonnegative(sqrt(-1))) is False
+    assert ask(Q.nonnegative(x), Q.imaginary(x)) is False
+
+def test_real_basic():
+    assert ask(Q.real(x)) is None
+    assert ask(Q.real(x), Q.real(x)) is True
+    assert ask(Q.real(x), Q.nonzero(x)) is True
+    assert ask(Q.real(x), Q.positive(x)) is True
+    assert ask(Q.real(x), Q.negative(x)) is True
+    assert ask(Q.real(x), Q.integer(x)) is True
+    assert ask(Q.real(x), Q.even(x)) is True
+    assert ask(Q.real(x), Q.prime(x)) is True
+
+    assert ask(Q.real(x/sqrt(2)), Q.real(x)) is True
+    assert ask(Q.real(x/sqrt(-2)), Q.real(x)) is False
+
+    assert ask(Q.real(x + 1), Q.real(x)) is True
+    assert ask(Q.real(x + I), Q.real(x)) is False
+    assert ask(Q.real(x + I), Q.complex(x)) is None
+
+    assert ask(Q.real(2*x), Q.real(x)) is True
+    assert ask(Q.real(I*x), Q.real(x)) is False
+    assert ask(Q.real(I*x), Q.imaginary(x)) is True
+    assert ask(Q.real(I*x), Q.complex(x)) is None
+
+
+def test_real_pow():
+    assert ask(Q.real(x**2), Q.real(x)) is True
+    assert ask(Q.real(sqrt(x)), Q.negative(x)) is False
+    assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) is None
+    assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) is True
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.imaginary(y)) is None  # I**I or (2*I)**I
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.real(y)) is None  # I**1 or I**0
+    assert ask(Q.real(x**y), Q.real(x) & Q.imaginary(y)) is None  # could be exp(2*pi*I) or 2**I
+    assert ask(Q.real(x**0), Q.imaginary(x)) is True
+    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) is True
+    assert ask(Q.real(x**y), Q.real(x) & Q.rational(y)) is None
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.integer(y)) is None
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.odd(y)) is False
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.even(y)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.rational(y/z) & Q.even(z) & Q.positive(x)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.rational(y/z) & Q.even(z) & Q.negative(x)) is None
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.integer(y/z)) is None
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.positive(x)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.negative(x)) is None
+    assert ask(Q.real((-I)**i), Q.imaginary(i)) is True
+    assert ask(Q.real(I**i), Q.imaginary(i)) is True
+    assert ask(Q.real(i**i), Q.imaginary(i)) is None  # i might be 2*I
+    assert ask(Q.real(x**i), Q.imaginary(i)) is None  # x could be 0
+    assert ask(Q.real(x**(I*pi/log(x))), Q.real(x)) is True
+
+    # https://github.com/sympy/sympy/issues/27485
+    assert ask(Q.real(n**p), Q.negative(n) & Q.positive(p)) is None
+
+    # https://github.com/sympy/sympy/issues/16530
+    assert ask(Q.real(1/Abs(x))) is None
+    assert ask(Q.real(x**y), Q.zero(x) & Q.real(y)) is None
+    assert ask(Q.real(x**y), Q.zero(x) & Q.positive(y)) is True
+
+
+@_both_exp_pow
+def test_real_functions():
+    # trigonometric functions
+    assert ask(Q.real(sin(x))) is None
+    assert ask(Q.real(cos(x))) is None
+    assert ask(Q.real(sin(x)), Q.real(x)) is True
+    assert ask(Q.real(cos(x)), Q.real(x)) is True
+
+    # exponential function
+    assert ask(Q.real(exp(x))) is None
+    assert ask(Q.real(exp(x)), Q.real(x)) is True
+    assert ask(Q.real(x + exp(x)), Q.real(x)) is True
+    assert ask(Q.real(exp(2*pi*I, evaluate=False))) is True
+    assert ask(Q.real(exp(pi*I, evaluate=False))) is True
+    assert ask(Q.real(exp(pi*I/2, evaluate=False))) is False
+
+    # logarithm
+    assert ask(Q.real(log(I))) is False
+    assert ask(Q.real(log(2*I))) is False
+    assert ask(Q.real(log(I + 1))) is False
+    assert ask(Q.real(log(x)), Q.complex(x)) is None
+    assert ask(Q.real(log(x)), Q.imaginary(x)) is False
+    assert ask(Q.real(log(exp(x))), Q.imaginary(x)) is None  # exp(2*pi*I) is 1, log(exp(pi*I)) is pi*I (disregarding periodicity)
+    assert ask(Q.real(log(exp(x))), Q.complex(x)) is None
+    eq = Pow(exp(2*pi*I*x, evaluate=False), x, evaluate=False)
+    assert ask(Q.real(eq), Q.integer(x)) is True
+    assert ask(Q.real(exp(x)**x), Q.imaginary(x)) is True
+    assert ask(Q.real(exp(x)**x), Q.complex(x)) is None
+
+    # Q.complexes
+    assert ask(Q.real(re(x))) is True
+    assert ask(Q.real(im(x))) is True
+
+
+def test_matrix():
+
+    # hermitian
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, 4], [2 - I, 3, I], [4, -I, 1]]))) == True
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, 4], [2 + I, 3, I], [4, -I, 1]]))) == False
+    z = symbols('z', complex=True)
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, z], [2 - I, 3, I], [4, -I, 1]]))) == None
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))))) == True
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, I, 0), (-5, 0, 11))))) == False
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, z, 0), (-5, 0, 11))))) == None
+
+    # antihermitian
+    A = Matrix([[0, -2 - I, 0], [2 - I, 0, -I], [0, -I, 0]])
+    B = Matrix([[-I, 2 + I, 0], [-2 + I, 0, 2 + I], [0, -2 + I, -I]])
+    assert ask(Q.antihermitian(A)) is True
+    assert ask(Q.antihermitian(B)) is True
+    assert ask(Q.antihermitian(A**2)) is False
+    C = (B**3)
+    C.simplify()
+    assert ask(Q.antihermitian(C)) is True
+    _A = Matrix([[0, -2 - I, 0], [z, 0, -I], [0, -I, 0]])
+    assert ask(Q.antihermitian(_A)) is None
+
+
+@_both_exp_pow
+def test_algebraic():
+    assert ask(Q.algebraic(x)) is None
+
+    assert ask(Q.algebraic(I)) is True
+    assert ask(Q.algebraic(2*I)) is True
+    assert ask(Q.algebraic(I/3)) is True
+
+    assert ask(Q.algebraic(sqrt(7))) is True
+    assert ask(Q.algebraic(2*sqrt(7))) is True
+    assert ask(Q.algebraic(sqrt(7)/3)) is True
+
+    assert ask(Q.algebraic(I*sqrt(3))) is True
+    assert ask(Q.algebraic(sqrt(1 + I*sqrt(3)))) is True
+
+    assert ask(Q.algebraic(1 + I*sqrt(3)**Rational(17, 31))) is True
+    assert ask(Q.algebraic(1 + I*sqrt(3)**(17/pi))) is None
+
+    for f in [exp, sin, tan, asin, atan, cos]:
+        assert ask(Q.algebraic(f(7))) is False
+        assert ask(Q.algebraic(f(7, evaluate=False))) is False
+        assert ask(Q.algebraic(f(0, evaluate=False))) is True
+        assert ask(Q.algebraic(f(x)), Q.algebraic(x)) is None
+        assert ask(Q.algebraic(f(x)), Q.algebraic(x) & Q.nonzero(x)) is False
+
+    for g in [log, acos]:
+        assert ask(Q.algebraic(g(7))) is False
+        assert ask(Q.algebraic(g(7, evaluate=False))) is False
+        assert ask(Q.algebraic(g(1, evaluate=False))) is True
+        assert ask(Q.algebraic(g(x)), Q.algebraic(x)) is None
+        assert ask(Q.algebraic(g(x)), Q.algebraic(x) & Q.nonzero(x - 1)) is False
+
+    for h in [cot, acot]:
+        assert ask(Q.algebraic(h(7))) is False
+        assert ask(Q.algebraic(h(7, evaluate=False))) is False
+        assert ask(Q.algebraic(h(x)), Q.algebraic(x)) is False
+
+    assert ask(Q.algebraic(sqrt(sin(7)))) is None
+    assert ask(Q.algebraic(sqrt(y + I*sqrt(7)))) is None
+
+    assert ask(Q.algebraic(2.47)) is True
+
+    assert ask(Q.algebraic(x), Q.transcendental(x)) is False
+    assert ask(Q.transcendental(x), Q.algebraic(x)) is False
+
+    #https://github.com/sympy/sympy/issues/27445
+    assert ask(Q.algebraic(Pow(1, x, evaluate=False)), Q.algebraic(x)) is None
+    assert ask(Q.algebraic(Pow(x, y))) is None
+    assert ask(Q.algebraic(Pow(1, x, evaluate=False))) is None
+    assert ask(Q.algebraic(x**(pi*I))) is None
+    assert ask(Q.algebraic(pi**n),Q.integer(n) & Q.positive(n)) is False
+    assert ask(Q.algebraic(x**y),Q.algebraic(x) & Q.rational(y)) is True
+
+
+def test_global():
+    """Test ask with global assumptions"""
+    assert ask(Q.integer(x)) is None
+    global_assumptions.add(Q.integer(x))
+    assert ask(Q.integer(x)) is True
+    global_assumptions.clear()
+    assert ask(Q.integer(x)) is None
+
+
+def test_custom_context():
+    """Test ask with custom assumptions context"""
+    assert ask(Q.integer(x)) is None
+    local_context = AssumptionsContext()
+    local_context.add(Q.integer(x))
+    assert ask(Q.integer(x), context=local_context) is True
+    assert ask(Q.integer(x)) is None
+
+
+def test_functions_in_assumptions():
+    assert ask(Q.negative(x), Q.real(x) >> Q.positive(x)) is False
+    assert ask(Q.negative(x), Equivalent(Q.real(x), Q.positive(x))) is False
+    assert ask(Q.negative(x), Xor(Q.real(x), Q.negative(x))) is False
+
+
+def test_composite_ask():
+    assert ask(Q.negative(x) & Q.integer(x),
+        assumptions=Q.real(x) >> Q.positive(x)) is False
+
+
+def test_composite_proposition():
+    assert ask(True) is True
+    assert ask(False) is False
+    assert ask(~Q.negative(x), Q.positive(x)) is True
+    assert ask(~Q.real(x), Q.commutative(x)) is None
+    assert ask(Q.negative(x) & Q.integer(x), Q.positive(x)) is False
+    assert ask(Q.negative(x) & Q.integer(x)) is None
+    assert ask(Q.real(x) | Q.integer(x), Q.positive(x)) is True
+    assert ask(Q.real(x) | Q.integer(x)) is None
+    assert ask(Q.real(x) >> Q.positive(x), Q.negative(x)) is False
+    assert ask(Implies(
+        Q.real(x), Q.positive(x), evaluate=False), Q.negative(x)) is False
+    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False)) is None
+    assert ask(Equivalent(Q.integer(x), Q.even(x)), Q.even(x)) is True
+    assert ask(Equivalent(Q.integer(x), Q.even(x))) is None
+    assert ask(Equivalent(Q.positive(x), Q.integer(x)), Q.integer(x)) is None
+    assert ask(Q.real(x) | Q.integer(x), Q.real(x) | Q.integer(x)) is True
+
+def test_tautology():
+    assert ask(Q.real(x) | ~Q.real(x)) is True
+    assert ask(Q.real(x) & ~Q.real(x)) is False
+
+def test_composite_assumptions():
+    assert ask(Q.real(x), Q.real(x) & Q.real(y)) is True
+    assert ask(Q.positive(x), Q.positive(x) | Q.positive(y)) is None
+    assert ask(Q.positive(x), Q.real(x) >> Q.positive(y)) is None
+    assert ask(Q.real(x), ~(Q.real(x) >> Q.real(y))) is True
+
+def test_key_extensibility():
+    """test that you can add keys to the ask system at runtime"""
+    # make sure the key is not defined
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+    # Old handler system
+    class MyAskHandler(AskHandler):
+        @staticmethod
+        def Symbol(expr, assumptions):
+            return True
+    try:
+        with warns_deprecated_sympy():
+            register_handler('my_key', MyAskHandler)
+        with warns_deprecated_sympy():
+            assert ask(Q.my_key(x)) is True
+        with warns_deprecated_sympy():
+            assert ask(Q.my_key(x + 1)) is None
+    finally:
+        # We have to disable the stacklevel testing here because this raises
+        # the warning twice from two different places
+        with warns_deprecated_sympy():
+            remove_handler('my_key', MyAskHandler)
+        del Q.my_key
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+    # New handler system
+    class MyPredicate(Predicate):
+        pass
+    try:
+        Q.my_key = MyPredicate()
+        @Q.my_key.register(Symbol)
+        def _(expr, assumptions):
+            return True
+        assert ask(Q.my_key(x)) is True
+        assert ask(Q.my_key(x+1)) is None
+    finally:
+        del Q.my_key
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+
+def test_type_extensibility():
+    """test that new types can be added to the ask system at runtime
+    """
+    from sympy.core import Basic
+
+    class MyType(Basic):
+        pass
+
+    @Q.prime.register(MyType)
+    def _(expr, assumptions):
+        return True
+
+    assert ask(Q.prime(MyType())) is True
+
+
+def test_single_fact_lookup():
+    known_facts = And(Implies(Q.integer, Q.rational),
+                      Implies(Q.rational, Q.real),
+                      Implies(Q.real, Q.complex))
+    known_facts_keys = {Q.integer, Q.rational, Q.real, Q.complex}
+
+    known_facts_cnf = to_cnf(known_facts)
+    mapping = single_fact_lookup(known_facts_keys, known_facts_cnf)
+
+    assert mapping[Q.rational] == {Q.real, Q.rational, Q.complex}
+
+
+def test_generate_known_facts_dict():
+    known_facts = And(Implies(Q.integer(x), Q.rational(x)),
+                      Implies(Q.rational(x), Q.real(x)),
+                      Implies(Q.real(x), Q.complex(x)))
+    known_facts_keys = {Q.integer(x), Q.rational(x), Q.real(x), Q.complex(x)}
+
+    assert generate_known_facts_dict(known_facts_keys, known_facts) == \
+        {Q.complex: ({Q.complex}, set()),
+         Q.integer: ({Q.complex, Q.integer, Q.rational, Q.real}, set()),
+         Q.rational: ({Q.complex, Q.rational, Q.real}, set()),
+         Q.real: ({Q.complex, Q.real}, set())}
+
+
+@slow
+def test_known_facts_consistent():
+    """"Test that ask_generated.py is up-to-date"""
+    x = Symbol('x')
+    fact = get_known_facts(x)
+    # test cnf clauses of fact between unary predicates
+    cnf = CNF.to_CNF(fact)
+    clauses = set()
+    clauses.update(frozenset(Literal(lit.arg.function, lit.is_Not) for lit in sorted(cl, key=str)) for cl in cnf.clauses)
+    assert get_all_known_facts() == clauses
+    # test dictionary of fact between unary predicates
+    keys = [pred(x) for pred in get_known_facts_keys()]
+    mapping = generate_known_facts_dict(keys, fact)
+    assert get_known_facts_dict() == mapping
+
+
+def test_Add_queries():
+    assert ask(Q.prime(12345678901234567890 + (cos(1)**2 + sin(1)**2))) is True
+    assert ask(Q.even(Add(S(2), S(2), evaluate=False))) is True
+    assert ask(Q.prime(Add(S(2), S(2), evaluate=False))) is False
+    assert ask(Q.integer(Add(S(2), S(2), evaluate=False))) is True
+
+
+def test_positive_assuming():
+    with assuming(Q.positive(x + 1)):
+        assert not ask(Q.positive(x))
+
+
+def test_issue_5421():
+    raises(TypeError, lambda: ask(pi/log(x), Q.real))
+
+
+def test_issue_3906():
+    raises(TypeError, lambda: ask(Q.positive))
+
+
+def test_issue_5833():
+    assert ask(Q.positive(log(x)**2), Q.positive(x)) is None
+    assert ask(~Q.negative(log(x)**2), Q.positive(x)) is True
+
+
+def test_issue_6732():
+    raises(ValueError, lambda: ask(Q.positive(x), Q.positive(x) & Q.negative(x)))
+    raises(ValueError, lambda: ask(Q.negative(x), Q.positive(x) & Q.negative(x)))
+
+
+def test_issue_7246():
+    assert ask(Q.positive(atan(p)), Q.positive(p)) is True
+    assert ask(Q.positive(atan(p)), Q.negative(p)) is False
+    assert ask(Q.positive(atan(p)), Q.zero(p)) is False
+    assert ask(Q.positive(atan(x))) is None
+
+    assert ask(Q.positive(asin(p)), Q.positive(p)) is None
+    assert ask(Q.positive(asin(p)), Q.zero(p)) is None
+    assert ask(Q.positive(asin(Rational(1, 7)))) is True
+    assert ask(Q.positive(asin(x)), Q.positive(x) & Q.nonpositive(x - 1)) is True
+    assert ask(Q.positive(asin(x)), Q.negative(x) & Q.nonnegative(x + 1)) is False
+
+    assert ask(Q.positive(acos(p)), Q.positive(p)) is None
+    assert ask(Q.positive(acos(Rational(1, 7)))) is True
+    assert ask(Q.positive(acos(x)), Q.nonnegative(x + 1) & Q.nonpositive(x - 1)) is True
+    assert ask(Q.positive(acos(x)), Q.nonnegative(x - 1)) is None
+
+    assert ask(Q.positive(acot(x)), Q.positive(x)) is True
+    assert ask(Q.positive(acot(x)), Q.real(x)) is True
+    assert ask(Q.positive(acot(x)), Q.imaginary(x)) is False
+    assert ask(Q.positive(acot(x))) is None
+
+
+@XFAIL
+def test_issue_7246_failing():
+    #Move this test to test_issue_7246 once
+    #the new assumptions module is improved.
+    assert ask(Q.positive(acos(x)), Q.zero(x)) is True
+
+
+def test_check_old_assumption():
+    x = symbols('x', real=True)
+    assert ask(Q.real(x)) is True
+    assert ask(Q.imaginary(x)) is False
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', imaginary=True)
+    assert ask(Q.real(x)) is False
+    assert ask(Q.imaginary(x)) is True
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', complex=True)
+    assert ask(Q.real(x)) is None
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', positive=True)
+    assert ask(Q.positive(x)) is True
+    assert ask(Q.negative(x)) is False
+    assert ask(Q.real(x)) is True
+
+    x = symbols('x', commutative=False)
+    assert ask(Q.commutative(x)) is False
+
+    x = symbols('x', negative=True)
+    assert ask(Q.positive(x)) is False
+    assert ask(Q.negative(x)) is True
+
+    x = symbols('x', nonnegative=True)
+    assert ask(Q.negative(x)) is False
+    assert ask(Q.positive(x)) is None
+    assert ask(Q.zero(x)) is None
+
+    x = symbols('x', finite=True)
+    assert ask(Q.finite(x)) is True
+
+    x = symbols('x', prime=True)
+    assert ask(Q.prime(x)) is True
+    assert ask(Q.composite(x)) is False
+
+    x = symbols('x', composite=True)
+    assert ask(Q.prime(x)) is False
+    assert ask(Q.composite(x)) is True
+
+    x = symbols('x', even=True)
+    assert ask(Q.even(x)) is True
+    assert ask(Q.odd(x)) is False
+
+    x = symbols('x', odd=True)
+    assert ask(Q.even(x)) is False
+    assert ask(Q.odd(x)) is True
+
+    x = symbols('x', nonzero=True)
+    assert ask(Q.nonzero(x)) is True
+    assert ask(Q.zero(x)) is False
+
+    x = symbols('x', zero=True)
+    assert ask(Q.zero(x)) is True
+
+    x = symbols('x', integer=True)
+    assert ask(Q.integer(x)) is True
+
+    x = symbols('x', rational=True)
+    assert ask(Q.rational(x)) is True
+    assert ask(Q.irrational(x)) is False
+
+    x = symbols('x', irrational=True)
+    assert ask(Q.irrational(x)) is True
+    assert ask(Q.rational(x)) is False
+
+
+def test_issue_9636():
+    assert ask(Q.integer(1.0)) is None
+    assert ask(Q.prime(3.0)) is None
+    assert ask(Q.composite(4.0)) is None
+    assert ask(Q.even(2.0)) is None
+    assert ask(Q.odd(3.0)) is None
+
+
+def test_autosimp_used_to_fail():
+    # See issue #9807
+    assert ask(Q.imaginary(0**I)) is None
+    assert ask(Q.imaginary(0**(-I))) is None
+    assert ask(Q.real(0**I)) is None
+    assert ask(Q.real(0**(-I))) is None
+
+
+def test_custom_AskHandler():
+    from sympy.logic.boolalg import conjuncts
+
+    # Old handler system
+    class MersenneHandler(AskHandler):
+        @staticmethod
+        def Integer(expr, assumptions):
+            if ask(Q.integer(log(expr + 1, 2))):
+                return True
+        @staticmethod
+        def Symbol(expr, assumptions):
+            if expr in conjuncts(assumptions):
+                return True
+    try:
+        with warns_deprecated_sympy():
+            register_handler('mersenne', MersenneHandler)
+        n = Symbol('n', integer=True)
+        with warns_deprecated_sympy():
+            assert ask(Q.mersenne(7))
+        with warns_deprecated_sympy():
+            assert ask(Q.mersenne(n), Q.mersenne(n))
+    finally:
+        del Q.mersenne
+
+    # New handler system
+    class MersennePredicate(Predicate):
+        pass
+    try:
+        Q.mersenne = MersennePredicate()
+        @Q.mersenne.register(Integer)
+        def _(expr, assumptions):
+            if ask(Q.integer(log(expr + 1, 2))):
+                return True
+        @Q.mersenne.register(Symbol)
+        def _(expr, assumptions):
+            if expr in conjuncts(assumptions):
+                return True
+        assert ask(Q.mersenne(7))
+        assert ask(Q.mersenne(n), Q.mersenne(n))
+    finally:
+        del Q.mersenne
+
+
+def test_polyadic_predicate():
+
+    class SexyPredicate(Predicate):
+        pass
+    try:
+        Q.sexyprime = SexyPredicate()
+
+        @Q.sexyprime.register(Integer, Integer)
+        def _(int1, int2, assumptions):
+            args = sorted([int1, int2])
+            if not all(ask(Q.prime(a), assumptions) for a in args):
+                return False
+            return args[1] - args[0] == 6
+
+        @Q.sexyprime.register(Integer, Integer, Integer)
+        def _(int1, int2, int3, assumptions):
+            args = sorted([int1, int2, int3])
+            if not all(ask(Q.prime(a), assumptions) for a in args):
+                return False
+            return args[2] - args[1] == 6 and args[1] - args[0] == 6
+
+        assert ask(Q.sexyprime(5, 11))
+        assert ask(Q.sexyprime(7, 13, 19))
+    finally:
+        del Q.sexyprime
+
+
+def test_Predicate_handler_is_unique():
+
+    # Undefined predicate does not have a handler
+    assert Predicate('mypredicate').handler is None
+
+    # Handler of defined predicate is unique to the class
+    class MyPredicate(Predicate):
+        pass
+    mp1 = MyPredicate(Str('mp1'))
+    mp2 = MyPredicate(Str('mp2'))
+    assert mp1.handler is mp2.handler
+
+
+def test_relational():
+    assert ask(Q.eq(x, 0), Q.zero(x))
+    assert not ask(Q.eq(x, 0), Q.nonzero(x))
+    assert not ask(Q.ne(x, 0), Q.zero(x))
+    assert ask(Q.ne(x, 0), Q.nonzero(x))
+
+
+def test_issue_25221():
+    assert ask(Q.transcendental(x), Q.algebraic(x) | Q.positive(y,y)) is None
+    assert ask(Q.transcendental(x), Q.algebraic(x) | (0 > y)) is None
+    assert ask(Q.transcendental(x), Q.algebraic(x) | Q.gt(0,y)) is None
+
+
+def test_issue_27440():
+    nan = S.NaN
+    assert ask(Q.negative(nan)) is None
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_refine.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_refine.py
new file mode 100644
index 0000000000000000000000000000000000000000..81533a88b232cd5c3cfb9be17d09dad404d679dc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_refine.py
@@ -0,0 +1,227 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.refine import refine
+from sympy.core.expr import Expr
+from sympy.core.numbers import (I, Rational, nan, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (Abs, arg, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, atan2)
+from sympy.abc import w, x, y, z
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+
+
+def test_Abs():
+    assert refine(Abs(x), Q.positive(x)) == x
+    assert refine(1 + Abs(x), Q.positive(x)) == 1 + x
+    assert refine(Abs(x), Q.negative(x)) == -x
+    assert refine(1 + Abs(x), Q.negative(x)) == 1 - x
+
+    assert refine(Abs(x**2)) != x**2
+    assert refine(Abs(x**2), Q.real(x)) == x**2
+
+
+def test_pow1():
+    assert refine((-1)**x, Q.even(x)) == 1
+    assert refine((-1)**x, Q.odd(x)) == -1
+    assert refine((-2)**x, Q.even(x)) == 2**x
+
+    # nested powers
+    assert refine(sqrt(x**2)) != Abs(x)
+    assert refine(sqrt(x**2), Q.complex(x)) != Abs(x)
+    assert refine(sqrt(x**2), Q.real(x)) == Abs(x)
+    assert refine(sqrt(x**2), Q.positive(x)) == x
+    assert refine((x**3)**Rational(1, 3)) != x
+
+    assert refine((x**3)**Rational(1, 3), Q.real(x)) != x
+    assert refine((x**3)**Rational(1, 3), Q.positive(x)) == x
+
+    assert refine(sqrt(1/x), Q.real(x)) != 1/sqrt(x)
+    assert refine(sqrt(1/x), Q.positive(x)) == 1/sqrt(x)
+
+    # powers of (-1)
+    assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
+    assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
+    assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
+    assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
+    assert refine((-1)**(x + 3)) == (-1)**(x + 1)
+
+    # continuation
+    assert refine((-1)**((-1)**x/2 - S.Half), Q.integer(x)) == (-1)**x
+    assert refine((-1)**((-1)**x/2 + S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 + 5*S.Half), Q.integer(x)) == (-1)**(x + 1)
+
+
+def test_pow2():
+    assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
+
+    # powers of Abs
+    assert refine(Abs(x)**2, Q.real(x)) == x**2
+    assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
+    assert refine(Abs(x)**2) == Abs(x)**2
+
+
+def test_exp():
+    x = Symbol('x', integer=True)
+    assert refine(exp(pi*I*2*x)) == 1
+    assert refine(exp(pi*I*2*(x + S.Half))) == -1
+    assert refine(exp(pi*I*2*(x + Rational(1, 4)))) == I
+    assert refine(exp(pi*I*2*(x + Rational(3, 4)))) == -I
+
+
+def test_Piecewise():
+    assert refine(Piecewise((1, x < 0), (3, True)), (x < 0)) == 1
+    assert refine(Piecewise((1, x < 0), (3, True)), ~(x < 0)) == 3
+    assert refine(Piecewise((1, x < 0), (3, True)), (y < 0)) == \
+        Piecewise((1, x < 0), (3, True))
+    assert refine(Piecewise((1, x > 0), (3, True)), (x > 0)) == 1
+    assert refine(Piecewise((1, x > 0), (3, True)), ~(x > 0)) == 3
+    assert refine(Piecewise((1, x > 0), (3, True)), (y > 0)) == \
+        Piecewise((1, x > 0), (3, True))
+    assert refine(Piecewise((1, x <= 0), (3, True)), (x <= 0)) == 1
+    assert refine(Piecewise((1, x <= 0), (3, True)), ~(x <= 0)) == 3
+    assert refine(Piecewise((1, x <= 0), (3, True)), (y <= 0)) == \
+        Piecewise((1, x <= 0), (3, True))
+    assert refine(Piecewise((1, x >= 0), (3, True)), (x >= 0)) == 1
+    assert refine(Piecewise((1, x >= 0), (3, True)), ~(x >= 0)) == 3
+    assert refine(Piecewise((1, x >= 0), (3, True)), (y >= 0)) == \
+        Piecewise((1, x >= 0), (3, True))
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(0, x)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(0, x)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(y, 0)))\
+        == Piecewise((1, Eq(x, 0)), (3, True))
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), ~(Ne(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(y, 0)))\
+        == Piecewise((1, Ne(x, 0)), (3, True))
+
+
+def test_atan2():
+    assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y/x) - pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y/x) + pi
+    assert refine(atan2(y, x), Q.zero(y) & Q.negative(x)) == pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.zero(x)) == pi/2
+    assert refine(atan2(y, x), Q.negative(y) & Q.zero(x)) == -pi/2
+    assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) is nan
+
+
+def test_re():
+    assert refine(re(x), Q.real(x)) == x
+    assert refine(re(x), Q.imaginary(x)) is S.Zero
+    assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y
+    assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x
+    assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y
+    assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0
+    assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z
+
+
+def test_im():
+    assert refine(im(x), Q.imaginary(x)) == -I*x
+    assert refine(im(x), Q.real(x)) is S.Zero
+    assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y
+    assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0
+    assert refine(im(1/x), Q.imaginary(x)) == -I/x
+    assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y)
+        & Q.imaginary(z)) == -I*x*y*z
+
+
+def test_complex():
+    assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        x/(x**2 + y**2)
+    assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        -y/(x**2 + y**2)
+    assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*y - x*z
+    assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*z + x*y
+
+
+def test_sign():
+    x = Symbol('x', real = True)
+    assert refine(sign(x), Q.positive(x)) == 1
+    assert refine(sign(x), Q.negative(x)) == -1
+    assert refine(sign(x), Q.zero(x)) == 0
+    assert refine(sign(x), True) == sign(x)
+    assert refine(sign(Abs(x)), Q.nonzero(x)) == 1
+
+    x = Symbol('x', imaginary=True)
+    assert refine(sign(x), Q.positive(im(x))) == S.ImaginaryUnit
+    assert refine(sign(x), Q.negative(im(x))) == -S.ImaginaryUnit
+    assert refine(sign(x), True) == sign(x)
+
+    x = Symbol('x', complex=True)
+    assert refine(sign(x), Q.zero(x)) == 0
+
+def test_arg():
+    x = Symbol('x', complex = True)
+    assert refine(arg(x), Q.positive(x)) == 0
+    assert refine(arg(x), Q.negative(x)) == pi
+
+def test_func_args():
+    class MyClass(Expr):
+        # A class with nontrivial .func
+
+        def __init__(self, *args):
+            self.my_member = ""
+
+        @property
+        def func(self):
+            def my_func(*args):
+                obj = MyClass(*args)
+                obj.my_member = self.my_member
+                return obj
+            return my_func
+
+    x = MyClass()
+    x.my_member = "A very important value"
+    assert x.my_member == refine(x).my_member
+
+def test_issue_refine_9384():
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.positive(x)) == 0
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.negative(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.positive(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.negative(x)) == 0
+
+
+def test_eval_refine():
+    class MockExpr(Expr):
+        def _eval_refine(self, assumptions):
+            return True
+
+    mock_obj = MockExpr()
+    assert refine(mock_obj)
+
+def test_refine_issue_12724():
+    expr1 = refine(Abs(x * y), Q.positive(x))
+    expr2 = refine(Abs(x * y * z), Q.positive(x))
+    assert expr1 == x * Abs(y)
+    assert expr2 == x * Abs(y * z)
+    y1 = Symbol('y1', real = True)
+    expr3 = refine(Abs(x * y1**2 * z), Q.positive(x))
+    assert expr3 == x * y1**2 * Abs(z)
+
+
+def test_matrixelement():
+    x = MatrixSymbol('x', 3, 3)
+    i = Symbol('i', positive = True)
+    j = Symbol('j', positive = True)
+    assert refine(x[0, 1], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[1, 0], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[i, j], Q.symmetric(x)) == x[j, i]
+    assert refine(x[j, i], Q.symmetric(x)) == x[j, i]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_rel_queries.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_rel_queries.py
new file mode 100644
index 0000000000000000000000000000000000000000..46fe3a35dc1adb23668e88d5794fe1c0ab22f33a
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_rel_queries.py
@@ -0,0 +1,172 @@
+from sympy.assumptions.lra_satask import lra_satask
+from sympy.logic.algorithms.lra_theory import UnhandledInput
+from sympy.assumptions.ask import Q, ask
+
+from sympy.core import symbols, Symbol
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.numbers import I
+
+from sympy.testing.pytest import raises, XFAIL
+x, y, z = symbols("x y z", real=True)
+
+def test_lra_satask():
+    im = Symbol('im', imaginary=True)
+
+    # test preprocessing of unequalities is working correctly
+    assert lra_satask(Q.eq(x, 1), ~Q.ne(x, 0)) is False
+    assert lra_satask(Q.eq(x, 0), ~Q.ne(x, 0)) is True
+    assert lra_satask(~Q.ne(x, 0), Q.eq(x, 0)) is True
+    assert lra_satask(~Q.eq(x, 0), Q.eq(x, 0)) is False
+    assert lra_satask(Q.ne(x, 0), Q.eq(x, 0)) is False
+
+    # basic tests
+    assert lra_satask(Q.ne(x, x)) is False
+    assert lra_satask(Q.eq(x, x)) is True
+    assert lra_satask(Q.gt(x, 0), Q.gt(x, 1)) is True
+
+    # check that True/False are handled
+    assert lra_satask(Q.gt(x, 0), True) is None
+    assert raises(ValueError, lambda: lra_satask(Q.gt(x, 0), False))
+
+    # check imaginary numbers are correctly handled
+    # (im * I).is_real returns True so this is an edge case
+    raises(UnhandledInput, lambda: lra_satask(Q.gt(im * I, 0), Q.gt(im * I, 0)))
+
+    # check matrix inputs
+    X = MatrixSymbol("X", 2, 2)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(X, 2) & Q.gt(X, 3)))
+
+
+def test_old_assumptions():
+    # test unhandled old assumptions
+    w = symbols("w")
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", rational=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", odd=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", even=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", prime=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", composite=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+
+    # test handled
+    w = symbols("w", positive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is False
+    assert lra_satask(Q.gt(w, 0)) is True
+    w = symbols("w", negative=True, real=True)
+    assert lra_satask(Q.lt(w, 0)) is True
+    assert lra_satask(Q.ge(w, 0)) is False
+    w = symbols("w", zero=True, real=True)
+    assert lra_satask(Q.eq(w, 0)) is True
+    assert lra_satask(Q.ne(w, 0)) is False
+    w = symbols("w", nonzero=True, real=True)
+    assert lra_satask(Q.ne(w, 0)) is True
+    assert lra_satask(Q.eq(w, 1)) is None
+    w = symbols("w", nonpositive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is True
+    assert lra_satask(Q.gt(w, 0)) is False
+    w = symbols("w", nonnegative=True, real=True)
+    assert lra_satask(Q.ge(w, 0)) is True
+    assert lra_satask(Q.lt(w, 0)) is False
+
+
+def test_rel_queries():
+    assert ask(Q.lt(x, 2) & Q.gt(x, 3)) is False
+    assert ask(Q.positive(x - z), (x > y) & (y > z)) is True
+    assert ask(x + y > 2, (x < 0) & (y <0)) is False
+    assert ask(x > z, (x > y) & (y > z)) is True
+
+
+def test_unhandled_queries():
+    X = MatrixSymbol("X", 2, 2)
+    assert ask(Q.lt(X, 2) & Q.gt(X, 3)) is None
+
+
+def test_all_pred():
+    # test usable pred
+    assert lra_satask(Q.extended_positive(x), (x > 2)) is True
+    assert lra_satask(Q.positive_infinite(x)) is False
+    assert lra_satask(Q.negative_infinite(x)) is False
+
+    # test disallowed pred
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.prime(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.composite(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.odd(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.even(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.integer(x)))
+
+
+def test_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Transitivity
+    # If a <= b and b <= c, then a <= c.
+    assert ask(a <= c, (a <= b) & (b <= c)) is True
+    # If a <= b and b < c, then a < c.
+    assert ask(a < c, (a <= b) & (b < c)) is True
+    # If a < b and b <= c, then a < c.
+    assert ask(a < c, (a < b) & (b <= c)) is True
+
+    # Addition and subtraction
+    # If a <= b, then a + c <= b + c and a - c <= b - c.
+    assert ask(a + c <= b + c, a <= b) is True
+    assert ask(a - c <= b - c, a <= b) is True
+
+
+@XFAIL
+def test_failing_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Multiplication and division
+    # If a <= b and c > 0, then ac <= bc and a/c <= b/c. (True for non-zero c)
+    assert ask(a*c <= b*c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    assert ask(a/c <= b/c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    # If a <= b and c < 0, then ac >= bc and a/c >= b/c. (True for non-zero c)
+    assert ask(a*c >= b*c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+    assert ask(a/c >= b/c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+
+    # Additive inverse
+    # If a <= b, then -a >= -b.
+    assert ask(-a >= -b, a <= b) is True
+
+    # Multiplicative inverse
+    # For a, b that are both negative or both positive:
+    # If a <= b, then 1/a >= 1/b .
+    assert ask(1/a >= 1/b, (a <= b) & Q.positive(x) & Q.positive(b)) is True
+    assert ask(1/a >= 1/b, (a <= b) & Q.negative(x) & Q.negative(b)) is True
+
+
+def test_equality():
+    # test symmetry and reflexivity
+    assert ask(Q.eq(x, x)) is True
+    assert ask(Q.eq(y, x), Q.eq(x, y)) is True
+    assert ask(Q.eq(y, x), ~Q.eq(z, z) | Q.eq(x, y)) is True
+
+    # test transitivity
+    assert ask(Q.eq(x,z), Q.eq(x,y) & Q.eq(y,z)) is True
+
+
+@XFAIL
+def test_equality_failing():
+    # Note that implementing the substitution property of equality
+    # most likely requires a redesign of the new assumptions.
+    # See issue #25485 for why this is the case and general ideas
+    # about how things could be redesigned.
+
+    # test substitution property
+    assert ask(Q.prime(x), Q.eq(x, y) & Q.prime(y)) is True
+    assert ask(Q.real(x), Q.eq(x, y) & Q.real(y)) is True
+    assert ask(Q.imaginary(x), Q.eq(x, y) & Q.imaginary(y)) is True
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_satask.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..5831b69e3e6bf2b1a906d1140967510c2ea8b630
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_satask.py
@@ -0,0 +1,378 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.assume import assuming
+from sympy.core.numbers import (I, pi)
+from sympy.core.relational import (Eq, Gt)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic.boolalg import Implies
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.assumptions.cnf import CNF, Literal
+from sympy.assumptions.satask import (satask, extract_predargs,
+    get_relevant_clsfacts)
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+x, y, z = symbols('x y z')
+
+
+def test_satask():
+    # No relevant facts
+    assert satask(Q.real(x), Q.real(x)) is True
+    assert satask(Q.real(x), ~Q.real(x)) is False
+    assert satask(Q.real(x)) is None
+
+    assert satask(Q.real(x), Q.positive(x)) is True
+    assert satask(Q.positive(x), Q.real(x)) is None
+    assert satask(Q.real(x), ~Q.positive(x)) is None
+    assert satask(Q.positive(x), ~Q.real(x)) is False
+
+    raises(ValueError, lambda: satask(Q.real(x), Q.real(x) & ~Q.real(x)))
+
+    with assuming(Q.positive(x)):
+        assert satask(Q.real(x)) is True
+        assert satask(~Q.positive(x)) is False
+        raises(ValueError, lambda: satask(Q.real(x), ~Q.positive(x)))
+
+    assert satask(Q.zero(x), Q.nonzero(x)) is False
+    assert satask(Q.positive(x), Q.zero(x)) is False
+    assert satask(Q.real(x), Q.zero(x)) is True
+    assert satask(Q.zero(x), Q.zero(x*y)) is None
+    assert satask(Q.zero(x*y), Q.zero(x))
+
+
+def test_zero():
+    """
+    Everything in this test doesn't work with the ask handlers, and most
+    things would be very difficult or impossible to make work under that
+    model.
+
+    """
+    assert satask(Q.zero(x) | Q.zero(y), Q.zero(x*y)) is True
+    assert satask(Q.zero(x*y), Q.zero(x) | Q.zero(y)) is True
+
+    assert satask(Implies(Q.zero(x), Q.zero(x*y))) is True
+
+    # This one in particular requires computing the fixed-point of the
+    # relevant facts, because going from Q.nonzero(x*y) -> ~Q.zero(x*y) and
+    # Q.zero(x*y) -> Equivalent(Q.zero(x*y), Q.zero(x) | Q.zero(y)) takes two
+    # steps.
+    assert satask(Q.zero(x) | Q.zero(y), Q.nonzero(x*y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**2)) is True
+
+
+def test_zero_positive():
+    assert satask(Q.zero(x + y), Q.positive(x) & Q.positive(y)) is False
+    assert satask(Q.positive(x) & Q.positive(y), Q.zero(x + y)) is False
+    assert satask(Q.nonzero(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(x) & Q.positive(y), Q.nonzero(x + y)) is None
+
+    # This one requires several levels of forward chaining
+    assert satask(Q.zero(x*(x + y)), Q.positive(x) & Q.positive(y)) is False
+
+    assert satask(Q.positive(pi*x*y + 1), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(pi*x*y - 5), Q.positive(x) & Q.positive(y)) is None
+
+
+def test_zero_pow():
+    assert satask(Q.zero(x**y), Q.zero(x) & Q.positive(y)) is True
+    assert satask(Q.zero(x**y), Q.nonzero(x) & Q.zero(y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**y)) is True
+
+    assert satask(Q.zero(x**y), Q.zero(x)) is None
+
+
+@XFAIL
+# Requires correct Q.square calculation first
+def test_invertible():
+    A = MatrixSymbol('A', 5, 5)
+    B = MatrixSymbol('B', 5, 5)
+    assert satask(Q.invertible(A*B), Q.invertible(A) & Q.invertible(B)) is True
+    assert satask(Q.invertible(A), Q.invertible(A*B)) is True
+    assert satask(Q.invertible(A) & Q.invertible(B), Q.invertible(A*B)) is True
+
+
+def test_prime():
+    assert satask(Q.prime(5)) is True
+    assert satask(Q.prime(6)) is False
+    assert satask(Q.prime(-5)) is False
+
+    assert satask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert satask(Q.prime(x*y), Q.prime(x) & Q.prime(y)) is False
+
+
+def test_old_assump():
+    assert satask(Q.positive(1)) is True
+    assert satask(Q.positive(-1)) is False
+    assert satask(Q.positive(0)) is False
+    assert satask(Q.positive(I)) is False
+    assert satask(Q.positive(pi)) is True
+
+    assert satask(Q.negative(1)) is False
+    assert satask(Q.negative(-1)) is True
+    assert satask(Q.negative(0)) is False
+    assert satask(Q.negative(I)) is False
+    assert satask(Q.negative(pi)) is False
+
+    assert satask(Q.zero(1)) is False
+    assert satask(Q.zero(-1)) is False
+    assert satask(Q.zero(0)) is True
+    assert satask(Q.zero(I)) is False
+    assert satask(Q.zero(pi)) is False
+
+    assert satask(Q.nonzero(1)) is True
+    assert satask(Q.nonzero(-1)) is True
+    assert satask(Q.nonzero(0)) is False
+    assert satask(Q.nonzero(I)) is False
+    assert satask(Q.nonzero(pi)) is True
+
+    assert satask(Q.nonpositive(1)) is False
+    assert satask(Q.nonpositive(-1)) is True
+    assert satask(Q.nonpositive(0)) is True
+    assert satask(Q.nonpositive(I)) is False
+    assert satask(Q.nonpositive(pi)) is False
+
+    assert satask(Q.nonnegative(1)) is True
+    assert satask(Q.nonnegative(-1)) is False
+    assert satask(Q.nonnegative(0)) is True
+    assert satask(Q.nonnegative(I)) is False
+    assert satask(Q.nonnegative(pi)) is True
+
+
+def test_rational_irrational():
+    assert satask(Q.irrational(2)) is False
+    assert satask(Q.rational(2)) is True
+    assert satask(Q.irrational(pi)) is True
+    assert satask(Q.rational(pi)) is False
+    assert satask(Q.irrational(I)) is False
+    assert satask(Q.rational(I)) is False
+
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi*x*y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi + x + y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+
+def test_even_satask():
+    assert satask(Q.even(2)) is True
+    assert satask(Q.even(3)) is False
+
+    assert satask(Q.even(x*y), Q.even(x) & Q.odd(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.integer(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.even(y)) is True
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+    assert satask(Q.even(x*y), Q.even(x)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+
+    assert satask(Q.even(abs(x)), Q.even(x)) is True
+    assert satask(Q.even(abs(x)), Q.odd(x)) is False
+    assert satask(Q.even(x), Q.even(abs(x))) is None # x could be complex
+
+
+def test_odd_satask():
+    assert satask(Q.odd(2)) is False
+    assert satask(Q.odd(3)) is True
+
+    assert satask(Q.odd(x*y), Q.even(x) & Q.odd(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.integer(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.even(y)) is False
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+    assert satask(Q.odd(x*y), Q.even(x)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+
+    assert satask(Q.odd(abs(x)), Q.even(x)) is False
+    assert satask(Q.odd(abs(x)), Q.odd(x)) is True
+    assert satask(Q.odd(x), Q.odd(abs(x))) is None # x could be complex
+
+
+def test_integer():
+    assert satask(Q.integer(1)) is True
+    assert satask(Q.integer(S.Half)) is False
+
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x + y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x + y), Q.integer(x) & ~Q.integer(y)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & Q.integer(y) &
+        ~Q.integer(z)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y) &
+        ~Q.integer(z)) is None
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.irrational(y)) is False
+
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x*y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.rational(y)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & Q.integer(y) &
+        ~Q.rational(z)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y) &
+        ~Q.rational(z)) is None
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.irrational(y)) is False
+
+
+def test_abs():
+    assert satask(Q.nonnegative(abs(x))) is True
+    assert satask(Q.positive(abs(x)), ~Q.zero(x)) is True
+    assert satask(Q.zero(x), ~Q.zero(abs(x))) is False
+    assert satask(Q.zero(x), Q.zero(abs(x))) is True
+    assert satask(Q.nonzero(x), ~Q.zero(abs(x))) is None # x could be complex
+    assert satask(Q.zero(abs(x)), Q.zero(x)) is True
+
+
+def test_imaginary():
+    assert satask(Q.imaginary(2*I)) is True
+    assert satask(Q.imaginary(x*y), Q.imaginary(x)) is None
+    assert satask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) is True
+    assert satask(Q.imaginary(x), Q.real(x)) is False
+    assert satask(Q.imaginary(1)) is False
+    assert satask(Q.imaginary(x*y), Q.real(x) & Q.real(y)) is False
+    assert satask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) is False
+
+
+def test_real():
+    assert satask(Q.real(x*y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x + y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y)) is None
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.imaginary(z)) is False
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y)) is None
+
+
+def test_pos_neg():
+    assert satask(~Q.positive(x), Q.negative(x)) is True
+    assert satask(~Q.negative(x), Q.positive(x)) is True
+    assert satask(Q.positive(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) is True
+    assert satask(Q.positive(x + y), Q.negative(x) & Q.negative(y)) is False
+    assert satask(Q.negative(x + y), Q.positive(x) & Q.positive(y)) is False
+
+
+def test_pow_pos_neg():
+    assert satask(Q.nonnegative(x**2), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.positive(x)) is False
+    assert satask(Q.positive(x**2), Q.positive(x)) is True
+    assert satask(Q.negative(x**2), Q.positive(x)) is False
+    assert satask(Q.real(x**2), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.negative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.negative(x)) is False
+    assert satask(Q.positive(x**2), Q.negative(x)) is True
+    assert satask(Q.negative(x**2), Q.negative(x)) is False
+    assert satask(Q.real(x**2), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**2), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**2), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonpositive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**2), Q.nonpositive(x)) is False
+    assert satask(Q.real(x**2), Q.nonpositive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.positive(x)) is False
+    assert satask(Q.positive(x**3), Q.positive(x)) is True
+    assert satask(Q.negative(x**3), Q.positive(x)) is False
+    assert satask(Q.real(x**3), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.negative(x)) is False
+    assert satask(Q.nonpositive(x**3), Q.negative(x)) is True
+    assert satask(Q.positive(x**3), Q.negative(x)) is False
+    assert satask(Q.negative(x**3), Q.negative(x)) is True
+    assert satask(Q.real(x**3), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**3), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**3), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**3), Q.nonpositive(x)) is True
+    assert satask(Q.positive(x**3), Q.nonpositive(x)) is False
+    assert satask(Q.negative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**3), Q.nonpositive(x)) is True
+
+    # If x is zero, x**negative is not real.
+    assert satask(Q.nonnegative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**-2), Q.nonpositive(x)) is None
+
+    # We could deduce things for negative powers if x is nonzero, but it
+    # isn't implemented yet.
+
+
+def test_prime_composite():
+    assert satask(Q.prime(x), Q.composite(x)) is False
+    assert satask(Q.composite(x), Q.prime(x)) is False
+    assert satask(Q.composite(x), ~Q.prime(x)) is None
+    assert satask(Q.prime(x), ~Q.composite(x)) is None
+    # since 1 is neither prime nor composite the following should hold
+    assert satask(Q.prime(x), Q.integer(x) & Q.positive(x) & ~Q.composite(x)) is None
+    assert satask(Q.prime(2)) is True
+    assert satask(Q.prime(4)) is False
+    assert satask(Q.prime(1)) is False
+    assert satask(Q.composite(1)) is False
+
+
+def test_extract_predargs():
+    props = CNF.from_prop(Q.zero(Abs(x*y)) & Q.zero(x*y))
+    assump = CNF.from_prop(Q.zero(x))
+    context = CNF.from_prop(Q.zero(y))
+    assert extract_predargs(props) == {Abs(x*y), x*y}
+    assert extract_predargs(props, assump) == {Abs(x*y), x*y, x}
+    assert extract_predargs(props, assump, context) == {Abs(x*y), x*y, x, y}
+
+    props = CNF.from_prop(Eq(x, y))
+    assump = CNF.from_prop(Gt(y, z))
+    assert extract_predargs(props, assump) == {x, y, z}
+
+
+def test_get_relevant_clsfacts():
+    exprs = {Abs(x*y)}
+    exprs, facts = get_relevant_clsfacts(exprs)
+    assert exprs == {x*y}
+    assert facts.clauses == \
+        {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.odd(Abs(x*y)), False),
+                    Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.even(x*y), True),
+                    Literal(Q.odd(Abs(x*y)), False)}),
+        frozenset({Literal(Q.positive(Abs(x*y)), False),
+                    Literal(Q.zero(Abs(x*y)), False)})}
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_sathandlers.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_sathandlers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d568ad8efe6ba7cf7f5eb03879ad6764c16e729
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_sathandlers.py
@@ -0,0 +1,50 @@
+from sympy.assumptions.ask import Q
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.symbol import symbols
+from sympy.logic.boolalg import (And, Or)
+
+from sympy.assumptions.sathandlers import (ClassFactRegistry, allargs,
+    anyarg, exactlyonearg,)
+
+x, y, z = symbols('x y z')
+
+
+def test_class_handler_registry():
+    my_handler_registry = ClassFactRegistry()
+
+    # The predicate doesn't matter here, so just pass
+    @my_handler_registry.register(Mul)
+    def fact1(expr):
+        pass
+    @my_handler_registry.multiregister(Expr)
+    def fact2(expr):
+        pass
+
+    assert my_handler_registry[Basic] == (frozenset(), frozenset())
+    assert my_handler_registry[Expr] == (frozenset(), frozenset({fact2}))
+    assert my_handler_registry[Mul] == (frozenset({fact1}), frozenset({fact2}))
+
+
+def test_allargs():
+    assert allargs(x, Q.zero(x), x*y) == And(Q.zero(x), Q.zero(y))
+    assert allargs(x, Q.positive(x) | Q.negative(x), x*y) == And(Q.positive(x) | Q.negative(x), Q.positive(y) | Q.negative(y))
+
+
+def test_anyarg():
+    assert anyarg(x, Q.zero(x), x*y) == Or(Q.zero(x), Q.zero(y))
+    assert anyarg(x, Q.positive(x) & Q.negative(x), x*y) == \
+        Or(Q.positive(x) & Q.negative(x), Q.positive(y) & Q.negative(y))
+
+
+def test_exactlyonearg():
+    assert exactlyonearg(x, Q.zero(x), x*y) == \
+        Or(Q.zero(x) & ~Q.zero(y), Q.zero(y) & ~Q.zero(x))
+    assert exactlyonearg(x, Q.zero(x), x*y*z) == \
+        Or(Q.zero(x) & ~Q.zero(y) & ~Q.zero(z), Q.zero(y)
+        & ~Q.zero(x) & ~Q.zero(z), Q.zero(z) & ~Q.zero(x) & ~Q.zero(y))
+    assert exactlyonearg(x, Q.positive(x) | Q.negative(x), x*y) == \
+        Or((Q.positive(x) | Q.negative(x)) &
+        ~(Q.positive(y) | Q.negative(y)), (Q.positive(y) | Q.negative(y)) &
+        ~(Q.positive(x) | Q.negative(x)))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_wrapper.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..af9afd5d51fb1341e0b08149dc842b78a39c329b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/tests/test_wrapper.py
@@ -0,0 +1,39 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.wrapper import (AssumptionsWrapper, is_infinite,
+    is_extended_real)
+from sympy.core.symbol import Symbol
+from sympy.core.assumptions import _assume_defined
+
+
+def test_all_predicates():
+    for fact in _assume_defined:
+        method_name = f'_eval_is_{fact}'
+        assert hasattr(AssumptionsWrapper, method_name)
+
+
+def test_AssumptionsWrapper():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert AssumptionsWrapper(x).is_positive
+    assert AssumptionsWrapper(y).is_positive is None
+    assert AssumptionsWrapper(y, Q.positive(y)).is_positive
+
+
+def test_is_infinite():
+    x = Symbol('x', infinite=True)
+    y = Symbol('y', infinite=False)
+    z = Symbol('z')
+    assert is_infinite(x)
+    assert not is_infinite(y)
+    assert is_infinite(z) is None
+    assert is_infinite(z, Q.infinite(z))
+
+
+def test_is_extended_real():
+    x = Symbol('x', extended_real=True)
+    y = Symbol('y', extended_real=False)
+    z = Symbol('z')
+    assert is_extended_real(x)
+    assert not is_extended_real(y)
+    assert is_extended_real(z) is None
+    assert is_extended_real(z, Q.extended_real(z))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/wrapper.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb06e9de770ed41a2b3d6fe63381ad1cb59acacc
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/assumptions/wrapper.py
@@ -0,0 +1,164 @@
+"""
+Functions and wrapper object to call assumption property and predicate
+query with same syntax.
+
+In SymPy, there are two assumption systems. Old assumption system is
+defined in sympy/core/assumptions, and it can be accessed by attribute
+such as ``x.is_even``. New assumption system is defined in
+sympy/assumptions, and it can be accessed by predicates such as
+``Q.even(x)``.
+
+Old assumption is fast, while new assumptions can freely take local facts.
+In general, old assumption is used in evaluation method and new assumption
+is used in refinement method.
+
+In most cases, both evaluation and refinement follow the same process, and
+the only difference is which assumption system is used. This module provides
+``is_[...]()`` functions and ``AssumptionsWrapper()`` class which allows
+using two systems with same syntax so that parallel code implementation can be
+avoided.
+
+Examples
+========
+
+For multiple use, use ``AssumptionsWrapper()``.
+
+>>> from sympy import Q, Symbol
+>>> from sympy.assumptions.wrapper import AssumptionsWrapper
+>>> x = Symbol('x')
+>>> _x = AssumptionsWrapper(x, Q.even(x))
+>>> _x.is_integer
+True
+>>> _x.is_odd
+False
+
+For single use, use ``is_[...]()`` functions.
+
+>>> from sympy.assumptions.wrapper import is_infinite
+>>> a = Symbol('a')
+>>> print(is_infinite(a))
+None
+>>> is_infinite(a, Q.finite(a))
+False
+
+"""
+
+from sympy.assumptions import ask, Q
+from sympy.core.basic import Basic
+from sympy.core.sympify import _sympify
+
+
+def make_eval_method(fact):
+    def getit(self):
+        pred = getattr(Q, fact)
+        ret = ask(pred(self.expr), self.assumptions)
+        return ret
+    return getit
+
+
+# we subclass Basic to use the fact deduction and caching
+class AssumptionsWrapper(Basic):
+    """
+    Wrapper over ``Basic`` instances to call predicate query by
+    ``.is_[...]`` property
+
+    Parameters
+    ==========
+
+    expr : Basic
+
+    assumptions : Boolean, optional
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Symbol
+    >>> from sympy.assumptions.wrapper import AssumptionsWrapper
+    >>> x = Symbol('x', even=True)
+    >>> AssumptionsWrapper(x).is_integer
+    True
+    >>> y = Symbol('y')
+    >>> AssumptionsWrapper(y, Q.even(y)).is_integer
+    True
+
+    With ``AssumptionsWrapper``, both evaluation and refinement can be supported
+    by single implementation.
+
+    >>> from sympy import Function
+    >>> class MyAbs(Function):
+    ...     @classmethod
+    ...     def eval(cls, x, assumptions=True):
+    ...         _x = AssumptionsWrapper(x, assumptions)
+    ...         if _x.is_nonnegative:
+    ...             return x
+    ...         if _x.is_negative:
+    ...             return -x
+    ...     def _eval_refine(self, assumptions):
+    ...         return MyAbs.eval(self.args[0], assumptions)
+    >>> MyAbs(x)
+    MyAbs(x)
+    >>> MyAbs(x).refine(Q.positive(x))
+    x
+    >>> MyAbs(Symbol('y', negative=True))
+    -y
+
+    """
+    def __new__(cls, expr, assumptions=None):
+        if assumptions is None:
+            return expr
+        obj = super().__new__(cls, expr, _sympify(assumptions))
+        obj.expr = expr
+        obj.assumptions = assumptions
+        return obj
+
+    _eval_is_algebraic = make_eval_method("algebraic")
+    _eval_is_antihermitian = make_eval_method("antihermitian")
+    _eval_is_commutative = make_eval_method("commutative")
+    _eval_is_complex = make_eval_method("complex")
+    _eval_is_composite = make_eval_method("composite")
+    _eval_is_even = make_eval_method("even")
+    _eval_is_extended_negative = make_eval_method("extended_negative")
+    _eval_is_extended_nonnegative = make_eval_method("extended_nonnegative")
+    _eval_is_extended_nonpositive = make_eval_method("extended_nonpositive")
+    _eval_is_extended_nonzero = make_eval_method("extended_nonzero")
+    _eval_is_extended_positive = make_eval_method("extended_positive")
+    _eval_is_extended_real = make_eval_method("extended_real")
+    _eval_is_finite = make_eval_method("finite")
+    _eval_is_hermitian = make_eval_method("hermitian")
+    _eval_is_imaginary = make_eval_method("imaginary")
+    _eval_is_infinite = make_eval_method("infinite")
+    _eval_is_integer = make_eval_method("integer")
+    _eval_is_irrational = make_eval_method("irrational")
+    _eval_is_negative = make_eval_method("negative")
+    _eval_is_noninteger = make_eval_method("noninteger")
+    _eval_is_nonnegative = make_eval_method("nonnegative")
+    _eval_is_nonpositive = make_eval_method("nonpositive")
+    _eval_is_nonzero = make_eval_method("nonzero")
+    _eval_is_odd = make_eval_method("odd")
+    _eval_is_polar = make_eval_method("polar")
+    _eval_is_positive = make_eval_method("positive")
+    _eval_is_prime = make_eval_method("prime")
+    _eval_is_rational = make_eval_method("rational")
+    _eval_is_real = make_eval_method("real")
+    _eval_is_transcendental = make_eval_method("transcendental")
+    _eval_is_zero = make_eval_method("zero")
+
+
+# one shot functions which are faster than AssumptionsWrapper
+
+def is_infinite(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_infinite
+    return ask(Q.infinite(obj), assumptions)
+
+
+def is_extended_real(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_extended_real
+    return ask(Q.extended_real(obj), assumptions)
+
+
+def is_extended_nonnegative(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_extended_nonnegative
+    return ask(Q.extended_nonnegative(obj), assumptions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..76b273909e415318a7d3bace00ffff2a0bc53762
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py
@@ -0,0 +1,83 @@
+import sys
+from time import time
+from sympy.ntheory.residue_ntheory import (discrete_log,
+        _discrete_log_trial_mul, _discrete_log_shanks_steps,
+        _discrete_log_pollard_rho, _discrete_log_pohlig_hellman)
+
+
+# Cyclic group (Z/pZ)* with p prime, order p - 1 and generator g
+data_set_1 = [
+        # p, p - 1, g
+        [191, 190, 19],
+        [46639, 46638, 6],
+        [14789363, 14789362, 2],
+        [4254225211, 4254225210, 2],
+        [432751500361, 432751500360, 7],
+        [158505390797053, 158505390797052, 2],
+        [6575202655312007, 6575202655312006, 5],
+        [8430573471995353769, 8430573471995353768, 3],
+        [3938471339744997827267, 3938471339744997827266, 2],
+        [875260951364705563393093, 875260951364705563393092, 5],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with prime order p and generator g
+# (n, p are primes and n = 2 * p + 1)
+data_set_2 = [
+        # n, p, g
+        [227, 113, 3],
+        [2447, 1223, 2],
+        [24527, 12263, 2],
+        [245639, 122819, 2],
+        [2456747, 1228373, 3],
+        [24567899, 12283949, 3],
+        [245679023, 122839511, 2],
+        [2456791307, 1228395653, 3],
+        [24567913439, 12283956719, 2],
+        [245679135407, 122839567703, 2],
+        [2456791354763, 1228395677381, 3],
+        [24567913550903, 12283956775451, 2],
+        [245679135509519, 122839567754759, 2],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with smooth order o and generator g
+data_set_3 = [
+        # n, o, g
+        [2**118, 2**116, 3],
+    ]
+
+
+def bench_discrete_log(data_set, algo=None):
+    if algo is None:
+        f = discrete_log
+    elif algo == 'trial':
+        f = _discrete_log_trial_mul
+    elif algo == 'shanks':
+        f = _discrete_log_shanks_steps
+    elif algo == 'rho':
+        f = _discrete_log_pollard_rho
+    elif algo == 'ph':
+        f = _discrete_log_pohlig_hellman
+    else:
+        raise ValueError("Argument 'algo' should be one"
+                " of ('trial', 'shanks', 'rho' or 'ph')")
+
+    for i, data in enumerate(data_set):
+        for j, (n, p, g) in enumerate(data):
+            t = time()
+            l = f(n, pow(g, p - 1, n), g, p)
+            t = time() - t
+            print('[%02d-%03d] %15.10f' % (i, j, t))
+            assert l == p - 1
+
+
+if __name__ == '__main__':
+    algo = sys.argv[1] \
+            if len(sys.argv) > 1 else None
+    data_set = [
+            data_set_1,
+            data_set_2,
+            data_set_3,
+        ]
+    bench_discrete_log(data_set, algo)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py
new file mode 100644
index 0000000000000000000000000000000000000000..d648c3e02463d5a7ee1dcbe3b22af5cc22fef43d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py
@@ -0,0 +1,261 @@
+# conceal the implicit import from the code quality tester
+from sympy.core.numbers import (oo, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.integrals.transforms import (mellin_transform,
+    inverse_fourier_transform, inverse_mellin_transform,
+    laplace_transform, inverse_laplace_transform, fourier_transform)
+
+LT = laplace_transform
+FT = fourier_transform
+MT = mellin_transform
+IFT = inverse_fourier_transform
+ILT = inverse_laplace_transform
+IMT = inverse_mellin_transform
+
+from sympy.abc import x, y
+nu, beta, rho = symbols('nu beta rho')
+
+apos, bpos, cpos, dpos, posk, p = symbols('a b c d k p', positive=True)
+k = Symbol('k', real=True)
+negk = Symbol('k', negative=True)
+
+mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True, finite=True)
+sigma1, sigma2 = symbols('sigma1 sigma2', real=True, nonzero=True,
+                         finite=True, positive=True)
+rate = Symbol('lambda', positive=True)
+
+
+def normal(x, mu, sigma):
+    return 1/sqrt(2*pi*sigma**2)*exp(-(x - mu)**2/2/sigma**2)
+
+
+def exponential(x, rate):
+    return rate*exp(-rate*x)
+alpha, beta = symbols('alpha beta', positive=True)
+betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
+    /gamma(alpha)/gamma(beta)
+kint = Symbol('k', integer=True, positive=True)
+chi = 2**(1 - kint/2)*x**(kint - 1)*exp(-x**2/2)/gamma(kint/2)
+chisquared = 2**(-k/2)/gamma(k/2)*x**(k/2 - 1)*exp(-x/2)
+dagum = apos*p/x*(x/bpos)**(apos*p)/(1 + x**apos/bpos**apos)**(p + 1)
+d1, d2 = symbols('d1 d2', positive=True)
+f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
+    /gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
+nupos, sigmapos = symbols('nu sigma', positive=True)
+rice = x/sigmapos**2*exp(-(x**2 + nupos**2)/2/sigmapos**2)*besseli(0, x*
+                         nupos/sigmapos**2)
+mu = Symbol('mu', real=True)
+laplace = exp(-abs(x - mu)/bpos)/2/bpos
+
+u = Symbol('u', polar=True)
+tpos = Symbol('t', positive=True)
+
+
+def E(expr):
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (x, 0, oo), (y, -oo, oo), meijerg=True)
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (y, -oo, oo), (x, 0, oo), meijerg=True)
+
+bench = [
+    'MT(x**nu*Heaviside(x - 1), x, s)',
+    'MT(x**nu*Heaviside(1 - x), x, s)',
+    'MT((1-x)**(beta - 1)*Heaviside(1-x), x, s)',
+    'MT((x-1)**(beta - 1)*Heaviside(x-1), x, s)',
+    'MT((1+x)**(-rho), x, s)',
+    'MT(abs(1-x)**(-rho), x, s)',
+    'MT((1-x)**(beta-1)*Heaviside(1-x) + a*(x-1)**(beta-1)*Heaviside(x-1), x, s)',
+    'MT((x**a-b**a)/(x-b), x, s)',
+    'MT((x**a-bpos**a)/(x-bpos), x, s)',
+    'MT(exp(-x), x, s)',
+    'MT(exp(-1/x), x, s)',
+    'MT(log(x)**4*Heaviside(1-x), x, s)',
+    'MT(log(x)**3*Heaviside(x-1), x, s)',
+    'MT(log(x + 1), x, s)',
+    'MT(log(1/x + 1), x, s)',
+    'MT(log(abs(1 - x)), x, s)',
+    'MT(log(abs(1 - 1/x)), x, s)',
+    'MT(log(x)/(x+1), x, s)',
+    'MT(log(x)**2/(x+1), x, s)',
+    'MT(log(x)/(x+1)**2, x, s)',
+    'MT(erf(sqrt(x)), x, s)',
+
+    'MT(besselj(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2, x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s)',
+    'MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)',
+    'MT(bessely(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s)',
+    'MT(bessely(a, sqrt(x))**2, x, s)',
+
+    'MT(besselk(a, 2*sqrt(x)), x, s)',
+    'MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(a, 2*sqrt(2*sqrt(x))), x, s)',
+    'MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(exp(-x/2)*besselk(a, x/2), x, s)',
+
+    # later: ILT, IMT
+
+    'LT((t-apos)**bpos*exp(-cpos*(t-apos))*Heaviside(t-apos), t, s)',
+    'LT(t**apos, t, s)',
+    'LT(Heaviside(t), t, s)',
+    'LT(Heaviside(t - apos), t, s)',
+    'LT(1 - exp(-apos*t), t, s)',
+    'LT((exp(2*t)-1)*exp(-bpos - t)*Heaviside(t)/2, t, s, noconds=True)',
+    'LT(exp(t), t, s)',
+    'LT(exp(2*t), t, s)',
+    'LT(exp(apos*t), t, s)',
+    'LT(log(t/apos), t, s)',
+    'LT(erf(t), t, s)',
+    'LT(sin(apos*t), t, s)',
+    'LT(cos(apos*t), t, s)',
+    'LT(exp(-apos*t)*sin(bpos*t), t, s)',
+    'LT(exp(-apos*t)*cos(bpos*t), t, s)',
+    'LT(besselj(0, t), t, s, noconds=True)',
+    'LT(besselj(1, t), t, s, noconds=True)',
+
+    'FT(Heaviside(1 - abs(2*apos*x)), x, k)',
+    'FT(Heaviside(1-abs(apos*x))*(1-abs(apos*x)), x, k)',
+    'FT(exp(-apos*x)*Heaviside(x), x, k)',
+    'IFT(1/(apos + 2*pi*I*x), x, posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, -posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, negk)',
+    'FT(x*exp(-apos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x)*sin(bpos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x**2), x, k)',
+    'IFT(sqrt(pi/apos)*exp(-(pi*k)**2/apos), k, x)',
+    'FT(exp(-apos*abs(x)), x, k)',
+
+    'integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y+1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y-1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                   (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'E(1)',
+    'E(x*y)',
+    'E(x*y**2)',
+    'E((x+y+1)**2)',
+    'E(x+y+1)',
+    'E((x+y-1)**2)',
+    'integrate(betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(chi, (x, 0, oo), meijerg=True)',
+    'integrate(x*chi, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chi, (x, 0, oo), meijerg=True)',
+    'integrate(chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(((x-k)/sqrt(2*k))**3*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(f, (x, 0, oo), meijerg=True)',
+    'integrate(x*f, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*f, (x, 0, oo), meijerg=True)',
+    'integrate(rice, (x, 0, oo), meijerg=True)',
+    'integrate(laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(log(x) * x**(k-1) * exp(-x) / gamma(k), (x, 0, oo))',
+
+    'integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*besselk(0,x), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(a,x)*besselj(b,x)/x, (x,0,oo), meijerg=True)',
+
+    'hyperexpand(meijerg((-s - a/2 + 1, -s + a/2 + 1), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), (a/2, -a/2), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), 1))',
+    "gammasimp(S('2**(2*s)*(-pi*gamma(-a + 1)*gamma(a + 1)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 3/2)*gamma(a + s + 1)/(a*(a + s)) - gamma(-a - 1/2)*gamma(-a + 1)*gamma(a + 1)*gamma(a + 3/2)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a + s + 1)*gamma(a - s + 1)/(a*(-a + s)))*gamma(-2*s + 1)*gamma(s + 1)/(pi*s*gamma(-a - 1/2)*gamma(a + 3/2)*gamma(-s + 1)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 1)*gamma(a - s + 3/2))'))",
+
+    'mellin_transform(E1(x), x, s)',
+    'inverse_mellin_transform(gamma(s)/s, s, x, (0, oo))',
+    'mellin_transform(expint(a, x), x, s)',
+    'mellin_transform(Si(x), x, s)',
+    'inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)/(2*s*gamma(-s/2 + 1)), s, x, (-1, 0))',
+    'mellin_transform(Ci(sqrt(x)), x, s)',
+    'inverse_mellin_transform(-4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S(1)/2)),s, u, (0, 1))',
+    'laplace_transform(Ci(x), x, s)',
+    'laplace_transform(expint(a, x), x, s)',
+    'laplace_transform(expint(1, x), x, s)',
+    'laplace_transform(expint(2, x), x, s)',
+    'inverse_laplace_transform(-log(1 + s**2)/2/s, s, u)',
+    'inverse_laplace_transform(log(s + 1)/s, s, x)',
+    'inverse_laplace_transform((s - log(s + 1))/s**2, s, x)',
+    'laplace_transform(Chi(x), x, s)',
+    'laplace_transform(Shi(x), x, s)',
+
+    'integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,conds="none")',
+    'integrate(-cos(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(-sin(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(sin(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(sinh(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(exp(-x)/x, x, meijerg=True)',
+    'integrate(exp(-x)/x**2, x, meijerg=True)',
+    'integrate(cos(u)/u, u, meijerg=True)',
+    'integrate(cosh(u)/u, u, meijerg=True)',
+    'integrate(expint(1, x), x, meijerg=True)',
+    'integrate(expint(2, x), x, meijerg=True)',
+    'integrate(Si(x), x, meijerg=True)',
+    'integrate(Ci(u), u, meijerg=True)',
+    'integrate(Shi(x), x, meijerg=True)',
+    'integrate(Chi(u), u, meijerg=True)',
+    'integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True)',
+    'integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True)'
+]
+
+from time import time
+from sympy.core.cache import clear_cache
+import sys
+
+timings = []
+
+if __name__ == '__main__':
+    for n, string in enumerate(bench):
+        clear_cache()
+        _t = time()
+        exec(string)
+        _t = time() - _t
+        timings += [(_t, string)]
+        sys.stdout.write('.')
+        sys.stdout.flush()
+        if n % (len(bench) // 10) == 0:
+            sys.stdout.write('%s' % (10*n // len(bench)))
+    print()
+
+    timings.sort(key=lambda x: -x[0])
+
+    for ti, string in timings:
+        print('%.2fs %s' % (ti, string))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ea700b44b677107f5345196a8895e8ed5a9d56d
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+from sympy.core.random import random
+from sympy.core.numbers import (I, Integer, pi)
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import factor
+from sympy.simplify.simplify import simplify
+from sympy.abc import x, y, z
+from timeit import default_timer as clock
+
+
+def bench_R1():
+    "real(f(f(f(f(f(f(f(f(f(f(i/2)))))))))))"
+    def f(z):
+        return sqrt(Integer(1)/3)*z**2 + I/3
+    f(f(f(f(f(f(f(f(f(f(I/2)))))))))).as_real_imag()[0]
+
+
+def bench_R2():
+    "Hermite polynomial hermite(15, y)"
+    def hermite(n, y):
+        if n == 1:
+            return 2*y
+        if n == 0:
+            return 1
+        return (2*y*hermite(n - 1, y) - 2*(n - 1)*hermite(n - 2, y)).expand()
+
+    hermite(15, y)
+
+
+def bench_R3():
+    "a = [bool(f==f) for _ in range(10)]"
+    f = x + y + z
+    [bool(f == f) for _ in range(10)]
+
+
+def bench_R4():
+    # we don't have Tuples
+    pass
+
+
+def bench_R5():
+    "blowup(L, 8); L=uniq(L)"
+    def blowup(L, n):
+        for i in range(n):
+            L.append( (L[i] + L[i + 1]) * L[i + 2] )
+
+    def uniq(x):
+        v = set(x)
+        return v
+    L = [x, y, z]
+    blowup(L, 8)
+    L = uniq(L)
+
+
+def bench_R6():
+    "sum(simplify((x+sin(i))/x+(x-sin(i))/x) for i in range(100))"
+    sum(simplify((x + sin(i))/x + (x - sin(i))/x) for i in range(100))
+
+
+def bench_R7():
+    "[f.subs(x, random()) for _ in range(10**4)]"
+    f = x**24 + 34*x**12 + 45*x**3 + 9*x**18 + 34*x**10 + 32*x**21
+    [f.subs(x, random()) for _ in range(10**4)]
+
+
+def bench_R8():
+    "right(x^2,0,5,10^4)"
+    def right(f, a, b, n):
+        a = sympify(a)
+        b = sympify(b)
+        n = sympify(n)
+        x = f.atoms(Symbol).pop()
+        Deltax = (b - a)/n
+        c = a
+        est = 0
+        for i in range(n):
+            c += Deltax
+            est += f.subs(x, c)
+        return est*Deltax
+
+    right(x**2, 0, 5, 10**4)
+
+
+def _bench_R9():
+    "factor(x^20 - pi^5*y^20)"
+    factor(x**20 - pi**5*y**20)
+
+
+def bench_R10():
+    "v = [-pi,-pi+1/10..,pi]"
+    def srange(min, max, step):
+        v = [min]
+        while (max - v[-1]).evalf() > 0:
+            v.append(v[-1] + step)
+        return v[:-1]
+    srange(-pi, pi, sympify(1)/10)
+
+
+def bench_R11():
+    "a = [random() + random()*I for w in [0..1000]]"
+    [random() + random()*I for w in range(1000)]
+
+
+def bench_S1():
+    "e=(x+y+z+1)**7;f=e*(e+1);f.expand()"
+    e = (x + y + z + 1)**7
+    f = e*(e + 1)
+    f.expand()
+
+
+if __name__ == '__main__':
+    benchmarks = [
+        bench_R1,
+        bench_R2,
+        bench_R3,
+        bench_R5,
+        bench_R6,
+        bench_R7,
+        bench_R8,
+        #_bench_R9,
+        bench_R10,
+        bench_R11,
+        #bench_S1,
+    ]
+
+    report = []
+    for b in benchmarks:
+        t = clock()
+        b()
+        t = clock() - t
+        print("%s%65s: %f" % (b.__name__, b.__doc__, t))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..865c0556769e35ca7e8a09a4c208a1cfbd17369c
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/__init__.py
@@ -0,0 +1,25 @@
+"""Calculus-related methods."""
+
+from .euler import euler_equations
+from .singularities import (singularities, is_increasing,
+                            is_strictly_increasing, is_decreasing,
+                            is_strictly_decreasing, is_monotonic)
+from .finite_diff import finite_diff_weights, apply_finite_diff, differentiate_finite
+from .util import (periodicity, not_empty_in, is_convex,
+                   stationary_points, minimum, maximum)
+from .accumulationbounds import AccumBounds
+
+__all__ = [
+'euler_equations',
+
+'singularities', 'is_increasing',
+'is_strictly_increasing', 'is_decreasing',
+'is_strictly_decreasing', 'is_monotonic',
+
+'finite_diff_weights', 'apply_finite_diff', 'differentiate_finite',
+
+'periodicity', 'not_empty_in', 'is_convex', 'stationary_points',
+'minimum', 'maximum',
+
+'AccumBounds'
+]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/accumulationbounds.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/accumulationbounds.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a2b0e634da1028c25399c8b03884865d981a56e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/accumulationbounds.py
@@ -0,0 +1,804 @@
+from sympy.core import Add, Mul, Pow, S
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.numbers import _sympifyit, oo, zoo
+from sympy.core.relational import is_le, is_lt, is_ge, is_gt
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import And
+from sympy.multipledispatch import dispatch
+from sympy.series.order import Order
+from sympy.sets.sets import FiniteSet
+
+
+class AccumulationBounds(Expr):
+    r"""An accumulation bounds.
+
+    # Note AccumulationBounds has an alias: AccumBounds
+
+    AccumulationBounds represent an interval `[a, b]`, which is always closed
+    at the ends. Here `a` and `b` can be any value from extended real numbers.
+
+    The intended meaning of AccummulationBounds is to give an approximate
+    location of the accumulation points of a real function at a limit point.
+
+    Let `a` and `b` be reals such that `a \le b`.
+
+    `\left\langle a, b\right\rangle = \{x \in \mathbb{R} \mid a \le x \le b\}`
+
+    `\left\langle -\infty, b\right\rangle = \{x \in \mathbb{R} \mid x \le b\} \cup \{-\infty, \infty\}`
+
+    `\left\langle a, \infty \right\rangle = \{x \in \mathbb{R} \mid a \le x\} \cup \{-\infty, \infty\}`
+
+    `\left\langle -\infty, \infty \right\rangle = \mathbb{R} \cup \{-\infty, \infty\}`
+
+    ``oo`` and ``-oo`` are added to the second and third definition respectively,
+    since if either ``-oo`` or ``oo`` is an argument, then the other one should
+    be included (though not as an end point). This is forced, since we have,
+    for example, ``1/AccumBounds(0, 1) = AccumBounds(1, oo)``, and the limit at
+    `0` is not one-sided. As `x` tends to `0-`, then `1/x \rightarrow -\infty`, so `-\infty`
+    should be interpreted as belonging to ``AccumBounds(1, oo)`` though it need
+    not appear explicitly.
+
+    In many cases it suffices to know that the limit set is bounded.
+    However, in some other cases more exact information could be useful.
+    For example, all accumulation values of `\cos(x) + 1` are non-negative.
+    (``AccumBounds(-1, 1) + 1 = AccumBounds(0, 2)``)
+
+    A AccumulationBounds object is defined to be real AccumulationBounds,
+    if its end points are finite reals.
+
+    Let `X`, `Y` be real AccumulationBounds, then their sum, difference,
+    product are defined to be the following sets:
+
+    `X + Y = \{ x+y \mid x \in X \cap y \in Y\}`
+
+    `X - Y = \{ x-y \mid x \in X \cap y \in Y\}`
+
+    `X \times Y = \{ x \times y \mid x \in X \cap y \in Y\}`
+
+    When an AccumBounds is raised to a negative power, if 0 is contained
+    between the bounds then an infinite range is returned, otherwise if an
+    endpoint is 0 then a semi-infinite range with consistent sign will be returned.
+
+    AccumBounds in expressions behave a lot like Intervals but the
+    semantics are not necessarily the same. Division (or exponentiation
+    to a negative integer power) could be handled with *intervals* by
+    returning a union of the results obtained after splitting the
+    bounds between negatives and positives, but that is not done with
+    AccumBounds. In addition, bounds are assumed to be independent of
+    each other; if the same bound is used in more than one place in an
+    expression, the result may not be the supremum or infimum of the
+    expression (see below). Finally, when a boundary is ``1``,
+    exponentiation to the power of ``oo`` yields ``oo``, neither
+    ``1`` nor ``nan``.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, sin, exp, log, pi, E, S, oo
+    >>> from sympy.abc import x
+
+    >>> AccumBounds(0, 1) + AccumBounds(1, 2)
+    AccumBounds(1, 3)
+
+    >>> AccumBounds(0, 1) - AccumBounds(0, 2)
+    AccumBounds(-2, 1)
+
+    >>> AccumBounds(-2, 3)*AccumBounds(-1, 1)
+    AccumBounds(-3, 3)
+
+    >>> AccumBounds(1, 2)*AccumBounds(3, 5)
+    AccumBounds(3, 10)
+
+    The exponentiation of AccumulationBounds is defined
+    as follows:
+
+    If 0 does not belong to `X` or `n > 0` then
+
+    `X^n = \{ x^n \mid x \in X\}`
+
+    >>> AccumBounds(1, 4)**(S(1)/2)
+    AccumBounds(1, 2)
+
+    otherwise, an infinite or semi-infinite result is obtained:
+
+    >>> 1/AccumBounds(-1, 1)
+    AccumBounds(-oo, oo)
+    >>> 1/AccumBounds(0, 2)
+    AccumBounds(1/2, oo)
+    >>> 1/AccumBounds(-oo, 0)
+    AccumBounds(-oo, 0)
+
+    A boundary of 1 will always generate all nonnegatives:
+
+    >>> AccumBounds(1, 2)**oo
+    AccumBounds(0, oo)
+    >>> AccumBounds(0, 1)**oo
+    AccumBounds(0, oo)
+
+    If the exponent is itself an AccumulationBounds or is not an
+    integer then unevaluated results will be returned unless the base
+    values are positive:
+
+    >>> AccumBounds(2, 3)**AccumBounds(-1, 2)
+    AccumBounds(1/3, 9)
+    >>> AccumBounds(-2, 3)**AccumBounds(-1, 2)
+    AccumBounds(-2, 3)**AccumBounds(-1, 2)
+
+    >>> AccumBounds(-2, -1)**(S(1)/2)
+    sqrt(AccumBounds(-2, -1))
+
+    Note: `\left\langle a, b\right\rangle^2` is not same as `\left\langle a, b\right\rangle \times \left\langle a, b\right\rangle`
+
+    >>> AccumBounds(-1, 1)**2
+    AccumBounds(0, 1)
+
+    >>> AccumBounds(1, 3) < 4
+    True
+
+    >>> AccumBounds(1, 3) < -1
+    False
+
+    Some elementary functions can also take AccumulationBounds as input.
+    A function `f` evaluated for some real AccumulationBounds `\left\langle a, b \right\rangle`
+    is defined as `f(\left\langle a, b\right\rangle) = \{ f(x) \mid a \le x \le b \}`
+
+    >>> sin(AccumBounds(pi/6, pi/3))
+    AccumBounds(1/2, sqrt(3)/2)
+
+    >>> exp(AccumBounds(0, 1))
+    AccumBounds(1, E)
+
+    >>> log(AccumBounds(1, E))
+    AccumBounds(0, 1)
+
+    Some symbol in an expression can be substituted for a AccumulationBounds
+    object. But it does not necessarily evaluate the AccumulationBounds for
+    that expression.
+
+    The same expression can be evaluated to different values depending upon
+    the form it is used for substitution since each instance of an
+    AccumulationBounds is considered independent. For example:
+
+    >>> (x**2 + 2*x + 1).subs(x, AccumBounds(-1, 1))
+    AccumBounds(-1, 4)
+
+    >>> ((x + 1)**2).subs(x, AccumBounds(-1, 1))
+    AccumBounds(0, 4)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Interval_arithmetic
+
+    .. [2] https://fab.cba.mit.edu/classes/S62.12/docs/Hickey_interval.pdf
+
+    Notes
+    =====
+
+    Do not use ``AccumulationBounds`` for floating point interval arithmetic
+    calculations, use ``mpmath.iv`` instead.
+    """
+
+    is_extended_real = True
+    is_number = False
+
+    def __new__(cls, min, max) -> Expr: # type: ignore
+
+        min = _sympify(min)
+        max = _sympify(max)
+
+        # Only allow real intervals (use symbols with 'is_extended_real=True').
+        if not min.is_extended_real or not max.is_extended_real:
+            raise ValueError("Only real AccumulationBounds are supported")
+
+        if max == min:
+            return max
+
+        # Make sure that the created AccumBounds object will be valid.
+        if max.is_number and min.is_number:
+            bad = max.is_comparable and min.is_comparable and max < min
+        else:
+            bad = (max - min).is_extended_negative
+        if bad:
+            raise ValueError(
+                "Lower limit should be smaller than upper limit")
+
+        return Basic.__new__(cls, min, max)
+
+    # setting the operation priority
+    _op_priority = 11.0
+
+    def _eval_is_real(self):
+        if self.min.is_real and self.max.is_real:
+            return True
+
+    @property
+    def min(self):
+        """
+        Returns the minimum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).min
+        1
+
+        """
+        return self.args[0]
+
+    @property
+    def max(self):
+        """
+        Returns the maximum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).max
+        3
+
+        """
+        return self.args[1]
+
+    @property
+    def delta(self):
+        """
+        Returns the difference of maximum possible value attained by
+        AccumulationBounds object and minimum possible value attained
+        by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).delta
+        2
+
+        """
+        return self.max - self.min
+
+    @property
+    def mid(self):
+        """
+        Returns the mean of maximum possible value attained by
+        AccumulationBounds object and minimum possible value
+        attained by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).mid
+        2
+
+        """
+        return (self.min + self.max) / 2
+
+    @_sympifyit('other', NotImplemented)
+    def _eval_power(self, other):
+        return self.__pow__(other)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, other.min),
+                    Add(self.max, other.max))
+            if other is S.Infinity and self.min is S.NegativeInfinity or \
+                    other is S.NegativeInfinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max + other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min + other, oo)
+                else:
+                    return AccumBounds(Add(self.min, other), Add(self.max, other))
+            return Add(self, other, evaluate=False)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return AccumBounds(-self.max, -self.min)
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, -other.max),
+                    Add(self.max, -other.min))
+            if other is S.NegativeInfinity and self.min is S.NegativeInfinity or \
+                    other is S.Infinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max - other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min - other, oo)
+                else:
+                    return AccumBounds(
+                        Add(self.min, -other),
+                        Add(self.max, -other))
+            return Add(self, -other, evaluate=False)
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        return self.__neg__() + other
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if self.args == (-oo, oo):
+            return self
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.args == (-oo, oo):
+                    return other
+                v = set()
+                for a in self.args:
+                    vi = other*a
+                    v.update(vi.args or (vi,))
+                return AccumBounds(Min(*v), Max(*v))
+            if other is S.Infinity:
+                if self.min.is_zero:
+                    return AccumBounds(0, oo)
+                if self.max.is_zero:
+                    return AccumBounds(-oo, 0)
+            if other is S.NegativeInfinity:
+                if self.min.is_zero:
+                    return AccumBounds(-oo, 0)
+                if self.max.is_zero:
+                    return AccumBounds(0, oo)
+            if other.is_extended_real:
+                if other.is_zero:
+                    if self.max is S.Infinity:
+                        return AccumBounds(0, oo)
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(-oo, 0)
+                    return S.Zero
+                if other.is_extended_positive:
+                    return AccumBounds(
+                        Mul(self.min, other),
+                        Mul(self.max, other))
+                elif other.is_extended_negative:
+                    return AccumBounds(
+                        Mul(self.max, other),
+                        Mul(self.min, other))
+            if isinstance(other, Order):
+                return other
+            return Mul(self, other, evaluate=False)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.min.is_positive or other.max.is_negative:
+                    return self * AccumBounds(1/other.max, 1/other.min)
+
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative and
+                    other.min.is_extended_nonpositive and other.max.is_extended_nonnegative):
+                    if self.min.is_zero and other.min.is_zero:
+                        return AccumBounds(0, oo)
+                    if self.max.is_zero and other.min.is_zero:
+                        return AccumBounds(-oo, 0)
+                    return AccumBounds(-oo, oo)
+
+                if self.max.is_extended_negative:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(self.max / other.min, oo)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.max/other.max),
+                            #       Interval(self.max/other.min, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(-oo, self.max / other.max)
+
+                if self.min.is_extended_positive:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(-oo, self.min / other.min)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.min/other.min),
+                            #       Interval(self.min/other.max, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(self.min / other.max, oo)
+
+            elif other.is_extended_real:
+                if other in (S.Infinity, S.NegativeInfinity):
+                    if self == AccumBounds(-oo, oo):
+                        return AccumBounds(-oo, oo)
+                    if self.max is S.Infinity:
+                        return AccumBounds(Min(0, other), Max(0, other))
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(Min(0, -other), Max(0, -other))
+                if other.is_extended_positive:
+                    return AccumBounds(self.min / other, self.max / other)
+                elif other.is_extended_negative:
+                    return AccumBounds(self.max / other, self.min / other)
+            if (1 / other) is S.ComplexInfinity:
+                return Mul(self, 1 / other, evaluate=False)
+            else:
+                return Mul(self, 1 / other)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rtruediv__(self, other):
+        if isinstance(other, Expr):
+            if other.is_extended_real:
+                if other.is_zero:
+                    return S.Zero
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative):
+                    if self.min.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(Mul(other, 1 / self.max), oo)
+                        if other.is_extended_negative:
+                            return AccumBounds(-oo, Mul(other, 1 / self.max))
+                    if self.max.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(-oo, Mul(other, 1 / self.min))
+                        if other.is_extended_negative:
+                            return AccumBounds(Mul(other, 1 / self.min), oo)
+                    return AccumBounds(-oo, oo)
+                else:
+                    return AccumBounds(Min(other / self.min, other / self.max),
+                                       Max(other / self.min, other / self.max))
+            return Mul(other, 1 / self, evaluate=False)
+        else:
+            return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __pow__(self, other):
+        if isinstance(other, Expr):
+            if other is S.Infinity:
+                if self.min.is_extended_nonnegative:
+                    if self.max < 1:
+                        return S.Zero
+                    if self.min > 1:
+                        return S.Infinity
+                    return AccumBounds(0, oo)
+                elif self.max.is_extended_negative:
+                    if self.min > -1:
+                        return S.Zero
+                    if self.max < -1:
+                        return zoo
+                    return S.NaN
+                else:
+                    if self.min > -1:
+                        if self.max < 1:
+                            return S.Zero
+                        return AccumBounds(0, oo)
+                    return AccumBounds(-oo, oo)
+
+            if other is S.NegativeInfinity:
+                return (1/self)**oo
+
+            # generically true
+            if (self.max - self.min).is_nonnegative:
+                # well defined
+                if self.min.is_nonnegative:
+                    # no 0 to worry about
+                    if other.is_nonnegative:
+                        # no infinity to worry about
+                        return self.func(self.min**other, self.max**other)
+
+            if other.is_zero:
+                return S.One  # x**0 = 1
+
+            if other.is_Integer or other.is_integer:
+                if self.min.is_extended_positive:
+                    return AccumBounds(
+                        Min(self.min**other, self.max**other),
+                        Max(self.min**other, self.max**other))
+                elif self.max.is_extended_negative:
+                    return AccumBounds(
+                        Min(self.max**other, self.min**other),
+                        Max(self.max**other, self.min**other))
+
+                if other % 2 == 0:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(self.min**other, oo)
+                        return (1/self)**(-other)
+                    return AccumBounds(
+                        S.Zero, Max(self.min**other, self.max**other))
+                elif other % 2 == 1:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(-oo, self.min**other)
+                        return (1/self)**(-other)
+                    return AccumBounds(self.min**other, self.max**other)
+
+            # non-integer exponent
+            # 0**neg or neg**frac yields complex
+            if (other.is_number or other.is_rational) and (
+                    self.min.is_extended_nonnegative or (
+                    other.is_extended_nonnegative and
+                    self.min.is_extended_nonnegative)):
+                num, den = other.as_numer_denom()
+                if num is S.One:
+                    return AccumBounds(*[i**(1/den) for i in self.args])
+
+                elif den is not S.One:  # e.g. if other is not Float
+                    return (self**num)**(1/den)  # ok for non-negative base
+
+            if isinstance(other, AccumBounds):
+                if (self.min.is_extended_positive or
+                        self.min.is_extended_nonnegative and
+                        other.min.is_extended_nonnegative):
+                    p = [self**i for i in other.args]
+                    if not any(i.is_Pow for i in p):
+                        a = [j for i in p for j in i.args or (i,)]
+                        try:
+                            return self.func(min(a), max(a))
+                        except TypeError:  # can't sort
+                            pass
+
+            return Pow(self, other, evaluate=False)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rpow__(self, other):
+        if other.is_real and other.is_extended_nonnegative and (
+                self.max - self.min).is_extended_positive:
+            if other is S.One:
+                return S.One
+            if other.is_extended_positive:
+                a, b = [other**i for i in self.args]
+                if min(a, b) != a:
+                    a, b = b, a
+                return self.func(a, b)
+            if other.is_zero:
+                if self.min.is_zero:
+                    return self.func(0, 1)
+                if self.min.is_extended_positive:
+                    return S.Zero
+
+        return Pow(other, self, evaluate=False)
+
+    def __abs__(self):
+        if self.max.is_extended_negative:
+            return self.__neg__()
+        elif self.min.is_extended_negative:
+            return AccumBounds(S.Zero, Max(abs(self.min), self.max))
+        else:
+            return self
+
+
+    def __contains__(self, other):
+        """
+        Returns ``True`` if other is contained in self, where other
+        belongs to extended real numbers, ``False`` if not contained,
+        otherwise TypeError is raised.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, oo
+        >>> 1 in AccumBounds(-1, 3)
+        True
+
+        -oo and oo go together as limits (in AccumulationBounds).
+
+        >>> -oo in AccumBounds(1, oo)
+        True
+
+        >>> oo in AccumBounds(-oo, 0)
+        True
+
+        """
+        other = _sympify(other)
+
+        if other in (S.Infinity, S.NegativeInfinity):
+            if self.min is S.NegativeInfinity or self.max is S.Infinity:
+                return True
+            return False
+
+        rv = And(self.min <= other, self.max >= other)
+        if rv not in (True, False):
+            raise TypeError("input failed to evaluate")
+        return rv
+
+    def intersection(self, other):
+        """
+        Returns the intersection of 'self' and 'other'.
+        Here other can be an instance of :py:class:`~.FiniteSet` or AccumulationBounds.
+
+        Parameters
+        ==========
+
+        other : AccumulationBounds
+            Another AccumulationBounds object with which the intersection
+            has to be computed.
+
+        Returns
+        =======
+
+        AccumulationBounds
+            Intersection of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, FiniteSet
+        >>> AccumBounds(1, 3).intersection(AccumBounds(2, 4))
+        AccumBounds(2, 3)
+
+        >>> AccumBounds(1, 3).intersection(AccumBounds(4, 6))
+        EmptySet
+
+        >>> AccumBounds(1, 4).intersection(FiniteSet(1, 2, 5))
+        {1, 2}
+
+        """
+        if not isinstance(other, (AccumBounds, FiniteSet)):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if isinstance(other, FiniteSet):
+            fin_set = S.EmptySet
+            for i in other:
+                if i in self:
+                    fin_set = fin_set + FiniteSet(i)
+            return fin_set
+
+        if self.max < other.min or self.min > other.max:
+            return S.EmptySet
+
+        if self.min <= other.min:
+            if self.max <= other.max:
+                return AccumBounds(other.min, self.max)
+            if self.max > other.max:
+                return other
+
+        if other.min <= self.min:
+            if other.max < self.max:
+                return AccumBounds(self.min, other.max)
+            if other.max > self.max:
+                return self
+
+    def union(self, other):
+        # TODO : Devise a better method for Union of AccumBounds
+        # this method is not actually correct and
+        # can be made better
+        if not isinstance(other, AccumBounds):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if self.min <= other.min and self.max >= other.min:
+            return AccumBounds(self.min, Max(self.max, other.max))
+
+        if other.min <= self.min and other.max >= self.min:
+            return AccumBounds(other.min, Max(self.max, other.max))
+
+
+@dispatch(AccumulationBounds, AccumulationBounds) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa:F811
+    if is_le(lhs.max, rhs.min):
+        return True
+    if is_gt(lhs.min, rhs.max):
+        return False
+
+
+@dispatch(AccumulationBounds, Basic) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa: F811
+
+    """
+    Returns ``True `` if range of values attained by ``lhs`` AccumulationBounds
+    object is greater than the range of values attained by ``rhs``,
+    where ``rhs`` may be any value of type AccumulationBounds object or
+    extended real number value, ``False`` if ``rhs`` satisfies
+    the same property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) > AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) > AccumBounds(3, 4)
+    AccumBounds(1, 4) > AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) > -1
+    True
+
+    """
+    if not rhs.is_extended_real:
+            raise TypeError(
+                "Invalid comparison of %s %s" %
+                (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_le(lhs.max, rhs):
+            return True
+        if is_gt(lhs.min, rhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+
+@dispatch(AccumulationBounds, Expr)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa: F811
+    """
+    Returns ``True`` if range of values attained by ``lhs`` AccumulationBounds
+    object is less that the range of values attained by ``rhs``, where
+    other may be any value of type AccumulationBounds object or extended
+    real number value, ``False`` if ``rhs`` satisfies the same
+    property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) >= AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) >= AccumBounds(3, 4)
+    AccumBounds(1, 4) >= AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) >= 1
+    True
+    """
+
+    if not rhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_ge(lhs.min, rhs):
+            return True
+        if is_lt(lhs.max, rhs):
+            return False
+
+
+@dispatch(Expr, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if not lhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(lhs), lhs))
+    elif lhs.is_comparable:
+        if is_le(rhs.max, lhs):
+            return True
+        if is_gt(rhs.min, lhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+# setting an alias for AccumulationBounds
+AccumBounds = AccumulationBounds
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/euler.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/euler.py
new file mode 100644
index 0000000000000000000000000000000000000000..817acf76091dfba2dba40487ca7735e307c0fc15
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/euler.py
@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/finite_diff.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/finite_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..17eece149aadad236cefeb350e1ef4a383c84f01
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/finite_diff.py
@@ -0,0 +1,476 @@
+"""
+Finite difference weights
+=========================
+
+This module implements an algorithm for efficient generation of finite
+difference weights for ordinary differentials of functions for
+derivatives from 0 (interpolation) up to arbitrary order.
+
+The core algorithm is provided in the finite difference weight generating
+function (``finite_diff_weights``), and two convenience functions are provided
+for:
+
+- estimating a derivative (or interpolate) directly from a series of points
+    is also provided (``apply_finite_diff``).
+- differentiating by using finite difference approximations
+    (``differentiate_finite``).
+
+"""
+
+from sympy.core.function import Derivative
+from sympy.core.singleton import S
+from sympy.core.function import Subs
+from sympy.core.traversal import preorder_traversal
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable
+
+
+
+def finite_diff_weights(order, x_list, x0=S.One):
+    """
+    Calculates the finite difference weights for an arbitrarily spaced
+    one-dimensional grid (``x_list``) for derivatives at ``x0`` of order
+    0, 1, ..., up to ``order`` using a recursive formula. Order of accuracy
+    is at least ``len(x_list) - order``, if ``x_list`` is defined correctly.
+
+    Parameters
+    ==========
+
+    order: int
+        Up to what derivative order weights should be calculated.
+        0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+        It is useful (but not necessary) to order ``x_list`` from
+        nearest to furthest from ``x0``; see examples below.
+    x0: Number or Symbol
+        Root or value of the independent variable for which the finite
+        difference weights should be generated. Default is ``S.One``.
+
+    Returns
+    =======
+
+    list
+        A list of sublists, each corresponding to coefficients for
+        increasing derivative order, and each containing lists of
+        coefficients for increasing subsets of x_list.
+
+    Examples
+    ========
+
+    >>> from sympy import finite_diff_weights, S
+    >>> res = finite_diff_weights(1, [-S(1)/2, S(1)/2, S(3)/2, S(5)/2], 0)
+    >>> res
+    [[[1, 0, 0, 0],
+      [1/2, 1/2, 0, 0],
+      [3/8, 3/4, -1/8, 0],
+      [5/16, 15/16, -5/16, 1/16]],
+     [[0, 0, 0, 0],
+      [-1, 1, 0, 0],
+      [-1, 1, 0, 0],
+      [-23/24, 7/8, 1/8, -1/24]]]
+    >>> res[0][-1]  # FD weights for 0th derivative, using full x_list
+    [5/16, 15/16, -5/16, 1/16]
+    >>> res[1][-1]  # FD weights for 1st derivative
+    [-23/24, 7/8, 1/8, -1/24]
+    >>> res[1][-2]  # FD weights for 1st derivative, using x_list[:-1]
+    [-1, 1, 0, 0]
+    >>> res[1][-1][0]  # FD weight for 1st deriv. for x_list[0]
+    -23/24
+    >>> res[1][-1][1]  # FD weight for 1st deriv. for x_list[1], etc.
+    7/8
+
+    Each sublist contains the most accurate formula at the end.
+    Note, that in the above example ``res[1][1]`` is the same as ``res[1][2]``.
+    Since res[1][2] has an order of accuracy of
+    ``len(x_list[:3]) - order = 3 - 1 = 2``, the same is true for ``res[1][1]``!
+
+    >>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)[1]
+    >>> res
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [0, 1/2, -1/2, 0, 0],
+     [-1/2, 1, -1/3, -1/6, 0],
+     [0, 2/3, -2/3, -1/12, 1/12]]
+    >>> res[0]  # no approximation possible, using x_list[0] only
+    [0, 0, 0, 0, 0]
+    >>> res[1]  # classic forward step approximation
+    [-1, 1, 0, 0, 0]
+    >>> res[2]  # classic centered approximation
+    [0, 1/2, -1/2, 0, 0]
+    >>> res[3:]  # higher order approximations
+    [[-1/2, 1, -1/3, -1/6, 0], [0, 2/3, -2/3, -1/12, 1/12]]
+
+    Let us compare this to a differently defined ``x_list``. Pay attention to
+    ``foo[i][k]`` corresponding to the gridpoint defined by ``x_list[k]``.
+
+    >>> foo = finite_diff_weights(1, [-S(2), -S(1), S(0), S(1), S(2)], 0)[1]
+    >>> foo
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [1/2, -2, 3/2, 0, 0],
+     [1/6, -1, 1/2, 1/3, 0],
+     [1/12, -2/3, 0, 2/3, -1/12]]
+    >>> foo[1]  # not the same and of lower accuracy as res[1]!
+    [-1, 1, 0, 0, 0]
+    >>> foo[2]  # classic double backward step approximation
+    [1/2, -2, 3/2, 0, 0]
+    >>> foo[4]  # the same as res[4]
+    [1/12, -2/3, 0, 2/3, -1/12]
+
+    Note that, unless you plan on using approximations based on subsets of
+    ``x_list``, the order of gridpoints does not matter.
+
+    The capability to generate weights at arbitrary points can be
+    used e.g. to minimize Runge's phenomenon by using Chebyshev nodes:
+
+    >>> from sympy import cos, symbols, pi, simplify
+    >>> N, (h, x) = 4, symbols('h x')
+    >>> x_list = [x+h*cos(i*pi/(N)) for i in range(N,-1,-1)] # chebyshev nodes
+    >>> print(x_list)
+    [-h + x, -sqrt(2)*h/2 + x, x, sqrt(2)*h/2 + x, h + x]
+    >>> mycoeffs = finite_diff_weights(1, x_list, 0)[1][4]
+    >>> [simplify(c) for c in  mycoeffs] #doctest: +NORMALIZE_WHITESPACE
+    [(h**3/2 + h**2*x - 3*h*x**2 - 4*x**3)/h**4,
+    (-sqrt(2)*h**3 - 4*h**2*x + 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (6*h**2*x - 8*x**3)/h**4,
+    (sqrt(2)*h**3 - 4*h**2*x - 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (-h**3/2 + h**2*x + 3*h*x**2 - 4*x**3)/h**4]
+
+    Notes
+    =====
+
+    If weights for a finite difference approximation of 3rd order
+    derivative is wanted, weights for 0th, 1st and 2nd order are
+    calculated "for free", so are formulae using subsets of ``x_list``.
+    This is something one can take advantage of to save computational cost.
+    Be aware that one should define ``x_list`` from nearest to furthest from
+    ``x0``. If not, subsets of ``x_list`` will yield poorer approximations,
+    which might not grand an order of accuracy of ``len(x_list) - order``.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+
+    References
+    ==========
+
+    .. [1] Generation of Finite Difference Formulas on Arbitrarily Spaced
+            Grids, Bengt Fornberg; Mathematics of computation; 51; 184;
+            (1988); 699-706; doi:10.1090/S0025-5718-1988-0935077-0
+
+    """
+    # The notation below closely corresponds to the one used in the paper.
+    order = S(order)
+    if not order.is_number:
+        raise ValueError("Cannot handle symbolic order.")
+    if order < 0:
+        raise ValueError("Negative derivative order illegal.")
+    if int(order) != order:
+        raise ValueError("Non-integer order illegal")
+    M = order
+    N = len(x_list) - 1
+    delta = [[[0 for nu in range(N+1)] for n in range(N+1)] for
+             m in range(M+1)]
+    delta[0][0][0] = S.One
+    c1 = S.One
+    for n in range(1, N+1):
+        c2 = S.One
+        for nu in range(n):
+            c3 = x_list[n] - x_list[nu]
+            c2 = c2 * c3
+            if n <= M:
+                delta[n][n-1][nu] = 0
+            for m in range(min(n, M)+1):
+                delta[m][n][nu] = (x_list[n]-x0)*delta[m][n-1][nu] -\
+                    m*delta[m-1][n-1][nu]
+                delta[m][n][nu] /= c3
+        for m in range(min(n, M)+1):
+            delta[m][n][n] = c1/c2*(m*delta[m-1][n-1][n-1] -
+                                    (x_list[n-1]-x0)*delta[m][n-1][n-1])
+        c1 = c2
+    return delta
+
+
+def apply_finite_diff(order, x_list, y_list, x0=S.Zero):
+    """
+    Calculates the finite difference approximation of
+    the derivative of requested order at ``x0`` from points
+    provided in ``x_list`` and ``y_list``.
+
+    Parameters
+    ==========
+
+    order: int
+        order of derivative to approximate. 0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+    y_list: sequence
+        The function value at corresponding values for the independent
+        variable in x_list.
+    x0: Number or Symbol
+        At what value of the independent variable the derivative should be
+        evaluated. Defaults to 0.
+
+    Returns
+    =======
+
+    sympy.core.add.Add or sympy.core.numbers.Number
+        The finite difference expression approximating the requested
+        derivative order at ``x0``.
+
+    Examples
+    ========
+
+    >>> from sympy import apply_finite_diff
+    >>> cube = lambda arg: (1.0*arg)**3
+    >>> xlist = range(-3,3+1)
+    >>> apply_finite_diff(2, xlist, map(cube, xlist), 2) - 12 # doctest: +SKIP
+    -3.55271367880050e-15
+
+    we see that the example above only contain rounding errors.
+    apply_finite_diff can also be used on more abstract objects:
+
+    >>> from sympy import IndexedBase, Idx
+    >>> x, y = map(IndexedBase, 'xy')
+    >>> i = Idx('i')
+    >>> x_list, y_list = zip(*[(x[i+j], y[i+j]) for j in range(-1,2)])
+    >>> apply_finite_diff(1, x_list, y_list, x[i])
+    ((x[i + 1] - x[i])/(-x[i - 1] + x[i]) - 1)*y[i]/(x[i + 1] - x[i]) -
+    (x[i + 1] - x[i])*y[i - 1]/((x[i + 1] - x[i - 1])*(-x[i - 1] + x[i])) +
+    (-x[i - 1] + x[i])*y[i + 1]/((x[i + 1] - x[i - 1])*(x[i + 1] - x[i]))
+
+    Notes
+    =====
+
+    Order = 0 corresponds to interpolation.
+    Only supply so many points you think makes sense
+    to around x0 when extracting the derivative (the function
+    need to be well behaved within that region). Also beware
+    of Runge's phenomenon.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    References
+    ==========
+
+    Fortran 90 implementation with Python interface for numerics: finitediff_
+
+    .. _finitediff: https://github.com/bjodah/finitediff
+
+    """
+
+    # In the original paper the following holds for the notation:
+    # M = order
+    # N = len(x_list) - 1
+
+    N = len(x_list) - 1
+    if len(x_list) != len(y_list):
+        raise ValueError("x_list and y_list not equal in length.")
+
+    delta = finite_diff_weights(order, x_list, x0)
+
+    derivative = 0
+    for nu in range(len(x_list)):
+        derivative += delta[order][N][nu]*y_list[nu]
+    return derivative
+
+
+def _as_finite_diff(derivative, points=1, x0=None, wrt=None):
+    """
+    Returns an approximation of a derivative of a function in
+    the form of a finite difference formula. The expression is a
+    weighted sum of the function at a number of discrete values of
+    (one of) the independent variable(s).
+
+    Parameters
+    ==========
+
+    derivative: a Derivative instance
+
+    points: sequence or coefficient, optional
+        If sequence: discrete values (length >= order+1) of the
+        independent variable used for generating the finite
+        difference weights.
+        If it is a coefficient, it will be used as the step-size
+        for generating an equidistant sequence of length order+1
+        centered around ``x0``. default: 1 (step-size 1)
+
+    x0: number or Symbol, optional
+        the value of the independent variable (``wrt``) at which the
+        derivative is to be approximated. Default: same as ``wrt``.
+
+    wrt: Symbol, optional
+        "with respect to" the variable for which the (partial)
+        derivative is to be approximated for. If not provided it
+        is required that the Derivative is ordinary. Default: ``None``.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Function, exp, sqrt, Symbol
+    >>> from sympy.calculus.finite_diff import _as_finite_diff
+    >>> x, h = symbols('x h')
+    >>> f = Function('f')
+    >>> _as_finite_diff(f(x).diff(x))
+    -f(x - 1/2) + f(x + 1/2)
+
+    The default step size and number of points are 1 and ``order + 1``
+    respectively. We can change the step size by passing a symbol
+    as a parameter:
+
+    >>> _as_finite_diff(f(x).diff(x), h)
+    -f(-h/2 + x)/h + f(h/2 + x)/h
+
+    We can also specify the discretized values to be used in a sequence:
+
+    >>> _as_finite_diff(f(x).diff(x), [x, x+h, x+2*h])
+    -3*f(x)/(2*h) + 2*f(h + x)/h - f(2*h + x)/(2*h)
+
+    The algorithm is not restricted to use equidistant spacing, nor
+    do we need to make the approximation around ``x0``, but we can get
+    an expression estimating the derivative at an offset:
+
+    >>> e, sq2 = exp(1), sqrt(2)
+    >>> xl = [x-h, x+h, x+e*h]
+    >>> _as_finite_diff(f(x).diff(x, 1), xl, x+h*sq2)
+    2*h*((h + sqrt(2)*h)/(2*h) - (-sqrt(2)*h + h)/(2*h))*f(E*h + x)/((-h + E*h)*(h + E*h)) +
+    (-(-sqrt(2)*h + h)/(2*h) - (-sqrt(2)*h + E*h)/(2*h))*f(-h + x)/(h + E*h) +
+    (-(h + sqrt(2)*h)/(2*h) + (-sqrt(2)*h + E*h)/(2*h))*f(h + x)/(-h + E*h)
+
+    Partial derivatives are also supported:
+
+    >>> y = Symbol('y')
+    >>> d2fdxdy=f(x,y).diff(x,y)
+    >>> _as_finite_diff(d2fdxdy, wrt=x)
+    -Derivative(f(x - 1/2, y), y) + Derivative(f(x + 1/2, y), y)
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    """
+    if derivative.is_Derivative:
+        pass
+    elif derivative.is_Atom:
+        return derivative
+    else:
+        return derivative.fromiter(
+            [_as_finite_diff(ar, points, x0, wrt) for ar
+             in derivative.args], **derivative.assumptions0)
+
+    if wrt is None:
+        old = None
+        for v in derivative.variables:
+            if old is v:
+                continue
+            derivative = _as_finite_diff(derivative, points, x0, v)
+            old = v
+        return derivative
+
+    order = derivative.variables.count(wrt)
+
+    if x0 is None:
+        x0 = wrt
+
+    if not iterable(points):
+        if getattr(points, 'is_Function', False) and wrt in points.args:
+            points = points.subs(wrt, x0)
+        # points is simply the step-size, let's make it a
+        # equidistant sequence centered around x0
+        if order % 2 == 0:
+            # even order => odd number of points, grid point included
+            points = [x0 + points*i for i
+                      in range(-order//2, order//2 + 1)]
+        else:
+            # odd order => even number of points, half-way wrt grid point
+            points = [x0 + points*S(i)/2 for i
+                      in range(-order, order + 1, 2)]
+    others = [wrt, 0]
+    for v in set(derivative.variables):
+        if v == wrt:
+            continue
+        others += [v, derivative.variables.count(v)]
+    if len(points) < order+1:
+        raise ValueError("Too few points for order %d" % order)
+    return apply_finite_diff(order, points, [
+        Derivative(derivative.expr.subs({wrt: x}), *others) for
+        x in points], x0)
+
+
+def differentiate_finite(expr, *symbols,
+                         points=1, x0=None, wrt=None, evaluate=False):
+    r""" Differentiate expr and replace Derivatives with finite differences.
+
+    Parameters
+    ==========
+
+    expr : expression
+    \*symbols : differentiate with respect to symbols
+    points: sequence, coefficient or undefined function, optional
+        see ``Derivative.as_finite_difference``
+    x0: number or Symbol, optional
+        see ``Derivative.as_finite_difference``
+    wrt: Symbol, optional
+        see ``Derivative.as_finite_difference``
+
+    Examples
+    ========
+
+    >>> from sympy import sin, Function, differentiate_finite
+    >>> from sympy.abc import x, y, h
+    >>> f, g = Function('f'), Function('g')
+    >>> differentiate_finite(f(x)*g(x), x, points=[x-h, x+h])
+    -f(-h + x)*g(-h + x)/(2*h) + f(h + x)*g(h + x)/(2*h)
+
+    ``differentiate_finite`` works on any expression, including the expressions
+    with embedded derivatives:
+
+    >>> differentiate_finite(f(x) + sin(x), x, 2)
+    -2*f(x) + f(x - 1) + f(x + 1) - 2*sin(x) + sin(x - 1) + sin(x + 1)
+    >>> differentiate_finite(f(x, y), x, y)
+    f(x - 1/2, y - 1/2) - f(x - 1/2, y + 1/2) - f(x + 1/2, y - 1/2) + f(x + 1/2, y + 1/2)
+    >>> differentiate_finite(f(x)*g(x).diff(x), x)
+    (-g(x) + g(x + 1))*f(x + 1/2) - (g(x) - g(x - 1))*f(x - 1/2)
+
+    To make finite difference with non-constant discretization step use
+    undefined functions:
+
+    >>> dx = Function('dx')
+    >>> differentiate_finite(f(x)*g(x).diff(x), points=dx(x))
+    -(-g(x - dx(x)/2 - dx(x - dx(x)/2)/2)/dx(x - dx(x)/2) +
+    g(x - dx(x)/2 + dx(x - dx(x)/2)/2)/dx(x - dx(x)/2))*f(x - dx(x)/2)/dx(x) +
+    (-g(x + dx(x)/2 - dx(x + dx(x)/2)/2)/dx(x + dx(x)/2) +
+    g(x + dx(x)/2 + dx(x + dx(x)/2)/2)/dx(x + dx(x)/2))*f(x + dx(x)/2)/dx(x)
+
+    """
+    if any(term.is_Derivative for term in list(preorder_traversal(expr))):
+        evaluate = False
+
+    Dexpr = expr.diff(*symbols, evaluate=evaluate)
+    if evaluate:
+        sympy_deprecation_warning("""
+        The evaluate flag to differentiate_finite() is deprecated.
+
+        evaluate=True expands the intermediate derivatives before computing
+        differences, but this usually not what you want, as it does not
+        satisfy the product rule.
+        """,
+            deprecated_since_version="1.5",
+             active_deprecations_target="deprecated-differentiate_finite-evaluate",
+        )
+        return Dexpr.replace(
+            lambda arg: arg.is_Derivative,
+            lambda arg: arg.as_finite_difference(points=points, x0=x0, wrt=wrt))
+    else:
+        DFexpr = Dexpr.as_finite_difference(points=points, x0=x0, wrt=wrt)
+        return DFexpr.replace(
+            lambda arg: isinstance(arg, Subs),
+            lambda arg: arg.expr.as_finite_difference(
+                    points=points, x0=arg.point[0], wrt=arg.variables[0]))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/singularities.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/singularities.py
new file mode 100644
index 0000000000000000000000000000000000000000..5adafc59efaf0bff44707f6b5e3f074be6bc1f32
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/singularities.py
@@ -0,0 +1,406 @@
+"""
+Singularities
+=============
+
+This module implements algorithms for finding singularities for a function
+and identifying types of functions.
+
+The differential calculus methods in this module include methods to identify
+the following function types in the given ``Interval``:
+- Increasing
+- Strictly Increasing
+- Decreasing
+- Strictly Decreasing
+- Monotonic
+
+"""
+
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import sec, csc, cot, tan, cos
+from sympy.functions.elementary.hyperbolic import (
+    sech, csch, coth, tanh, cosh, asech, acsch, atanh, acoth)
+from sympy.utilities.misc import filldedent
+
+
+def singularities(expression, symbol, domain=None):
+    """
+    Find singularities of a given function.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function in which singularities need to be found.
+    symbol : Symbol
+        The symbol over the values of which the singularity in
+        expression in being searched for.
+
+    Returns
+    =======
+
+    Set
+        A set of values for ``symbol`` for which ``expression`` has a
+        singularity. An ``EmptySet`` is returned if ``expression`` has no
+        singularities for any given value of ``Symbol``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Methods for determining the singularities of this function have
+        not been developed.
+
+    Notes
+    =====
+
+    This function does not find non-isolated singularities
+    nor does it find branch points of the expression.
+
+    Currently supported functions are:
+        - univariate continuous (real or complex) functions
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity
+
+    Examples
+    ========
+
+    >>> from sympy import singularities, Symbol, log
+    >>> x = Symbol('x', real=True)
+    >>> y = Symbol('y', real=False)
+    >>> singularities(x**2 + x + 1, x)
+    EmptySet
+    >>> singularities(1/(x + 1), x)
+    {-1}
+    >>> singularities(1/(y**2 + 1), y)
+    {-I, I}
+    >>> singularities(1/(y**3 + 1), y)
+    {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
+    >>> singularities(log(x), x)
+    {0}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is None:
+        domain = S.Reals if symbol.is_real else S.Complexes
+    try:
+        sings = S.EmptySet
+        e = expression.rewrite([sec, csc, cot, tan], cos)
+        e = e.rewrite([sech, csch, coth, tanh], cosh)
+        for i in e.atoms(Pow):
+            if i.exp.is_infinite:
+                raise NotImplementedError
+            if i.exp.is_negative:
+                # XXX: exponent of varying sign not handled
+                sings += solveset(i.base, symbol, domain)
+        for i in expression.atoms(log, asech, acsch):
+            sings += solveset(i.args[0], symbol, domain)
+        for i in expression.atoms(atanh, acoth):
+            sings += solveset(i.args[0] - 1, symbol, domain)
+            sings += solveset(i.args[0] + 1, symbol, domain)
+        return sings
+    except NotImplementedError:
+        raise NotImplementedError(filldedent('''
+            Methods for determining the singularities
+            of this function have not been developed.'''))
+
+
+###########################################################################
+#                      DIFFERENTIAL CALCULUS METHODS                      #
+###########################################################################
+
+
+def monotonicity_helper(expression, predicate, interval=S.Reals, symbol=None):
+    """
+    Helper function for functions checking function monotonicity.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked
+    predicate : function
+        The property being tested for. The function takes in an integer
+        and returns a boolean. The integer input is the derivative and
+        the boolean result should be true if the property is being held,
+        and false otherwise.
+    interval : Set, optional
+        The range of values in which we are testing, defaults to all reals.
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    It returns a boolean indicating whether the interval in which
+    the function's derivative satisfies given predicate is a superset
+    of the given interval.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``predicate`` is true for all the derivatives when ``symbol``
+        is varied in ``range``, False otherwise.
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+    free = expression.free_symbols
+
+    if symbol is None:
+        if len(free) > 1:
+            raise NotImplementedError(
+                'The function has not yet been implemented'
+                ' for all multivariate expressions.'
+            )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    derivative = expression.diff(variable)
+    predicate_interval = solveset(predicate(derivative), variable, S.Reals)
+    return interval.is_subset(predicate_interval)
+
+
+def is_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is increasing (either strictly increasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_increasing(-x**2, Interval(-oo, 0))
+    True
+    >>> is_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    False
+    >>> is_increasing(x**2 + y, Interval(1, 2), x)
+    True
+
+    """
+    return monotonicity_helper(expression, lambda x: x >= 0, interval, symbol)
+
+
+def is_strictly_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly increasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import Interval, oo
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    False
+    >>> is_strictly_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x > 0, interval, symbol)
+
+
+def is_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is decreasing (either strictly decreasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x <= 0, interval, symbol)
+
+
+def is_strictly_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly decreasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x < 0, interval, symbol)
+
+
+def is_monotonic(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is monotonic in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is monotonic in the given ``interval``,
+        False otherwise.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Monotonicity check has not been implemented for the queried function.
+
+    Examples
+    ========
+
+    >>> from sympy import is_monotonic
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_monotonic(-x**2, S.Reals)
+    False
+    >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    True
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+
+    free = expression.free_symbols
+    if symbol is None and len(free) > 1:
+        raise NotImplementedError(
+            'is_monotonic has not yet been implemented'
+            ' for all multivariate expressions.'
+        )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    turning_points = solveset(expression.diff(variable), variable, interval)
+    return interval.intersection(turning_points) is S.EmptySet
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_accumulationbounds.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_accumulationbounds.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcc47c66327fe21ddca3a6b73ca5914e0441b38e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_accumulationbounds.py
@@ -0,0 +1,336 @@
+from sympy.core.numbers import (E, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core import Add, Mul, Pow
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import x
+
+a = Symbol('a', real=True)
+B = AccumBounds
+
+
+def test_AccumBounds():
+    assert B(1, 2).args == (1, 2)
+    assert B(1, 2).delta is S.One
+    assert B(1, 2).mid == Rational(3, 2)
+    assert B(1, 3).is_real == True
+
+    assert B(1, 1) is S.One
+
+    assert B(1, 2) + 1 == B(2, 3)
+    assert 1 + B(1, 2) == B(2, 3)
+    assert B(1, 2) + B(2, 3) == B(3, 5)
+
+    assert -B(1, 2) == B(-2, -1)
+
+    assert B(1, 2) - 1 == B(0, 1)
+    assert 1 - B(1, 2) == B(-1, 0)
+    assert B(2, 3) - B(1, 2) == B(0, 2)
+
+    assert x + B(1, 2) == Add(B(1, 2), x)
+    assert a + B(1, 2) == B(1 + a, 2 + a)
+    assert B(1, 2) - x == Add(B(1, 2), -x)
+
+    assert B(-oo, 1) + oo == B(-oo, oo)
+    assert B(1, oo) + oo is oo
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert (-oo - B(-1, oo)) is -oo
+    assert B(-oo, 1) - oo is -oo
+
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert B(-oo, 1) - (-oo) == B(-oo, oo)
+    assert (oo - B(1, oo)) == B(-oo, oo)
+    assert (-oo - B(1, oo)) is -oo
+
+    assert B(1, 2)/2 == B(S.Half, 1)
+    assert 2/B(2, 3) == B(Rational(2, 3), 1)
+    assert 1/B(-1, 1) == B(-oo, oo)
+
+    assert abs(B(1, 2)) == B(1, 2)
+    assert abs(B(-2, -1)) == B(1, 2)
+    assert abs(B(-2, 1)) == B(0, 2)
+    assert abs(B(-1, 2)) == B(0, 2)
+    c = Symbol('c')
+    raises(ValueError, lambda: B(0, c))
+    raises(ValueError, lambda: B(1, -1))
+    r = Symbol('r', real=True)
+    raises(ValueError, lambda: B(r, r - 1))
+
+
+def test_AccumBounds_mul():
+    assert B(1, 2)*2 == B(2, 4)
+    assert 2*B(1, 2) == B(2, 4)
+    assert B(1, 2)*B(2, 3) == B(2, 6)
+    assert B(0, 2)*B(2, oo) == B(0, oo)
+    l, r = B(-oo, oo), B(-a, a)
+    assert l*r == B(-oo, oo)
+    assert r*l == B(-oo, oo)
+    l, r = B(1, oo), B(-3, -2)
+    assert l*r == B(-oo, -2)
+    assert r*l == B(-oo, -2)
+    assert B(1, 2)*0 == 0
+    assert B(1, oo)*0 == B(0, oo)
+    assert B(-oo, 1)*0 == B(-oo, 0)
+    assert B(-oo, oo)*0 == B(-oo, oo)
+
+    assert B(1, 2)*x == Mul(B(1, 2), x, evaluate=False)
+
+    assert B(0, 2)*oo == B(0, oo)
+    assert B(-2, 0)*oo == B(-oo, 0)
+    assert B(0, 2)*(-oo) == B(-oo, 0)
+    assert B(-2, 0)*(-oo) == B(0, oo)
+    assert B(-1, 1)*oo == B(-oo, oo)
+    assert B(-1, 1)*(-oo) == B(-oo, oo)
+    assert B(-oo, oo)*oo == B(-oo, oo)
+
+
+def test_AccumBounds_div():
+    assert B(-1, 3)/B(3, 4) == B(Rational(-1, 3), 1)
+    assert B(-2, 4)/B(-3, 4) == B(-oo, oo)
+    assert B(-3, -2)/B(-4, 0) == B(S.Half, oo)
+
+    # these two tests can have a better answer
+    # after Union of B is improved
+    assert B(-3, -2)/B(-2, 1) == B(-oo, oo)
+    assert B(2, 3)/B(-2, 2) == B(-oo, oo)
+
+    assert B(-3, -2)/B(0, 4) == B(-oo, Rational(-1, 2))
+    assert B(2, 4)/B(-3, 0) == B(-oo, Rational(-2, 3))
+    assert B(2, 4)/B(0, 3) == B(Rational(2, 3), oo)
+
+    assert B(0, 1)/B(0, 1) == B(0, oo)
+    assert B(-1, 0)/B(0, 1) == B(-oo, 0)
+    assert B(-1, 2)/B(-2, 2) == B(-oo, oo)
+
+    assert 1/B(-1, 2) == B(-oo, oo)
+    assert 1/B(0, 2) == B(S.Half, oo)
+    assert (-1)/B(0, 2) == B(-oo, Rational(-1, 2))
+    assert 1/B(-oo, 0) == B(-oo, 0)
+    assert 1/B(-1, 0) == B(-oo, -1)
+    assert (-2)/B(-oo, 0) == B(0, oo)
+    assert 1/B(-oo, -1) == B(-1, 0)
+
+    assert B(1, 2)/a == Mul(B(1, 2), 1/a, evaluate=False)
+
+    assert B(1, 2)/0 == B(1, 2)*zoo
+    assert B(1, oo)/oo == B(0, oo)
+    assert B(1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, -1)/oo == B(-oo, 0)
+    assert B(-oo, -1)/(-oo) == B(0, oo)
+    assert B(-oo, oo)/oo == B(-oo, oo)
+    assert B(-oo, oo)/(-oo) == B(-oo, oo)
+    assert B(-1, oo)/oo == B(0, oo)
+    assert B(-1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, 1)/oo == B(-oo, 0)
+    assert B(-oo, 1)/(-oo) == B(0, oo)
+
+
+def test_issue_18795():
+    r = Symbol('r', real=True)
+    a = B(-1,1)
+    c = B(7, oo)
+    b = B(-oo, oo)
+    assert c - tan(r) == B(7-tan(r), oo)
+    assert b + tan(r) == B(-oo, oo)
+    assert (a + r)/a == B(-oo, oo)*B(r - 1, r + 1)
+    assert (b + a)/a == B(-oo, oo)
+
+
+def test_AccumBounds_func():
+    assert (x**2 + 2*x + 1).subs(x, B(-1, 1)) == B(-1, 4)
+    assert exp(B(0, 1)) == B(1, E)
+    assert exp(B(-oo, oo)) == B(0, oo)
+    assert log(B(3, 6)) == B(log(3), log(6))
+
+
+@XFAIL
+def test_AccumBounds_powf():
+    nn = Symbol('nn', nonnegative=True)
+    assert B(1 + nn, 2 + nn)**B(1, 2) == B(1 + nn, (2 + nn)**2)
+    i = Symbol('i', integer=True, negative=True)
+    assert B(1, 2)**i == B(2**i, 1)
+
+
+def test_AccumBounds_pow():
+    assert B(0, 2)**2 == B(0, 4)
+    assert B(-1, 1)**2 == B(0, 1)
+    assert B(1, 2)**2 == B(1, 4)
+    assert B(-1, 2)**3 == B(-1, 8)
+    assert B(-1, 1)**0 == 1
+
+    assert B(1, 2)**Rational(5, 2) == B(1, 4*sqrt(2))
+    assert B(0, 2)**S.Half == B(0, sqrt(2))
+
+    neg = Symbol('neg', negative=True)
+    assert unchanged(Pow, B(neg, 1), S.Half)
+    nn = Symbol('nn', nonnegative=True)
+    assert B(nn, nn + 1)**S.Half == B(sqrt(nn), sqrt(nn + 1))
+    assert B(nn, nn + 1)**nn == B(nn**nn, (nn + 1)**nn)
+    assert unchanged(Pow, B(nn, nn + 1), x)
+    i = Symbol('i', integer=True)
+    assert B(1, 2)**i == B(Min(1, 2**i), Max(1, 2**i))
+    i = Symbol('i', integer=True, nonnegative=True)
+    assert B(1, 2)**i == B(1, 2**i)
+    assert B(0, 1)**i == B(0**i, 1)
+
+    assert B(1, 5)**(-2) == B(Rational(1, 25), 1)
+    assert B(-1, 3)**(-2) == B(0, oo)
+    assert B(0, 2)**(-3) == B(Rational(1, 8), oo)
+    assert B(-2, 0)**(-3) == B(-oo, -Rational(1, 8))
+    assert B(0, 2)**(-2) == B(Rational(1, 4), oo)
+    assert B(-1, 2)**(-3) == B(-oo, oo)
+    assert B(-3, -2)**(-3) == B(Rational(-1, 8), Rational(-1, 27))
+    assert B(-3, -2)**(-2) == B(Rational(1, 9), Rational(1, 4))
+    assert B(0, oo)**S.Half == B(0, oo)
+    assert B(-oo, 0)**(-2) == B(0, oo)
+    assert B(-2, 0)**(-2) == B(Rational(1, 4), oo)
+
+    assert B(Rational(1, 3), S.Half)**oo is S.Zero
+    assert B(0, S.Half)**oo is S.Zero
+    assert B(S.Half, 1)**oo == B(0, oo)
+    assert B(0, 1)**oo == B(0, oo)
+    assert B(2, 3)**oo is oo
+    assert B(1, 2)**oo == B(0, oo)
+    assert B(S.Half, 3)**oo == B(0, oo)
+    assert B(Rational(-1, 3), Rational(-1, 4))**oo is S.Zero
+    assert B(-1, Rational(-1, 2))**oo is S.NaN
+    assert B(-3, -2)**oo is zoo
+    assert B(-2, -1)**oo is S.NaN
+    assert B(-2, Rational(-1, 2))**oo is S.NaN
+    assert B(Rational(-1, 2), S.Half)**oo is S.Zero
+    assert B(Rational(-1, 2), 1)**oo == B(0, oo)
+    assert B(Rational(-2, 3), 2)**oo == B(0, oo)
+    assert B(-1, 1)**oo == B(-oo, oo)
+    assert B(-1, S.Half)**oo == B(-oo, oo)
+    assert B(-1, 2)**oo == B(-oo, oo)
+    assert B(-2, S.Half)**oo == B(-oo, oo)
+
+    assert B(1, 2)**x == Pow(B(1, 2), x, evaluate=False)
+
+    assert B(2, 3)**(-oo) is S.Zero
+    assert B(0, 2)**(-oo) == B(0, oo)
+    assert B(-1, 2)**(-oo) == B(-oo, oo)
+
+    assert (tan(x)**sin(2*x)).subs(x, B(0, pi/2)) == \
+        Pow(B(-oo, oo), B(0, 1))
+
+
+def test_AccumBounds_exponent():
+    # base is 0
+    z = 0**B(a, a + S.Half)
+    assert z.subs(a, 0) == B(0, 1)
+    assert z.subs(a, 1) == 0
+    p = z.subs(a, -1)
+    assert p.is_Pow and p.args == (0, B(-1, -S.Half))
+    # base > 0
+    #   when base is 1 the type of bounds does not matter
+    assert 1**B(a, a + 1) == 1
+    #  otherwise we need to know if 0 is in the bounds
+    assert S.Half**B(-2, 2) == B(S(1)/4, 4)
+    assert 2**B(-2, 2) == B(S(1)/4, 4)
+
+    # +eps may introduce +oo
+    # if there is a negative integer exponent
+    assert B(0, 1)**B(S(1)/2, 1) == B(0, 1)
+    assert B(0, 1)**B(0, 1) == B(0, 1)
+
+    # positive bases have positive bounds
+    assert B(2, 3)**B(-3, -2) == B(S(1)/27, S(1)/4)
+    assert B(2, 3)**B(-3, 2) == B(S(1)/27, 9)
+
+    # bounds generating imaginary parts unevaluated
+    assert unchanged(Pow, B(-1, 1), B(1, 2))
+    assert B(0, S(1)/2)**B(1, oo) == B(0, S(1)/2)
+    assert B(0, 1)**B(1, oo) == B(0, oo)
+    assert B(0, 2)**B(1, oo) == B(0, oo)
+    assert B(0, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, oo) == B(0, oo)
+    assert B(1, 2)**B(1, oo) == B(0, oo)
+    assert B(1, 2)**B(-oo, -1) == B(0, oo)
+    assert B(1, 2)**B(-oo, oo) == B(0, oo)
+    assert B(1, oo)**B(1, oo) == B(0, oo)
+    assert B(1, oo)**B(-oo, -1) == B(0, oo)
+    assert B(1, oo)**B(-oo, oo) == B(0, oo)
+    assert B(2, oo)**B(1, oo) == B(2, oo)
+    assert B(2, oo)**B(-oo, -1) == B(0, S(1)/2)
+    assert B(2, oo)**B(-oo, oo) == B(0, oo)
+
+
+def test_comparison_AccumBounds():
+    assert (B(1, 3) < 4) == S.true
+    assert (B(1, 3) < -1) == S.false
+    assert (B(1, 3) < 2).rel_op == '<'
+    assert (B(1, 3) <= 2).rel_op == '<='
+
+    assert (B(1, 3) > 4) == S.false
+    assert (B(1, 3) > -1) == S.true
+    assert (B(1, 3) > 2).rel_op == '>'
+    assert (B(1, 3) >= 2).rel_op == '>='
+
+    assert (B(1, 3) < B(4, 6)) == S.true
+    assert (B(1, 3) < B(2, 4)).rel_op == '<'
+    assert (B(1, 3) < B(-2, 0)) == S.false
+
+    assert (B(1, 3) <= B(4, 6)) == S.true
+    assert (B(1, 3) <= B(-2, 0)) == S.false
+
+    assert (B(1, 3) > B(4, 6)) == S.false
+    assert (B(1, 3) > B(-2, 0)) == S.true
+
+    assert (B(1, 3) >= B(4, 6)) == S.false
+    assert (B(1, 3) >= B(-2, 0)) == S.true
+
+    # issue 13499
+    assert (cos(x) > 0).subs(x, oo) == (B(-1, 1) > 0)
+
+    c = Symbol('c')
+    raises(TypeError, lambda: (B(0, 1) < c))
+    raises(TypeError, lambda: (B(0, 1) <= c))
+    raises(TypeError, lambda: (B(0, 1) > c))
+    raises(TypeError, lambda: (B(0, 1) >= c))
+
+
+def test_contains_AccumBounds():
+    assert (1 in B(1, 2)) == S.true
+    raises(TypeError, lambda: a in B(1, 2))
+    assert 0 in B(-1, 0)
+    raises(TypeError, lambda:
+        (cos(1)**2 + sin(1)**2 - 1) in B(-1, 0))
+    assert (-oo in B(1, oo)) == S.true
+    assert (oo in B(-oo, 0)) == S.true
+
+    # issue 13159
+    assert Mul(0, B(-1, 1)) == Mul(B(-1, 1), 0) == 0
+    import itertools
+    for perm in itertools.permutations([0, B(-1, 1), x]):
+        assert Mul(*perm) == 0
+
+
+def test_intersection_AccumBounds():
+    assert B(0, 3).intersection(B(1, 2)) == B(1, 2)
+    assert B(0, 3).intersection(B(1, 4)) == B(1, 3)
+    assert B(0, 3).intersection(B(-1, 2)) == B(0, 2)
+    assert B(0, 3).intersection(B(-1, 4)) == B(0, 3)
+    assert B(0, 1).intersection(B(2, 3)) == S.EmptySet
+    raises(TypeError, lambda: B(0, 3).intersection(1))
+
+
+def test_union_AccumBounds():
+    assert B(0, 3).union(B(1, 2)) == B(0, 3)
+    assert B(0, 3).union(B(1, 4)) == B(0, 4)
+    assert B(0, 3).union(B(-1, 2)) == B(-1, 3)
+    assert B(0, 3).union(B(-1, 4)) == B(-1, 4)
+    raises(TypeError, lambda: B(0, 3).union(1))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_euler.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_euler.py
new file mode 100644
index 0000000000000000000000000000000000000000..56371c8c787d9459d1390e18c306fddde94d2745
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_euler.py
@@ -0,0 +1,74 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.calculus.euler import euler_equations as euler
+
+
+def test_euler_interface():
+    x = Function('x')
+    y = Symbol('y')
+    t = Symbol('t')
+    raises(TypeError, lambda: euler())
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [x(t), y]))
+    raises(ValueError, lambda: euler(D(x(t), t)*x(y), [x(t), x(y)]))
+    raises(TypeError, lambda: euler(D(x(t), t)**2, x(0)))
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [t]))
+    assert euler(D(x(t), t)**2/2, {x(t)}) == [Eq(-D(x(t), t, t), 0)]
+    assert euler(D(x(t), t)**2/2, x(t), {t}) == [Eq(-D(x(t), t, t), 0)]
+
+
+def test_euler_pendulum():
+    x = Function('x')
+    t = Symbol('t')
+    L = D(x(t), t)**2/2 + cos(x(t))
+    assert euler(L, x(t), t) == [Eq(-sin(x(t)) - D(x(t), t, t), 0)]
+
+
+def test_euler_henonheiles():
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = sum(D(z(t), t)**2/2 - z(t)**2/2 for z in [x, y])
+    L += -x(t)**2*y(t) + y(t)**3/3
+    assert euler(L, [x(t), y(t)], t) == [Eq(-2*x(t)*y(t) - x(t) -
+                                            D(x(t), t, t), 0),
+                                         Eq(-x(t)**2 + y(t)**2 -
+                                            y(t) - D(y(t), t, t), 0)]
+
+
+def test_euler_sineg():
+    psi = Function('psi')
+    t = Symbol('t')
+    x = Symbol('x')
+    L = D(psi(t, x), t)**2/2 - D(psi(t, x), x)**2/2 + cos(psi(t, x))
+    assert euler(L, psi(t, x), [t, x]) == [Eq(-sin(psi(t, x)) -
+                                              D(psi(t, x), t, t) +
+                                              D(psi(t, x), x, x), 0)]
+
+
+def test_euler_high_order():
+    # an example from hep-th/0309038
+    m = Symbol('m')
+    k = Symbol('k')
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = (m*D(x(t), t)**2/2 + m*D(y(t), t)**2/2 -
+         k*D(x(t), t)*D(y(t), t, t) + k*D(y(t), t)*D(x(t), t, t))
+    assert euler(L, [x(t), y(t)]) == [Eq(2*k*D(y(t), t, t, t) -
+                                         m*D(x(t), t, t), 0),
+                                      Eq(-2*k*D(x(t), t, t, t) -
+                                         m*D(y(t), t, t), 0)]
+
+    w = Symbol('w')
+    L = D(x(t, w), t, w)**2/2
+    assert euler(L) == [Eq(D(x(t, w), t, t, w, w), 0)]
+
+def test_issue_18653():
+    x, y, z = symbols("x y z")
+    f, g, h = symbols("f g h", cls=Function, args=(x, y))
+    f, g, h = f(), g(), h()
+    expr2 = f.diff(x)*h.diff(z)
+    assert euler(expr2, (f,), (x, y)) == []
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_finite_diff.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_finite_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9ecfbdd61b15f516c54bd6d716ba1f264ee2ca0
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_finite_diff.py
@@ -0,0 +1,164 @@
+from itertools import product
+
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.calculus.finite_diff import (
+    apply_finite_diff, differentiate_finite, finite_diff_weights,
+    _as_finite_diff
+)
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_apply_finite_diff():
+    x, h = symbols('x h')
+    f = Function('f')
+    assert (apply_finite_diff(1, [x-h, x+h], [f(x-h), f(x+h)], x) -
+            (f(x+h)-f(x-h))/(2*h)).simplify() == 0
+
+    assert (apply_finite_diff(1, [5, 6, 7], [f(5), f(6), f(7)], 5) -
+            (Rational(-3, 2)*f(5) + 2*f(6) - S.Half*f(7))).simplify() == 0
+    raises(ValueError, lambda: apply_finite_diff(1, [x, h], [f(x)]))
+
+
+def test_finite_diff_weights():
+
+    d = finite_diff_weights(1, [5, 6, 7], 5)
+    assert d[1][2] == [Rational(-3, 2), 2, Rational(-1, 2)]
+
+    # Table 1, p. 702 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [0, 1, -1, 2, -2, 3, -3, 4, -4]
+
+    # d holds all coefficients
+    d = finite_diff_weights(4, xl, S.Zero)
+
+    # Zeroeth derivative
+    for i in range(5):
+        assert d[0][i] == [S.One] + [S.Zero]*8
+
+    # First derivative
+    assert d[1][0] == [S.Zero]*9
+    assert d[1][2] == [S.Zero, S.Half, Rational(-1, 2)] + [S.Zero]*6
+    assert d[1][4] == [S.Zero, Rational(2, 3), Rational(-2, 3), Rational(-1, 12), Rational(1, 12)] + [S.Zero]*4
+    assert d[1][6] == [S.Zero, Rational(3, 4), Rational(-3, 4), Rational(-3, 20), Rational(3, 20),
+                       Rational(1, 60), Rational(-1, 60)] + [S.Zero]*2
+    assert d[1][8] == [S.Zero, Rational(4, 5), Rational(-4, 5), Rational(-1, 5), Rational(1, 5),
+                       Rational(4, 105), Rational(-4, 105), Rational(-1, 280), Rational(1, 280)]
+
+    # Second derivative
+    for i in range(2):
+        assert d[2][i] == [S.Zero]*9
+    assert d[2][2] == [-S(2), S.One, S.One] + [S.Zero]*6
+    assert d[2][4] == [Rational(-5, 2), Rational(4, 3), Rational(4, 3), Rational(-1, 12), Rational(-1, 12)] + [S.Zero]*4
+    assert d[2][6] == [Rational(-49, 18), Rational(3, 2), Rational(3, 2), Rational(-3, 20), Rational(-3, 20),
+                       Rational(1, 90), Rational(1, 90)] + [S.Zero]*2
+    assert d[2][8] == [Rational(-205, 72), Rational(8, 5), Rational(8, 5), Rational(-1, 5), Rational(-1, 5),
+                       Rational(8, 315), Rational(8, 315), Rational(-1, 560), Rational(-1, 560)]
+
+    # Third derivative
+    for i in range(3):
+        assert d[3][i] == [S.Zero]*9
+    assert d[3][4] == [S.Zero, -S.One, S.One, S.Half, Rational(-1, 2)] + [S.Zero]*4
+    assert d[3][6] == [S.Zero, Rational(-13, 8), Rational(13, 8), S.One, -S.One,
+                       Rational(-1, 8), Rational(1, 8)] + [S.Zero]*2
+    assert d[3][8] == [S.Zero, Rational(-61, 30), Rational(61, 30), Rational(169, 120), Rational(-169, 120),
+                       Rational(-3, 10), Rational(3, 10), Rational(7, 240), Rational(-7, 240)]
+
+    # Fourth derivative
+    for i in range(4):
+        assert d[4][i] == [S.Zero]*9
+    assert d[4][4] == [S(6), -S(4), -S(4), S.One, S.One] + [S.Zero]*4
+    assert d[4][6] == [Rational(28, 3), Rational(-13, 2), Rational(-13, 2), S(2), S(2),
+                       Rational(-1, 6), Rational(-1, 6)] + [S.Zero]*2
+    assert d[4][8] == [Rational(91, 8), Rational(-122, 15), Rational(-122, 15), Rational(169, 60), Rational(169, 60),
+                       Rational(-2, 5), Rational(-2, 5), Rational(7, 240), Rational(7, 240)]
+
+    # Table 2, p. 703 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [[j/S(2) for j in list(range(-i*2+1, 0, 2))+list(range(1, i*2+1, 2))]
+          for i in range(1, 5)]
+
+    # d holds all coefficients
+    d = [finite_diff_weights({0: 1, 1: 2, 2: 4, 3: 4}[i], xl[i], 0) for
+         i in range(4)]
+
+    # Zeroth derivative
+    assert d[0][0][1] == [S.Half, S.Half]
+    assert d[1][0][3] == [Rational(-1, 16), Rational(9, 16), Rational(9, 16), Rational(-1, 16)]
+    assert d[2][0][5] == [Rational(3, 256), Rational(-25, 256), Rational(75, 128), Rational(75, 128),
+                          Rational(-25, 256), Rational(3, 256)]
+    assert d[3][0][7] == [Rational(-5, 2048), Rational(49, 2048), Rational(-245, 2048), Rational(1225, 2048),
+                          Rational(1225, 2048), Rational(-245, 2048), Rational(49, 2048), Rational(-5, 2048)]
+
+    # First derivative
+    assert d[0][1][1] == [-S.One, S.One]
+    assert d[1][1][3] == [Rational(1, 24), Rational(-9, 8), Rational(9, 8), Rational(-1, 24)]
+    assert d[2][1][5] == [Rational(-3, 640), Rational(25, 384), Rational(-75, 64),
+                          Rational(75, 64), Rational(-25, 384), Rational(3, 640)]
+    assert d[3][1][7] == [Rational(5, 7168), Rational(-49, 5120),
+                          Rational(245, 3072), Rational(-1225, 1024),
+                          Rational(1225, 1024), Rational(-245, 3072),
+                          Rational(49, 5120), Rational(-5, 7168)]
+
+    # Reasonably the rest of the table is also correct... (testing of that
+    # deemed excessive at the moment)
+    raises(ValueError, lambda: finite_diff_weights(-1, [1, 2]))
+    raises(ValueError, lambda: finite_diff_weights(1.2, [1, 2]))
+    x = symbols('x')
+    raises(ValueError, lambda: finite_diff_weights(x, [1, 2]))
+
+
+def test_as_finite_diff():
+    x = symbols('x')
+    f = Function('f')
+    dx = Function('dx')
+
+    _as_finite_diff(f(x).diff(x), [x-2, x-1, x, x+1, x+2])
+
+    # Use of undefined functions in ``points``
+    df_true = -f(x+dx(x)/2-dx(x+dx(x)/2)/2) / dx(x+dx(x)/2) \
+              + f(x+dx(x)/2+dx(x+dx(x)/2)/2) / dx(x+dx(x)/2)
+    df_test = diff(f(x), x).as_finite_difference(points=dx(x), x0=x+dx(x)/2)
+    assert (df_test - df_true).simplify() == 0
+
+
+def test_differentiate_finite():
+    x, y, h = symbols('x y h')
+    f = Function('f')
+    with warns_deprecated_sympy():
+        res0 = differentiate_finite(f(x, y) + exp(42), x, y, evaluate=True)
+    xm, xp, ym, yp = [v + sign*S.Half for v, sign in product([x, y], [-1, 1])]
+    ref0 = f(xm, ym) + f(xp, yp) - f(xm, yp) - f(xp, ym)
+    assert (res0 - ref0).simplify() == 0
+
+    g = Function('g')
+    with warns_deprecated_sympy():
+        res1 = differentiate_finite(f(x)*g(x) + 42, x, evaluate=True)
+    ref1 = (-f(x - S.Half) + f(x + S.Half))*g(x) + \
+           (-g(x - S.Half) + g(x + S.Half))*f(x)
+    assert (res1 - ref1).simplify() == 0
+
+    res2 = differentiate_finite(f(x) + x**3 + 42, x, points=[x-1, x+1])
+    ref2 = (f(x + 1) + (x + 1)**3 - f(x - 1) - (x - 1)**3)/2
+    assert (res2 - ref2).simplify() == 0
+    raises(TypeError, lambda: differentiate_finite(f(x)*g(x), x,
+                                                   pints=[x-1, x+1]))
+
+    res3 = differentiate_finite(f(x)*g(x).diff(x), x)
+    ref3 = (-g(x) + g(x + 1))*f(x + S.Half) - (g(x) - g(x - 1))*f(x - S.Half)
+    assert res3 == ref3
+
+    res4 = differentiate_finite(f(x)*g(x).diff(x).diff(x), x)
+    ref4 = -((g(x - Rational(3, 2)) - 2*g(x - S.Half) + g(x + S.Half))*f(x - S.Half)) \
+           + (g(x - S.Half) - 2*g(x + S.Half) + g(x + Rational(3, 2)))*f(x + S.Half)
+    assert res4 == ref4
+
+    res5_expr = f(x).diff(x)*g(x).diff(x)
+    res5 = differentiate_finite(res5_expr, points=[x-h, x, x+h])
+    ref5 = (-2*f(x)/h + f(-h + x)/(2*h) + 3*f(h + x)/(2*h))*(-2*g(x)/h + g(-h + x)/(2*h) \
+           + 3*g(h + x)/(2*h))/(2*h) - (2*f(x)/h - 3*f(-h + x)/(2*h) - \
+           f(h + x)/(2*h))*(2*g(x)/h - 3*g(-h + x)/(2*h) - g(h + x)/(2*h))/(2*h)
+    assert res5 == ref5
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_singularities.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_singularities.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a042332326658021ce12a38f4e058f55903869
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_singularities.py
@@ -0,0 +1,122 @@
+from sympy.core.numbers import (I, Rational, pi, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.function import Lambda
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import sec, csc
+from sympy.functions.elementary.hyperbolic import (coth, sech,
+                                                   atanh, asech, acoth, acsch)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.calculus.singularities import (
+    singularities,
+    is_increasing,
+    is_strictly_increasing,
+    is_decreasing,
+    is_strictly_decreasing,
+    is_monotonic
+)
+from sympy.sets import Interval, FiniteSet, Union, ImageSet
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+
+def test_singularities():
+    x = Symbol('x')
+    assert singularities(x**2, x) == S.EmptySet
+    assert singularities(x/(x**2 + 3*x + 2), x) == FiniteSet(-2, -1)
+    assert singularities(1/(x**2 + 1), x) == FiniteSet(I, -I)
+    assert singularities(x/(x**3 + 1), x) == \
+        FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
+    assert singularities(1/(y**2 + 2*I*y + 1), y) == \
+        FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
+    _n = Dummy('n')
+    assert singularities(sech(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi/2), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi + 3*I*pi/2), S.Integers)))
+    assert singularities(coth(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi), S.Integers)))
+    assert singularities(atanh(x), x) == FiniteSet(-1, 1)
+    assert singularities(acoth(x), x) == FiniteSet(-1, 1)
+    assert singularities(asech(x), x) == FiniteSet(0)
+    assert singularities(acsch(x), x) == FiniteSet(0)
+
+    x = Symbol('x', real=True)
+    assert singularities(1/(x**2 + 1), x) == S.EmptySet
+    assert singularities(exp(1/x), x, S.Reals) == FiniteSet(0)
+    assert singularities(exp(1/x), x, Interval(1, 2)) == S.EmptySet
+    assert singularities(log((x - 2)**2), x, Interval(1, 3)) == FiniteSet(2)
+    raises(NotImplementedError, lambda: singularities(x**-oo, x))
+    assert singularities(sec(x), x, Interval(0, 3*pi)) == FiniteSet(
+        pi/2, 3*pi/2, 5*pi/2)
+    assert singularities(csc(x), x, Interval(0, 3*pi)) == FiniteSet(
+        0, pi, 2*pi, 3*pi)
+
+
+def test_is_increasing():
+    """Test whether is_increasing returns correct value."""
+    a = Symbol('a', negative=True)
+
+    assert is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert is_increasing(-x**2, Interval(-oo, 0))
+    assert not is_increasing(-x**2, Interval(0, oo))
+    assert not is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    assert is_increasing(x**2 + y, Interval(1, oo), x)
+    assert is_increasing(-x**2*a, Interval(1, oo), x)
+    assert is_increasing(1)
+
+    assert is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3)) is False
+
+
+def test_is_strictly_increasing():
+    """Test whether is_strictly_increasing returns correct value."""
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    assert not is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    assert not is_strictly_increasing(-x**2, Interval(0, oo))
+    assert not is_strictly_decreasing(1)
+
+    assert is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3)) is False
+
+
+def test_is_decreasing():
+    """Test whether is_decreasing returns correct value."""
+    b = Symbol('b', positive=True)
+
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_decreasing(-x**2*b, Interval(-oo, 0), x)
+
+
+def test_is_strictly_decreasing():
+    """Test whether is_strictly_decreasing returns correct value."""
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_strictly_decreasing(
+        1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_strictly_decreasing(1)
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+
+
+def test_is_monotonic():
+    """Test whether is_monotonic returns correct value."""
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert not is_monotonic(-x**2, S.Reals)
+    assert is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    raises(NotImplementedError, lambda: is_monotonic(x**2 + y + 1))
+
+
+def test_issue_23401():
+    x = Symbol('x')
+    expr = (x + 1)/(-1.0e-3*x**2 + 0.1*x + 0.1)
+    assert is_increasing(expr, Interval(1,2), x)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_util.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..c18b7a79fd54fdb2638cc746d43ab26753fc72a9
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/tests/test_util.py
@@ -0,0 +1,392 @@
+from sympy.core.function import Lambda
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.complexes import (Abs, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    cos, cot, csc, sec, sin, tan, asin, acos, atan, acot, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.error_functions import expint
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.simplify import simplify
+from sympy.calculus.util import (function_range, continuous_domain, not_empty_in,
+                                 periodicity, lcim, is_convex,
+                                 stationary_points, minimum, maximum)
+from sympy.sets.sets import (Interval, FiniteSet, Complement, Union)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.testing.pytest import XFAIL, raises, _both_exp_pow, slow
+from sympy.abc import x, y
+
+a = Symbol('a', real=True)
+
+def test_function_range():
+    assert function_range(sin(x), x, Interval(-pi/2, pi/2)
+        ) == Interval(-1, 1)
+    assert function_range(sin(x), x, Interval(0, pi)
+        ) == Interval(0, 1)
+    assert function_range(tan(x), x, Interval(0, pi)
+        ) == Interval(-oo, oo)
+    assert function_range(tan(x), x, Interval(pi/2, pi)
+        ) == Interval(-oo, 0)
+    assert function_range((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) == Union(Interval(-oo, Rational(2, 7)), Interval(Rational(8, 3), oo))
+    assert function_range(1/(x**2), x, Interval(-1, 1)
+        ) == Interval(1, oo)
+    assert function_range(exp(x), x, Interval(-1, 1)
+        ) == Interval(exp(-1), exp(1))
+    assert function_range(log(x) - x, x, S.Reals
+        ) == Interval(-oo, -1)
+    assert function_range(sqrt(3*x - 1), x, Interval(0, 2)
+        ) == Interval(0, sqrt(5))
+    assert function_range(x*(x - 1) - (x**2 - x), x, S.Reals
+        ) == FiniteSet(0)
+    assert function_range(x*(x - 1) - (x**2 - x) + y, x, S.Reals
+        ) == FiniteSet(y)
+    assert function_range(sin(x), x, Union(Interval(-5, -3), FiniteSet(4))
+        ) == Union(Interval(-sin(3), 1), FiniteSet(sin(4)))
+    assert function_range(cos(x), x, Interval(-oo, -4)
+        ) == Interval(-1, 1)
+    assert function_range(cos(x), x, S.EmptySet) == S.EmptySet
+    assert function_range(x/sqrt(x**2+1), x, S.Reals) == Interval.open(-1,1)
+    raises(NotImplementedError, lambda : function_range(
+        exp(x)*(sin(x) - cos(x))/2 - x, x, S.Reals))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x) + x, x, S.Reals)) # issue 13273
+    raises(NotImplementedError, lambda : function_range(
+        log(x), x, S.Integers))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x)/2, x, S.Naturals))
+
+
+@slow
+def test_function_range1():
+    assert function_range(tan(x)**2 + tan(3*x)**2 + 1, x, S.Reals) == Interval(1,oo)
+
+
+def test_continuous_domain():
+    assert continuous_domain(sin(x), x, Interval(0, 2*pi)) == Interval(0, 2*pi)
+    assert continuous_domain(tan(x), x, Interval(0, 2*pi)) == \
+        Union(Interval(0, pi/2, False, True), Interval(pi/2, pi*Rational(3, 2), True, True),
+              Interval(pi*Rational(3, 2), 2*pi, True, False))
+    assert continuous_domain(cot(x), x, Interval(0, 2*pi)) == Union(
+        Interval.open(0, pi), Interval.open(pi, 2*pi))
+    assert continuous_domain((x - 1)/((x - 1)**2), x, S.Reals) == \
+        Union(Interval(-oo, 1, True, True), Interval(1, oo, True, True))
+    assert continuous_domain(log(x) + log(4*x - 1), x, S.Reals) == \
+        Interval(Rational(1, 4), oo, True, True)
+    assert continuous_domain(1/sqrt(x - 3), x, S.Reals) == Interval(3, oo, True, True)
+    assert continuous_domain(1/x - 2, x, S.Reals) == \
+        Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(1/(x**2 - 4) + 2, x, S.Reals) == \
+        Union(Interval.open(-oo, -2), Interval.open(-2, 2), Interval.open(2, oo))
+    assert continuous_domain((x+1)**pi, x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain((x+1)**(pi/2), x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain(x**x, x, S.Reals) == Interval(0, oo)
+    assert continuous_domain((x+1)**log(x**2), x, S.Reals) == Union(
+        Interval.Ropen(-1, 0), Interval.open(0, oo))
+    domain = continuous_domain(log(tan(x)**2 + 1), x, S.Reals)
+    assert not domain.contains(3*pi/2)
+    assert domain.contains(5)
+    d = Symbol('d', even=True, zero=False)
+    assert continuous_domain(x**(1/d), x, S.Reals) == Interval(0, oo)
+    n = Dummy('n')
+    assert continuous_domain(1/sin(x), x, S.Reals).dummy_eq(Complement(
+        S.Reals, Union(ImageSet(Lambda(n, 2*n*pi + pi), S.Integers),
+                       ImageSet(Lambda(n, 2*n*pi), S.Integers))))
+    assert continuous_domain(sin(x) + cos(x), x, S.Reals) == S.Reals
+    assert continuous_domain(asin(x), x, S.Reals) == Interval(-1, 1) # issue #21786
+    assert continuous_domain(1/acos(log(x)), x, S.Reals) == Interval.Ropen(exp(-1), E)
+    assert continuous_domain(sinh(x)+cosh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(tanh(x)+sech(x), x, S.Reals) == S.Reals
+    assert continuous_domain(atan(x)+asinh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(acosh(x), x, S.Reals) == Interval(1, oo)
+    assert continuous_domain(atanh(x), x, S.Reals) == Interval.open(-1, 1)
+    assert continuous_domain(atanh(x)+acosh(x), x, S.Reals) == S.EmptySet
+    assert continuous_domain(asech(x), x, S.Reals) == Interval.Lopen(0, 1)
+    assert continuous_domain(acoth(x), x, S.Reals) == Union(
+        Interval.open(-oo, -1), Interval.open(1, oo))
+    assert continuous_domain(asec(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    assert continuous_domain(acsc(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    for f in (coth, acsch, csch):
+        assert continuous_domain(f(x), x, S.Reals) == Union(
+            Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(acot(x), x, S.Reals).contains(0) == False
+    assert continuous_domain(1/(exp(x) - x), x, S.Reals) == Complement(
+        S.Reals, ConditionSet(x, Eq(-x + exp(x), 0), S.Reals))
+    assert continuous_domain(frac(x**2), x, Interval(-2,-1)) == Union(
+        Interval.open(-2, -sqrt(3)), Interval.open(-sqrt(2), -1),
+        Interval.open(-sqrt(3), -sqrt(2)))
+    assert continuous_domain(frac(x), x, S.Reals) == Complement(
+        S.Reals, S.Integers)
+    raises(NotImplementedError, lambda : continuous_domain(
+        1/(x**2+1), x, S.Complexes))
+    raises(NotImplementedError, lambda : continuous_domain(
+        gamma(x), x, Interval(-5,0)))
+    assert continuous_domain(x + gamma(pi), x, S.Reals) == S.Reals
+
+
+@XFAIL
+def test_continuous_domain_acot():
+    acot_cont = Piecewise((pi+acot(x), x<0), (acot(x), True))
+    assert continuous_domain(acot_cont, x, S.Reals) == S.Reals
+
+@XFAIL
+def test_continuous_domain_gamma():
+    assert continuous_domain(gamma(x), x, S.Reals).contains(-1) == False
+
+@XFAIL
+def test_continuous_domain_neg_power():
+    assert continuous_domain((x-2)**(1-x), x, S.Reals) == Interval.open(2, oo)
+
+
+def test_not_empty_in():
+    assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \
+        Interval(S.Half, 2, True, False)
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \
+        Union(Interval(-sqrt(2), -1), Interval(1, 2))
+    assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \
+        Union(Interval(-sqrt(17)/2 - S.Half, -2),
+              Interval(1, Rational(-1, 2) + sqrt(17)/2), Interval(2, 4))
+    assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(-oo, oo)
+    assert not_empty_in(FiniteSet(4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(S(3)/2, 2)
+    assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(-1, 1))
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True),
+                                                           Interval(4, 5))), x) == \
+        Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True),
+              Interval(1, 3, True, True), Interval(4, 5))
+    assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet
+    assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \
+        Union(Interval(-2, -1, True, False), Interval(2, oo))
+    raises(ValueError, lambda: not_empty_in(x))
+    raises(ValueError, lambda: not_empty_in(Interval(0, 1), x))
+    raises(NotImplementedError,
+           lambda: not_empty_in(FiniteSet(x).intersect(S.Reals), x, a))
+
+
+@_both_exp_pow
+def test_periodicity():
+    assert periodicity(sin(2*x), x) == pi
+    assert periodicity((-2)*tan(4*x), x) == pi/4
+    assert periodicity(sin(x)**2, x) == 2*pi
+    assert periodicity(3**tan(3*x), x) == pi/3
+    assert periodicity(tan(x)*cos(x), x) == 2*pi
+    assert periodicity(sin(x)**(tan(x)), x) == 2*pi
+    assert periodicity(tan(x)*sec(x), x) == 2*pi
+    assert periodicity(sin(2*x)*cos(2*x) - y, x) == pi/2
+    assert periodicity(tan(x) + cot(x), x) == pi
+    assert periodicity(sin(x) - cos(2*x), x) == 2*pi
+    assert periodicity(sin(x) - 1, x) == 2*pi
+    assert periodicity(sin(4*x) + sin(x)*cos(x), x) == pi
+    assert periodicity(exp(sin(x)), x) == 2*pi
+    assert periodicity(log(cot(2*x)) - sin(cos(2*x)), x) == pi
+    assert periodicity(sin(2*x)*exp(tan(x) - csc(2*x)), x) == pi
+    assert periodicity(cos(sec(x) - csc(2*x)), x) == 2*pi
+    assert periodicity(tan(sin(2*x)), x) == pi
+    assert periodicity(2*tan(x)**2, x) == pi
+    assert periodicity(sin(x%4), x) == 4
+    assert periodicity(sin(x)%4, x) == 2*pi
+    assert periodicity(tan((3*x-2)%4), x) == Rational(4, 3)
+    assert periodicity((sqrt(2)*(x+1)+x) % 3, x) == 3 / (sqrt(2)+1)
+    assert periodicity((x**2+1) % x, x) is None
+    assert periodicity(sin(re(x)), x) == 2*pi
+    assert periodicity(sin(x)**2 + cos(x)**2, x) is S.Zero
+    assert periodicity(tan(x), y) is S.Zero
+    assert periodicity(sin(x) + I*cos(x), x) == 2*pi
+    assert periodicity(x - sin(2*y), y) == pi
+
+    assert periodicity(exp(x), x) is None
+    assert periodicity(exp(I*x), x) == 2*pi
+    assert periodicity(exp(I*a), a) == 2*pi
+    assert periodicity(exp(a), a) is None
+    assert periodicity(exp(log(sin(a) + I*cos(2*a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(log(sin(2*a) + I*cos(a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(sin(a)), a) == 2*pi
+    assert periodicity(exp(2*I*a), a) == pi
+    assert periodicity(exp(a + I*sin(a)), a) is None
+    assert periodicity(exp(cos(a/2) + sin(a)), a) == 4*pi
+    assert periodicity(log(x), x) is None
+    assert periodicity(exp(x)**sin(x), x) is None
+    assert periodicity(sin(x)**y, y) is None
+
+    assert periodicity(Abs(sin(Abs(sin(x)))), x) == pi
+    assert all(periodicity(Abs(f(x)), x) == pi for f in (
+        cos, sin, sec, csc, tan, cot))
+    assert periodicity(Abs(sin(tan(x))), x) == pi
+    assert periodicity(Abs(sin(sin(x) + tan(x))), x) == 2*pi
+    assert periodicity(sin(x) > S.Half, x) == 2*pi
+
+    assert periodicity(x > 2, x) is None
+    assert periodicity(x**3 - x**2 + 1, x) is None
+    assert periodicity(Abs(x), x) is None
+    assert periodicity(Abs(x**2 - 1), x) is None
+
+    assert periodicity((x**2 + 4)%2, x) is None
+    assert periodicity((E**x)%3, x) is None
+
+    assert periodicity(sin(expint(1, x))/expint(1, x), x) is None
+    # returning `None` for any Piecewise
+    p = Piecewise((0, x < -1), (x**2, x <= 1), (log(x), True))
+    assert periodicity(p, x) is None
+
+    m = MatrixSymbol('m', 3, 3)
+    raises(NotImplementedError, lambda: periodicity(sin(m), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m), m[0, 0]))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m[0, 0]))
+
+
+def test_periodicity_check():
+    assert periodicity(tan(x), x, check=True) == pi
+    assert periodicity(sin(x) + cos(x), x, check=True) == 2*pi
+    assert periodicity(sec(x), x) == 2*pi
+    assert periodicity(sin(x*y), x) == 2*pi/abs(y)
+    assert periodicity(Abs(sec(sec(x))), x) == pi
+
+
+def test_lcim():
+    assert lcim([S.Half, S(2), S(3)]) == 6
+    assert lcim([pi/2, pi/4, pi]) == pi
+    assert lcim([2*pi, pi/2]) == 2*pi
+    assert lcim([S.One, 2*pi]) is None
+    assert lcim([S(2) + 2*E, E/3 + Rational(1, 3), S.One + E]) == S(2) + 2*E
+
+
+def test_is_convex():
+    assert is_convex(1/x, x, domain=Interval.open(0, oo)) == True
+    assert is_convex(1/x, x, domain=Interval(-oo, 0)) == False
+    assert is_convex(x**2, x, domain=Interval(0, oo)) == True
+    assert is_convex(1/x**3, x, domain=Interval.Lopen(0, oo)) == True
+    assert is_convex(-1/x**3, x, domain=Interval.Ropen(-oo, 0)) == True
+    assert is_convex(log(x) ,x) == False
+    assert is_convex(x**2+y**2, x, y) == True
+    assert is_convex(cos(x) + cos(y), x) == False
+    assert is_convex(8*x**2 - 2*y**2, x, y) == False
+
+
+def test_stationary_points():
+    assert stationary_points(sin(x), x, Interval(-pi/2, pi/2)
+        ) == {-pi/2, pi/2}
+    assert  stationary_points(sin(x), x, Interval.Ropen(0, pi/4)
+        ) is S.EmptySet
+    assert stationary_points(tan(x), x,
+        ) is S.EmptySet
+    assert stationary_points(sin(x)*cos(x), x, Interval(0, pi)
+        ) == {pi/4, pi*Rational(3, 4)}
+    assert stationary_points(sec(x), x, Interval(0, pi)
+        ) == {0, pi}
+    assert stationary_points((x+3)*(x-2), x
+        ) == FiniteSet(Rational(-1, 2))
+    assert stationary_points((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) is S.EmptySet
+    assert stationary_points((x**2+3)/(x-2), x
+        ) == {2 - sqrt(7), 2 + sqrt(7)}
+    assert stationary_points((x**2+3)/(x-2), x, Interval(0, 5)
+        ) == {2 + sqrt(7)}
+    assert stationary_points(x**4 + x**3 - 5*x**2, x, S.Reals
+        ) == FiniteSet(-2, 0, Rational(5, 4))
+    assert stationary_points(exp(x), x
+        ) is S.EmptySet
+    assert stationary_points(log(x) - x, x, S.Reals
+        ) == {1}
+    assert stationary_points(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) == {0, -pi, pi}
+    assert stationary_points(y, x, S.Reals
+        ) == S.Reals
+    assert stationary_points(y, x, S.EmptySet) == S.EmptySet
+
+
+def test_maximum():
+    assert maximum(sin(x), x) is S.One
+    assert maximum(sin(x), x, Interval(0, 1)) == sin(1)
+    assert maximum(tan(x), x) is oo
+    assert maximum(tan(x), x, Interval(-pi/4, pi/4)) is S.One
+    assert maximum(sin(x)*cos(x), x, S.Reals) == S.Half
+    assert simplify(maximum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == sqrt(2)/4
+    assert maximum((x+3)*(x-2), x) is oo
+    assert maximum((x+3)*(x-2), x, Interval(-5, 0)) == S(14)
+    assert maximum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(2, 7)
+    assert simplify(maximum(-x**4-x**3+x**2+10, x)
+        ) == 41*sqrt(41)/512 + Rational(5419, 512)
+    assert maximum(exp(x), x, Interval(-oo, 2)) == exp(2)
+    assert maximum(log(x) - x, x, S.Reals) is S.NegativeOne
+    assert maximum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.One
+    assert maximum(cos(x)-sin(x), x, S.Reals) == sqrt(2)
+    assert maximum(y, x, S.Reals) == y
+    assert maximum(abs(a**3 + a), a, Interval(0, 2)) == 10
+    assert maximum(abs(60*a**3 + 24*a), a, Interval(0, 2)) == 528
+    assert maximum(abs(12*a*(5*a**2 + 2)), a, Interval(0, 2)) == 528
+    assert maximum(x/sqrt(x**2+1), x, S.Reals) == 1
+
+    raises(ValueError, lambda : maximum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), sin(x)))
+    raises(ValueError, lambda : maximum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), S.One))
+
+
+def test_minimum():
+    assert minimum(sin(x), x) is S.NegativeOne
+    assert minimum(sin(x), x, Interval(1, 4)) == sin(4)
+    assert minimum(tan(x), x) is -oo
+    assert minimum(tan(x), x, Interval(-pi/4, pi/4)) is S.NegativeOne
+    assert minimum(sin(x)*cos(x), x, S.Reals) == Rational(-1, 2)
+    assert simplify(minimum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == -sqrt(2)/4
+    assert minimum((x+3)*(x-2), x) == Rational(-25, 4)
+    assert minimum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(-3, 2)
+    assert minimum(x**4-x**3+x**2+10, x) == S(10)
+    assert minimum(exp(x), x, Interval(-2, oo)) == exp(-2)
+    assert minimum(log(x) - x, x, S.Reals) is -oo
+    assert minimum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.NegativeOne
+    assert minimum(cos(x)-sin(x), x, S.Reals) == -sqrt(2)
+    assert minimum(y, x, S.Reals) == y
+    assert minimum(x/sqrt(x**2+1), x, S.Reals) == -1
+
+    raises(ValueError, lambda : minimum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), sin(x)))
+    raises(ValueError, lambda : minimum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), S.One))
+
+
+def test_issue_19869():
+    assert (maximum(sqrt(3)*(x - 1)/(3*sqrt(x**2 + 1)), x)
+        ) == sqrt(3)/3
+
+
+def test_issue_16469():
+    f = abs(a)
+    assert function_range(f, a, S.Reals) == Interval(0, oo, False, True)
+
+
+@_both_exp_pow
+def test_issue_18747():
+    assert periodicity(exp(pi*I*(x/4 + S.Half/2)), x) == 8
+
+
+def test_issue_25942():
+    assert (acos(x) > pi/3).as_set() == Interval.Ropen(-1, S(1)/2)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/util.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..dac316358873de2418dd8ab56445823f07a37b1b
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/calculus/util.py
@@ -0,0 +1,895 @@
+from .accumulationbounds import AccumBounds, AccumulationBounds # noqa: F401
+from .singularities import singularities
+from sympy.core import Pow, S
+from sympy.core.function import diff, expand_mul, Function
+from sympy.core.kind import NumberKind
+from sympy.core.mod import Mod
+from sympy.core.numbers import equal_valued
+from sympy.core.relational import Relational
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    TrigonometricFunction, sin, cos, tan, cot, csc, sec,
+    asin, acos, acot, atan, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.polys.polytools import degree, lcm_list
+from sympy.sets.sets import (Interval, Intersection, FiniteSet, Union,
+                             Complement)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.utilities import filldedent
+from sympy.utilities.iterables import iterable
+from sympy.matrices.dense import hessian
+
+
+def continuous_domain(f, symbol, domain):
+    """
+    Returns the domain on which the function expression f is continuous.
+
+    This function is limited by the ability to determine the various
+    singularities and discontinuities of the given function.
+    The result is either given as a union of intervals or constructed using
+    other set operations.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the intervals are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the continuity of the symbol has to be checked.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
+    >>> from sympy.calculus.util import continuous_domain
+    >>> x = Symbol('x')
+    >>> continuous_domain(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> continuous_domain(tan(x), x, Interval(0, pi))
+    Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
+    >>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
+    Interval(2, 5)
+    >>> continuous_domain(log(2*x - 1), x, S.Reals)
+    Interval.open(1/2, oo)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all intervals where the function is continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If the method to determine continuity of such a function
+        has not yet been developed.
+
+    """
+    from sympy.solvers.inequalities import solve_univariate_inequality
+
+    if not domain.is_subset(S.Reals):
+        raise NotImplementedError(filldedent('''
+            Domain must be a subset of S.Reals.
+            '''))
+    implemented = [Pow, exp, log, Abs, frac,
+                   sin, cos, tan, cot, sec, csc,
+                   asin, acos, atan, acot, asec, acsc,
+                   sinh, cosh, tanh, coth, sech, csch,
+                   asinh, acosh, atanh, acoth, asech, acsch]
+    used = [fct.func for fct in f.atoms(Function) if fct.has(symbol)]
+    if any(func not in implemented for func in used):
+        raise NotImplementedError(filldedent('''
+            Unable to determine the domain of the given function.
+            '''))
+
+    x = Symbol('x')
+    constraints = {
+        log: (x > 0,),
+        asin: (x >= -1, x <= 1),
+        acos: (x >= -1, x <= 1),
+        acosh: (x >= 1,),
+        atanh: (x > -1, x < 1),
+        asech: (x > 0, x <= 1)
+    }
+    constraints_union = {
+        asec: (x <= -1, x >= 1),
+        acsc: (x <= -1, x >= 1),
+        acoth: (x < -1, x > 1)
+    }
+
+    cont_domain = domain
+    for atom in f.atoms(Pow):
+        den = atom.exp.as_numer_denom()[1]
+        if atom.exp.is_rational and den.is_odd:
+            pass    # 0**negative handled by singularities()
+        else:
+            constraint = solve_univariate_inequality(atom.base >= 0,
+                                                        symbol).as_set()
+            cont_domain = Intersection(constraint, cont_domain)
+
+    for atom in f.atoms(Function):
+        if atom.func in constraints:
+            for c in constraints[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set = solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+                cont_domain = Intersection(constraint_set, cont_domain)
+        elif atom.func in constraints_union:
+            constraint_set = S.EmptySet
+            for c in constraints_union[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set += solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+            cont_domain = Intersection(constraint_set, cont_domain)
+        # XXX: the discontinuities below could be factored out in
+        # a new "discontinuities()".
+        elif atom.func == acot:
+            from sympy.solvers.solveset import solveset_real
+            # Sympy's acot() has a step discontinuity at 0. Since it's
+            # neither an essential singularity nor a pole, singularities()
+            # will not report it. But it's still relevant for determining
+            # the continuity of the function f.
+            cont_domain -= solveset_real(atom.args[0], symbol)
+            # Note that the above may introduce spurious discontinuities, e.g.
+            # for abs(acot(x)) at 0.
+        elif atom.func == frac:
+            from sympy.solvers.solveset import solveset_real
+            r = function_range(atom.args[0], symbol, domain)
+            r = Intersection(r, S.Integers)
+            if r.is_finite_set:
+                discont = S.EmptySet
+                for n in r:
+                    discont += solveset_real(atom.args[0]-n, symbol)
+            else:
+                discont = ConditionSet(
+                    symbol, S.Integers.contains(atom.args[0]), cont_domain)
+            cont_domain -= discont
+
+    return cont_domain - singularities(f, symbol, domain)
+
+
+def function_range(f, symbol, domain):
+    """
+    Finds the range of a function in a given domain.
+    This method is limited by the ability to determine the singularities and
+    determine limits.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the range of function is to be determined.
+    domain : :py:class:`~.Interval`
+        The domain under which the range of the function has to be found.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
+    >>> from sympy.calculus.util import function_range
+    >>> x = Symbol('x')
+    >>> function_range(sin(x), x, Interval(0, 2*pi))
+    Interval(-1, 1)
+    >>> function_range(tan(x), x, Interval(-pi/2, pi/2))
+    Interval(-oo, oo)
+    >>> function_range(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> function_range(exp(x), x, S.Reals)
+    Interval.open(0, oo)
+    >>> function_range(log(x), x, S.Reals)
+    Interval(-oo, oo)
+    >>> function_range(sqrt(x), x, Interval(-5, 9))
+    Interval(0, 3)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all ranges for all intervals under domain where function is
+        continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If any of the intervals, in the given domain, for which function
+        is continuous are not finite or real,
+        OR if the critical points of the function on the domain cannot be found.
+    """
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    period = periodicity(f, symbol)
+    if period == S.Zero:
+        # the expression is constant wrt symbol
+        return FiniteSet(f.expand())
+
+    from sympy.series.limits import limit
+    from sympy.solvers.solveset import solveset
+
+    if period is not None:
+        if isinstance(domain, Interval):
+            if (domain.inf - domain.sup).is_infinite:
+                domain = Interval(0, period)
+        elif isinstance(domain, Union):
+            for sub_dom in domain.args:
+                if isinstance(sub_dom, Interval) and \
+                ((sub_dom.inf - sub_dom.sup).is_infinite):
+                    domain = Interval(0, period)
+
+    intervals = continuous_domain(f, symbol, domain)
+    range_int = S.EmptySet
+    if isinstance(intervals,(Interval, FiniteSet)):
+        interval_iter = (intervals,)
+    elif isinstance(intervals, Union):
+        interval_iter = intervals.args
+    else:
+        raise NotImplementedError("Unable to find range for the given domain.")
+
+    for interval in interval_iter:
+        if isinstance(interval, FiniteSet):
+            for singleton in interval:
+                if singleton in domain:
+                    range_int += FiniteSet(f.subs(symbol, singleton))
+        elif isinstance(interval, Interval):
+            vals = S.EmptySet
+            critical_values = S.EmptySet
+            bounds = ((interval.left_open, interval.inf, '+'),
+                   (interval.right_open, interval.sup, '-'))
+
+            for is_open, limit_point, direction in bounds:
+                if is_open:
+                    critical_values += FiniteSet(limit(f, symbol, limit_point, direction))
+                    vals += critical_values
+                else:
+                    vals += FiniteSet(f.subs(symbol, limit_point))
+
+            critical_points = solveset(f.diff(symbol), symbol, interval)
+
+            if not iterable(critical_points):
+                raise NotImplementedError(
+                        'Unable to find critical points for {}'.format(f))
+            if isinstance(critical_points, ImageSet):
+                raise NotImplementedError(
+                        'Infinite number of critical points for {}'.format(f))
+
+            for critical_point in critical_points:
+                vals += FiniteSet(f.subs(symbol, critical_point))
+
+            left_open, right_open = False, False
+
+            if critical_values is not S.EmptySet:
+                if critical_values.inf == vals.inf:
+                    left_open = True
+
+                if critical_values.sup == vals.sup:
+                    right_open = True
+
+            range_int += Interval(vals.inf, vals.sup, left_open, right_open)
+        else:
+            raise NotImplementedError("Unable to find range for the given domain.")
+
+    return range_int
+
+
+def not_empty_in(finset_intersection, *syms):
+    """
+    Finds the domain of the functions in ``finset_intersection`` in which the
+    ``finite_set`` is not-empty.
+
+    Parameters
+    ==========
+
+    finset_intersection : Intersection of FiniteSet
+        The unevaluated intersection of FiniteSet containing
+        real-valued functions with Union of Sets
+    syms : Tuple of symbols
+        Symbol for which domain is to be found
+
+    Raises
+    ======
+
+    NotImplementedError
+        The algorithms to find the non-emptiness of the given FiniteSet are
+        not yet implemented.
+    ValueError
+        The input is not valid.
+    RuntimeError
+        It is a bug, please report it to the github issue tracker
+        (https://github.com/sympy/sympy/issues).
+
+    Examples
+    ========
+
+    >>> from sympy import FiniteSet, Interval, not_empty_in, oo
+    >>> from sympy.abc import x
+    >>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
+    Interval(0, 2)
+    >>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
+    Union(Interval(1, 2), Interval(-sqrt(2), -1))
+    >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
+    Union(Interval.Lopen(-2, -1), Interval(2, oo))
+    """
+
+    # TODO: handle piecewise defined functions
+    # TODO: handle transcendental functions
+    # TODO: handle multivariate functions
+    if len(syms) == 0:
+        raise ValueError("One or more symbols must be given in syms.")
+
+    if finset_intersection is S.EmptySet:
+        return S.EmptySet
+
+    if isinstance(finset_intersection, Union):
+        elm_in_sets = finset_intersection.args[0]
+        return Union(not_empty_in(finset_intersection.args[1], *syms),
+                     elm_in_sets)
+
+    if isinstance(finset_intersection, FiniteSet):
+        finite_set = finset_intersection
+        _sets = S.Reals
+    else:
+        finite_set = finset_intersection.args[1]
+        _sets = finset_intersection.args[0]
+
+    if not isinstance(finite_set, FiniteSet):
+        raise ValueError('A FiniteSet must be given, not %s: %s' %
+                         (type(finite_set), finite_set))
+
+    if len(syms) == 1:
+        symb = syms[0]
+    else:
+        raise NotImplementedError('more than one variables %s not handled' %
+                                  (syms,))
+
+    def elm_domain(expr, intrvl):
+        """ Finds the domain of an expression in any given interval """
+        from sympy.solvers.solveset import solveset
+
+        _start = intrvl.start
+        _end = intrvl.end
+        _singularities = solveset(expr.as_numer_denom()[1], symb,
+                                  domain=S.Reals)
+
+        if intrvl.right_open:
+            if _end is S.Infinity:
+                _domain1 = S.Reals
+            else:
+                _domain1 = solveset(expr < _end, symb, domain=S.Reals)
+        else:
+            _domain1 = solveset(expr <= _end, symb, domain=S.Reals)
+
+        if intrvl.left_open:
+            if _start is S.NegativeInfinity:
+                _domain2 = S.Reals
+            else:
+                _domain2 = solveset(expr > _start, symb, domain=S.Reals)
+        else:
+            _domain2 = solveset(expr >= _start, symb, domain=S.Reals)
+
+        # domain in the interval
+        expr_with_sing = Intersection(_domain1, _domain2)
+        expr_domain = Complement(expr_with_sing, _singularities)
+        return expr_domain
+
+    if isinstance(_sets, Interval):
+        return Union(*[elm_domain(element, _sets) for element in finite_set])
+
+    if isinstance(_sets, Union):
+        _domain = S.EmptySet
+        for intrvl in _sets.args:
+            _domain_element = Union(*[elm_domain(element, intrvl)
+                                      for element in finite_set])
+            _domain = Union(_domain, _domain_element)
+        return _domain
+
+
+def periodicity(f, symbol, check=False):
+    """
+    Tests the given function for periodicity in the given symbol.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the period is to be determined.
+    check : bool, optional
+        The flag to verify whether the value being returned is a period or not.
+
+    Returns
+    =======
+
+    period
+        The period of the function is returned.
+        ``None`` is returned when the function is aperiodic or has a complex period.
+        The value of $0$ is returned as the period of a constant function.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The value of the period computed cannot be verified.
+
+
+    Notes
+    =====
+
+    Currently, we do not support functions with a complex period.
+    The period of functions having complex periodic values such
+    as ``exp``, ``sinh`` is evaluated to ``None``.
+
+    The value returned might not be the "fundamental" period of the given
+    function i.e. it may not be the smallest periodic value of the function.
+
+    The verification of the period through the ``check`` flag is not reliable
+    due to internal simplification of the given expression. Hence, it is set
+    to ``False`` by default.
+
+    Examples
+    ========
+    >>> from sympy import periodicity, Symbol, sin, cos, tan, exp
+    >>> x = Symbol('x')
+    >>> f = sin(x) + sin(2*x) + sin(3*x)
+    >>> periodicity(f, x)
+    2*pi
+    >>> periodicity(sin(x)*cos(x), x)
+    pi
+    >>> periodicity(exp(tan(2*x) - 1), x)
+    pi/2
+    >>> periodicity(sin(4*x)**cos(2*x), x)
+    pi
+    >>> periodicity(exp(x), x)
+    """
+    if symbol.kind is not NumberKind:
+        raise NotImplementedError("Cannot use symbol of kind %s" % symbol.kind)
+    temp = Dummy('x', real=True)
+    f = f.subs(symbol, temp)
+    symbol = temp
+
+    def _check(orig_f, period):
+        '''Return the checked period or raise an error.'''
+        new_f = orig_f.subs(symbol, symbol + period)
+        if new_f.equals(orig_f):
+            return period
+        else:
+            raise NotImplementedError(filldedent('''
+                The period of the given function cannot be verified.
+                When `%s` was replaced with `%s + %s` in `%s`, the result
+                was `%s` which was not recognized as being the same as
+                the original function.
+                So either the period was wrong or the two forms were
+                not recognized as being equal.
+                Set check=False to obtain the value.''' %
+                (symbol, symbol, period, orig_f, new_f)))
+
+    orig_f = f
+    period = None
+
+    if isinstance(f, Relational):
+        f = f.lhs - f.rhs
+
+    f = f.simplify()
+
+    if symbol not in f.free_symbols:
+        return S.Zero
+
+    if isinstance(f, TrigonometricFunction):
+        try:
+            period = f.period(symbol)
+        except NotImplementedError:
+            pass
+
+    if isinstance(f, Abs):
+        arg = f.args[0]
+        if isinstance(arg, (sec, csc, cos)):
+            # all but tan and cot might have a
+            # a period that is half as large
+            # so recast as sin
+            arg = sin(arg.args[0])
+        period = periodicity(arg, symbol)
+        if period is not None and isinstance(arg, sin):
+            # the argument of Abs was a trigonometric other than
+            # cot or tan; test to see if the half-period
+            # is valid. Abs(arg) has behaviour equivalent to
+            # orig_f, so use that for test:
+            orig_f = Abs(arg)
+            try:
+                return _check(orig_f, period/2)
+            except NotImplementedError as err:
+                if check:
+                    raise NotImplementedError(err)
+            # else let new orig_f and period be
+            # checked below
+
+    if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+        f = Pow(S.Exp1, expand_mul(f.exp))
+        if im(f) != 0:
+            period_real = periodicity(re(f), symbol)
+            period_imag = periodicity(im(f), symbol)
+            if period_real is not None and period_imag is not None:
+                period = lcim([period_real, period_imag])
+
+    if f.is_Pow and f.base != S.Exp1:
+        base, expo = f.args
+        base_has_sym = base.has(symbol)
+        expo_has_sym = expo.has(symbol)
+
+        if base_has_sym and not expo_has_sym:
+            period = periodicity(base, symbol)
+
+        elif expo_has_sym and not base_has_sym:
+            period = periodicity(expo, symbol)
+
+        else:
+            period = _periodicity(f.args, symbol)
+
+    elif f.is_Mul:
+        coeff, g = f.as_independent(symbol, as_Add=False)
+        if isinstance(g, TrigonometricFunction) or not equal_valued(coeff, 1):
+            period = periodicity(g, symbol)
+        else:
+            period = _periodicity(g.args, symbol)
+
+    elif f.is_Add:
+        k, g = f.as_independent(symbol)
+        if k is not S.Zero:
+            return periodicity(g, symbol)
+
+        period = _periodicity(g.args, symbol)
+
+    elif isinstance(f, Mod):
+        a, n = f.args
+
+        if a == symbol:
+            period = n
+        elif isinstance(a, TrigonometricFunction):
+            period = periodicity(a, symbol)
+        #check if 'f' is linear in 'symbol'
+        elif (a.is_polynomial(symbol) and degree(a, symbol) == 1 and
+            symbol not in n.free_symbols):
+                period = Abs(n / a.diff(symbol))
+
+    elif isinstance(f, Piecewise):
+        pass  # not handling Piecewise yet as the return type is not favorable
+
+    elif period is None:
+        from sympy.solvers.decompogen import compogen, decompogen
+        g_s = decompogen(f, symbol)
+        num_of_gs = len(g_s)
+        if num_of_gs > 1:
+            for index, g in enumerate(reversed(g_s)):
+                start_index = num_of_gs - 1 - index
+                g = compogen(g_s[start_index:], symbol)
+                if g not in (orig_f, f): # Fix for issue 12620
+                    period = periodicity(g, symbol)
+                    if period is not None:
+                        break
+
+    if period is not None:
+        if check:
+            return _check(orig_f, period)
+        return period
+
+    return None
+
+
+def _periodicity(args, symbol):
+    """
+    Helper for `periodicity` to find the period of a list of simpler
+    functions.
+    It uses the `lcim` method to find the least common period of
+    all the functions.
+
+    Parameters
+    ==========
+
+    args : Tuple of :py:class:`~.Symbol`
+        All the symbols present in a function.
+
+    symbol : :py:class:`~.Symbol`
+        The symbol over which the function is to be evaluated.
+
+    Returns
+    =======
+
+    period
+        The least common period of the function for all the symbols
+        of the function.
+        ``None`` if for at least one of the symbols the function is aperiodic.
+
+    """
+    periods = []
+    for f in args:
+        period = periodicity(f, symbol)
+        if period is None:
+            return None
+
+        if period is not S.Zero:
+            periods.append(period)
+
+    if len(periods) > 1:
+        return lcim(periods)
+
+    if periods:
+        return periods[0]
+
+
+def lcim(numbers):
+    """Returns the least common integral multiple of a list of numbers.
+
+    The numbers can be rational or irrational or a mixture of both.
+    `None` is returned for incommensurable numbers.
+
+    Parameters
+    ==========
+
+    numbers : list
+        Numbers (rational and/or irrational) for which lcim is to be found.
+
+    Returns
+    =======
+
+    number
+        lcim if it exists, otherwise ``None`` for incommensurable numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.calculus.util import lcim
+    >>> from sympy import S, pi
+    >>> lcim([S(1)/2, S(3)/4, S(5)/6])
+    15/2
+    >>> lcim([2*pi, 3*pi, pi, pi/2])
+    6*pi
+    >>> lcim([S(1), 2*pi])
+    """
+    result = None
+    if all(num.is_irrational for num in numbers):
+        factorized_nums = [num.factor() for num in numbers]
+        factors_num = [num.as_coeff_Mul() for num in factorized_nums]
+        term = factors_num[0][1]
+        if all(factor == term for coeff, factor in factors_num):
+            common_term = term
+            coeffs = [coeff for coeff, factor in factors_num]
+            result = lcm_list(coeffs) * common_term
+
+    elif all(num.is_rational for num in numbers):
+        result = lcm_list(numbers)
+
+    else:
+        pass
+
+    return result
+
+def is_convex(f, *syms, domain=S.Reals):
+    r"""Determines the  convexity of the function passed in the argument.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    syms : Tuple of :py:class:`~.Symbol`
+        The variables with respect to which the convexity is to be determined.
+    domain : :py:class:`~.Interval`, optional
+        The domain over which the convexity of the function has to be checked.
+        If unspecified, S.Reals will be the default domain.
+
+    Returns
+    =======
+
+    bool
+        The method returns ``True`` if the function is convex otherwise it
+        returns ``False``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The check for the convexity of multivariate functions is not implemented yet.
+
+    Notes
+    =====
+
+    To determine concavity of a function pass `-f` as the concerned function.
+    To determine logarithmic convexity of a function pass `\log(f)` as
+    concerned function.
+    To determine logarithmic concavity of a function pass `-\log(f)` as
+    concerned function.
+
+    Currently, convexity check of multivariate functions is not handled.
+
+    Examples
+    ========
+
+    >>> from sympy import is_convex, symbols, exp, oo, Interval
+    >>> x = symbols('x')
+    >>> is_convex(exp(x), x)
+    True
+    >>> is_convex(x**3, x, domain = Interval(-1, oo))
+    False
+    >>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convex_function
+    .. [2] http://www.ifp.illinois.edu/~angelia/L3_convfunc.pdf
+    .. [3] https://en.wikipedia.org/wiki/Logarithmically_convex_function
+    .. [4] https://en.wikipedia.org/wiki/Logarithmically_concave_function
+    .. [5] https://en.wikipedia.org/wiki/Concave_function
+
+    """
+    if len(syms) > 1 :
+        return hessian(f, syms).is_positive_semidefinite
+    from sympy.solvers.inequalities import solve_univariate_inequality
+    f = _sympify(f)
+    var = syms[0]
+    if any(s in domain for s in singularities(f, var)):
+        return False
+    condition = f.diff(var, 2) < 0
+    if solve_univariate_inequality(condition, var, False, domain):
+        return False
+    return True
+
+
+def stationary_points(f, symbol, domain=S.Reals):
+    """
+    Returns the stationary points of a function (where derivative of the
+    function is 0) in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the stationary points are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the stationary points have to be checked.
+        If unspecified, ``S.Reals`` will be the default domain.
+
+    Returns
+    =======
+
+    Set
+        A set of stationary points for the function. If there are no
+        stationary point, an :py:class:`~.EmptySet` is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
+    >>> x = Symbol('x')
+
+    >>> stationary_points(1/x, x, S.Reals)
+    EmptySet
+
+    >>> pprint(stationary_points(sin(x), x), use_unicode=False)
+              pi                              3*pi
+    {2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
+              2                                2
+
+    >>> stationary_points(sin(x),x, Interval(0, 4*pi))
+    {pi/2, 3*pi/2, 5*pi/2, 7*pi/2}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    domain = continuous_domain(f, symbol, domain)
+    set = solveset(diff(f, symbol), symbol, domain)
+
+    return set
+
+
+def maximum(f, symbol, domain=S.Reals):
+    """
+    Returns the maximum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for maximum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the maximum have to be checked.
+        If unspecified, then the global maximum is returned.
+
+    Returns
+    =======
+
+    number
+        Maximum value of the function in given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
+    >>> x = Symbol('x')
+
+    >>> f = -x**2 + 2*x + 5
+    >>> maximum(f, x, S.Reals)
+    6
+
+    >>> maximum(sin(x), x, Interval(-pi, pi/4))
+    sqrt(2)/2
+
+    >>> maximum(sin(x)*cos(x), x)
+    1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Maximum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).sup
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
+
+
+def minimum(f, symbol, domain=S.Reals):
+    """
+    Returns the minimum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for minimum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the minimum have to be checked.
+        If unspecified, then the global minimum is returned.
+
+    Returns
+    =======
+
+    number
+        Minimum value of the function in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, minimum
+    >>> x = Symbol('x')
+
+    >>> f = x**2 + 2*x + 5
+    >>> minimum(f, x, S.Reals)
+    4
+
+    >>> minimum(sin(x), x, Interval(2, 3))
+    sin(3)
+
+    >>> minimum(sin(x)*cos(x), x)
+    -1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Minimum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).inf
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c5007308a1b232e57f9ed164276862df0c5f265
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/__init__.py
@@ -0,0 +1,33 @@
+"""
+Category Theory module.
+
+Provides some of the fundamental category-theory-related classes,
+including categories, morphisms, diagrams.  Functors are not
+implemented yet.
+
+The general reference work this module tries to follow is
+
+  [JoyOfCats] J. Adamek, H. Herrlich. G. E. Strecker: Abstract and
+              Concrete Categories. The Joy of Cats.
+
+The latest version of this book should be available for free download
+from
+
+   katmat.math.uni-bremen.de/acc/acc.pdf
+
+"""
+
+from .baseclasses import (Object, Morphism, IdentityMorphism,
+                         NamedMorphism, CompositeMorphism, Category,
+                         Diagram)
+
+from .diagram_drawing import (DiagramGrid, XypicDiagramDrawer,
+                             xypic_draw_diagram, preview_diagram)
+
+__all__ = [
+    'Object', 'Morphism', 'IdentityMorphism', 'NamedMorphism',
+    'CompositeMorphism', 'Category', 'Diagram',
+
+    'DiagramGrid', 'XypicDiagramDrawer', 'xypic_draw_diagram',
+    'preview_diagram',
+]
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/baseclasses.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/baseclasses.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6ab5153ae4e95f193030864c8f32a52254f2458
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/baseclasses.py
@@ -0,0 +1,978 @@
+from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
+from sympy.core.symbol import Str
+from sympy.sets import Set, FiniteSet, EmptySet
+from sympy.utilities.iterables import iterable
+
+
+class Class(Set):
+    r"""
+    The base class for any kind of class in the set-theoretic sense.
+
+    Explanation
+    ===========
+
+    In axiomatic set theories, everything is a class.  A class which
+    can be a member of another class is a set.  A class which is not a
+    member of another class is a proper class.  The class `\{1, 2\}`
+    is a set; the class of all sets is a proper class.
+
+    This class is essentially a synonym for :class:`sympy.core.Set`.
+    The goal of this class is to assure easier migration to the
+    eventual proper implementation of set theory.
+    """
+    is_proper = False
+
+
+class Object(Symbol):
+    """
+    The base class for any kind of object in an abstract category.
+
+    Explanation
+    ===========
+
+    While technically any instance of :class:`~.Basic` will do, this
+    class is the recommended way to create abstract objects in
+    abstract categories.
+    """
+
+
+class Morphism(Basic):
+    """
+    The base class for any morphism in an abstract category.
+
+    Explanation
+    ===========
+
+    In abstract categories, a morphism is an arrow between two
+    category objects.  The object where the arrow starts is called the
+    domain, while the object where the arrow ends is called the
+    codomain.
+
+    Two morphisms between the same pair of objects are considered to
+    be the same morphisms.  To distinguish between morphisms between
+    the same objects use :class:`NamedMorphism`.
+
+    It is prohibited to instantiate this class.  Use one of the
+    derived classes instead.
+
+    See Also
+    ========
+
+    IdentityMorphism, NamedMorphism, CompositeMorphism
+    """
+    def __new__(cls, domain, codomain):
+        raise(NotImplementedError(
+            "Cannot instantiate Morphism.  Use derived classes instead."))
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.domain
+        Object("A")
+
+        """
+        return self.args[0]
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.codomain
+        Object("B")
+
+        """
+        return self.args[1]
+
+    def compose(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The order of elements in the composition is the usual order,
+        i.e., to construct `g\circ f` use ``g.compose(f)``.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> g * f
+        CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g")))
+        >>> (g * f).domain
+        Object("A")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return CompositeMorphism(other, self)
+
+    def __mul__(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The semantics of this operation is given by the following
+        equation: ``g * f == g.compose(f)`` for composable morphisms
+        ``g`` and ``f``.
+
+        See Also
+        ========
+
+        compose
+        """
+        return self.compose(other)
+
+
+class IdentityMorphism(Morphism):
+    """
+    Represents an identity morphism.
+
+    Explanation
+    ===========
+
+    An identity morphism is a morphism with equal domain and codomain,
+    which acts as an identity with respect to composition.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, IdentityMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> id_A = IdentityMorphism(A)
+    >>> id_B = IdentityMorphism(B)
+    >>> f * id_A == f
+    True
+    >>> id_B * f == f
+    True
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain):
+        return Basic.__new__(cls, domain)
+
+    @property
+    def codomain(self):
+        return self.domain
+
+
+class NamedMorphism(Morphism):
+    """
+    Represents a morphism which has a name.
+
+    Explanation
+    ===========
+
+    Names are used to distinguish between morphisms which have the
+    same domain and codomain: two named morphisms are equal if they
+    have the same domains, codomains, and names.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> f
+    NamedMorphism(Object("A"), Object("B"), "f")
+    >>> f.name
+    'f'
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain, codomain, name):
+        if not name:
+            raise ValueError("Empty morphism names not allowed.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        return Basic.__new__(cls, domain, codomain, name)
+
+    @property
+    def name(self):
+        """
+        Returns the name of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.name
+        'f'
+
+        """
+        return self.args[2].name
+
+
+class CompositeMorphism(Morphism):
+    r"""
+    Represents a morphism which is a composition of other morphisms.
+
+    Explanation
+    ===========
+
+    Two composite morphisms are equal if the morphisms they were
+    obtained from (components) are the same and were listed in the
+    same order.
+
+    The arguments to the constructor for this class should be listed
+    in diagram order: to obtain the composition `g\circ f` from the
+    instances of :class:`Morphism` ``g`` and ``f`` use
+    ``CompositeMorphism(f, g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, CompositeMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> g * f
+    CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+    NamedMorphism(Object("B"), Object("C"), "g")))
+    >>> CompositeMorphism(f, g) == g * f
+    True
+
+    """
+    @staticmethod
+    def _add_morphism(t, morphism):
+        """
+        Intelligently adds ``morphism`` to tuple ``t``.
+
+        Explanation
+        ===========
+
+        If ``morphism`` is a composite morphism, its components are
+        added to the tuple.  If ``morphism`` is an identity, nothing
+        is added to the tuple.
+
+        No composability checks are performed.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            # ``morphism`` is a composite morphism; we have to
+            # denest its components.
+            return t + morphism.components
+        elif isinstance(morphism, IdentityMorphism):
+            # ``morphism`` is an identity.  Nothing happens.
+            return t
+        else:
+            return t + Tuple(morphism)
+
+    def __new__(cls, *components):
+        if components and not isinstance(components[0], Morphism):
+            # Maybe the user has explicitly supplied a list of
+            # morphisms.
+            return CompositeMorphism.__new__(cls, *components[0])
+
+        normalised_components = Tuple()
+
+        for current, following in zip(components, components[1:]):
+            if not isinstance(current, Morphism) or \
+                    not isinstance(following, Morphism):
+                raise TypeError("All components must be morphisms.")
+
+            if current.codomain != following.domain:
+                raise ValueError("Uncomposable morphisms.")
+
+            normalised_components = CompositeMorphism._add_morphism(
+                normalised_components, current)
+
+        # We haven't added the last morphism to the list of normalised
+        # components.  Add it now.
+        normalised_components = CompositeMorphism._add_morphism(
+            normalised_components, components[-1])
+
+        if not normalised_components:
+            # If ``normalised_components`` is empty, only identities
+            # were supplied.  Since they all were composable, they are
+            # all the same identities.
+            return components[0]
+        elif len(normalised_components) == 1:
+            # No sense to construct a whole CompositeMorphism.
+            return normalised_components[0]
+
+        return Basic.__new__(cls, normalised_components)
+
+    @property
+    def components(self):
+        """
+        Returns the components of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).components
+        (NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g"))
+
+        """
+        return self.args[0]
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of this composite morphism.
+
+        The domain of the composite morphism is the domain of its
+        first component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).domain
+        Object("A")
+
+        """
+        return self.components[0].domain
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of this composite morphism.
+
+        The codomain of the composite morphism is the codomain of its
+        last component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return self.components[-1].codomain
+
+    def flatten(self, new_name):
+        """
+        Forgets the composite structure of this morphism.
+
+        Explanation
+        ===========
+
+        If ``new_name`` is not empty, returns a :class:`NamedMorphism`
+        with the supplied name, otherwise returns a :class:`Morphism`.
+        In both cases the domain of the new morphism is the domain of
+        this composite morphism and the codomain of the new morphism
+        is the codomain of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).flatten("h")
+        NamedMorphism(Object("A"), Object("C"), "h")
+
+        """
+        return NamedMorphism(self.domain, self.codomain, new_name)
+
+
+class Category(Basic):
+    r"""
+    An (abstract) category.
+
+    Explanation
+    ===========
+
+    A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id,
+    \circ)` consisting of
+
+    * a (set-theoretical) class `O`, whose members are called
+      `K`-objects,
+
+    * for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose
+      members are called `K`-morphisms from `A` to `B`,
+
+    * for a each `K`-object `A`, a morphism `id:A\rightarrow A`,
+      called the `K`-identity of `A`,
+
+    * a composition law `\circ` associating with every `K`-morphisms
+      `f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ
+      f:A\rightarrow C`, called the composite of `f` and `g`.
+
+    Composition is associative, `K`-identities are identities with
+    respect to composition, and the sets `\hom(A, B)` are pairwise
+    disjoint.
+
+    This class knows nothing about its objects and morphisms.
+    Concrete cases of (abstract) categories should be implemented as
+    classes derived from this one.
+
+    Certain instances of :class:`Diagram` can be asserted to be
+    commutative in a :class:`Category` by supplying the argument
+    ``commutative_diagrams`` in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+    >>> from sympy import FiniteSet
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> K = Category("K", commutative_diagrams=[d])
+    >>> K.commutative_diagrams == FiniteSet(d)
+    True
+
+    See Also
+    ========
+
+    Diagram
+    """
+    def __new__(cls, name, objects=EmptySet, commutative_diagrams=EmptySet):
+        if not name:
+            raise ValueError("A Category cannot have an empty name.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        if not isinstance(objects, Class):
+            objects = Class(objects)
+
+        new_category = Basic.__new__(cls, name, objects,
+                                     FiniteSet(*commutative_diagrams))
+        return new_category
+
+    @property
+    def name(self):
+        """
+        Returns the name of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Category
+        >>> K = Category("K")
+        >>> K.name
+        'K'
+
+        """
+        return self.args[0].name
+
+    @property
+    def objects(self):
+        """
+        Returns the class of objects of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> K = Category("K", FiniteSet(A, B))
+        >>> K.objects
+        Class({Object("A"), Object("B")})
+
+        """
+        return self.args[1]
+
+    @property
+    def commutative_diagrams(self):
+        """
+        Returns the :class:`~.FiniteSet` of diagrams which are known to
+        be commutative in this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> K = Category("K", commutative_diagrams=[d])
+        >>> K.commutative_diagrams == FiniteSet(d)
+        True
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        raise NotImplementedError(
+            "hom-sets are not implemented in Category.")
+
+    def all_morphisms(self):
+        raise NotImplementedError(
+            "Obtaining the class of morphisms is not implemented in Category.")
+
+
+class Diagram(Basic):
+    r"""
+    Represents a diagram in a certain category.
+
+    Explanation
+    ===========
+
+    Informally, a diagram is a collection of objects of a category and
+    certain morphisms between them.  A diagram is still a monoid with
+    respect to morphism composition; i.e., identity morphisms, as well
+    as all composites of morphisms included in the diagram belong to
+    the diagram.  For a more formal approach to this notion see
+    [Pare1970].
+
+    The components of composite morphisms are also added to the
+    diagram.  No properties are assigned to such morphisms by default.
+
+    A commutative diagram is often accompanied by a statement of the
+    following kind: "if such morphisms with such properties exist,
+    then such morphisms which such properties exist and the diagram is
+    commutative".  To represent this, an instance of :class:`Diagram`
+    includes a collection of morphisms which are the premises and
+    another collection of conclusions.  ``premises`` and
+    ``conclusions`` associate morphisms belonging to the corresponding
+    categories with the :class:`~.FiniteSet`'s of their properties.
+
+    The set of properties of a composite morphism is the intersection
+    of the sets of properties of its components.  The domain and
+    codomain of a conclusion morphism should be among the domains and
+    codomains of the morphisms listed as the premises of a diagram.
+
+    No checks are carried out of whether the supplied object and
+    morphisms do belong to one and the same category.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy import pprint, default_sort_key
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> premises_keys = sorted(d.premises.keys(), key=default_sort_key)
+    >>> pprint(premises_keys, use_unicode=False)
+    [g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C]
+    >>> pprint(d.premises, use_unicode=False)
+    {g*f:A-->C: EmptySet, id:A-->A: EmptySet, id:B-->B: EmptySet,
+     id:C-->C: EmptySet, f:A-->B: EmptySet, g:B-->C: EmptySet}
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> pprint(d.conclusions,use_unicode=False)
+    {g*f:A-->C: {unique}}
+
+    References
+    ==========
+
+    [Pare1970] B. Pareigis: Categories and functors.  Academic Press, 1970.
+
+    """
+    @staticmethod
+    def _set_dict_union(dictionary, key, value):
+        """
+        If ``key`` is in ``dictionary``, set the new value of ``key``
+        to be the union between the old value and ``value``.
+        Otherwise, set the value of ``key`` to ``value.
+
+        Returns ``True`` if the key already was in the dictionary and
+        ``False`` otherwise.
+        """
+        if key in dictionary:
+            dictionary[key] = dictionary[key] | value
+            return True
+        else:
+            dictionary[key] = value
+            return False
+
+    @staticmethod
+    def _add_morphism_closure(morphisms, morphism, props, add_identities=True,
+                              recurse_composites=True):
+        """
+        Adds a morphism and its attributes to the supplied dictionary
+        ``morphisms``.  If ``add_identities`` is True, also adds the
+        identity morphisms for the domain and the codomain of
+        ``morphism``.
+        """
+        if not Diagram._set_dict_union(morphisms, morphism, props):
+            # We have just added a new morphism.
+
+            if isinstance(morphism, IdentityMorphism):
+                if props:
+                    # Properties for identity morphisms don't really
+                    # make sense, because very much is known about
+                    # identity morphisms already, so much that they
+                    # are trivial.  Having properties for identity
+                    # morphisms would only be confusing.
+                    raise ValueError(
+                        "Instances of IdentityMorphism cannot have properties.")
+                return
+
+            if add_identities:
+                empty = EmptySet
+
+                id_dom = IdentityMorphism(morphism.domain)
+                id_cod = IdentityMorphism(morphism.codomain)
+
+                Diagram._set_dict_union(morphisms, id_dom, empty)
+                Diagram._set_dict_union(morphisms, id_cod, empty)
+
+            for existing_morphism, existing_props in list(morphisms.items()):
+                new_props = existing_props & props
+                if morphism.domain == existing_morphism.codomain:
+                    left = morphism * existing_morphism
+                    Diagram._set_dict_union(morphisms, left, new_props)
+                if morphism.codomain == existing_morphism.domain:
+                    right = existing_morphism * morphism
+                    Diagram._set_dict_union(morphisms, right, new_props)
+
+            if isinstance(morphism, CompositeMorphism) and recurse_composites:
+                # This is a composite morphism, add its components as
+                # well.
+                empty = EmptySet
+                for component in morphism.components:
+                    Diagram._add_morphism_closure(morphisms, component, empty,
+                                                  add_identities)
+
+    def __new__(cls, *args):
+        """
+        Construct a new instance of Diagram.
+
+        Explanation
+        ===========
+
+        If no arguments are supplied, an empty diagram is created.
+
+        If at least an argument is supplied, ``args[0]`` is
+        interpreted as the premises of the diagram.  If ``args[0]`` is
+        a list, it is interpreted as a list of :class:`Morphism`'s, in
+        which each :class:`Morphism` has an empty set of properties.
+        If ``args[0]`` is a Python dictionary or a :class:`Dict`, it
+        is interpreted as a dictionary associating to some
+        :class:`Morphism`'s some properties.
+
+        If at least two arguments are supplied ``args[1]`` is
+        interpreted as the conclusions of the diagram.  The type of
+        ``args[1]`` is interpreted in exactly the same way as the type
+        of ``args[0]``.  If only one argument is supplied, the diagram
+        has no conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f]
+        {unique}
+
+        """
+        premises = {}
+        conclusions = {}
+
+        # Here we will keep track of the objects which appear in the
+        # premises.
+        objects = EmptySet
+
+        if len(args) >= 1:
+            # We've got some premises in the arguments.
+            premises_arg = args[0]
+
+            if isinstance(premises_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in premises_arg:
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(premises, morphism, empty)
+            elif isinstance(premises_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in premises_arg.items():
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(
+                        premises, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props))
+
+        if len(args) >= 2:
+            # We also have some conclusions.
+            conclusions_arg = args[1]
+
+            if isinstance(conclusions_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in conclusions_arg:
+                    # Check that no new objects appear in conclusions.
+                    if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                        (sympify(objects.contains(morphism.codomain)) is S.true)):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, empty, add_identities=False,
+                            recurse_composites=False)
+            elif isinstance(conclusions_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in conclusions_arg.items():
+                    # Check that no new objects appear in conclusions.
+                    if (morphism.domain in objects) and \
+                       (morphism.codomain in objects):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props),
+                            add_identities=False, recurse_composites=False)
+
+        return Basic.__new__(cls, Dict(premises), Dict(conclusions), objects)
+
+    @property
+    def premises(self):
+        """
+        Returns the premises of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> id_A = IdentityMorphism(A)
+        >>> id_B = IdentityMorphism(B)
+        >>> d = Diagram([f])
+        >>> print(pretty(d.premises, use_unicode=False))
+        {id:A-->A: EmptySet, id:B-->B: EmptySet, f:A-->B: EmptySet}
+
+        """
+        return self.args[0]
+
+    @property
+    def conclusions(self):
+        """
+        Returns the conclusions of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f] == FiniteSet("unique")
+        True
+
+        """
+        return self.args[1]
+
+    @property
+    def objects(self):
+        """
+        Returns the :class:`~.FiniteSet` of objects that appear in this
+        diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> d.objects
+        {Object("A"), Object("B"), Object("C")}
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        """
+        Returns a 2-tuple of sets of morphisms between objects ``A`` and
+        ``B``: one set of morphisms listed as premises, and the other set
+        of morphisms listed as conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> print(pretty(d.hom(A, C), use_unicode=False))
+        ({g*f:A-->C}, {g*f:A-->C})
+
+        See Also
+        ========
+        Object, Morphism
+        """
+        premises = EmptySet
+        conclusions = EmptySet
+
+        for morphism in self.premises.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                premises |= FiniteSet(morphism)
+        for morphism in self.conclusions.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                conclusions |= FiniteSet(morphism)
+
+        return (premises, conclusions)
+
+    def is_subdiagram(self, diagram):
+        """
+        Checks whether ``diagram`` is a subdiagram of ``self``.
+        Diagram `D'` is a subdiagram of `D` if all premises
+        (conclusions) of `D'` are contained in the premises
+        (conclusions) of `D`.  The morphisms contained
+        both in `D'` and `D` should have the same properties for `D'`
+        to be a subdiagram of `D`.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d1 = Diagram([f])
+        >>> d.is_subdiagram(d1)
+        True
+        >>> d1.is_subdiagram(d)
+        False
+        """
+        premises = all((m in self.premises) and
+                       (diagram.premises[m] == self.premises[m])
+                       for m in diagram.premises)
+        if not premises:
+            return False
+
+        conclusions = all((m in self.conclusions) and
+                          (diagram.conclusions[m] == self.conclusions[m])
+                          for m in diagram.conclusions)
+
+        # Premises is surely ``True`` here.
+        return conclusions
+
+    def subdiagram_from_objects(self, objects):
+        """
+        If ``objects`` is a subset of the objects of ``self``, returns
+        a diagram which has as premises all those premises of ``self``
+        which have a domains and codomains in ``objects``, likewise
+        for conclusions.  Properties are preserved.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"})
+        >>> d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+        >>> d1 == Diagram([f], {f: "unique"})
+        True
+        """
+        if not objects.is_subset(self.objects):
+            raise ValueError(
+                "Supplied objects should all belong to the diagram.")
+
+        new_premises = {}
+        for morphism, props in self.premises.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_premises[morphism] = props
+
+        new_conclusions = {}
+        for morphism, props in self.conclusions.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_conclusions[morphism] = props
+
+        return Diagram(new_premises, new_conclusions)
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/diagram_drawing.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/diagram_drawing.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a9b507cd86cf0e633b5abf7a0c9a353740af334
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/diagram_drawing.py
@@ -0,0 +1,2580 @@
+r"""
+This module contains the functionality to arrange the nodes of a
+diagram on an abstract grid, and then to produce a graphical
+representation of the grid.
+
+The currently supported back-ends are Xy-pic [Xypic].
+
+Layout Algorithm
+================
+
+This section provides an overview of the algorithms implemented in
+:class:`DiagramGrid` to lay out diagrams.
+
+The first step of the algorithm is the removal composite and identity
+morphisms which do not have properties in the supplied diagram.  The
+premises and conclusions of the diagram are then merged.
+
+The generic layout algorithm begins with the construction of the
+"skeleton" of the diagram.  The skeleton is an undirected graph which
+has the objects of the diagram as vertices and has an (undirected)
+edge between each pair of objects between which there exist morphisms.
+The direction of the morphisms does not matter at this stage.  The
+skeleton also includes an edge between each pair of vertices `A` and
+`C` such that there exists an object `B` which is connected via
+a morphism to `A`, and via a morphism to `C`.
+
+The skeleton constructed in this way has the property that every
+object is a vertex of a triangle formed by three edges of the
+skeleton.  This property lies at the base of the generic layout
+algorithm.
+
+After the skeleton has been constructed, the algorithm lists all
+triangles which can be formed.  Note that some triangles will not have
+all edges corresponding to morphisms which will actually be drawn.
+Triangles which have only one edge or less which will actually be
+drawn are immediately discarded.
+
+The list of triangles is sorted according to the number of edges which
+correspond to morphisms, then the triangle with the least number of such
+edges is selected.  One of such edges is picked and the corresponding
+objects are placed horizontally, on a grid.  This edge is recorded to
+be in the fringe.  The algorithm then finds a "welding" of a triangle
+to the fringe.  A welding is an edge in the fringe where a triangle
+could be attached.  If the algorithm succeeds in finding such a
+welding, it adds to the grid that vertex of the triangle which was not
+yet included in any edge in the fringe and records the two new edges in
+the fringe.  This process continues iteratively until all objects of
+the diagram has been placed or until no more weldings can be found.
+
+An edge is only removed from the fringe when a welding to this edge
+has been found, and there is no room around this edge to place
+another vertex.
+
+When no more weldings can be found, but there are still triangles
+left, the algorithm searches for a possibility of attaching one of the
+remaining triangles to the existing structure by a vertex.  If such a
+possibility is found, the corresponding edge of the found triangle is
+placed in the found space and the iterative process of welding
+triangles restarts.
+
+When logical groups are supplied, each of these groups is laid out
+independently.  Then a diagram is constructed in which groups are
+objects and any two logical groups between which there exist morphisms
+are connected via a morphism.  This diagram is laid out.  Finally,
+the grid which includes all objects of the initial diagram is
+constructed by replacing the cells which contain logical groups with
+the corresponding laid out grids, and by correspondingly expanding the
+rows and columns.
+
+The sequential layout algorithm begins by constructing the
+underlying undirected graph defined by the morphisms obtained after
+simplifying premises and conclusions and merging them (see above).
+The vertex with the minimal degree is then picked up and depth-first
+search is started from it.  All objects which are located at distance
+`n` from the root in the depth-first search tree, are positioned in
+the `n`-th column of the resulting grid.  The sequential layout will
+therefore attempt to lay the objects out along a line.
+
+References
+==========
+
+.. [Xypic] https://xy-pic.sourceforge.net/
+
+"""
+from sympy.categories import (CompositeMorphism, IdentityMorphism,
+                              NamedMorphism, Diagram)
+from sympy.core import Dict, Symbol, default_sort_key
+from sympy.printing.latex import latex
+from sympy.sets import FiniteSet
+from sympy.utilities.iterables import iterable
+from sympy.utilities.decorator import doctest_depends_on
+
+from itertools import chain
+
+
+__doctest_requires__ = {('preview_diagram',): 'pyglet'}
+
+
+class _GrowableGrid:
+    """
+    Holds a growable grid of objects.
+
+    Explanation
+    ===========
+
+    It is possible to append or prepend a row or a column to the grid
+    using the corresponding methods.  Prepending rows or columns has
+    the effect of changing the coordinates of the already existing
+    elements.
+
+    This class currently represents a naive implementation of the
+    functionality with little attempt at optimisation.
+    """
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+
+        self._array = [[None for j in range(width)] for i in range(height)]
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        return self._array[i][j]
+
+    def __setitem__(self, i_j, newvalue):
+        """
+        Sets the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        self._array[i][j] = newvalue
+
+    def append_row(self):
+        """
+        Appends an empty row to the grid.
+        """
+        self._height += 1
+        self._array.append([None for j in range(self._width)])
+
+    def append_column(self):
+        """
+        Appends an empty column to the grid.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].append(None)
+
+    def prepend_row(self):
+        """
+        Prepends the grid with an empty row.
+        """
+        self._height += 1
+        self._array.insert(0, [None for j in range(self._width)])
+
+    def prepend_column(self):
+        """
+        Prepends the grid with an empty column.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].insert(0, None)
+
+
+class DiagramGrid:
+    r"""
+    Constructs and holds the fitting of the diagram into a grid.
+
+    Explanation
+    ===========
+
+    The mission of this class is to analyse the structure of the
+    supplied diagram and to place its objects on a grid such that,
+    when the objects and the morphisms are actually drawn, the diagram
+    would be "readable", in the sense that there will not be many
+    intersections of moprhisms.  This class does not perform any
+    actual drawing.  It does strive nevertheless to offer sufficient
+    metadata to draw a diagram.
+
+    Consider the following simple diagram.
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> from sympy.categories import Diagram, DiagramGrid
+    >>> from sympy import pprint
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g])
+
+    The simplest way to have a diagram laid out is the following:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> (grid.width, grid.height)
+    (2, 2)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C
+
+    Sometimes one sees the diagram as consisting of logical groups.
+    One can advise ``DiagramGrid`` as to such groups by employing the
+    ``groups`` keyword argument.
+
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+
+    Lay it out with generic layout:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B  D
+    <BLANKLINE>
+       C
+
+    Now, we can group the objects `A` and `D` to have them near one
+    another:
+
+    >>> grid = DiagramGrid(diagram, groups=[[A, D], B, C])
+    >>> pprint(grid)
+    B     C
+    <BLANKLINE>
+    A  D
+
+    Note how the positioning of the other objects changes.
+
+    Further indications can be supplied to the constructor of
+    :class:`DiagramGrid` using keyword arguments.  The currently
+    supported hints are explained in the following paragraphs.
+
+    :class:`DiagramGrid` does not automatically guess which layout
+    would suit the supplied diagram better.  Consider, for example,
+    the following linear diagram:
+
+    >>> E = Object("E")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(C, D, "h")
+    >>> i = NamedMorphism(D, E, "i")
+    >>> diagram = Diagram([f, g, h, i])
+
+    When laid out with the generic layout, it does not get to look
+    linear:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C  D
+    <BLANKLINE>
+          E
+
+    To get it laid out in a line, use ``layout="sequential"``:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential")
+    >>> pprint(grid)
+    A  B  C  D  E
+
+    One may sometimes need to transpose the resulting layout.  While
+    this can always be done by hand, :class:`DiagramGrid` provides a
+    hint for that purpose:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential", transpose=True)
+    >>> pprint(grid)
+    A
+    <BLANKLINE>
+    B
+    <BLANKLINE>
+    C
+    <BLANKLINE>
+    D
+    <BLANKLINE>
+    E
+
+    Separate hints can also be provided for each group.  For an
+    example, refer to ``tests/test_drawing.py``, and see the different
+    ways in which the five lemma [FiveLemma] can be laid out.
+
+    See Also
+    ========
+
+    Diagram
+
+    References
+    ==========
+
+    .. [FiveLemma] https://en.wikipedia.org/wiki/Five_lemma
+    """
+    @staticmethod
+    def _simplify_morphisms(morphisms):
+        """
+        Given a dictionary mapping morphisms to their properties,
+        returns a new dictionary in which there are no morphisms which
+        do not have properties, and which are compositions of other
+        morphisms included in the dictionary.  Identities are dropped
+        as well.
+        """
+        newmorphisms = {}
+        for morphism, props in morphisms.items():
+            if isinstance(morphism, CompositeMorphism) and not props:
+                continue
+            elif isinstance(morphism, IdentityMorphism):
+                continue
+            else:
+                newmorphisms[morphism] = props
+        return newmorphisms
+
+    @staticmethod
+    def _merge_premises_conclusions(premises, conclusions):
+        """
+        Given two dictionaries of morphisms and their properties,
+        produces a single dictionary which includes elements from both
+        dictionaries.  If a morphism has some properties in premises
+        and also in conclusions, the properties in conclusions take
+        priority.
+        """
+        return dict(chain(premises.items(), conclusions.items()))
+
+    @staticmethod
+    def _juxtapose_edges(edge1, edge2):
+        """
+        If ``edge1`` and ``edge2`` have precisely one common endpoint,
+        returns an edge which would form a triangle with ``edge1`` and
+        ``edge2``.
+
+        If ``edge1`` and ``edge2`` do not have a common endpoint,
+        returns ``None``.
+
+        If ``edge1`` and ``edge`` are the same edge, returns ``None``.
+        """
+        intersection = edge1 & edge2
+        if len(intersection) != 1:
+            # The edges either have no common points or are equal.
+            return None
+
+        # The edges have a common endpoint.  Extract the different
+        # endpoints and set up the new edge.
+        return (edge1 - intersection) | (edge2 - intersection)
+
+    @staticmethod
+    def _add_edge_append(dictionary, edge, elem):
+        """
+        If ``edge`` is not in ``dictionary``, adds ``edge`` to the
+        dictionary and sets its value to ``[elem]``.  Otherwise
+        appends ``elem`` to the value of existing entry.
+
+        Note that edges are undirected, thus `(A, B) = (B, A)`.
+        """
+        if edge in dictionary:
+            dictionary[edge].append(elem)
+        else:
+            dictionary[edge] = [elem]
+
+    @staticmethod
+    def _build_skeleton(morphisms):
+        """
+        Creates a dictionary which maps edges to corresponding
+        morphisms.  Thus for a morphism `f:A\rightarrow B`, the edge
+        `(A, B)` will be associated with `f`.  This function also adds
+        to the list those edges which are formed by juxtaposition of
+        two edges already in the list.  These new edges are not
+        associated with any morphism and are only added to assure that
+        the diagram can be decomposed into triangles.
+        """
+        edges = {}
+        # Create edges for morphisms.
+        for morphism in morphisms:
+            DiagramGrid._add_edge_append(
+                edges, frozenset([morphism.domain, morphism.codomain]), morphism)
+
+        # Create new edges by juxtaposing existing edges.
+        edges1 = dict(edges)
+        for w in edges1:
+            for v in edges1:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv not in edges:
+                    edges[wv] = []
+
+        return edges
+
+    @staticmethod
+    def _list_triangles(edges):
+        """
+        Builds the set of triangles formed by the supplied edges.  The
+        triangles are arbitrary and need not be commutative.  A
+        triangle is a set that contains all three of its sides.
+        """
+        triangles = set()
+
+        for w in edges:
+            for v in edges:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv in edges:
+                    triangles.add(frozenset([w, v, wv]))
+
+        return triangles
+
+    @staticmethod
+    def _drop_redundant_triangles(triangles, skeleton):
+        """
+        Returns a list which contains only those triangles who have
+        morphisms associated with at least two edges.
+        """
+        return [tri for tri in triangles
+                if len([e for e in tri if skeleton[e]]) >= 2]
+
+    @staticmethod
+    def _morphism_length(morphism):
+        """
+        Returns the length of a morphism.  The length of a morphism is
+        the number of components it consists of.  A non-composite
+        morphism is of length 1.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            return len(morphism.components)
+        else:
+            return 1
+
+    @staticmethod
+    def _compute_triangle_min_sizes(triangles, edges):
+        r"""
+        Returns a dictionary mapping triangles to their minimal sizes.
+        The minimal size of a triangle is the sum of maximal lengths
+        of morphisms associated to the sides of the triangle.  The
+        length of a morphism is the number of components it consists
+        of.  A non-composite morphism is of length 1.
+
+        Sorting triangles by this metric attempts to address two
+        aspects of layout.  For triangles with only simple morphisms
+        in the edge, this assures that triangles with all three edges
+        visible will get typeset after triangles with less visible
+        edges, which sometimes minimizes the necessity in diagonal
+        arrows.  For triangles with composite morphisms in the edges,
+        this assures that objects connected with shorter morphisms
+        will be laid out first, resulting the visual proximity of
+        those objects which are connected by shorter morphisms.
+        """
+        triangle_sizes = {}
+        for triangle in triangles:
+            size = 0
+            for e in triangle:
+                morphisms = edges[e]
+                if morphisms:
+                    size += max(DiagramGrid._morphism_length(m)
+                                for m in morphisms)
+            triangle_sizes[triangle] = size
+        return triangle_sizes
+
+    @staticmethod
+    def _triangle_objects(triangle):
+        """
+        Given a triangle, returns the objects included in it.
+        """
+        # A triangle is a frozenset of three two-element frozensets
+        # (the edges).  This chains the three edges together and
+        # creates a frozenset from the iterator, thus producing a
+        # frozenset of objects of the triangle.
+        return frozenset(chain(*tuple(triangle)))
+
+    @staticmethod
+    def _other_vertex(triangle, edge):
+        """
+        Given a triangle and an edge of it, returns the vertex which
+        opposes the edge.
+        """
+        # This gets the set of objects of the triangle and then
+        # subtracts the set of objects employed in ``edge`` to get the
+        # vertex opposite to ``edge``.
+        return list(DiagramGrid._triangle_objects(triangle) - set(edge))[0]
+
+    @staticmethod
+    def _empty_point(pt, grid):
+        """
+        Checks if the cell at coordinates ``pt`` is either empty or
+        out of the bounds of the grid.
+        """
+        if (pt[0] < 0) or (pt[1] < 0) or \
+           (pt[0] >= grid.height) or (pt[1] >= grid.width):
+            return True
+        return grid[pt] is None
+
+    @staticmethod
+    def _put_object(coords, obj, grid, fringe):
+        """
+        Places an object at the coordinate ``cords`` in ``grid``,
+        growing the grid and updating ``fringe``, if necessary.
+        Returns (0, 0) if no row or column has been prepended, (1, 0)
+        if a row was prepended, (0, 1) if a column was prepended and
+        (1, 1) if both a column and a row were prepended.
+        """
+        (i, j) = coords
+        offset = (0, 0)
+        if i == -1:
+            grid.prepend_row()
+            i = 0
+            offset = (1, 0)
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1 + 1, j1), (i2 + 1, j2))
+        elif i == grid.height:
+            grid.append_row()
+
+        if j == -1:
+            j = 0
+            offset = (offset[0], 1)
+            grid.prepend_column()
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1, j1 + 1), (i2, j2 + 1))
+        elif j == grid.width:
+            grid.append_column()
+
+        grid[i, j] = obj
+        return offset
+
+    @staticmethod
+    def _choose_target_cell(pt1, pt2, edge, obj, skeleton, grid):
+        """
+        Given two points, ``pt1`` and ``pt2``, and the welding edge
+        ``edge``, chooses one of the two points to place the opposing
+        vertex ``obj`` of the triangle.  If neither of this points
+        fits, returns ``None``.
+        """
+        pt1_empty = DiagramGrid._empty_point(pt1, grid)
+        pt2_empty = DiagramGrid._empty_point(pt2, grid)
+
+        if pt1_empty and pt2_empty:
+            # Both cells are empty.  Of these two, choose that cell
+            # which will assure that a visible edge of the triangle
+            # will be drawn perpendicularly to the current welding
+            # edge.
+
+            A = grid[edge[0]]
+
+            if skeleton.get(frozenset([A, obj])):
+                return pt1
+            else:
+                return pt2
+        if pt1_empty:
+            return pt1
+        elif pt2_empty:
+            return pt2
+        else:
+            return None
+
+    @staticmethod
+    def _find_triangle_to_weld(triangles, fringe, grid):
+        """
+        Finds, if possible, a triangle and an edge in the ``fringe`` to
+        which the triangle could be attached.  Returns the tuple
+        containing the triangle and the index of the corresponding
+        edge in the ``fringe``.
+
+        This function relies on the fact that objects are unique in
+        the diagram.
+        """
+        for triangle in triangles:
+            for (a, b) in fringe:
+                if frozenset([grid[a], grid[b]]) in triangle:
+                    return (triangle, (a, b))
+        return None
+
+    @staticmethod
+    def _weld_triangle(tri, welding_edge, fringe, grid, skeleton):
+        """
+        If possible, welds the triangle ``tri`` to ``fringe`` and
+        returns ``False``.  If this method encounters a degenerate
+        situation in the fringe and corrects it such that a restart of
+        the search is required, it returns ``True`` (which means that
+        a restart in finding triangle weldings is required).
+
+        A degenerate situation is a situation when an edge listed in
+        the fringe does not belong to the visual boundary of the
+        diagram.
+        """
+        a, b = welding_edge
+        target_cell = None
+
+        obj = DiagramGrid._other_vertex(tri, (grid[a], grid[b]))
+
+        # We now have a triangle and an edge where it can be welded to
+        # the fringe.  Decide where to place the other vertex of the
+        # triangle and check for degenerate situations en route.
+
+        if (abs(a[0] - b[0]) == 1) and (abs(a[1] - b[1]) == 1):
+            # A diagonal edge.
+            target_cell = (a[0], b[1])
+            if grid[target_cell]:
+                # That cell is already occupied.
+                target_cell = (b[0], a[1])
+
+                if grid[target_cell]:
+                    # Degenerate situation, this edge is not
+                    # on the actual fringe.  Correct the
+                    # fringe and go on.
+                    fringe.remove((a, b))
+                    return True
+        elif a[0] == b[0]:
+            # A horizontal edge.  We first attempt to build the
+            # triangle in the downward direction.
+
+            down_left = a[0] + 1, a[1]
+            down_right = a[0] + 1, b[1]
+
+            target_cell = DiagramGrid._choose_target_cell(
+                down_left, down_right, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room below this edge.  Check above.
+                up_left = a[0] - 1, a[1]
+                up_right = a[0] - 1, b[1]
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    up_left, up_right, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+        elif a[1] == b[1]:
+            # A vertical edge.  We will attempt to place the other
+            # vertex of the triangle to the right of this edge.
+            right_up = a[0], a[1] + 1
+            right_down = b[0], a[1] + 1
+
+            target_cell = DiagramGrid._choose_target_cell(
+                right_up, right_down, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room to the left.  See what's to the right.
+                left_up = a[0], a[1] - 1
+                left_down = b[0], a[1] - 1
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    left_up, left_down, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+
+        # We now know where to place the other vertex of the
+        # triangle.
+        offset = DiagramGrid._put_object(target_cell, obj, grid, fringe)
+
+        # Take care of the displacement of coordinates if a row or
+        # a column was prepended.
+        target_cell = (target_cell[0] + offset[0],
+                       target_cell[1] + offset[1])
+        a = (a[0] + offset[0], a[1] + offset[1])
+        b = (b[0] + offset[0], b[1] + offset[1])
+
+        fringe.extend([(a, target_cell), (b, target_cell)])
+
+        # No restart is required.
+        return False
+
+    @staticmethod
+    def _triangle_key(tri, triangle_sizes):
+        """
+        Returns a key for the supplied triangle.  It should be the
+        same independently of the hash randomisation.
+        """
+        objects = sorted(
+            DiagramGrid._triangle_objects(tri), key=default_sort_key)
+        return (triangle_sizes[tri], default_sort_key(objects))
+
+    @staticmethod
+    def _pick_root_edge(tri, skeleton):
+        """
+        For a given triangle always picks the same root edge.  The
+        root edge is the edge that will be placed first on the grid.
+        """
+        candidates = [sorted(e, key=default_sort_key)
+                      for e in tri if skeleton[e]]
+        sorted_candidates = sorted(candidates, key=default_sort_key)
+        # Don't forget to assure the proper ordering of the vertices
+        # in this edge.
+        return tuple(sorted(sorted_candidates[0], key=default_sort_key))
+
+    @staticmethod
+    def _drop_irrelevant_triangles(triangles, placed_objects):
+        """
+        Returns only those triangles whose set of objects is not
+        completely included in ``placed_objects``.
+        """
+        return [tri for tri in triangles if not placed_objects.issuperset(
+            DiagramGrid._triangle_objects(tri))]
+
+    @staticmethod
+    def _grow_pseudopod(triangles, fringe, grid, skeleton, placed_objects):
+        """
+        Starting from an object in the existing structure on the ``grid``,
+        adds an edge to which a triangle from ``triangles`` could be
+        welded.  If this method has found a way to do so, it returns
+        the object it has just added.
+
+        This method should be applied when ``_weld_triangle`` cannot
+        find weldings any more.
+        """
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if not obj:
+                    continue
+
+                # Here we need to choose a triangle which has only
+                # ``obj`` in common with the existing structure.  The
+                # situations when this is not possible should be
+                # handled elsewhere.
+
+                def good_triangle(tri):
+                    objs = DiagramGrid._triangle_objects(tri)
+                    return obj in objs and \
+                        placed_objects & (objs - {obj}) == set()
+
+                tris = [tri for tri in triangles if good_triangle(tri)]
+                if not tris:
+                    # This object is not interesting.
+                    continue
+
+                # Pick the "simplest" of the triangles which could be
+                # attached.  Remember that the list of triangles is
+                # sorted according to their "simplicity" (see
+                # _compute_triangle_min_sizes for the metric).
+                #
+                # Note that ``tris`` are sequentially built from
+                # ``triangles``, so we don't have to worry about hash
+                # randomisation.
+                tri = tris[0]
+
+                # We have found a triangle which could be attached to
+                # the existing structure by a vertex.
+
+                candidates = sorted([e for e in tri if skeleton[e]],
+                                    key=lambda e: FiniteSet(*e).sort_key())
+                edges = [e for e in candidates if obj in e]
+
+                # Note that a meaningful edge (i.e., and edge that is
+                # associated with a morphism) containing ``obj``
+                # always exists.  That's because all triangles are
+                # guaranteed to have at least two meaningful edges.
+                # See _drop_redundant_triangles.
+
+                # Get the object at the other end of the edge.
+                edge = edges[0]
+                other_obj = tuple(edge - frozenset([obj]))[0]
+
+                # Now check for free directions.  When checking for
+                # free directions, prefer the horizontal and vertical
+                # directions.
+                neighbours = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1),
+                              (i - 1, j - 1), (i - 1, j + 1), (i + 1, j - 1), (i + 1, j + 1)]
+
+                for pt in neighbours:
+                    if DiagramGrid._empty_point(pt, grid):
+                        # We have a found a place to grow the
+                        # pseudopod into.
+                        offset = DiagramGrid._put_object(
+                            pt, other_obj, grid, fringe)
+
+                        i += offset[0]
+                        j += offset[1]
+                        pt = (pt[0] + offset[0], pt[1] + offset[1])
+                        fringe.append(((i, j), pt))
+
+                        return other_obj
+
+        # This diagram is actually cooler that I can handle.  Fail cowardly.
+        return None
+
+    @staticmethod
+    def _handle_groups(diagram, groups, merged_morphisms, hints):
+        """
+        Given the slightly preprocessed morphisms of the diagram,
+        produces a grid laid out according to ``groups``.
+
+        If a group has hints, it is laid out with those hints only,
+        without any influence from ``hints``.  Otherwise, it is laid
+        out with ``hints``.
+        """
+        def lay_out_group(group, local_hints):
+            """
+            If ``group`` is a set of objects, uses a ``DiagramGrid``
+            to lay it out and returns the grid.  Otherwise returns the
+            object (i.e., ``group``).  If ``local_hints`` is not
+            empty, it is supplied to ``DiagramGrid`` as the dictionary
+            of hints.  Otherwise, the ``hints`` argument of
+            ``_handle_groups`` is used.
+            """
+            if isinstance(group, FiniteSet):
+                # Set up the corresponding object-to-group
+                # mappings.
+                for obj in group:
+                    obj_groups[obj] = group
+
+                # Lay out the current group.
+                if local_hints:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **local_hints)
+                else:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **hints)
+            else:
+                obj_groups[group] = group
+
+        def group_to_finiteset(group):
+            """
+            Converts ``group`` to a :class:``FiniteSet`` if it is an
+            iterable.
+            """
+            if iterable(group):
+                return FiniteSet(*group)
+            else:
+                return group
+
+        obj_groups = {}
+        groups_grids = {}
+
+        # We would like to support various containers to represent
+        # groups.  To achieve that, before laying each group out, it
+        # should be converted to a FiniteSet, because that is what the
+        # following code expects.
+
+        if isinstance(groups, (dict, Dict)):
+            finiteset_groups = {}
+            for group, local_hints in groups.items():
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups[finiteset_group] = local_hints
+                lay_out_group(group, local_hints)
+            groups = finiteset_groups
+        else:
+            finiteset_groups = []
+            for group in groups:
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups.append(finiteset_group)
+                lay_out_group(finiteset_group, None)
+            groups = finiteset_groups
+
+        new_morphisms = []
+        for morphism in merged_morphisms:
+            dom = obj_groups[morphism.domain]
+            cod = obj_groups[morphism.codomain]
+            # Note that we are not really interested in morphisms
+            # which do not employ two different groups, because
+            # these do not influence the layout.
+            if dom != cod:
+                # These are essentially unnamed morphisms; they are
+                # not going to mess in the final layout.  By giving
+                # them the same names, we avoid unnecessary
+                # duplicates.
+                new_morphisms.append(NamedMorphism(dom, cod, "dummy"))
+
+        # Lay out the new diagram.  Since these are dummy morphisms,
+        # properties and conclusions are irrelevant.
+        top_grid = DiagramGrid(Diagram(new_morphisms))
+
+        # We now have to substitute the groups with the corresponding
+        # grids, laid out at the beginning of this function.  Compute
+        # the size of each row and column in the grid, so that all
+        # nested grids fit.
+
+        def group_size(group):
+            """
+            For the supplied group (or object, eventually), returns
+            the size of the cell that will hold this group (object).
+            """
+            if group in groups_grids:
+                grid = groups_grids[group]
+                return (grid.height, grid.width)
+            else:
+                return (1, 1)
+
+        row_heights = [max(group_size(top_grid[i, j])[0]
+                           for j in range(top_grid.width))
+                       for i in range(top_grid.height)]
+
+        column_widths = [max(group_size(top_grid[i, j])[1]
+                             for i in range(top_grid.height))
+                         for j in range(top_grid.width)]
+
+        grid = _GrowableGrid(sum(column_widths), sum(row_heights))
+
+        real_row = 0
+        real_column = 0
+        for logical_row in range(top_grid.height):
+            for logical_column in range(top_grid.width):
+                obj = top_grid[logical_row, logical_column]
+
+                if obj in groups_grids:
+                    # This is a group.  Copy the corresponding grid in
+                    # place.
+                    local_grid = groups_grids[obj]
+                    for i in range(local_grid.height):
+                        for j in range(local_grid.width):
+                            grid[real_row + i,
+                                real_column + j] = local_grid[i, j]
+                else:
+                    # This is an object.  Just put it there.
+                    grid[real_row, real_column] = obj
+
+                real_column += column_widths[logical_column]
+            real_column = 0
+            real_row += row_heights[logical_row]
+
+        return grid
+
+    @staticmethod
+    def _generic_layout(diagram, merged_morphisms):
+        """
+        Produces the generic layout for the supplied diagram.
+        """
+        all_objects = set(diagram.objects)
+        if len(all_objects) == 1:
+            # There only one object in the diagram, just put in on 1x1
+            # grid.
+            grid = _GrowableGrid(1, 1)
+            grid[0, 0] = tuple(all_objects)[0]
+            return grid
+
+        skeleton = DiagramGrid._build_skeleton(merged_morphisms)
+
+        grid = _GrowableGrid(2, 1)
+
+        if len(skeleton) == 1:
+            # This diagram contains only one morphism.  Draw it
+            # horizontally.
+            objects = sorted(all_objects, key=default_sort_key)
+            grid[0, 0] = objects[0]
+            grid[0, 1] = objects[1]
+
+            return grid
+
+        triangles = DiagramGrid._list_triangles(skeleton)
+        triangles = DiagramGrid._drop_redundant_triangles(triangles, skeleton)
+        triangle_sizes = DiagramGrid._compute_triangle_min_sizes(
+            triangles, skeleton)
+
+        triangles = sorted(triangles, key=lambda tri:
+                           DiagramGrid._triangle_key(tri, triangle_sizes))
+
+        # Place the first edge on the grid.
+        root_edge = DiagramGrid._pick_root_edge(triangles[0], skeleton)
+        grid[0, 0], grid[0, 1] = root_edge
+        fringe = [((0, 0), (0, 1))]
+
+        # Record which objects we now have on the grid.
+        placed_objects = set(root_edge)
+
+        while placed_objects != all_objects:
+            welding = DiagramGrid._find_triangle_to_weld(
+                triangles, fringe, grid)
+
+            if welding:
+                (triangle, welding_edge) = welding
+
+                restart_required = DiagramGrid._weld_triangle(
+                    triangle, welding_edge, fringe, grid, skeleton)
+                if restart_required:
+                    continue
+
+                placed_objects.update(
+                    DiagramGrid._triangle_objects(triangle))
+            else:
+                # No more weldings found.  Try to attach triangles by
+                # vertices.
+                new_obj = DiagramGrid._grow_pseudopod(
+                    triangles, fringe, grid, skeleton, placed_objects)
+
+                if not new_obj:
+                    # No more triangles can be attached, not even by
+                    # the edge.  We will set up a new diagram out of
+                    # what has been left, laid it out independently,
+                    # and then attach it to this one.
+
+                    remaining_objects = all_objects - placed_objects
+
+                    remaining_diagram = diagram.subdiagram_from_objects(
+                        FiniteSet(*remaining_objects))
+                    remaining_grid = DiagramGrid(remaining_diagram)
+
+                    # Now, let's glue ``remaining_grid`` to ``grid``.
+                    final_width = grid.width + remaining_grid.width
+                    final_height = max(grid.height, remaining_grid.height)
+                    final_grid = _GrowableGrid(final_width, final_height)
+
+                    for i in range(grid.width):
+                        for j in range(grid.height):
+                            final_grid[i, j] = grid[i, j]
+
+                    start_j = grid.width
+                    for i in range(remaining_grid.height):
+                        for j in range(remaining_grid.width):
+                            final_grid[i, start_j + j] = remaining_grid[i, j]
+
+                    return final_grid
+
+                placed_objects.add(new_obj)
+
+            triangles = DiagramGrid._drop_irrelevant_triangles(
+                triangles, placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _get_undirected_graph(objects, merged_morphisms):
+        """
+        Given the objects and the relevant morphisms of a diagram,
+        returns the adjacency lists of the underlying undirected
+        graph.
+        """
+        adjlists = {obj: [] for obj in objects}
+
+        for morphism in merged_morphisms:
+            adjlists[morphism.domain].append(morphism.codomain)
+            adjlists[morphism.codomain].append(morphism.domain)
+
+        # Assure that the objects in the adjacency list are always in
+        # the same order.
+        for obj in adjlists.keys():
+            adjlists[obj].sort(key=default_sort_key)
+
+        return adjlists
+
+    @staticmethod
+    def _sequential_layout(diagram, merged_morphisms):
+        r"""
+        Lays out the diagram in "sequential" layout.  This method
+        will attempt to produce a result as close to a line as
+        possible.  For linear diagrams, the result will actually be a
+        line.
+        """
+        objects = diagram.objects
+        sorted_objects = sorted(objects, key=default_sort_key)
+
+        # Set up the adjacency lists of the underlying undirected
+        # graph of ``merged_morphisms``.
+        adjlists = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        root = min(sorted_objects, key=lambda x: len(adjlists[x]))
+        grid = _GrowableGrid(1, 1)
+        grid[0, 0] = root
+
+        placed_objects = {root}
+
+        def place_objects(pt, placed_objects):
+            """
+            Does depth-first search in the underlying graph of the
+            diagram and places the objects en route.
+            """
+            # We will start placing new objects from here.
+            new_pt = (pt[0], pt[1] + 1)
+
+            for adjacent_obj in adjlists[grid[pt]]:
+                if adjacent_obj in placed_objects:
+                    # This object has already been placed.
+                    continue
+
+                DiagramGrid._put_object(new_pt, adjacent_obj, grid, [])
+                placed_objects.add(adjacent_obj)
+                placed_objects.update(place_objects(new_pt, placed_objects))
+
+                new_pt = (new_pt[0] + 1, new_pt[1])
+
+            return placed_objects
+
+        place_objects((0, 0), placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _drop_inessential_morphisms(merged_morphisms):
+        r"""
+        Removes those morphisms which should appear in the diagram,
+        but which have no relevance to object layout.
+
+        Currently this removes "loop" morphisms: the non-identity
+        morphisms with the same domains and codomains.
+        """
+        morphisms = [m for m in merged_morphisms if m.domain != m.codomain]
+        return morphisms
+
+    @staticmethod
+    def _get_connected_components(objects, merged_morphisms):
+        """
+        Given a container of morphisms, returns a list of connected
+        components formed by these morphisms.  A connected component
+        is represented by a diagram consisting of the corresponding
+        morphisms.
+        """
+        component_index = {}
+        for o in objects:
+            component_index[o] = None
+
+        # Get the underlying undirected graph of the diagram.
+        adjlist = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        def traverse_component(object, current_index):
+            """
+            Does a depth-first search traversal of the component
+            containing ``object``.
+            """
+            component_index[object] = current_index
+            for o in adjlist[object]:
+                if component_index[o] is None:
+                    traverse_component(o, current_index)
+
+        # Traverse all components.
+        current_index = 0
+        for o in adjlist:
+            if component_index[o] is None:
+                traverse_component(o, current_index)
+                current_index += 1
+
+        # List the objects of the components.
+        component_objects = [[] for i in range(current_index)]
+        for o, idx in component_index.items():
+            component_objects[idx].append(o)
+
+        # Finally, list the morphisms belonging to each component.
+        #
+        # Note: If some objects are isolated, they will not get any
+        # morphisms at this stage, and since the layout algorithm
+        # relies, we are essentially going to lose this object.
+        # Therefore, check if there are isolated objects and, for each
+        # of them, provide the trivial identity morphism.  It will get
+        # discarded later, but the object will be there.
+
+        component_morphisms = []
+        for component in component_objects:
+            current_morphisms = {}
+            for m in merged_morphisms:
+                if (m.domain in component) and (m.codomain in component):
+                    current_morphisms[m] = merged_morphisms[m]
+
+            if len(component) == 1:
+                # Let's add an identity morphism, for the sake of
+                # surely having morphisms in this component.
+                current_morphisms[IdentityMorphism(component[0])] = FiniteSet()
+
+            component_morphisms.append(Diagram(current_morphisms))
+
+        return component_morphisms
+
+    def __init__(self, diagram, groups=None, **hints):
+        premises = DiagramGrid._simplify_morphisms(diagram.premises)
+        conclusions = DiagramGrid._simplify_morphisms(diagram.conclusions)
+        all_merged_morphisms = DiagramGrid._merge_premises_conclusions(
+            premises, conclusions)
+        merged_morphisms = DiagramGrid._drop_inessential_morphisms(
+            all_merged_morphisms)
+
+        # Store the merged morphisms for later use.
+        self._morphisms = all_merged_morphisms
+
+        components = DiagramGrid._get_connected_components(
+            diagram.objects, all_merged_morphisms)
+
+        if groups and (groups != diagram.objects):
+            # Lay out the diagram according to the groups.
+            self._grid = DiagramGrid._handle_groups(
+                diagram, groups, merged_morphisms, hints)
+        elif len(components) > 1:
+            # Note that we check for connectedness _before_ checking
+            # the layout hints because the layout strategies don't
+            # know how to deal with disconnected diagrams.
+
+            # The diagram is disconnected.  Lay out the components
+            # independently.
+            grids = []
+
+            # Sort the components to eventually get the grids arranged
+            # in a fixed, hash-independent order.
+            components = sorted(components, key=default_sort_key)
+
+            for component in components:
+                grid = DiagramGrid(component, **hints)
+                grids.append(grid)
+
+            # Throw the grids together, in a line.
+            total_width = sum(g.width for g in grids)
+            total_height = max(g.height for g in grids)
+
+            grid = _GrowableGrid(total_width, total_height)
+            start_j = 0
+            for g in grids:
+                for i in range(g.height):
+                    for j in range(g.width):
+                        grid[i, start_j + j] = g[i, j]
+
+                start_j += g.width
+
+            self._grid = grid
+        elif "layout" in hints:
+            if hints["layout"] == "sequential":
+                self._grid = DiagramGrid._sequential_layout(
+                    diagram, merged_morphisms)
+        else:
+            self._grid = DiagramGrid._generic_layout(diagram, merged_morphisms)
+
+        if hints.get("transpose"):
+            # Transpose the resulting grid.
+            grid = _GrowableGrid(self._grid.height, self._grid.width)
+            for i in range(self._grid.height):
+                for j in range(self._grid.width):
+                    grid[j, i] = self._grid[i, j]
+            self._grid = grid
+
+    @property
+    def width(self):
+        """
+        Returns the number of columns in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.width
+        2
+
+        """
+        return self._grid.width
+
+    @property
+    def height(self):
+        """
+        Returns the number of rows in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.height
+        2
+
+        """
+        return self._grid.height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the object placed in the row ``i`` and column ``j``.
+        The indices are 0-based.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> (grid[0, 0], grid[0, 1])
+        (Object("A"), Object("B"))
+        >>> (grid[1, 0], grid[1, 1])
+        (None, Object("C"))
+
+        """
+        i, j = i_j
+        return self._grid[i, j]
+
+    @property
+    def morphisms(self):
+        """
+        Returns those morphisms (and their properties) which are
+        sufficiently meaningful to be drawn.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.morphisms
+        {NamedMorphism(Object("A"), Object("B"), "f"): EmptySet,
+        NamedMorphism(Object("B"), Object("C"), "g"): EmptySet}
+
+        """
+        return self._morphisms
+
+    def __str__(self):
+        """
+        Produces a string representation of this class.
+
+        This method returns a string representation of the underlying
+        list of lists of objects.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> print(grid)
+        [[Object("A"), Object("B")],
+        [None, Object("C")]]
+
+        """
+        return repr(self._grid._array)
+
+
+class ArrowStringDescription:
+    r"""
+    Stores the information necessary for producing an Xy-pic
+    description of an arrow.
+
+    The principal goal of this class is to abstract away the string
+    representation of an arrow and to also provide the functionality
+    to produce the actual Xy-pic string.
+
+    ``unit`` sets the unit which will be used to specify the amount of
+    curving and other distances.  ``horizontal_direction`` should be a
+    string of ``"r"`` or ``"l"`` specifying the horizontal offset of the
+    target cell of the arrow relatively to the current one.
+    ``vertical_direction`` should  specify the vertical offset using a
+    series of either ``"d"`` or ``"u"``.  ``label_position`` should be
+    either ``"^"``, ``"_"``,  or ``"|"`` to specify that the label should
+    be positioned above the arrow, below the arrow or just over the arrow,
+    in a break.  Note that the notions "above" and "below" are relative
+    to arrow direction.  ``label`` stores the morphism label.
+
+    This works as follows (disregard the yet unexplained arguments):
+
+    >>> from sympy.categories.diagram_drawing import ArrowStringDescription
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar[dr]_{f}
+
+    ``curving`` should be one of ``"^"``, ``"_"`` to specify in which
+    direction the arrow is going to curve. ``curving_amount`` is a number
+    describing how many ``unit``'s the morphism is going to curve:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_{f}
+
+    ``looping_start`` and ``looping_end`` are currently only used for
+    loop morphisms, those which have the same domain and codomain.
+    These two attributes should store a valid Xy-pic direction and
+    specify, correspondingly, the direction the arrow gets out into
+    and the direction the arrow gets back from:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start="u", looping_end="l", horizontal_direction="",
+    ... vertical_direction="", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@(u,l)[]_{f}
+
+    ``label_displacement`` controls how far the arrow label is from
+    the ends of the arrow.  For example, to position the arrow label
+    near the arrow head, use ">":
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.label_displacement = ">"
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_>{f}
+
+    Finally, ``arrow_style`` is used to specify the arrow style.  To
+    get a dashed arrow, for example, use "{-->}" as arrow style:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.arrow_style = "{-->}"
+    >>> print(str(astr))
+    \ar@/^12mm/@{-->}[dr]_{f}
+
+    Notes
+    =====
+
+    Instances of :class:`ArrowStringDescription` will be constructed
+    by :class:`XypicDiagramDrawer` and provided for further use in
+    formatters.  The user is not expected to construct instances of
+    :class:`ArrowStringDescription` themselves.
+
+    To be able to properly utilise this class, the reader is encouraged
+    to checkout the Xy-pic user guide, available at [Xypic].
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+
+    References
+    ==========
+
+    .. [Xypic] https://xy-pic.sourceforge.net/
+    """
+    def __init__(self, unit, curving, curving_amount, looping_start,
+                 looping_end, horizontal_direction, vertical_direction,
+                 label_position, label):
+        self.unit = unit
+        self.curving = curving
+        self.curving_amount = curving_amount
+        self.looping_start = looping_start
+        self.looping_end = looping_end
+        self.horizontal_direction = horizontal_direction
+        self.vertical_direction = vertical_direction
+        self.label_position = label_position
+        self.label = label
+
+        self.label_displacement = ""
+        self.arrow_style = ""
+
+        # This flag shows that the position of the label of this
+        # morphism was set while typesetting a curved morphism and
+        # should not be modified later.
+        self.forced_label_position = False
+
+    def __str__(self):
+        if self.curving:
+            curving_str = "@/%s%d%s/" % (self.curving, self.curving_amount,
+                                         self.unit)
+        else:
+            curving_str = ""
+
+        if self.looping_start and self.looping_end:
+            looping_str = "@(%s,%s)" % (self.looping_start, self.looping_end)
+        else:
+            looping_str = ""
+
+        if self.arrow_style:
+
+            style_str = "@" + self.arrow_style
+        else:
+            style_str = ""
+
+        return "\\ar%s%s%s[%s%s]%s%s{%s}" % \
+               (curving_str, looping_str, style_str, self.horizontal_direction,
+                self.vertical_direction, self.label_position,
+                self.label_displacement, self.label)
+
+
+class XypicDiagramDrawer:
+    r"""
+    Given a :class:`~.Diagram` and the corresponding
+    :class:`DiagramGrid`, produces the Xy-pic representation of the
+    diagram.
+
+    The most important method in this class is ``draw``.  Consider the
+    following triangle diagram:
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+    To draw this diagram, its objects need to be laid out with a
+    :class:`DiagramGrid`::
+
+    >>> grid = DiagramGrid(diagram)
+
+    Finally, the drawing:
+
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    For further details see the docstring of this method.
+
+    To control the appearance of the arrows, formatters are used.  The
+    dictionary ``arrow_formatters`` maps morphisms to formatter
+    functions.  A formatter is accepts an
+    :class:`ArrowStringDescription` and is allowed to modify any of
+    the arrow properties exposed thereby.  For example, to have all
+    morphisms with the property ``unique`` appear as dashed arrows,
+    and to have their names prepended with `\exists !`, the following
+    should be done:
+
+    >>> def formatter(astr):
+    ...   astr.label = r"\exists !" + astr.label
+    ...   astr.arrow_style = "{-->}"
+    >>> drawer.arrow_formatters["unique"] = formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    To modify the appearance of all arrows in the diagram, set
+    ``default_arrow_formatter``.  For example, to place all morphism
+    labels a little bit farther from the arrow head so that they look
+    more centred, do as follows:
+
+    >>> def default_formatter(astr):
+    ...   astr.label_displacement = "(0.45)"
+    >>> drawer.default_arrow_formatter = default_formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\
+    C &
+    }
+
+    In some diagrams some morphisms are drawn as curved arrows.
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> E = Object("E")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+    >>> grid = DiagramGrid(diagram)
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\
+    & C &
+    }
+
+    To control how far the morphisms are curved by default, one can
+    use the ``unit`` and ``default_curving_amount`` attributes:
+
+    >>> drawer.unit = "cm"
+    >>> drawer.default_curving_amount = 1
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\
+    & C &
+    }
+
+    In some diagrams, there are multiple curved morphisms between the
+    same two objects.  To control by how much the curving changes
+    between two such successive morphisms, use
+    ``default_curving_step``:
+
+    >>> drawer.default_curving_step = 1
+    >>> h1 = NamedMorphism(A, D, "h1")
+    >>> diagram = Diagram([f, g, h, k, h1])
+    >>> grid = DiagramGrid(diagram)
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\
+    & C &
+    }
+
+    The default value of ``default_curving_step`` is 4 units.
+
+    See Also
+    ========
+
+    draw, ArrowStringDescription
+    """
+    def __init__(self):
+        self.unit = "mm"
+        self.default_curving_amount = 3
+        self.default_curving_step = 4
+
+        # This dictionary maps properties to the corresponding arrow
+        # formatters.
+        self.arrow_formatters = {}
+
+        # This is the default arrow formatter which will be applied to
+        # each arrow independently of its properties.
+        self.default_arrow_formatter = None
+
+    @staticmethod
+    def _process_loop_morphism(i, j, grid, morphisms_str_info, object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a loop morphism.  This function is invoked
+        from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        # This is a loop morphism.  Count how many morphisms stick
+        # in each of the four quadrants.  Note that straight
+        # vertical and horizontal morphisms count in two quadrants
+        # at the same time (i.e., a morphism going up counts both
+        # in the first and the second quadrants).
+
+        # The usual numbering (counterclockwise) of quadrants
+        # applies.
+        quadrant = [0, 0, 0, 0]
+
+        obj = grid[i, j]
+
+        for m, m_str_info in morphisms_str_info.items():
+            if (m.domain == obj) and (m.codomain == obj):
+                # That's another loop morphism.  Check how it
+                # loops and mark the corresponding quadrants as
+                # busy.
+                (l_s, l_e) = (m_str_info.looping_start, m_str_info.looping_end)
+
+                if (l_s, l_e) == ("r", "u"):
+                    quadrant[0] += 1
+                elif (l_s, l_e) == ("u", "l"):
+                    quadrant[1] += 1
+                elif (l_s, l_e) == ("l", "d"):
+                    quadrant[2] += 1
+                elif (l_s, l_e) == ("d", "r"):
+                    quadrant[3] += 1
+
+                continue
+            if m.domain == obj:
+                (end_i, end_j) = object_coords[m.codomain]
+                goes_out = True
+            elif m.codomain == obj:
+                (end_i, end_j) = object_coords[m.domain]
+                goes_out = False
+            else:
+                continue
+
+            d_i = end_i - i
+            d_j = end_j - j
+            m_curving = m_str_info.curving
+
+            if (d_i != 0) and (d_j != 0):
+                # This is really a diagonal morphism.  Detect the
+                # quadrant.
+                if (d_i > 0) and (d_j > 0):
+                    quadrant[0] += 1
+                elif (d_i > 0) and (d_j < 0):
+                    quadrant[1] += 1
+                elif (d_i < 0) and (d_j < 0):
+                    quadrant[2] += 1
+                elif (d_i < 0) and (d_j > 0):
+                    quadrant[3] += 1
+            elif d_i == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the upper one and which is
+                # the lower one.
+                if d_j > 0:
+                    if goes_out:
+                        upper_quadrant = 0
+                        lower_quadrant = 3
+                    else:
+                        upper_quadrant = 3
+                        lower_quadrant = 0
+                else:
+                    if goes_out:
+                        upper_quadrant = 2
+                        lower_quadrant = 1
+                    else:
+                        upper_quadrant = 1
+                        lower_quadrant = 2
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[upper_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[lower_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[upper_quadrant] += 1
+                    quadrant[lower_quadrant] += 1
+            elif d_j == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the left one and which is
+                # the right one.
+                if d_i < 0:
+                    if goes_out:
+                        left_quadrant = 1
+                        right_quadrant = 0
+                    else:
+                        left_quadrant = 0
+                        right_quadrant = 1
+                else:
+                    if goes_out:
+                        left_quadrant = 3
+                        right_quadrant = 2
+                    else:
+                        left_quadrant = 2
+                        right_quadrant = 3
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[left_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[right_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[left_quadrant] += 1
+                    quadrant[right_quadrant] += 1
+
+        # Pick the freest quadrant to curve our morphism into.
+        freest_quadrant = 0
+        for i in range(4):
+            if quadrant[i] < quadrant[freest_quadrant]:
+                freest_quadrant = i
+
+        # Now set up proper looping.
+        (looping_start, looping_end) = [("r", "u"), ("u", "l"), ("l", "d"),
+                                        ("d", "r")][freest_quadrant]
+
+        return (curving, label_pos, looping_start, looping_end)
+
+    @staticmethod
+    def _process_horizontal_morphism(i, j, target_j, grid, morphisms_str_info,
+                                     object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a horizontal morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # The arrow is horizontal.  Check if it goes from left to
+        # right (``backwards == False``) or from right to left
+        # (``backwards == True``).
+        backwards = False
+        start = j
+        end = target_j
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out
+        # upwards, and how many stick out downwards.
+        #
+        # For example, consider the situation:
+        #
+        #    B1 C1
+        #    |  |
+        # A--B--C--D
+        #    |
+        #    B2
+        #
+        # Between the objects `A` and `D` there are two objects:
+        # `B` and `C`.  Further, there are two morphisms which
+        # stick out upward (the ones between `B1` and `B` and
+        # between `C` and `C1`) and one morphism which sticks out
+        # downward (the one between `B and `B2`).
+        #
+        # We need this information to decide how to curve the
+        # arrow between `A` and `D`.  First of all, since there
+        # are two objects between `A` and `D``, we must curve the
+        # arrow.  Then, we will have it curve downward, because
+        # there is more space (less morphisms stick out downward
+        # than upward).
+        up = []
+        down = []
+        straight_horizontal = []
+        for k in range(start + 1, end):
+            obj = grid[i, k]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_i > i:
+                    down.append(m)
+                elif end_i < i:
+                    up.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight horizontal morphism,
+                    # because it has no curving.
+                    straight_horizontal.append(m)
+
+        if len(up) < len(down):
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the lower side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the upper side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    @staticmethod
+    def _process_vertical_morphism(i, j, target_i, grid, morphisms_str_info,
+                                   object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a vertical morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # This arrow is vertical.  Check if it goes from top to
+        # bottom (``backwards == False``) or from bottom to top
+        # (``backwards == True``).
+        backwards = False
+        start = i
+        end = target_i
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out to
+        # the left, and how many stick out to the right.
+        #
+        # See the corresponding comment in the previous branch of
+        # this if-statement for more details.
+        left = []
+        right = []
+        straight_vertical = []
+        for k in range(start + 1, end):
+            obj = grid[k, j]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_j > j:
+                    right.append(m)
+                elif end_j < j:
+                    left.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight vertical morphism,
+                    # because it has no curving.
+                    straight_vertical.append(m)
+
+        if len(left) < len(right):
+            # More morphisms stick out to the left than to the
+            # right, let's curve the morphism to the right.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the left side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out to the right than to the
+            # left, let's curve the morphism to the left.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the right side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    def _process_morphism(self, diagram, grid, morphism, object_coords,
+                          morphisms, morphisms_str_info):
+        """
+        Given the required information, produces the string
+        representation of ``morphism``.
+        """
+        def repeat_string_cond(times, str_gt, str_lt):
+            """
+            If ``times > 0``, repeats ``str_gt`` ``times`` times.
+            Otherwise, repeats ``str_lt`` ``-times`` times.
+            """
+            if times > 0:
+                return str_gt * times
+            else:
+                return str_lt * (-times)
+
+        def count_morphisms_undirected(A, B):
+            """
+            Counts how many processed morphisms there are between the
+            two supplied objects.
+            """
+            return len([m for m in morphisms_str_info
+                        if {m.domain, m.codomain} == {A, B}])
+
+        def count_morphisms_filtered(dom, cod, curving):
+            """
+            Counts the processed morphisms which go out of ``dom``
+            into ``cod`` with curving ``curving``.
+            """
+            return len([m for m, m_str_info in morphisms_str_info.items()
+                        if (m.domain, m.codomain) == (dom, cod) and
+                        (m_str_info.curving == curving)])
+
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        # We now need to determine the direction of
+        # the arrow.
+        delta_i = target_i - i
+        delta_j = target_j - j
+        vertical_direction = repeat_string_cond(delta_i,
+                                                "d", "u")
+        horizontal_direction = repeat_string_cond(delta_j,
+                                                  "r", "l")
+
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        if (delta_i == 0) and (delta_j == 0):
+            # This is a loop morphism.
+            (curving, label_pos, looping_start,
+             looping_end) = XypicDiagramDrawer._process_loop_morphism(
+                 i, j, grid, morphisms_str_info, object_coords)
+        elif (delta_i == 0) and (abs(j - target_j) > 1):
+            # This is a horizontal morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_horizontal_morphism(
+                i, j, target_j, grid, morphisms_str_info, object_coords)
+        elif (delta_j == 0) and (abs(i - target_i) > 1):
+            # This is a vertical morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_vertical_morphism(
+                i, j, target_i, grid, morphisms_str_info, object_coords)
+
+        count = count_morphisms_undirected(morphism.domain, morphism.codomain)
+        curving_amount = ""
+        if curving:
+            # This morphisms should be curved anyway.
+            curving_amount = self.default_curving_amount + count * \
+                self.default_curving_step
+        elif count:
+            # There are no objects between the domain and codomain of
+            # the current morphism, but this is not there already are
+            # some morphisms with the same domain and codomain, so we
+            # have to curve this one.
+            curving = "^"
+            filtered_morphisms = count_morphisms_filtered(
+                morphism.domain, morphism.codomain, curving)
+            curving_amount = self.default_curving_amount + \
+                filtered_morphisms * \
+                self.default_curving_step
+
+        # Let's now get the name of the morphism.
+        morphism_name = ""
+        if isinstance(morphism, IdentityMorphism):
+            morphism_name = "id_{%s}" + latex(grid[i, j])
+        elif isinstance(morphism, CompositeMorphism):
+            component_names = [latex(Symbol(component.name)) for
+                               component in morphism.components]
+            component_names.reverse()
+            morphism_name = "\\circ ".join(component_names)
+        elif isinstance(morphism, NamedMorphism):
+            morphism_name = latex(Symbol(morphism.name))
+
+        return ArrowStringDescription(
+            self.unit, curving, curving_amount, looping_start,
+            looping_end, horizontal_direction, vertical_direction,
+            label_pos, morphism_name)
+
+    @staticmethod
+    def _check_free_space_horizontal(dom_i, dom_j, cod_j, grid):
+        """
+        For a horizontal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        if dom_j < cod_j:
+            (start, end) = (dom_j, cod_j)
+            backwards = False
+        else:
+            (start, end) = (cod_j, dom_j)
+            backwards = True
+
+        # Check for free space above.
+        if dom_i == 0:
+            free_up = True
+        else:
+            free_up = all(grid[dom_i - 1, j] for j in
+                          range(start, end + 1))
+
+        # Check for free space below.
+        if dom_i == grid.height - 1:
+            free_down = True
+        else:
+            free_down = not any(grid[dom_i + 1, j] for j in
+                                range(start, end + 1))
+
+        return (free_up, free_down, backwards)
+
+    @staticmethod
+    def _check_free_space_vertical(dom_i, cod_i, dom_j, grid):
+        """
+        For a vertical morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) to the left of the
+        morphism or to the right of it.
+        """
+        if dom_i < cod_i:
+            (start, end) = (dom_i, cod_i)
+            backwards = False
+        else:
+            (start, end) = (cod_i, dom_i)
+            backwards = True
+
+        # Check if there's space to the left.
+        if dom_j == 0:
+            free_left = True
+        else:
+            free_left = not any(grid[i, dom_j - 1] for i in
+                                range(start, end + 1))
+
+        if dom_j == grid.width - 1:
+            free_right = True
+        else:
+            free_right = not any(grid[i, dom_j + 1] for i in
+                                 range(start, end + 1))
+
+        return (free_left, free_right, backwards)
+
+    @staticmethod
+    def _check_free_space_diagonal(dom_i, cod_i, dom_j, cod_j, grid):
+        """
+        For a diagonal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        def abs_xrange(start, end):
+            if start < end:
+                return range(start, end + 1)
+            else:
+                return range(end, start + 1)
+
+        if dom_i < cod_i and dom_j < cod_j:
+            # This morphism goes from top-left to
+            # bottom-right.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = False
+        elif dom_i > cod_i and dom_j > cod_j:
+            # This morphism goes from bottom-right to
+            # top-left.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = True
+        if dom_i < cod_i and dom_j > cod_j:
+            # This morphism goes from top-right to
+            # bottom-left.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = True
+        elif dom_i > cod_i and dom_j < cod_j:
+            # This morphism goes from bottom-left to
+            # top-right.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = False
+
+        # This is an attempt at a fast and furious strategy to
+        # decide where there is free space on the two sides of
+        # a diagonal morphism.  For a diagonal morphism
+        # starting at ``(start_i, start_j)`` and ending at
+        # ``(end_i, end_j)`` the rectangle defined by these
+        # two points is considered.  The slope of the diagonal
+        # ``alpha`` is then computed.  Then, for every cell
+        # ``(i, j)`` within the rectangle, the slope
+        # ``alpha1`` of the line through ``(start_i,
+        # start_j)`` and ``(i, j)`` is considered.  If
+        # ``alpha1`` is between 0 and ``alpha``, the point
+        # ``(i, j)`` is above the diagonal, if ``alpha1`` is
+        # between ``alpha`` and infinity, the point is below
+        # the diagonal.  Also note that, with some beforehand
+        # precautions, this trick works for both the main and
+        # the secondary diagonals of the rectangle.
+
+        # I have considered the possibility to only follow the
+        # shorter diagonals immediately above and below the
+        # main (or secondary) diagonal.  This, however,
+        # wouldn't have resulted in much performance gain or
+        # better detection of outer edges, because of
+        # relatively small sizes of diagram grids, while the
+        # code would have become harder to understand.
+
+        alpha = float(end_i - start_i)/(end_j - start_j)
+        free_up = True
+        free_down = True
+        for i in abs_xrange(start_i, end_i):
+            if not free_up and not free_down:
+                break
+
+            for j in abs_xrange(start_j, end_j):
+                if not free_up and not free_down:
+                    break
+
+                if (i, j) == (start_i, start_j):
+                    continue
+
+                if j == start_j:
+                    alpha1 = "inf"
+                else:
+                    alpha1 = float(i - start_i)/(j - start_j)
+
+                if grid[i, j]:
+                    if (alpha1 == "inf") or (abs(alpha1) > abs(alpha)):
+                        free_down = False
+                    elif abs(alpha1) < abs(alpha):
+                        free_up = False
+
+        return (free_up, free_down, backwards)
+
+    def _push_labels_out(self, morphisms_str_info, grid, object_coords):
+        """
+        For all straight morphisms which form the visual boundary of
+        the laid out diagram, puts their labels on their outer sides.
+        """
+        def set_label_position(free1, free2, pos1, pos2, backwards, m_str_info):
+            """
+            Given the information about room available to one side and
+            to the other side of a morphism (``free1`` and ``free2``),
+            sets the position of the morphism label in such a way that
+            it is on the freer side.  This latter operations involves
+            choice between ``pos1`` and ``pos2``, taking ``backwards``
+            in consideration.
+
+            Thus this function will do nothing if either both ``free1
+            == True`` and ``free2 == True`` or both ``free1 == False``
+            and ``free2 == False``.  In either case, choosing one side
+            over the other presents no advantage.
+            """
+            if backwards:
+                (pos1, pos2) = (pos2, pos1)
+
+            if free1 and not free2:
+                m_str_info.label_position = pos1
+            elif free2 and not free1:
+                m_str_info.label_position = pos2
+
+        for m, m_str_info in morphisms_str_info.items():
+            if m_str_info.curving or m_str_info.forced_label_position:
+                # This is either a curved morphism, and curved
+                # morphisms have other magic, or the position of this
+                # label has already been fixed.
+                continue
+
+            if m.domain == m.codomain:
+                # This is a loop morphism, their labels, again have a
+                # different magic.
+                continue
+
+            (dom_i, dom_j) = object_coords[m.domain]
+            (cod_i, cod_j) = object_coords[m.codomain]
+
+            if dom_i == cod_i:
+                # Horizontal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_horizontal(
+                     dom_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+            elif dom_j == cod_j:
+                # Vertical morphism.
+                (free_left, free_right,
+                 backwards) = XypicDiagramDrawer._check_free_space_vertical(
+                     dom_i, cod_i, dom_j, grid)
+
+                set_label_position(free_left, free_right, "_", "^",
+                                   backwards, m_str_info)
+            else:
+                # A diagonal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_diagonal(
+                     dom_i, cod_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+
+    @staticmethod
+    def _morphism_sort_key(morphism, object_coords):
+        """
+        Provides a morphism sorting key such that horizontal or
+        vertical morphisms between neighbouring objects come
+        first, then horizontal or vertical morphisms between more
+        far away objects, and finally, all other morphisms.
+        """
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        if morphism.domain == morphism.codomain:
+            # Loop morphisms should get after diagonal morphisms
+            # so that the proper direction in which to curve the
+            # loop can be determined.
+            return (3, 0, default_sort_key(morphism))
+
+        if target_i == i:
+            return (1, abs(target_j - j), default_sort_key(morphism))
+
+        if target_j == j:
+            return (1, abs(target_i - i), default_sort_key(morphism))
+
+        # Diagonal morphism.
+        return (2, 0, default_sort_key(morphism))
+
+    @staticmethod
+    def _build_xypic_string(diagram, grid, morphisms,
+                            morphisms_str_info, diagram_format):
+        """
+        Given a collection of :class:`ArrowStringDescription`
+        describing the morphisms of a diagram and the object layout
+        information of a diagram, produces the final Xy-pic picture.
+        """
+        # Build the mapping between objects and morphisms which have
+        # them as domains.
+        object_morphisms = {}
+        for obj in diagram.objects:
+            object_morphisms[obj] = []
+        for morphism in morphisms:
+            object_morphisms[morphism.domain].append(morphism)
+
+        result = "\\xymatrix%s{\n" % diagram_format
+
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if obj:
+                    result += latex(obj) + " "
+
+                    morphisms_to_draw = object_morphisms[obj]
+                    for morphism in morphisms_to_draw:
+                        result += str(morphisms_str_info[morphism]) + " "
+
+                # Don't put the & after the last column.
+                if j < grid.width - 1:
+                    result += "& "
+
+            # Don't put the line break after the last row.
+            if i < grid.height - 1:
+                result += "\\\\"
+            result += "\n"
+
+        result += "}\n"
+
+        return result
+
+    def draw(self, diagram, grid, masked=None, diagram_format=""):
+        r"""
+        Returns the Xy-pic representation of ``diagram`` laid out in
+        ``grid``.
+
+        Consider the following simple triangle diagram.
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+        To draw this diagram, its objects need to be laid out with a
+        :class:`DiagramGrid`::
+
+        >>> grid = DiagramGrid(diagram)
+
+        Finally, the drawing:
+
+        >>> drawer = XypicDiagramDrawer()
+        >>> print(drawer.draw(diagram, grid))
+        \xymatrix{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        The argument ``masked`` can be used to skip morphisms in the
+        presentation of the diagram:
+
+        >>> print(drawer.draw(diagram, grid, masked=[g * f]))
+        \xymatrix{
+        A \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        Finally, the ``diagram_format`` argument can be used to
+        specify the format string of the diagram.  For example, to
+        increase the spacing by 1 cm, proceeding as follows:
+
+        >>> print(drawer.draw(diagram, grid, diagram_format="@+1cm"))
+        \xymatrix@+1cm{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        """
+        # This method works in several steps.  It starts by removing
+        # the masked morphisms, if necessary, and then maps objects to
+        # their positions in the grid (coordinate tuples).  Remember
+        # that objects are unique in ``Diagram`` and in the layout
+        # produced by ``DiagramGrid``, so every object is mapped to a
+        # single coordinate pair.
+        #
+        # The next step is the central step and is concerned with
+        # analysing the morphisms of the diagram and deciding how to
+        # draw them.  For example, how to curve the arrows is decided
+        # at this step.  The bulk of the analysis is implemented in
+        # ``_process_morphism``, to the result of which the
+        # appropriate formatters are applied.
+        #
+        # The result of the previous step is a list of
+        # ``ArrowStringDescription``.  After the analysis and
+        # application of formatters, some extra logic tries to assure
+        # better positioning of morphism labels (for example, an
+        # attempt is made to avoid the situations when arrows cross
+        # labels).  This functionality constitutes the next step and
+        # is implemented in ``_push_labels_out``.  Note that label
+        # positions which have been set via a formatter are not
+        # affected in this step.
+        #
+        # Finally, at the closing step, the array of
+        # ``ArrowStringDescription`` and the layout information
+        # incorporated in ``DiagramGrid`` are combined to produce the
+        # resulting Xy-pic picture.  This part of code lies in
+        # ``_build_xypic_string``.
+
+        if not masked:
+            morphisms_props = grid.morphisms
+        else:
+            morphisms_props = {}
+            for m, props in grid.morphisms.items():
+                if m in masked:
+                    continue
+                morphisms_props[m] = props
+
+        # Build the mapping between objects and their position in the
+        # grid.
+        object_coords = {}
+        for i in range(grid.height):
+            for j in range(grid.width):
+                if grid[i, j]:
+                    object_coords[grid[i, j]] = (i, j)
+
+        morphisms = sorted(morphisms_props,
+                           key=lambda m: XypicDiagramDrawer._morphism_sort_key(
+                               m, object_coords))
+
+        # Build the tuples defining the string representations of
+        # morphisms.
+        morphisms_str_info = {}
+        for morphism in morphisms:
+            string_description = self._process_morphism(
+                diagram, grid, morphism, object_coords, morphisms,
+                morphisms_str_info)
+
+            if self.default_arrow_formatter:
+                self.default_arrow_formatter(string_description)
+
+            for prop in morphisms_props[morphism]:
+                # prop is a Symbol.  TODO: Find out why.
+                if prop.name in self.arrow_formatters:
+                    formatter = self.arrow_formatters[prop.name]
+                    formatter(string_description)
+
+            morphisms_str_info[morphism] = string_description
+
+        # Reposition the labels a bit.
+        self._push_labels_out(morphisms_str_info, grid, object_coords)
+
+        return XypicDiagramDrawer._build_xypic_string(
+            diagram, grid, morphisms, morphisms_str_info, diagram_format)
+
+
+def xypic_draw_diagram(diagram, masked=None, diagram_format="",
+                       groups=None, **hints):
+    r"""
+    Provides a shortcut combining :class:`DiagramGrid` and
+    :class:`XypicDiagramDrawer`.  Returns an Xy-pic presentation of
+    ``diagram``.  The argument ``masked`` is a list of morphisms which
+    will be not be drawn.  The argument ``diagram_format`` is the
+    format string inserted after "\xymatrix".  ``groups`` should be a
+    set of logical groups.  The ``hints`` will be passed directly to
+    the constructor of :class:`DiagramGrid`.
+
+    For more information about the arguments, see the docstrings of
+    :class:`DiagramGrid` and ``XypicDiagramDrawer.draw``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import xypic_draw_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+    >>> print(xypic_draw_diagram(diagram))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    See Also
+    ========
+
+    XypicDiagramDrawer, DiagramGrid
+    """
+    grid = DiagramGrid(diagram, groups, **hints)
+    drawer = XypicDiagramDrawer()
+    return drawer.draw(diagram, grid, masked, diagram_format)
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',))
+def preview_diagram(diagram, masked=None, diagram_format="", groups=None,
+                    output='png', viewer=None, euler=True, **hints):
+    """
+    Combines the functionality of ``xypic_draw_diagram`` and
+    ``sympy.printing.preview``.  The arguments ``masked``,
+    ``diagram_format``, ``groups``, and ``hints`` are passed to
+    ``xypic_draw_diagram``, while ``output``, ``viewer, and ``euler``
+    are passed to ``preview``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import preview_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> preview_diagram(d)
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+    """
+    from sympy.printing import preview
+    latex_output = xypic_draw_diagram(diagram, masked, diagram_format,
+                                      groups, **hints)
+    preview(latex_output, output, viewer, euler, ("xypic",))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/tests/__init__.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/tests/test_baseclasses.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/tests/test_baseclasses.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfac32229768fb5903b23b11ffb236912c0b931e
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/categories/tests/test_baseclasses.py
@@ -0,0 +1,209 @@
+from sympy.categories import (Object, Morphism, IdentityMorphism,
+                              NamedMorphism, CompositeMorphism,
+                              Diagram, Category)
+from sympy.categories.baseclasses import Class
+from sympy.testing.pytest import raises
+from sympy.core.containers import (Dict, Tuple)
+from sympy.sets import EmptySet
+from sympy.sets.sets import FiniteSet
+
+
+def test_morphisms():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    # Test the base morphism.
+    f = NamedMorphism(A, B, "f")
+    assert f.domain == A
+    assert f.codomain == B
+    assert f == NamedMorphism(A, B, "f")
+
+    # Test identities.
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    assert id_A.domain == A
+    assert id_A.codomain == A
+    assert id_A == IdentityMorphism(A)
+    assert id_A != id_B
+
+    # Test named morphisms.
+    g = NamedMorphism(B, C, "g")
+    assert g.name == "g"
+    assert g != f
+    assert g == NamedMorphism(B, C, "g")
+    assert g != NamedMorphism(B, C, "f")
+
+    # Test composite morphisms.
+    assert f == CompositeMorphism(f)
+
+    k = g.compose(f)
+    assert k.domain == A
+    assert k.codomain == C
+    assert k.components == Tuple(f, g)
+    assert g * f == k
+    assert CompositeMorphism(f, g) == k
+
+    assert CompositeMorphism(g * f) == g * f
+
+    # Test the associativity of composition.
+    h = NamedMorphism(C, D, "h")
+
+    p = h * g
+    u = h * g * f
+
+    assert h * k == u
+    assert p * f == u
+    assert CompositeMorphism(f, g, h) == u
+
+    # Test flattening.
+    u2 = u.flatten("u")
+    assert isinstance(u2, NamedMorphism)
+    assert u2.name == "u"
+    assert u2.domain == A
+    assert u2.codomain == D
+
+    # Test identities.
+    assert f * id_A == f
+    assert id_B * f == f
+    assert id_A * id_A == id_A
+    assert CompositeMorphism(id_A) == id_A
+
+    # Test bad compositions.
+    raises(ValueError, lambda: f * g)
+
+    raises(TypeError, lambda: f.compose(None))
+    raises(TypeError, lambda: id_A.compose(None))
+    raises(TypeError, lambda: f * None)
+    raises(TypeError, lambda: id_A * None)
+
+    raises(TypeError, lambda: CompositeMorphism(f, None, 1))
+
+    raises(ValueError, lambda: NamedMorphism(A, B, ""))
+    raises(NotImplementedError, lambda: Morphism(A, B))
+
+
+def test_diagram():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+
+    empty = EmptySet
+
+    # Test the addition of identities.
+    d1 = Diagram([f])
+
+    assert d1.objects == FiniteSet(A, B)
+    assert d1.hom(A, B) == (FiniteSet(f), empty)
+    assert d1.hom(A, A) == (FiniteSet(id_A), empty)
+    assert d1.hom(B, B) == (FiniteSet(id_B), empty)
+
+    assert d1 == Diagram([id_A, f])
+    assert d1 == Diagram([f, f])
+
+    # Test the addition of composites.
+    d2 = Diagram([f, g])
+    homAC = d2.hom(A, C)[0]
+
+    assert d2.objects == FiniteSet(A, B, C)
+    assert g * f in d2.premises.keys()
+    assert homAC == FiniteSet(g * f)
+
+    # Test equality, inequality and hash.
+    d11 = Diagram([f])
+
+    assert d1 == d11
+    assert d1 != d2
+    assert hash(d1) == hash(d11)
+
+    d11 = Diagram({f: "unique"})
+    assert d1 != d11
+
+    # Make sure that (re-)adding composites (with new properties)
+    # works as expected.
+    d = Diagram([f, g], {g * f: "unique"})
+    assert d.conclusions == Dict({g * f: FiniteSet("unique")})
+
+    # Check the hom-sets when there are premises and conclusions.
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    d = Diagram([f, g], [g * f])
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+
+    # Check how the properties of composite morphisms are computed.
+    d = Diagram({f: ["unique", "isomorphism"], g: "unique"})
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check that conclusion morphisms with new objects are not allowed.
+    d = Diagram([f], [g])
+    assert d.conclusions == Dict({})
+
+    # Test an empty diagram.
+    d = Diagram()
+    assert d.premises == Dict({})
+    assert d.conclusions == Dict({})
+    assert d.objects == empty
+
+    # Check a SymPy Dict object.
+    d = Diagram(Dict({f: FiniteSet("unique", "isomorphism"), g: "unique"}))
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check the addition of components of composite morphisms.
+    d = Diagram([g * f])
+    assert f in d.premises
+    assert g in d.premises
+
+    # Check subdiagrams.
+    d = Diagram([f, g], {g * f: "unique"})
+
+    d1 = Diagram([f])
+    assert d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([NamedMorphism(B, A, "f'")])
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d1 = Diagram([f, g], {g * f: ["unique", "something"]})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram({f: "blooh"})
+    d1 = Diagram({f: "bleeh"})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([f, g], {f: "unique", g * f: "veryunique"})
+    d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+    assert d1 == Diagram([f], {f: "unique"})
+    raises(ValueError, lambda: d.subdiagram_from_objects(FiniteSet(A,
+           Object("D"))))
+
+    raises(ValueError, lambda: Diagram({IdentityMorphism(A): "unique"}))
+
+
+def test_category():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+
+    objects = d1.objects | d2.objects
+
+    K = Category("K", objects, commutative_diagrams=[d1, d2])
+
+    assert K.name == "K"
+    assert K.objects == Class(objects)
+    assert K.commutative_diagrams == FiniteSet(d1, d2)
+
+    raises(ValueError, lambda: Category(""))
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/conftest.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..788ec7ed8a38de422b76c4ac19057513670d2d38
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/conftest.py
@@ -0,0 +1,96 @@
+import sys
+
+sys._running_pytest = True  # type: ignore
+from sympy.external.importtools import version_tuple
+
+import pytest
+from sympy.core.cache import clear_cache, USE_CACHE
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.misc import ARCH
+import re
+
+try:
+    import hypothesis
+
+    hypothesis.settings.register_profile("sympy_hypothesis_profile", deadline=None)
+    hypothesis.settings.load_profile("sympy_hypothesis_profile")
+except ImportError:
+    raise ImportError(
+        "hypothesis is a required dependency to run the SymPy test suite. "
+        "Install it with 'pip install hypothesis' or 'conda install -c conda-forge hypothesis'"
+    )
+
+
+sp = re.compile(r"([0-9]+)/([1-9][0-9]*)")
+
+
+def process_split(config, items):
+    split = config.getoption("--split")
+    if not split:
+        return
+    m = sp.match(split)
+    if not m:
+        raise ValueError(
+            "split must be a string of the form a/b " "where a and b are ints."
+        )
+    i, t = map(int, m.groups())
+    start, end = (i - 1) * len(items) // t, i * len(items) // t
+
+    if i < t:
+        # remove elements from end of list first
+        del items[end:]
+    del items[:start]
+
+
+def pytest_report_header(config):
+    s = "architecture: %s\n" % ARCH
+    s += "cache:        %s\n" % USE_CACHE
+    version = ""
+    if GROUND_TYPES == "gmpy":
+        import gmpy2
+
+        version = gmpy2.version()
+    elif GROUND_TYPES == "flint":
+        try:
+            from flint import __version__
+        except ImportError:
+            version = "unknown"
+        else:
+            version = f'(python-flint=={__version__})'
+    s += "ground types: %s %s\n" % (GROUND_TYPES, version)
+    return s
+
+
+def pytest_terminal_summary(terminalreporter):
+    if terminalreporter.stats.get("error", None) or terminalreporter.stats.get(
+        "failed", None
+    ):
+        terminalreporter.write_sep(" ", "DO *NOT* COMMIT!", red=True, bold=True)
+
+
+def pytest_addoption(parser):
+    parser.addoption("--split", action="store", default="", help="split tests")
+
+
+def pytest_collection_modifyitems(config, items):
+    """pytest hook."""
+    # handle splits
+    process_split(config, items)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def file_clear_cache():
+    clear_cache()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def check_disabled(request):
+    if getattr(request.module, "disabled", False):
+        pytest.skip("test requirements not met.")
+    elif getattr(request.module, "ipython", False):
+        # need to check version and options for ipython tests
+        if (
+            version_tuple(pytest.__version__) < version_tuple("2.6.3")
+            and pytest.config.getvalue("-s") != "no"
+        ):
+            pytest.skip("run py.test with -s or upgrade to newer version.")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/galgebra.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/galgebra.py
new file mode 100644
index 0000000000000000000000000000000000000000..be812bfcbcece834c86d7b55eb846286acd0ac08
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/galgebra.py
@@ -0,0 +1 @@
+raise ImportError("""As of SymPy 1.0 the galgebra module is maintained separately at https://github.com/pygae/galgebra""")
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/release.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/release.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9f68edb2f571e7bfaad9472d36a2d357b5574b2
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/release.py
@@ -0,0 +1 @@
+__version__ = "1.14.0"
diff --git a/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/this.py b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/this.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2a5504ac42c7d57790d65524b066a6df86ab539
--- /dev/null
+++ b/miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/this.py
@@ -0,0 +1,21 @@
+"""
+The Zen of SymPy.
+"""
+
+s = """The Zen of SymPy
+
+Unevaluated is better than evaluated.
+The user interface matters.
+Printing matters.
+Pure Python can be fast enough.
+If it's too slow, it's (probably) your fault.
+Documentation matters.
+Correctness is more important than speed.
+Push it in now and improve upon it later.
+Coverage by testing matters.
+Smart tests are better than random tests.
+But random tests sometimes find what your smartest test missed.
+The Python way is probably the right way.
+Community is more important than code."""
+
+print(s)