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

//! `public_api` example (P367).
//!
//! The canonical "this is the supported entry point" reference.
//! Walks the public Tokitai facade (`Tokitai::cpu_only()`,
//! `plan_public`, `execute_i64`, `plan_padic_sum_products`,
//! `plan_sheaf_glue_check`, `verify_sheaf_glue`, `audit_report`)
//! and prints the return type of each. New contributors should
//! start here before reaching into the 8 internal layers.
//!
//! Run with:
//!   cargo run --offline --example public_api

use tokitai_operator::backend::TensorStore;
use tokitai_operator::backend::hardware::DeviceKind;
use tokitai_operator::domain::Domain;
use tokitai_operator::facade::{AuditExportFormat, Tokitai};
use tokitai_operator::object::Shape;
use tokitai_operator::object::Tensor;
use tokitai_operator::object::sheaf::{Cover, FiniteSite, Inclusion, OpenId, SectionTable};

fn main() -> tokitai_operator::Result<()> {
    let cpu = Tokitai::cpu_only();
    let q5 = cpu.padic_domain(5, 3)?;
    let padic_plan = cpu.plan_padic_sum_products(&q5, 0, 1, 2)?;
    let mut store = TensorStore::new();
    store.insert(
        0,
        Tensor::dense_cpu(
            q5.id(),
            Shape::from(vec![4]),
            vec![q5.element(1), q5.element(25), q5.element(5), q5.element(2)],
        ),
    );
    store.insert(
        1,
        Tensor::dense_cpu(
            q5.id(),
            Shape::from(vec![4]),
            vec![q5.element(2), q5.element(5), q5.element(25), q5.element(3)],
        ),
    );
    let report = cpu.execute_padic_sum_products(&padic_plan, &mut store)?;
    println!(
        "padic selected={:?} skipped={} evaluated={}",
        padic_plan.selected_target.kind, report.skipped_terms, report.evaluated_terms
    );

    let prefer_gpu = Tokitai::prefer_gpu_with_cpu_fallback();
    let fallback_plan = prefer_gpu.plan_padic_sum_products(&q5, 0, 1, 2)?;
    println!(
        "prefer-gpu requested={:?} selected={:?} fallback={}",
        fallback_plan.requested_target.kind,
        fallback_plan.selected_target.kind,
        fallback_plan.fallback_reason.as_deref().unwrap_or("none")
    );

    let strict_gpu = Tokitai::strict_gpu();
    let strict_error = strict_gpu
        .plan_padic_sum_products(&q5, 0, 1, 2)
        .unwrap_err();
    println!("strict-gpu rejected={strict_error}");

    let cover = Cover::new("U", ["A", "B"]);
    let sheaf_plan = cpu.plan_sheaf_glue_check(&cover)?;
    let site = FiniteSite::new(
        vec![open("U"), open("A"), open("B"), open("A_cap_B")],
        vec![
            Inclusion::new("A", "U"),
            Inclusion::new("B", "U"),
            Inclusion::new("A_cap_B", "A"),
            Inclusion::new("A_cap_B", "B"),
            Inclusion::new("A_cap_B", "U"),
        ],
    )
    .with_intersection(open("A"), open("B"), open("A_cap_B"));
    let mut sections = SectionTable::new();
    sections.insert(open("A"), 7);
    sections.insert(open("B"), 7);
    sections.insert(open("A_cap_B"), 7);
    let glued = cpu.verify_sheaf_glue(&sheaf_plan, &site, &cover, &sections, 42)?;
    println!(
        "sheaf selected={:?} glued_open={} glued_value={}",
        sheaf_plan.selected_target.kind, glued.open.0, glued.value
    );

    let audit_json = cpu.export_audit(&padic_plan.plan, AuditExportFormat::Json);
    println!(
        "audit_json_contains_math_bound={}",
        audit_json.contains("math_bound")
    );
    assert_eq!(fallback_plan.selected_target.kind, DeviceKind::Cpu);
    Ok(())
}

fn open(id: &str) -> OpenId {
    OpenId(id.to_string())
}