Struct QuantumReasoningConfig 

pub struct QuantumReasoningConfig {
    pub logical_reasoning: bool,
    pub causal_reasoning: bool,
    pub analogical_reasoning: bool,
    pub reasoning_steps: usize,
    pub circuit_depth: usize,
    pub entanglement_strength: f64,
}

Quantum reasoning configuration

Fields

logical_reasoning: bool

Enable quantum logical reasoning

causal_reasoning: bool

Enable quantum causal reasoning

analogical_reasoning: bool

Enable quantum analogical reasoning

reasoning_steps: usize

Number of reasoning steps

circuit_depth: usize

Reasoning circuit depth

entanglement_strength: f64

Quantum entanglement strength for reasoning

Implementations

impl QuantumReasoningConfig

pub fn default() -> Self

Default reasoning configuration

Examples found in repository

examples/quantum_llm.rs (line 209)

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   --- {} Reasoning ---", name);

        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;

            base_value + 0.05 * (b as f64 + d as f64 * 0.001)
        });

        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: {:.3}", coherence);

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01 * (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(|x| x.abs())
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {:.4}", enhancement_effect);
    }

    Ok(())
}

pub fn enhanced() -> Self

Enhanced reasoning configuration

Examples found in repository

examples/quantum_llm.rs (line 210)

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   --- {} Reasoning ---", name);

        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;

            base_value + 0.05 * (b as f64 + d as f64 * 0.001)
        });

        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: {:.3}", coherence);

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01 * (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(|x| x.abs())
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {:.4}", enhancement_effect);
    }

    Ok(())
}

pub fn advanced() -> Self

Advanced reasoning configuration

Examples found in repository

examples/quantum_llm.rs (line 211)

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   --- {} Reasoning ---", name);

        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;

            base_value + 0.05 * (b as f64 + d as f64 * 0.001)
        });

        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: {:.3}", coherence);

        // Test token selection enhancement
        let sample_logits = Array1::from_shape_fn(1000, |i| {
            0.01 * (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(|x| x.abs())
            .mean()
            .unwrap_or(0.0);
        println!("   Token selection enhancement: {:.4}", enhancement_effect);
    }

    Ok(())
}

Trait Implementations

impl Clone for QuantumReasoningConfig

fn clone(&self) -> QuantumReasoningConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumReasoningConfig

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

Formats the value using the given formatter.