Struct QuantumReasoningModule 

pub struct QuantumReasoningModule { /* private fields */ }

Quantum reasoning module

Implementations

impl QuantumReasoningModule

pub fn new(config: QuantumReasoningConfig) -> Result<Self>

Create new quantum reasoning module

Examples found in repository

examples/quantum_llm.rs (line 226)

fn quantum_reasoning_demo() -> Result<()> {
    println!("   Testing quantum reasoning modules...");

    let reasoning_configs = vec![
        ("Basic Logical", QuantumReasoningConfig::default()),
        ("Enhanced Causal", QuantumReasoningConfig::enhanced()),
        ("Advanced Analogical", QuantumReasoningConfig::advanced()),
    ];

    for (name, config) in reasoning_configs {
        println!("\n   --- {name} Reasoning ---");

        let mut reasoning_module = QuantumReasoningModule::new(config.clone())?;

        println!("   Reasoning capabilities:");
        println!("   - Logical reasoning: {}", config.logical_reasoning);
        println!("   - Causal reasoning: {}", config.causal_reasoning);
        println!("   - Analogical reasoning: {}", config.analogical_reasoning);
        println!("   - Reasoning steps: {}", config.reasoning_steps);
        println!("   - Circuit depth: {}", config.circuit_depth);
        println!(
            "   - Entanglement strength: {:.2}",
            config.entanglement_strength
        );

        // Test reasoning on sample hidden states
        let hidden_states = Array3::from_shape_fn((2, 8, 256), |(b, s, d)| {
            // Create patterns that require reasoning
            let logical_pattern = if s % 2 == 0 { 0.8 } else { 0.2 };
            let causal_pattern = s as f64 * 0.1;
            let base_value = logical_pattern + causal_pattern;

            0.05f64.mul_add((d as f64).mul_add(0.001, b as f64), base_value)
        });

        println!("   Input hidden states shape: {:?}", hidden_states.dim());

        // Apply quantum reasoning
        let reasoned_output = reasoning_module.apply_reasoning(&hidden_states)?;
        println!("   Reasoned output shape: {:?}", reasoned_output.dim());

        // Analyze reasoning effects
        let reasoning_enhancement =
            analyze_reasoning_enhancement(&hidden_states, &reasoned_output)?;
        println!("   Reasoning enhancement metrics:");
        println!(
            "   - Pattern amplification: {:.3}",
            reasoning_enhancement.pattern_amplification
        );
        println!(
            "   - Logical consistency: {:.3}",
            reasoning_enhancement.logical_consistency
        );
        println!(
            "   - Causal coherence: {:.3}",
            reasoning_enhancement.causal_coherence
        );

        // Test quantum coherence during reasoning
        let coherence = reasoning_module.measure_coherence()?;
        println!("   Quantum coherence: {coherence:.3}");

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01f64.mul_add((i as f64 * 0.1).sin(), 0.001 * fastrand::f64())
        });

        let enhanced_logits = reasoning_module.enhance_token_selection(&sample_logits)?;
        let enhancement_effect = (&enhanced_logits - &sample_logits)
            .mapv(f64::abs)
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {enhancement_effect:.4}");
    }

    Ok(())
}

pub fn apply_reasoning( &mut self, hidden_states: &Array3<f64>, ) -> Result<Array3<f64>>

Apply quantum reasoning to transformer output

Examples found in repository

examples/quantum_llm.rs (line 252)

