Merge branch 'main' into release-plz-2026-06-17T03-04-27Z

Author: marvin-hansen

build/scripts/miri.sh

@@ -0,0 +1,44 @@
+#
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
+#
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+CRATES=(
+    "deep_causality"
+    "deep_causality_algorithms"
+    "deep_causality_ast"
+    "deep_causality_calculus"
+    "deep_causality_cfd"
+    "deep_causality_core"
+    "deep_causality_data_structures"
+    "deep_causality_discovery"
+    "deep_causality_ethos"
+    "deep_causality_fft"
+    "deep_causality_haft"
+    "deep_causality_macros"
+    "deep_causality_metric"
+    "deep_causality_multivector"
+    "deep_causality_num"
+    "deep_causality_par"
+    "deep_causality_rand"
+    "deep_causality_physics"
+    "deep_causality_sparse"
+    "deep_causality_tensor"
+    "deep_causality_topology"
+    "deep_causality_uncertain"
+    "ultragraph"
+)
+
+for CRATE_NAME in "${CRATES[@]}"; do
+    echo "Running MIRI for crate: $CRATE_NAME"
+     if !  cargo miri test -p "$CRATE_NAME" --lib --tests
+    then
+        echo "Failed to run MIRI for $CRATE_NAME"
+    fi
+done
+
+echo "MIRI complete."

deep_causality_algorithms/tests/causal_discovery/brcd/family_tests.rs

