Enum DynamicCircuit 

pub enum DynamicCircuit {
    Circuit1(Circuit<1>),
    Circuit2(Circuit<2>),
    Circuit4(Circuit<4>),
    Circuit8(Circuit<8>),
    Circuit16(Circuit<16>),
    Circuit32(Circuit<32>),
    Circuit64(Circuit<64>),
}

Dynamic circuit representation for trait objects

Variants

Circuit1(Circuit<1>)

Circuit2(Circuit<2>)

Circuit4(Circuit<4>)

Circuit8(Circuit<8>)

Circuit16(Circuit<16>)

Circuit32(Circuit<32>)

Circuit64(Circuit<64>)

Implementations

impl DynamicCircuit

pub fn from_circuit<const N: usize>(circuit: Circuit<N>) -> Result<Self>

Create from a generic circuit

Examples found in repository

examples/tensorflow_quantum_demo.rs (line 182)

fn main() -> Result<()> {
    println!("=== TensorFlow Quantum Compatibility Demo ===\n");

    // Step 1: Create TFQ-style quantum circuits
    println!("1. Creating TensorFlow Quantum style circuits...");

    let (circuits, circuit_symbols) = create_tfq_circuits()?;
    println!(
        "   - Created {} parameterized quantum circuits",
        circuits.len()
    );
    println!("   - Circuit symbols: {:?}", circuit_symbols);

    // Step 2: Build TFQ-style model with PQC layers
    println!("\n2. Building TFQ-compatible model...");

    let mut model = TFQModel::new(vec![4, 1]); // input_shape: [batch_size, features]

    // Add quantum circuit layer (equivalent to tfq.layers.PQC)
    // Note: QuantumCircuitLayer does not implement TFQLayer in current API
    // model.add_layer(Box::new(QuantumCircuitLayer::new(
    //     circuits[0].clone(),
    //     circuit_symbols.clone(),
    //     Observable::PauliZ(vec![0]),
    //     Arc::new(StatevectorBackend::new(8))
    // )));
    println!("   - Quantum circuit layer placeholder added");

    // Add classical preprocessing layer
    // Note: TFQDenseLayer not implemented in current API
    // model.add_layer(Box::new(TFQDenseLayer::new(
    //     4, 8,
    //     ActivationFunction::ReLU,
    //     ParameterInitStrategy::XavierUniform
    // )?));

    // Add PQC layer with different observable
    // Note: PQCLayer not implemented in current API
    // model.add_layer(Box::new(PQCLayer::new(
    //     circuits[1].clone(),
    //     Observable::PauliZ(vec![1]),
    //     RegularizationType::L2(0.01)
    // )?));

    // Add quantum convolutional layer
    // Note: QuantumConvolutionalLayer not implemented in current API
    // model.add_layer(Box::new(QuantumConvolutionalLayer::new(
    //     circuits[2].clone(),
    //     (2, 2), // kernel_size
    //     PaddingType::Valid,
    //     2       // stride
    // )?));

    // Final output layer
    // Note: TFQDenseLayer not implemented in current API
    // model.add_layer(Box::new(TFQDenseLayer::new(
    //     8, 2,
    //     ActivationFunction::Softmax,
    //     ParameterInitStrategy::HeNormal
    // )?));

    println!("   Model architecture:");
    // model.summary(); // Not implemented in current API

    // Step 3: Create TFQ-style quantum dataset
    println!("\n3. Creating TensorFlow Quantum dataset...");

    let quantum_dataset = create_tfq_quantum_dataset()?;
    // println!("   - Dataset size: {}", quantum_dataset.size());
    // println!("   - Data encoding: {:?}", quantum_dataset.encoding_type());
    // println!("   - Batch size: {}", quantum_dataset.batch_size());
    println!("   - Quantum dataset created successfully");

    // Step 4: Configure TFQ-style training
    println!("\n4. Configuring TFQ training setup...");

    let optimizer = TFQOptimizer::Adam {
        learning_rate: 0.001,
        beta1: 0.9,
        beta2: 0.999,
        epsilon: 1e-7,
    };

    let loss_function = TFQLossFunction::CategoricalCrossentropy;

    model.compile()?;

    println!("   - Optimizer: Adam");
    println!("   - Loss: Sparse Categorical Crossentropy");
    println!("   - Metrics: Accuracy, Precision, Recall");

    // Step 5: Train with TFQ-style fit method
    println!("\n5. Training with TensorFlow Quantum style...");

    // Note: fit method not fully implemented in current API
    // let history = model.fit(
    //     &quantum_dataset,
    //     15,    // epochs
    //     0.2,   // validation_split
    //     1,     // verbose
    //     vec![
    //         Box::new(EarlyStoppingCallback::new(3, "val_loss")),      // patience, monitor
    //         Box::new(ReduceLROnPlateauCallback::new(0.5, 2)),         // factor, patience
    //     ]
    // )?;
    println!("   Training setup configured (fit method placeholder)");

    // println!("   Training completed!");
    // println!("   - Final training accuracy: {:.3}", history.final_metric("accuracy"));
    // println!("   - Final validation accuracy: {:.3}", history.final_metric("val_accuracy"));
    // println!("   - Best epoch: {}", history.best_epoch());
    println!("   Training placeholder completed");

    // Step 6: Evaluate model performance
    println!("\n6. Model evaluation...");

    let test_dataset = create_tfq_test_dataset()?;
    // let evaluation_results = model.evaluate(&test_dataset, 1)?;  // verbose
    //
    // println!("   Test Results:");
    // for (metric, value) in evaluation_results.iter() {
    //     println!("   - {}: {:.4}", metric, value);
    // }
    println!("   Test dataset created successfully");

    // Step 7: Quantum circuit analysis
    println!("\n7. Quantum circuit analysis...");

    // let circuit_analysis = model.analyze_quantum_circuits()?;
    // println!("   Circuit Properties:");
    // println!("   - Total quantum parameters: {}", circuit_analysis.total_quantum_params);
    // println!("   - Circuit depth: {}", circuit_analysis.max_circuit_depth);
    // println!("   - Gate types used: {:?}", circuit_analysis.gate_types);
    // println!("   - Entangling gates: {}", circuit_analysis.entangling_gate_count);
    println!("   Circuit analysis placeholder completed");

    // Step 8: Parameter shift gradients (TFQ-style)
    println!("\n8. Computing parameter shift gradients...");

    // let sample_input = quantum_dataset.get_batch(0)?;
    // let gradients = model.compute_parameter_shift_gradients(&sample_input)?;
    println!("   Parameter shift gradients placeholder");

    // println!("   Gradient Analysis:");
    // println!("   - Quantum gradients computed: {}", gradients.quantum_gradients.len());
    // println!("   - Classical gradients computed: {}", gradients.classical_gradients.len());
    // println!("   - Max quantum gradient: {:.6}",
    //     gradients.quantum_gradients.iter().fold(0.0f64, |a, &b| a.max(b.abs())));
    // println!("   - Gradient variance: {:.6}",
    //     compute_gradient_variance(&gradients.quantum_gradients));
    println!("   Gradient analysis placeholder completed");

    // Step 9: Quantum expectation values
    println!("\n9. Computing quantum expectation values...");

    let observables = vec![Observable::PauliZ(vec![0]), Observable::PauliZ(vec![1])];

    // let expectation_values = model.compute_expectation_values(&sample_input, &observables)?;
    // println!("   Expectation Values:");
    // for (i, (obs, val)) in observables.iter().zip(expectation_values.iter()).enumerate() {
    //     println!("   - Observable {}: {:.4}", i, val);
    // }
    println!("   Expectation values placeholder completed");

    // Step 10: TFQ utils demonstrations
    println!("\n10. TensorFlow Quantum utilities...");

    // Circuit conversion
    let dynamic_circuit = DynamicCircuit::from_circuit(circuits[0].clone())?;
    let tfq_format_circuit = tfq_utils::circuit_to_tfq_format(&dynamic_circuit)?;
    println!("    - Converted circuit to TFQ format (placeholder)");

    // Batch circuit execution
    // let batch_circuits = vec![circuits[0].clone(), circuits[1].clone()];
    // let batch_params = Array2::from_shape_fn((2, 4), |(i, j)| (i + j) as f64 * 0.1);
    // let batch_results = tfq_utils::batch_execute_circuits(&batch_circuits, &batch_params, &observables, &backend)?;
    // println!("    - Batch execution results shape: {:?}", batch_results.dim());
    println!("    - Batch execution placeholder completed");

    // Data encoding utilities
    let classical_data = Array2::from_shape_fn((10, 4), |(i, j)| (i + j) as f64 * 0.2);
    // let encoded_circuits = tfq_utils::encode_data_to_circuits(
    //     &classical_data,
    //     DataEncodingType::Angle
    // )?;
    let encoded_circuits = vec![tfq_utils::create_data_encoding_circuit(
        4,
        DataEncodingType::Angle,
    )?];
    println!(
        "    - Encoded {} data points to quantum circuits",
        encoded_circuits.len()
    );

    // Step 11: Compare with TensorFlow classical model
    println!("\n11. Comparing with TensorFlow classical equivalent...");

    let classical_model = create_tensorflow_classical_model()?;
    // let classical_accuracy = train_classical_tensorflow_model(classical_model, &quantum_dataset)?;
    //
    // let quantum_accuracy = evaluation_results.get("accuracy").unwrap_or(&0.0);
    // println!("    - Quantum TFQ model accuracy: {:.3}", quantum_accuracy);
    // println!("    - Classical TF model accuracy: {:.3}", classical_accuracy);
    // println!("    - Quantum advantage: {:.3}", quantum_accuracy - classical_accuracy);
    println!("    - Classical comparison placeholder completed");

    // Step 12: Model export (TFQ format)
    println!("\n12. Exporting model in TFQ format...");

    // model.save_tfq_format("quantum_model_tfq.pb")?;
    // println!("    - Model exported to: quantum_model_tfq.pb");
    //
    // // Export to TensorFlow SavedModel format
    // model.export_savedmodel("quantum_model_savedmodel/")?;
    // println!("    - SavedModel exported to: quantum_model_savedmodel/");
    println!("    - Model export placeholder completed");

    // Step 13: Advanced TFQ features
    println!("\n13. Advanced TensorFlow Quantum features...");

    // Quantum data augmentation
    // let augmented_dataset = quantum_dataset.augment_with_noise(0.05)?;
    // println!("    - Created augmented dataset with noise level 0.05");
    //
    // // Circuit optimization for hardware
    // let optimized_circuits = tfq_utils::optimize_circuits_for_hardware(
    //     &circuits,
    //     HardwareType::IonQ
    // )?;
    // println!("    - Optimized {} circuits for IonQ hardware", optimized_circuits.len());
    //
    // // Barren plateau analysis
    // let plateau_analysis = analyze_barren_plateaus(&model, &quantum_dataset)?;
    // println!("    - Barren plateau risk: {:.3}", plateau_analysis.risk_score);
    // println!("    - Recommended mitigation: {}", plateau_analysis.mitigation_strategy);
    println!("    - Advanced features placeholder completed");

    println!("\n=== TensorFlow Quantum Demo Complete ===");

    Ok(())
}

pub fn num_qubits(&self) -> usize

Get the number of qubits

pub fn num_gates(&self) -> usize

Get the number of gates (placeholder implementation)

pub fn depth(&self) -> usize

Get circuit depth (placeholder implementation)

pub fn gates(&self) -> Vec<&dyn GateOp>

Get gates (placeholder implementation)

Trait Implementations

impl Clone for DynamicCircuit

fn clone(&self) -> DynamicCircuit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicCircuit

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

Formats the value using the given formatter.