fn quantum_reasoning_demo() -> Result<()> {
    println!("   Testing quantum reasoning modules...");

    let reasoning_configs = vec![
        ("Basic Logical", QuantumReasoningConfig::default()),
        ("Enhanced Causal", QuantumReasoningConfig::enhanced()),
        ("Advanced Analogical", QuantumReasoningConfig::advanced()),
    ];

    for (name, config) in reasoning_configs {
        println!("\n   --- {name} Reasoning ---");

        let mut reasoning_module = QuantumReasoningModule::new(config.clone())?;

        println!("   Reasoning capabilities:");
        println!("   - Logical reasoning: {}", config.logical_reasoning);
        println!("   - Causal reasoning: {}", config.causal_reasoning);
        println!("   - Analogical reasoning: {}", config.analogical_reasoning);
        println!("   - Reasoning steps: {}", config.reasoning_steps);
        println!("   - Circuit depth: {}", config.circuit_depth);
        println!(
            "   - Entanglement strength: {:.2}",
            config.entanglement_strength
        );

        // Test reasoning on sample hidden states
        let hidden_states = Array3::from_shape_fn((2, 8, 256), |(b, s, d)| {
            // Create patterns that require reasoning
            let logical_pattern = if s % 2 == 0 { 0.8 } else { 0.2 };
            let causal_pattern = s as f64 * 0.1;
            let base_value = logical_pattern + causal_pattern;

            0.05f64.mul_add((d as f64).mul_add(0.001, b as f64), base_value)
        });

        println!("   Input hidden states shape: {:?}", hidden_states.dim());

        // Apply quantum reasoning
        let reasoned_output = reasoning_module.apply_reasoning(&hidden_states)?;
        println!("   Reasoned output shape: {:?}", reasoned_output.dim());

        // Analyze reasoning effects
        let reasoning_enhancement =
            analyze_reasoning_enhancement(&hidden_states, &reasoned_output)?;
        println!("   Reasoning enhancement metrics:");
        println!(
            "   - Pattern amplification: {:.3}",
            reasoning_enhancement.pattern_amplification
        );
        println!(
            "   - Logical consistency: {:.3}",
            reasoning_enhancement.logical_consistency
        );
        println!(
            "   - Causal coherence: {:.3}",
            reasoning_enhancement.causal_coherence
        );

        // Test quantum coherence during reasoning
        let coherence = reasoning_module.measure_coherence()?;
        println!("   Quantum coherence: {coherence:.3}");

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01f64.mul_add((i as f64 * 0.1).sin(), 0.001 * fastrand::f64())
        });

        let enhanced_logits = reasoning_module.enhance_token_selection(&sample_logits)?;
        let enhancement_effect = (&enhanced_logits - &sample_logits)
            .mapv(f64::abs)
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {enhancement_effect:.4}");
    }

    Ok(())
}

pub fn enhance_token_selection( &self, logits: &Array1<f64>, ) -> Result<Array1<f64>>

Enhance token selection with quantum reasoning

Examples found in repository

examples/quantum_llm.rs (line 281)

fn quantum_reasoning_demo() -> Result<()> {
    println!("   Testing quantum reasoning modules...");

    let reasoning_configs = vec![
        ("Basic Logical", QuantumReasoningConfig::default()),
        ("Enhanced Causal", QuantumReasoningConfig::enhanced()),
        ("Advanced Analogical", QuantumReasoningConfig::advanced()),
    ];

    for (name, config) in reasoning_configs {
        println!("\n   --- {name} Reasoning ---");

        let mut reasoning_module = QuantumReasoningModule::new(config.clone())?;

        println!("   Reasoning capabilities:");
        println!("   - Logical reasoning: {}", config.logical_reasoning);
        println!("   - Causal reasoning: {}", config.causal_reasoning);
        println!("   - Analogical reasoning: {}", config.analogical_reasoning);
        println!("   - Reasoning steps: {}", config.reasoning_steps);
        println!("   - Circuit depth: {}", config.circuit_depth);
        println!(
            "   - Entanglement strength: {:.2}",
            config.entanglement_strength
        );

        // Test reasoning on sample hidden states
        let hidden_states = Array3::from_shape_fn((2, 8, 256), |(b, s, d)| {
            // Create patterns that require reasoning
            let logical_pattern = if s % 2 == 0 { 0.8 } else { 0.2 };
            let causal_pattern = s as f64 * 0.1;
            let base_value = logical_pattern + causal_pattern;

            0.05f64.mul_add((d as f64).mul_add(0.001, b as f64), base_value)
        });

        println!("   Input hidden states shape: {:?}", hidden_states.dim());

        // Apply quantum reasoning
        let reasoned_output = reasoning_module.apply_reasoning(&hidden_states)?;
        println!("   Reasoned output shape: {:?}", reasoned_output.dim());

        // Analyze reasoning effects
        let reasoning_enhancement =
            analyze_reasoning_enhancement(&hidden_states, &reasoned_output)?;
        println!("   Reasoning enhancement metrics:");
        println!(
            "   - Pattern amplification: {:.3}",
            reasoning_enhancement.pattern_amplification
        );
        println!(
            "   - Logical consistency: {:.3}",
            reasoning_enhancement.logical_consistency
        );
        println!(
            "   - Causal coherence: {:.3}",
            reasoning_enhancement.causal_coherence
        );

        // Test quantum coherence during reasoning
        let coherence = reasoning_module.measure_coherence()?;
        println!("   Quantum coherence: {coherence:.3}");

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01f64.mul_add((i as f64 * 0.1).sin(), 0.001 * fastrand::f64())
        });

        let enhanced_logits = reasoning_module.enhance_token_selection(&sample_logits)?;
        let enhancement_effect = (&enhanced_logits - &sample_logits)
            .mapv(f64::abs)
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {enhancement_effect:.4}");
    }

    Ok(())
}

