Crate tensorlogic_compiler 

TLExpr → EinsumGraph compiler (planning only).

Version: 0.1.0 | 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

Unified Pipeline (Recommended)

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::CachedResult;

pub use cache::CachingCompiler;

pub use cache::CompilationCache;

pub use cache::ExprFingerprint;

pub use cache::LruCompilationCache;

pub use complexity::check_complexity;

pub use complexity::BatchComplexityStats;

pub use complexity::ComplexityComparison;

pub use complexity::ComplexityThresholds;

pub use complexity::ComplexityWarning;

pub use complexity::ExprComplexity;

pub use complexity::WarningSeverity;

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 const_prop::ConstPropConfig;

pub use const_prop::ConstPropStats;

pub use const_prop::ConstantPropagator;

pub use dead_code::DceConfig;

pub use dead_code::DceStats;

pub use dead_code::DeadCodeEliminator;

pub use error_recovery::compile_tolerant;

pub use error_recovery::compile_tolerant_with_strategy;

pub use error_recovery::Diagnostic;

pub use error_recovery::DiagnosticCollector;

pub use error_recovery::PartialCompilationResult;

pub use error_recovery::RecoveryAction;

pub use error_recovery::RecoveryStrategy;

pub use error_recovery::Severity;

pub use error_recovery::SourceSpan;

pub use error_recovery::TolerantCompiler;

pub use expr_diff::expr_diff;

pub use expr_diff::DiffEntry;

pub use expr_diff::DiffKind;

pub use expr_diff::ExprDiff;

pub use inline::InlineConfig;

pub use inline::InlineStats;

pub use inline::LetInliner;

pub use jit::JitCompiler;

pub use jit::JitError;

pub use jit::JitStats;

pub use partial_eval::partially_evaluate;

pub use partial_eval::specialize;

pub use partial_eval::specialize_batch;

pub use partial_eval::PEConfig;

pub use partial_eval::PEEnv;

pub use partial_eval::PEResult;

pub use partial_eval::PEStats;

pub use partial_eval::PEValue;

pub use pipeline::CompilerPassId;

pub use pipeline::CompilerPassOrder;

pub use pipeline::CompilerPassStats;

pub use pipeline::CompilerPipeline;

pub use pipeline::CompilerPipelineConfig;

pub use pipeline::CompilerPipelineResult;

pub use pipeline::CompilerPipelineStats;

pub use pipeline::PassBenchmark;

pub use profiling::profile_phase;

pub use profiling::CompilationProfiler;

pub use profiling::ProfileEntry;

pub use profiling::ProfileReport;

pub use rewrite::builtin_rules;

pub use rewrite::EliminateAndTrue;

pub use rewrite::EliminateDoubleNeg;

pub use rewrite::EliminateOrFalse;

pub use rewrite::FlattenNestedAnd;

pub use rewrite::FlattenNestedOr;

pub use rewrite::RewriteEngine;

pub use rewrite::RewriteRule;

pub use rewrite::RewriteStats;

pub use symbolic_diff::differentiate;

pub use symbolic_diff::jacobian;

pub use symbolic_diff::simplify_derivative;

pub use symbolic_diff::DiffConfig;

pub use symbolic_diff::DiffError;

pub use symbolic_diff::DiffResult;

pub use type_infer::annotate;

pub use type_infer::infer_type;

pub use type_infer::Substitution as TypeSubstitution;

pub use type_infer::TLType;

pub use type_infer::TyVarCounter;

pub use type_infer::TypeEnv;

pub use type_infer::TypeInferError;

pub use type_infer::TypeInferResult;

pub use type_infer::TypedExpr;

pub use passes::validate_arity;

pub use bytecode::compile;

pub use bytecode::compile_with_config;

pub use bytecode::execute;

pub use bytecode::execute_with_stats;

pub use bytecode::BytecodeProgram;

pub use bytecode::CompileError;

pub use bytecode::Instruction;

pub use bytecode::VmEnv;

pub use bytecode::VmError;

pub use bytecode::VmStats;

pub use bytecode::VmValue;

Modules

bytecode

Stack-based bytecode VM for TensorLogic expressions.

cache

Compilation cache for TensorLogic expressions.

compile

Core compilation functions for TLExpr → EinsumGraph.

complexity

Expression complexity analysis for TLExpr trees.

config

Compilation configuration and strategy selection.

const_prop

Constant Propagation pass for TLExpr trees.

dead_code

Dead-code elimination pass.

debug

Debug utilities for tracing compilation.

error_recovery

Partial error recovery for multi-expression compilation.

export

Export compiled TensorLogic graphs to various formats.

expr_diff

Structural diff between two TLExpr trees.

import

Logic Expression Import

incremental

Incremental compilation for efficient recompilation when expressions change.

inline

Let-Inlining pass for TLExpr trees.

jit

JIT compilation for hot expression paths.

optimize

Expression optimization passes.

partial_eval

Partial evaluation / expression specialization for TLExpr.

passes

Compiler passes (validation, optimization, etc.).

pipeline

Full compiler optimization pipeline for TLExpr expressions.

profiling

Compilation profiling: track time and resource usage across phases.

rewrite

Pattern-matching rewrite rules engine for TLExpr transformation.

symbolic_diff

Symbolic differentiation of TLExpr.

type_infer

Unification-based type inference for TLExpr subexpressions.

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.