spectral_vm 0.1.6

HYPERION: Production-ready zero-knowledge virtual machine with spectral analysis
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

/*
 * ═══════════════════════════════════════════════════════════════════════════
 * HYPERION: Sovereign-Class Spectral ZK-VM
 * ═══════════════════════════════════════════════════════════════════════════
 *
 * A high-performance, bit-level provable virtual machine utilizing
 * Hypercube Spectral Analysis and Walsh-Hadamard Transforms.
 *
 * TECHNICAL SUMMARY:
 * - Field: Goldilocks (2^64 - 2^32 + 1) — zero-cost modular arithmetic
 * - Transform: Fast Walsh-Hadamard (O(n log n) Time ↔ Spectral)
 * - Arithmetization: Boolean Hypercube signal processing (polynomial-less)
 * - Constraints: Dyadic Convolution Theorem & Spectral Idempotence
 * - Soundness: Strict Spectral Folding & Fiat-Shamir Transcript
 *
 * SOVEREIGN PARADIGM:
 * - Spectral Integrity: x² = x for all hypercube signals (Booleanity)
 * - Hypercube Compaction: No polynomial interpolation—spectral compression only
 * - Dyadic Convolution: All logic verified in frequency domain
 * ═══════════════════════════════════════════════════════════════════════════
 */

// ═══════════════════════════════════════════════════════════════════════════
// SOVEREIGN MODULES
// ═══════════════════════════════════════════════════════════════════════════

/// Comprehensive error types for all operations.
pub mod error;
/// Attestation generation and verification (proof system).
pub mod attestor;
/// Security Audit (Soundness Quantification).
pub mod audit;
/// Circuit Compilation & Optimization Pipeline.
pub mod compiler;
/// High-level Circuit Compiler (Source → S-RISC).
pub mod circuit_compiler;
/// LLVM/MLIR Integration (Clang/Rust Frontend → Spectral IR).
#[cfg(feature = "llvm")]
pub mod llvm_integration;
/// Spectral constraint verification (AND, XOR, Selection, Booleanity).
pub mod constraints;
/// Goldilocks field arithmetic (2^64 - 2^32 + 1).
pub mod field;
/// Spectral folding engine (IOPP-based compaction).
pub mod folding;
/// Fast Reed-Solomon Interactive Oracle Proofs (FRI).
pub mod fri;
/// Reed-Solomon Error-Correcting Codes for FRI.
pub mod reed_solomon;
/// Memory Pool Allocator for Large FRI Operations.
pub mod memory_pool;
/// Configuration Management (TOML + Environment Variables).
pub mod config;
/// Formal Cryptographic Specification & Security Audit.
pub mod cryptographic_specification;
/// Fast Walsh-Hadamard Transform (Time ↔ Spectral bridge).
pub mod fwht;
/// Parallel Merkle tree commitment layer.
pub mod merkle;
/// Zero-knowledge privacy via FRI-aware entropy shielding.
pub mod privacy;
/// Spectral signals and manifolds (hypercube data structures).
pub mod signal;
/// Fiat-Shamir transcript (random oracle model).
pub mod transcript;
/// Sovereign Virtual Machine (Wave-Execution Engine).
pub mod vm;

// ═══════════════════════════════════════════════════════════════════════════
// HARDWARE-ALIGNED MODULES
// ═══════════════════════════════════════════════════════════════════════════

/// 64-bit Spectral ALU (adders, multipliers, shifters).
pub mod alu;
/// 1-bit atomic arithmetic primitives (full-adder, full-subtractor).
pub mod byte;

// ═══════════════════════════════════════════════════════════════════════════
// BACKWARD COMPATIBILITY (Deprecated, remove in v2.0)
// ═══════════════════════════════════════════════════════════════════════════

#[deprecated(note = "Use attestor module instead")]
pub mod snark {
    pub use crate::attestor::*;
    // Additional type aliases for complete backward compatibility
    #[deprecated(note = "Use SpectralPathAttestation instead")]
    pub type PathProof = crate::attestor::SpectralPathAttestation;
    #[deprecated(note = "Use FoldingLayerEvidence instead")]
    pub type LayerQuery = crate::attestor::FoldingLayerEvidence;
}

#[deprecated(note = "Use constraints module instead")]
pub mod gates {
    pub use crate::constraints::*;
}

#[deprecated(note = "Use fri module for FRI protocol, folding module for basic spectral folding")]
pub mod spectral_fri {
    pub use crate::folding::*;
}

#[deprecated(note = "Use signal module instead")]
pub mod tensor {
    pub use crate::signal::*;
}