geoit 0.0.2

//! # geoit — Exact Geometric Algebra for Rust
//!
//! A governed geometric algebra engine with exact arithmetic.
//! Zero floating-point operations. Zero dependencies.
//!
//! ## Where to Start
//!
//! **Easy path:** use [`standard_registry()`] to get a working CGA, PGA, or VGA
//! governance in one call — no manual class or construction setup.
//!
//! **Custom path:** use [`GovernanceBuilder`] to define your own geometric classes
//! with polynomial constraints, constructions, and transform rules.
//!
//! ## Quick Start
//!
//! ```
//! use geoit::*;
//! use geoit::governance;
//!
//! // One call: complete CGA(2) with classes, constructions, constraints
//! let gov = standard_registry().instantiate_family("CGA", 2).unwrap();
//! let point = gov.construct(0, &[Scalar::from(3), Scalar::from(4)]).unwrap();
//! let geoit = governance::govern(&point, &gov, 0).unwrap();
//! assert!(geoit.is_satisfied());
//! ```
//!
//! ## Custom Governance
//!
//! ```
//! use geoit::*;
//! use geoit::governance::expr::Expr;
//!
//! let alg = Algebra::new(Signature::new(0, 0, 3).unwrap());
//! let class = GeomClassBuilder::new(&alg).grades(&[1]).build();
//! let body = Expr::Add(
//!     Expr::add(Expr::mul(Expr::param(0), Expr::gen(0)),
//!               Expr::mul(Expr::param(1), Expr::gen(1))),
//!     Expr::mul(Expr::param(2), Expr::gen(2)),
//! );
//! let gov = GovernanceBuilder::new(alg)
//!     .class("Vector", class)
//!     .construction("Vector", "Vector", 3, body)
//!     .build();
//!
//! let p = gov.construct("Vector", &[Scalar::from(3), Scalar::from(4), Scalar::from(5)]).unwrap();
//! let g = gov.govern(&p, "Vector").unwrap();
//! assert!(g.is_satisfied());
//! assert_eq!(g.read_all().unwrap(), vec![Scalar::from(3), Scalar::from(4), Scalar::from(5)]);
//! ```
//!
//! ## Five-Layer Architecture
//!
//! 1. **[`Scalar`]** / **[`Rat`]** — exact arithmetic (ℚ → BigRat → radical extensions)
//! 2. **[`Signature`]** — define the algebra: `Signature::new(1, 0, 3)?` for CGA(2)
//! 3. **[`Mv`]** — sparse multivectors with exact coefficients
//! 4. **[`Governance`]** — polynomial constraints, constructions, transform rules
//! 5. **[`Geoit`]** — certified multivector with proof, profile, and readings

pub mod algebra;
pub mod builder;
pub mod codec;
pub mod error;
pub mod governance;
pub mod scalar;

// ─── Public re-exports ───

// Layer 1: Signature
pub use algebra::signature::Signature;

// Layer 2: Governance
pub use governance::field::FieldOp;
pub use governance::governance::Governance;
pub use governance::phase::Phase;

// v0.0.2: Governance composition
pub use governance::category::{GovernanceCategory, GovernedMorphism};
pub use governance::compile::{compile_field_eval_from_construction, partial_eval_expr, PartialMv};
pub use governance::compile::{CompiledFieldEval, IntPoly};
pub use governance::family::{standard_registry, GovernanceFamily, GovernanceRegistry};
pub use governance::pencil::{
    build_full_hierarchy, classify_pencil, is_pencil_constructible, pencil_levels_to_rules,
    PencilType,
};
pub use governance::profile::GeneratorProfile;
pub use governance::rule::{ProofTerm, TransformOp, TransformRule};

// Layer 3: Mv
pub use algebra::blade_new::{BladeKey, BladeMask};
pub use algebra::mv::Mv;
pub use scalar::{Coeff, Rat, Scalar};

// Layer 4: Geoit
pub use governance::geoit::Geoit;
pub use governance::geoit::GeoitSnapshot;

// Builder API
pub use builder::{Algebra, GeomClassBuilder, GovernanceBuilder, NamedGovernance};

// Error types
pub use error::{Error, NotFoundError, SignatureError};

// ─── Send + Sync assertions ───

#[cfg(test)]
mod send_sync {
    fn assert_send<T: Send>() {}
    fn assert_sync<T: Sync>() {}

    #[test]
    fn public_types_are_send_sync() {
        assert_send::<super::Signature>();
        assert_sync::<super::Signature>();
        assert_send::<super::Governance>();
        assert_sync::<super::Governance>();
        assert_send::<super::Mv>();
        assert_sync::<super::Mv>();
        assert_send::<super::Geoit>();
        assert_sync::<super::Geoit>();
        assert_send::<super::GeoitSnapshot>();
        assert_sync::<super::GeoitSnapshot>();
        assert_send::<super::Scalar>();
        assert_sync::<super::Scalar>();
        assert_send::<super::Rat>();
        assert_sync::<super::Rat>();
        assert_send::<super::Coeff>();
        assert_sync::<super::Coeff>();
        assert_send::<super::Phase>();
        assert_sync::<super::Phase>();
        assert_send::<super::FieldOp>();
        assert_sync::<super::FieldOp>();
        assert_send::<super::Algebra>();
        assert_sync::<super::Algebra>();
        assert_send::<super::NamedGovernance>();
        assert_sync::<super::NamedGovernance>();
        assert_send::<super::Error>();
        assert_sync::<super::Error>();
        // v0.0.2 types
        assert_send::<super::GeneratorProfile>();
        assert_sync::<super::GeneratorProfile>();
        assert_send::<super::TransformRule>();
        assert_sync::<super::TransformRule>();
        assert_send::<super::GovernanceCategory>();
        assert_sync::<super::GovernanceCategory>();
        assert_send::<super::GovernanceRegistry>();
        assert_sync::<super::GovernanceRegistry>();
        assert_send::<super::CompiledFieldEval>();
        assert_sync::<super::CompiledFieldEval>();
    }
}