Skip to main content

Crate tensorlogic_compiler

Crate tensorlogic_compiler 

Source
Expand description

TLExpr → EinsumGraph compiler (planning only).

Version: 0.1.0-beta.1 | Status: Production Ready

This crate compiles logical expressions into tensor computation graphs represented as einsum operations. It provides a bridge between symbolic logic and numeric tensor computations.

§Overview

The tensorlogic-compiler translates high-level logical expressions (predicates, quantifiers, implications) into low-level tensor operations that can be executed efficiently on various backends (CPU, GPU, etc.).

Key Features:

  • Logic-to-tensor mapping with configurable strategies
  • Type checking and scope analysis
  • Optimization passes (negation, CSE, einsum optimization)
  • Enhanced diagnostics with helpful error messages
  • Support for arithmetic, comparison, and conditional expressions

§Quick Start

use tensorlogic_compiler::{compile_to_einsum_with_context, CompilerContext};
use tensorlogic_ir::{TLExpr, Term};

let mut ctx = CompilerContext::new();
ctx.add_domain("Person", 100);

// Define a logic rule: ∃y. knows(x, y)
// "Find all persons x who know someone"
let rule = TLExpr::exists(
    "y",
    "Person",
    TLExpr::pred("knows", vec![Term::var("x"), Term::var("y")]),
);

// Compile to tensor operations
let graph = compile_to_einsum_with_context(&rule, &mut ctx).unwrap();

§Compilation Pipeline

The compiler follows a multi-stage pipeline:

  1. Pre-compilation passes:

    • Scope analysis (detect unbound variables)
    • Type checking (validate predicate arity and types)
    • Expression optimization (negation optimization, CSE)

  2. Compilation:

    • Variable axis assignment
    • Logic-to-tensor mapping (using configurable strategies)
    • Einsum graph construction

  3. Post-compilation passes:

    • Dead code elimination
    • Einsum operation merging
    • Identity elimination

§Modules

  • config: Compilation configuration and strategy selection
  • optimize: Expression-level optimization passes
  • passes: Analysis and validation passes

§Examples

§Basic Predicate Compilation

use tensorlogic_compiler::compile_to_einsum;
use tensorlogic_ir::{TLExpr, Term};

let expr = TLExpr::pred("knows", vec![Term::var("x"), Term::var("y")]);
let graph = compile_to_einsum(&expr).unwrap();

§Compilation with Context

use tensorlogic_compiler::{compile_to_einsum_with_context, CompilerContext};
use tensorlogic_ir::{TLExpr, Term};

let mut ctx = CompilerContext::new();
ctx.add_domain("Person", 100);

let expr = TLExpr::exists(
    "y",
    "Person",
    TLExpr::pred("knows", vec![Term::var("x"), Term::var("y")]),
);

let graph = compile_to_einsum_with_context(&expr, &mut ctx).unwrap();

§Using Optimization Passes

use tensorlogic_compiler::optimize::{OptimizationPipeline, PipelineConfig};
use tensorlogic_ir::{TLExpr, Term};

let pipeline = OptimizationPipeline::new();
let expr = TLExpr::add(
    TLExpr::mul(TLExpr::Constant(2.0), TLExpr::Constant(3.0)),
    TLExpr::Constant(0.0)
);
let (optimized, stats) = pipeline.optimize(&expr);
println!("Applied {} optimizations", stats.total_optimizations());

§Individual Passes

use tensorlogic_compiler::optimize::optimize_negations;
use tensorlogic_ir::{TLExpr, Term};

let expr = TLExpr::negate(TLExpr::negate(
    TLExpr::pred("p", vec![Term::var("x")])
));

let (optimized, stats) = optimize_negations(&expr);
assert_eq!(stats.double_negations_eliminated, 1);

Re-exports§

pub use cache::CacheStats;
pub use cache::CompilationCache;
pub use config::AndStrategy;
pub use config::CompilationConfig;
pub use config::CompilationConfigBuilder;
pub use config::ExistsStrategy;
pub use config::ForallStrategy;
pub use config::ImplicationStrategy;
pub use config::ModalStrategy;
pub use config::NotStrategy;
pub use config::OrStrategy;
pub use config::TemporalStrategy;
pub use passes::validate_arity;

Modules§

cache
Compilation caching for improved performance.
compile
Core compilation functions for TLExpr → EinsumGraph.
config
Compilation configuration and strategy selection.
debug
Debug utilities for tracing compilation.
export
Export compiled TensorLogic graphs to various formats.
import
Logic Expression Import
incremental
Incremental compilation for efficient recompilation when expressions change.
optimize
Expression optimization passes.
passes
Compiler passes (validation, optimization, etc.).
profiling
Compilation profiling and performance tracking.

Structs§

CompilerContext
Compiler context for managing compilation state.
DomainInfo
Domain information including cardinality and optional element enumeration
PredicateInfo
Predicate metadata including arity and domain types
SymbolTable
Symbol table containing all domain, predicate, and variable information

Functions§

compile_to_einsum
Compile a TLExpr into an EinsumGraph with an empty context.
compile_to_einsum_with_config
Compile a TLExpr into an EinsumGraph with a custom compilation configuration.
compile_to_einsum_with_context
Compile a TLExpr into an EinsumGraph with an existing context.