@@ -77,6 +77,7 @@ fn mixture_with_all_anomalous_collapses_to_the_present_expert() {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn mixture_is_finite_and_deterministic() {
     let node = vec![0.0, 1.0, 2.0, 8.0, 9.0, 10.0];
     let parents = vec![

deep_causality_algorithms/tests/causal_discovery/brcd/mod.rs

@@ -4,7 +4,9 @@
  */
 #[cfg(test)]
 mod augment_tests;
+// Disabled under Miri
 #[cfg(test)]
+#[cfg(not(miri))]
 mod boss_bootstrap_tests;
 #[cfg(test)]
 mod boss_config_tests;
@@ -33,12 +35,15 @@ mod gate_tests;
 #[cfg(test)]
 mod gaussian_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 mod mapconfig_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 mod mec_tests;
 #[cfg(test)]
 mod meek_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 mod update_tests;
 #[cfg(test)]
 mod validity_tests;

deep_causality_algorithms/tests/mod.rs

@@ -3,5 +3,7 @@
  * Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 mod causal_discovery;
+// MIRI takes forever on DAG sampling
+#[cfg(not(miri))]
 mod dag_sampling;
 mod feature_selection;

deep_causality_cfd/tests/solvers/dec/boundary_zone_tests.rs

@@ -54,6 +54,7 @@ fn march(solver: &DecNsSolver<'_, 2, f64>, seed: &SolenoidalField<f64>, steps: u
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn body_force_zone_marches_bit_identically_to_the_legacy_solver() {
     let (m, h) = channel(9, [true, false]);
     let dt = 0.5 * h * h / (4.0 * NU);

deep_causality_cfd/tests/solvers/mod.rs

@@ -3,5 +3,7 @@
  * Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
+#[cfg(test)]
+#[cfg(not(miri))]
 mod dec;
 mod dec_config;

deep_causality_cfd/tests/types/flow/coupling_tests.rs

@@ -209,6 +209,7 @@ fn a_stage_error_short_circuits_the_coupling() {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn coupled_viscosity_feedback_changes_the_flow_dynamics() {
     // A 3D Taylor–Green vortex decay marched twice: once single-physics, once with a hot-wall
     // thermal relaxation feeding ν(T) back through the ambient. The coupled run dissipates

deep_causality_cfd/tests/types/flow/mod.rs

@@ -24,19 +24,26 @@ where
 pub mod coupling_tests;
 #[cfg(test)]
 pub mod frequency_tests;
+// IO operations are unsupported under MIRI.
 #[cfg(test)]
+#[cfg(not(miri))]
 pub mod io_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 pub mod march_case_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 pub mod march_run_tests;
 #[cfg(test)]
 pub mod mms_tests;
 #[cfg(test)]
+#[cfg(not(miri))]
 pub mod operator_study_tests;
 #[cfg(test)]
 pub mod report_tests;
+// IO operations are unsupported under MIRI.
 #[cfg(test)]
+#[cfg(not(miri))]
 pub mod uncertain_march_run_tests;
 #[cfg(test)]
 pub mod verify_tests;

deep_causality_physics/src/lib.rs

@@ -13,6 +13,8 @@ pub(crate) mod error;
 pub(crate) mod kernels;
 pub mod quantities;
 pub mod theories;
+#[cfg(feature = "alloc")]
+pub mod utils_tests;
 
 pub use crate::constants::*;
 

deep_causality_physics/src/utils_tests/mod.rs

@@ -0,0 +1,110 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+//! Shared test fixtures for the physics test suite.
+//!
+//! These helpers build discrete manifolds and cochains used by the
+//! `SolenoidalField` tests. They live in the source tree (rather than inside
+//! the `tests/` folder) because the Bazel `rust_test_suite` compiles each
+//! `*_tests.rs` file as a standalone crate, so test files cannot share helpers
+//! across one another — only the crate under test is visible to all of them.
+
+use alloc::{vec, vec::Vec};
+use deep_causality_num::{FromPrimitive, RealField};
+use deep_causality_tensor::CausalTensor;
+use deep_causality_topology::{ChainComplex, CubicalReggeGeometry, LatticeComplex, Manifold};
+
+/// A 2D square-torus lattice manifold of side `n` with unit cubical metric.
+pub fn unit_manifold<R>(n: usize) -> Manifold<LatticeComplex<2, R>, R>
+where
+    R: RealField
+        + deep_causality_par::MaybeParallel
+        + FromPrimitive
+        + Default
+        + PartialEq
+        + core::fmt::Debug
+        + core::fmt::Display,
+{
+    let lattice: LatticeComplex<2, R> = LatticeComplex::square_torus(n);
+    let total: usize = (0..=2).map(|k| lattice.num_cells(k)).sum();
+    let data = CausalTensor::new(vec![R::zero(); total], vec![total]).unwrap();
+    let metric: CubicalReggeGeometry<2, R> = CubicalReggeGeometry::unit();
+    Manifold::from_cubical_with_metric(lattice, data, metric, 0)
+}
+
+/// A deterministic pseudo-random cochain of length `len` in `[-1, 1]`.
+pub fn random_cochain<R: RealField + FromPrimitive>(len: usize, seed: u64) -> Vec<R> {
+    let mut state = seed
+        .wrapping_mul(6364136223846793005)
+        .wrapping_add(1442695040888963407);
+    (0..len)
+        .map(|_| {
+            state = state
+                .wrapping_mul(6364136223846793005)
+                .wrapping_add(1442695040888963407);
+            let unit = (state >> 11) as f64 / (1u64 << 53) as f64;
+            R::from_f64(2.0 * unit - 1.0).expect("[-1,1] lifts")
+        })
+        .collect()
+}
+
+/// Discrete divergence of an edge cochain: place at grade 1, apply δ.
+pub fn divergence<R>(manifold: &Manifold<LatticeComplex<2, R>, R>, one_form: &[R]) -> Vec<R>
+where
+    R: RealField
+        + deep_causality_par::MaybeParallel
+        + FromPrimitive
+        + Default
+        + PartialEq
+        + core::fmt::Debug
+        + core::fmt::Display,
+{
+    let lattice = LatticeComplex::<2, R>::square_torus(
+        // shape is square by fixture construction
+        manifold.complex().shape()[0],
+    );
+    let total: usize = (0..=2).map(|g| lattice.num_cells(g)).sum();
+    let n0 = lattice.num_cells(0);
+    let mut data = vec![R::zero(); total];
+    data[n0..n0 + one_form.len()].copy_from_slice(one_form);
+    let tensor = CausalTensor::new(data, vec![total]).unwrap();
+    let metric: CubicalReggeGeometry<2, R> = CubicalReggeGeometry::unit();
+    let m = Manifold::from_cubical_with_metric(lattice, tensor, metric, 0);
+    m.codifferential(1).as_slice().to_vec()
+}
+
+/// Supremum (max-abs) norm of a slice.
+pub fn sup_norm<R: RealField>(v: &[R]) -> R {
+    v.iter()
+        .map(|x| x.abs())
+        .fold(R::zero(), |m, x| if x > m { x } else { m })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sup_norm() {
+        assert_eq!(sup_norm(&[-3.0_f64, 1.0, 2.0]), 3.0);
+        assert_eq!(sup_norm::<f64>(&[]), 0.0);
+    }
+
+    #[test]
+    fn test_random_cochain_is_bounded_and_deterministic() {
+        let a = random_cochain::<f64>(16, 7);
+        let b = random_cochain::<f64>(16, 7);
+        assert_eq!(a, b);
+        assert!(a.iter().all(|&x| (-1.0..=1.0).contains(&x)));
+    }
+
+    #[test]
+    fn test_unit_manifold_and_divergence_dimensions() {
+        let manifold = unit_manifold::<f64>(4);
+        let n1 = manifold.complex().num_cells(1);
+        let div = divergence(&manifold, &random_cochain::<f64>(n1, 1));
+        assert_eq!(div.len(), manifold.complex().num_cells(0));
+    }
+}