pub fn measure_coherence(&self) -> Result<f64>

Measure quantum coherence in reasoning

Examples found in repository

examples/quantum_llm.rs (line 273)

fn quantum_reasoning_demo() -> Result<()> {
    println!("   Testing quantum reasoning modules...");

    let reasoning_configs = vec![
        ("Basic Logical", QuantumReasoningConfig::default()),
        ("Enhanced Causal", QuantumReasoningConfig::enhanced()),
        ("Advanced Analogical", QuantumReasoningConfig::advanced()),
    ];

    for (name, config) in reasoning_configs {
        println!("\n   --- {name} Reasoning ---");

        let mut reasoning_module = QuantumReasoningModule::new(config.clone())?;

        println!("   Reasoning capabilities:");
        println!("   - Logical reasoning: {}", config.logical_reasoning);
        println!("   - Causal reasoning: {}", config.causal_reasoning);
        println!("   - Analogical reasoning: {}", config.analogical_reasoning);
        println!("   - Reasoning steps: {}", config.reasoning_steps);
        println!("   - Circuit depth: {}", config.circuit_depth);
        println!(
            "   - Entanglement strength: {:.2}",
            config.entanglement_strength
        );

        // Test reasoning on sample hidden states
        let hidden_states = Array3::from_shape_fn((2, 8, 256), |(b, s, d)| {
            // Create patterns that require reasoning
            let logical_pattern = if s % 2 == 0 { 0.8 } else { 0.2 };
            let causal_pattern = s as f64 * 0.1;
            let base_value = logical_pattern + causal_pattern;

            0.05f64.mul_add((d as f64).mul_add(0.001, b as f64), base_value)
        });

        println!("   Input hidden states shape: {:?}", hidden_states.dim());

        // Apply quantum reasoning
        let reasoned_output = reasoning_module.apply_reasoning(&hidden_states)?;
        println!("   Reasoned output shape: {:?}", reasoned_output.dim());

        // Analyze reasoning effects
        let reasoning_enhancement =
            analyze_reasoning_enhancement(&hidden_states, &reasoned_output)?;
        println!("   Reasoning enhancement metrics:");
        println!(
            "   - Pattern amplification: {:.3}",
            reasoning_enhancement.pattern_amplification
        );
        println!(
            "   - Logical consistency: {:.3}",
            reasoning_enhancement.logical_consistency
        );
        println!(
            "   - Causal coherence: {:.3}",
            reasoning_enhancement.causal_coherence
        );

        // Test quantum coherence during reasoning
        let coherence = reasoning_module.measure_coherence()?;
        println!("   Quantum coherence: {coherence:.3}");

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01f64.mul_add((i as f64 * 0.1).sin(), 0.001 * fastrand::f64())
        });

        let enhanced_logits = reasoning_module.enhance_token_selection(&sample_logits)?;
        let enhancement_effect = (&enhanced_logits - &sample_logits)
            .mapv(f64::abs)
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {enhancement_effect:.4}");
    }

    Ok(())
}

pub fn num_parameters(&self) -> usize

Get number of parameters

Trait Implementations

impl Clone for QuantumReasoningModule

fn clone(&self) -> QuantumReasoningModule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantumReasoningModule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.