tokitai-operator 0.1.0

Verified DL kernel compiler: formally-checked GEMM, p-adic, sheaf, contract-carrying ops. Paper-artifact grade.
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

use tokitai_operator::domain::{Padic, PadicDomain};
use tokitai_operator::object::{Dim, Shape, Tensor};

#[test]
fn dim_display_covers_all_variants() {
    assert_eq!(Dim::Static(3).to_string(), "3");
    assert_eq!(Dim::Symbolic("N".to_string()).to_string(), "N");
    assert_eq!(
        Dim::Bounded {
            name: "K".to_string(),
            min: 1,
            max: 8
        }
        .to_string(),
        "K∈[1..8]"
    );
    assert_eq!(
        Dim::DataDependent("batch".to_string()).to_string(),
        "batch?"
    );
}

#[test]
fn shape_display_handles_scalar_and_n_dimensions() {
    let scalar = Shape::scalar();
    assert_eq!(scalar.to_string(), "scalar");

    let one_d = Shape::from(vec![4usize]);
    assert_eq!(one_d.to_string(), "[4]");

    let two_d = Shape::from(vec![2usize, 3]);
    assert_eq!(two_d.to_string(), "[2, 3]");

    let mixed = Shape::new(vec![
        Dim::Symbolic("M".to_string()),
        Dim::Bounded {
            name: "K".to_string(),
            min: 1,
            max: 8,
        },
        Dim::Static(7),
    ]);
    assert_eq!(mixed.to_string(), "[M, K∈[1..8], 7]");
}

#[test]
fn tensor_display_handles_scalar_1d_and_high_rank() {
    let scalar_int = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("integer"),
        Shape::scalar(),
        vec![42_i64],
    );
    assert_eq!(scalar_int.to_string(), "42");

    let vec_int = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("integer"),
        Shape::from(vec![3usize]),
        vec![1_i64, 2, 3],
    );
    assert_eq!(vec_int.to_string(), "[1, 2, 3]");

    let mat_int = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("integer"),
        Shape::from(vec![2usize, 2]),
        vec![1_i64, 2, 3, 4],
    );
    let mat_str = mat_int.to_string();
    // The high-rank Display prints a header containing shape and length.
    assert!(mat_str.contains("Tensor<i64>"), "{mat_str}");
    assert!(mat_str.contains("shape=[2, 2]"), "{mat_str}");
    assert!(mat_str.contains("len=4"), "{mat_str}");
}

#[test]
fn tensor_display_works_for_padic_values() {
    let q5 = PadicDomain::new(5, 3).expect("5 must be a valid prime");
    let p1 = q5.element(7);
    let p2 = q5.element(42);
    let padic_vec = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("Q_5[3]"),
        Shape::from(vec![2usize]),
        vec![p1, p2],
    );
    // The Display output is non-empty and contains the values.
    let rendered = padic_vec.to_string();
    assert!(rendered.starts_with("["), "{rendered}");
    assert!(rendered.ends_with("]"), "{rendered}");
    assert!(rendered.contains("7"), "{rendered}");
    assert!(rendered.contains("42"), "{rendered}");
}

#[test]
fn display_impls_do_not_break_existing_equality() {
    // Sanity: Display is purely additive, not altering PartialEq/Eq semantics.
    let s1 = Shape::from(vec![2usize, 2]);
    let s2 = Shape::from(vec![2usize, 2]);
    assert_eq!(s1, s2);
    assert_eq!(s1.to_string(), s2.to_string());

    let t1 = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("integer"),
        Shape::from(vec![3usize]),
        vec![10_i64, 20, 30],
    );
    let t2 = Tensor::dense_cpu(
        tokitai_operator::domain::DomainId::new("integer"),
        Shape::from(vec![3usize]),
        vec![10_i64, 20, 30],
    );
    assert_eq!(t1, t2);
    assert_eq!(t1.to_string(), t2.to_string());
}