gam-sae 0.3.155

Sparse-autoencoder latent-manifold terms for the gam penalized-likelihood engine
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#![cfg(test)]
//! #2818 recovery of #2280 transition contracts through surviving atlas output.

use super::{AtlasOrientability, ChartTransition, LocalAtlas, LocalAtlasConfig};
use crate::manifold::tests_topology_fixtures::{embedded_plane, spherical_band, swiss_roll};

fn genuine_triangle(atlas: &LocalAtlas) -> [&ChartTransition; 3] {
    for ab in atlas.transitions() {
        for bc in atlas
            .transitions()
            .iter()
            .filter(|edge| edge.from_patch == ab.to_patch)
        {
            for ac in atlas
                .transitions()
                .iter()
                .filter(|edge| edge.from_patch == ab.from_patch && edge.to_patch == bc.to_patch)
            {
                // Pairwise overlap alone does not establish a genuine triple.
                // Require a row in all three registered overlap components.
                if ab.shared_rows.iter().any(|row| {
                    bc.shared_rows.binary_search(row).is_ok()
                        && ac.shared_rows.binary_search(row).is_ok()
                }) {
                    return [ab, bc, ac];
                }
            }
        }
    }
    panic!("the deterministic atlas must have a genuine triple overlap");
}

fn triangle_defect(edges: [&ChartTransition; 3]) -> f64 {
    let [ab, bc, ac] = edges;
    let product = ac.rotation.t().dot(&bc.rotation.dot(&ab.rotation));
    product
        .indexed_iter()
        .map(|((row, column), value)| {
            let identity = if row == column { 1.0 } else { 0.0 };
            (value - identity).powi(2)
        })
        .sum::<f64>()
        .sqrt()
}

#[test]
fn swiss_roll_charts_injective_and_cocycle_closes_2280() {
    let points = swiss_roll(40, 8);
    let atlas = LocalAtlas::build(points.view(), LocalAtlasConfig::balanced(points.nrows(), 2))
        .expect("the original swiss-roll atlas must build");
    assert!(atlas.chart_count() >= 3);
    for chart in atlas.charts() {
        assert!(chart.certificate.min_projection_stretch > 0.0);
        assert!(chart.certificate.captured_variance_fraction > 0.7);
    }
    let edges = genuine_triangle(&atlas);
    let defect = triangle_defect(edges);
    assert!(defect < 0.5, "swiss-roll rotation cocycle defect={defect}");
    assert_eq!(edges.iter().map(|edge| edge.sign).product::<i8>(), 1);
    eprintln!(
        "#2280 swiss-roll: charts={} cocycle_defect={defect:.6e}",
        atlas.chart_count()
    );
}

#[test]
fn embedded_plane_cocycle_closes_to_rounding_2280() {
    let points = embedded_plane(12, 12);
    let atlas = LocalAtlas::build(points.view(), LocalAtlasConfig::balanced(points.nrows(), 2))
        .expect("the original plane atlas must build");
    for chart in atlas.charts() {
        assert!(chart.certificate.captured_variance_fraction > 1.0 - 1e-9);
        assert!((chart.certificate.min_projection_stretch - 1.0).abs() < 1e-6);
    }
    let edges = genuine_triangle(&atlas);
    let defect = triangle_defect(edges);
    assert!(
        defect < 1e-8,
        "exact-plane rotation cocycle defect={defect}"
    );
    assert_eq!(
        atlas.observed_orientability(),
        AtlasOrientability::Orientable
    );
    // On the exact plane the complete affine maps must compose as well as
    // their rotations. This also exercises the live public transition action.
    let [ab, bc, ac] = edges;
    let row = *ab
        .shared_rows
        .iter()
        .find(|row| {
            bc.shared_rows.binary_search(row).is_ok() && ac.shared_rows.binary_search(row).is_ok()
        })
        .expect("the selected edges share a real row");
    let coordinate = atlas.charts()[ab.from_patch].project(points.row(row));
    let via_b = bc.apply(ab.apply(coordinate.view()).view());
    let direct = ac.apply(coordinate.view());
    let observed = atlas.charts()[ac.to_patch].project(points.row(row));
    for (&mapped, &projected) in direct.iter().zip(observed.iter()) {
        assert!(
            (mapped - projected).abs() < 1e-8,
            "the transition must reproduce the observed target coordinate"
        );
    }
    let affine_error = via_b
        .iter()
        .zip(direct.iter())
        .map(|(left, right)| (left - right).abs())
        .fold(0.0_f64, f64::max);
    assert!(
        affine_error < 1e-8,
        "exact-plane affine cocycle error={affine_error}"
    );
    eprintln!(
        "#2280 plane: charts={} cocycle_defect={defect:.6e} affine_error={affine_error:.6e}",
        atlas.chart_count()
    );
}

#[test]
fn sphere_charts_injective_and_orientable_2280() {
    // The historical fixture is a spherical band with polar caps removed.
    // Its orientability and local transition contract do not imply sphere homology.
    let points = spherical_band(14, 20);
    let atlas = LocalAtlas::build(points.view(), LocalAtlasConfig::balanced(points.nrows(), 2))
        .expect("the original spherical-band atlas must build");
    for chart in atlas.charts() {
        assert!(chart.certificate.min_projection_stretch > 0.0);
    }
    assert_eq!(
        atlas.observed_orientability(),
        AtlasOrientability::Orientable
    );
    let edges = genuine_triangle(&atlas);
    assert_eq!(edges.iter().map(|edge| edge.sign).product::<i8>(), 1);
    let defect = triangle_defect(edges);
    assert!(
        defect < 0.75,
        "spherical-band rotation cocycle defect={defect}"
    );
    eprintln!(
        "#2280 spherical band: charts={} cocycle_defect={defect:.6e}",
        atlas.chart_count()
    );
}