Variational_Quantum_Eigensolver_Base.h

Go to the documentation of this file.

/*
Created on Fri Jun 26 14:13:26 2020
Copyright 2020 Peter Rakyta, Ph.D.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

@author: Peter Rakyta, Ph.D.
*/
#ifndef VARIATIONAL_QUANTUM_EIGENSOLVER_BASE_H
#define VARIATIONAL_QUANTUM_EIGENSOLVER_BASE_H

#include "Optimization_Interface.h"

namespace squander {
namespace density {
class DensityMatrix;
class NoisyCircuit;
} // namespace density
} // namespace squander

//=====================================================================================================================================================================================
//=====================================================================================================================================================================================
//=====================================================================================================================================================================================

// --- SimulationResult struct ---
struct SimulationResult {
  double mean;
  double variance;
  double std_error;
};
//=====================================================================================================================================================================================
//=====================================================================================================================================================================================
//=====================================================================================================================================================================================

typedef enum ansatz_type { HEA, HEA_ZYZ } ansatz_type;

typedef enum vqe_backend_type {
  STATE_VECTOR_BACKEND = 0,
  DENSITY_MATRIX_BACKEND = 1
} vqe_backend_type;

typedef enum density_noise_type {
  LOCAL_DEPOLARIZING_NOISE = 0,
  AMPLITUDE_DAMPING_NOISE = 1,
  PHASE_DAMPING_NOISE = 2
} density_noise_type;

typedef enum vqe_circuit_source_type {
  VQE_CIRCUIT_SOURCE_UNSET = 0,
  VQE_CIRCUIT_SOURCE_GENERATED_HEA = 1,
  VQE_CIRCUIT_SOURCE_GENERATED_HEA_ZYZ = 2,
  VQE_CIRCUIT_SOURCE_BINARY_IMPORT = 3,
  VQE_CIRCUIT_SOURCE_CUSTOM_GATE_STRUCTURE = 4
} vqe_circuit_source_type;

struct DensityNoiseSpec {
  density_noise_type type;
  int target_qbit;
  int after_gate_index;
  double value;
};

struct DensityBridgeOperationInfo {
  std::string name;
  bool is_unitary;
  int source_gate_index;
  int target_qbit;
  int control_qbit;
  int param_count;
  int param_start;
  bool has_fixed_value;
  double fixed_value;
};

class Variational_Quantum_Eigensolver_Base : public Optimization_Interface {
public:
  //================================================================================================================================================================================
  //================================================================================================================================================================================
  //================================================================================================================================================================================

  Matrix get_initial_state() const { return initial_state.copy(); }

  std::string get_density_bridge_source_label() const;

  std::vector<DensityBridgeOperationInfo> inspect_density_bridge();
  //================================================================================================================================================================================
  //================================================================================================================================================================================
  //================================================================================================================================================================================

private:
  Matrix_sparse Hamiltonian;

  Matrix initial_state;

  ansatz_type ansatz;

  vqe_backend_type backend_mode;

  vqe_circuit_source_type circuit_source;

  std::vector<DensityNoiseSpec> density_noise_specs;

  void validate_density_anchor_support(bool require_optimizer_support = false,
                                       bool require_gradient_support = false);
  void
  append_density_noise_for_gate_index(squander::density::NoisyCircuit &circuit,
                                      int gate_index) const;
  void lower_anchor_circuit_to_noisy_circuit(
      squander::density::NoisyCircuit &circuit);
  double evaluate_density_matrix_backend(Matrix_real &parameters);
  double expectation_value_of_density_energy_real(
      const squander::density::DensityMatrix &rho) const;
  bool density_optimizer_supported() const;

public:
  //================================================================================================================================================================================
  //================================================================================================================================================================================
  //================================================================================================================================================================================

  std::vector<std::tuple<int, int, double>> zz_terms;

  std::vector<std::pair<int, double>> z_terms;

  std::vector<std::tuple<int, int, double>> xx_terms;

  std::vector<std::tuple<int, int, double>> yy_terms;

  //================================================================================================================================================================================
  //================================================================================================================================================================================
  //================================================================================================================================================================================

  Variational_Quantum_Eigensolver_Base();

  Variational_Quantum_Eigensolver_Base(
      Matrix_sparse Hamiltonian_in, int qbit_num_in,
      std::map<std::string, Config_Element> &config_in,
      int accelerator_num = 0);

  virtual ~Variational_Quantum_Eigensolver_Base();

  QGD_Complex16 Expectation_value_of_energy(Matrix &State_left,
                                            Matrix &State_right);

  double Expectation_value_of_energy_real(Matrix &State_left,
                                          Matrix &State_right);

  //=====================================================================================================================================================================================
  //=====================================================================================================================================================================================
  //=====================================================================================================================================================================================

  SimulationResult Expectation_value_with_shot_noise_real(Matrix &State,
                                                          int shots,
                                                          uint64_t seed,
                                                          double p_readout);

  //=====================================================================================================================================================================================
  //=====================================================================================================================================================================================
  //=====================================================================================================================================================================================

  virtual double optimization_problem(Matrix_real &parameters) override;

  virtual double optimization_problem_non_static(Matrix_real parameters,
                                                 void *void_instance) override;

#ifdef __GROQ__

  double optimization_problem_Groq(Matrix_real &parameters, int chosen_device);
#endif

  using Decomposition_Base::optimization_problem;

  double optimization_problem(double *parameters);

  virtual void
  optimization_problem_combined_non_static(Matrix_real parameters,
                                           void *void_instance, double *f0,
                                           Matrix_real &grad) override;

  virtual void optimization_problem_combined(Matrix_real parameters, double *f0,
                                             Matrix_real grad) override;

  static void optimization_problem_grad_vqe(Matrix_real parameters,
                                            void *void_instance,
                                            Matrix_real &grad);

  void initialize_zero_state();

  void start_optimization();

  void set_ansatz(ansatz_type ansatz_in);

  void generate_circuit(int layers, int inner_blocks);

  void set_gate_structure(std::string filename);

  void set_custom_gate_structure(Gates_block *gate_structure_in);

  void set_initial_state(Matrix initial_state_in);

  void set_density_noise_specs(
      const std::vector<DensityNoiseSpec> &density_noise_specs_in);
};

#endif