ariadnetor-algorithms 0.0.1

Tensor-network algorithms built on ariadnetor
Documentation 
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

//! Source-forwarding / non-duplication contract for the crate's
//! `thiserror`-derived error enums.
//!
//! Each wrapping variant must expose its child through `source()`
//! (so the chain stays walkable) while keeping its own `Display` to
//! the current layer — it must NOT fold the child's message into its
//! own `Display`, which would surface the cause twice in a
//! `source()`-walking reporter. These tests pin both halves: the
//! child is reachable via `source()`, and the wrapper's `Display`
//! does not contain the child's message.

use std::error::Error;

use ariadnetor_algorithms::dmrg::{
    DmrgEnvError, DmrgError, DmrgHeffError, DmrgSweepError, SweepDirection,
};
use ariadnetor_linalg::LinalgError;

/// A `LinalgError` carrying a distinctive marker token, so a
/// "wrapper Display does not contain the child message" assertion
/// cannot pass by coincidence.
fn marker_linalg_error() -> LinalgError {
    LinalgError::InvalidArgument("probe-marker-token".to_string())
}

/// Assert the standard contract for one wrapping error value: its
/// `Display` matches `expected_self_layer` exactly (so no child text
/// leaked in), it does not contain the child's message, and its
/// `source()` is the child.
fn assert_forwards(err: &dyn Error, expected_self_layer: &str, child_display: &str) {
    assert_eq!(
        err.to_string(),
        expected_self_layer,
        "wrapper Display must stay self-layer"
    );
    assert!(
        !err.to_string().contains(child_display),
        "wrapper Display must not duplicate the child message: {:?}",
        err.to_string()
    );
    let source = err
        .source()
        .expect("wrapping variant must expose its child via source()");
    assert_eq!(
        source.to_string(),
        child_display,
        "source() must reach the child error unchanged"
    );
}

#[test]
fn dmrg_error_env_forwards_to_source() {
    let child = DmrgEnvError::EmptyChain;
    let child_display = child.to_string();
    let err = DmrgError::Env(child);
    assert_forwards(&err, "DMRG environment build failed", &child_display);
}

#[test]
fn dmrg_error_sweep_forwards_to_source() {
    let child = DmrgSweepError::TooFewSites { n_sites: 1 };
    let child_display = child.to_string();
    let err = DmrgError::Sweep(child);
    assert_forwards(&err, "DMRG sweep driver failed", &child_display);
}

#[test]
fn dmrg_env_error_contract_forwards_to_source() {
    let child = marker_linalg_error();
    let child_display = child.to_string();
    let err = DmrgEnvError::Contract(child);
    assert_forwards(
        &err,
        "contract failure during DMRG environment update",
        &child_display,
    );
}

#[test]
fn dmrg_heff_error_contract_forwards_to_source() {
    let child = marker_linalg_error();
    let child_display = child.to_string();
    let err = DmrgHeffError::Contract(child);
    assert_forwards(
        &err,
        "linalg failure during two-site DMRG step",
        &child_display,
    );
}

#[test]
fn dmrg_sweep_error_step_forwards_to_source() {
    let child = DmrgHeffError::InvalidSite {
        site: 0,
        n_sites: 0,
    };
    let child_display = child.to_string();
    let err = DmrgSweepError::Step {
        sweep: 0,
        direction: SweepDirection::LeftToRight,
        site: 0,
        source: child,
    };
    assert_forwards(
        &err,
        "2-site DMRG step failed at sweep 0, LeftToRight, site 0",
        &child_display,
    );
}

#[test]
fn dmrg_sweep_error_env_forwards_to_source() {
    let child = DmrgEnvError::EmptyChain;
    let child_display = child.to_string();
    let err = DmrgSweepError::Env {
        sweep: 1,
        direction: SweepDirection::RightToLeft,
        site: 2,
        source: child,
    };
    assert_forwards(
        &err,
        "DmrgEnvs advance failed at sweep 1, RightToLeft, site 2",
        &child_display,
    );
}

#[test]
fn dmrg_sweep_error_scale_forwards_to_source() {
    let child = marker_linalg_error();
    let child_display = child.to_string();
    let err = DmrgSweepError::Scale {
        sweep: 0,
        direction: SweepDirection::LeftToRight,
        site: 0,
        source: child,
    };
    assert_forwards(
        &err,
        "S-absorb (diagonal scale) failed during sweep 0, LeftToRight, site 0",
        &child_display,
    );
}