pyqpanda.Algorithm.hamiltonian_simulation

Simulating a specific hamitonian (PauliOperator)

Copyright (C) Origin Quantum 2017-2018

Licensed Under Apache Licence 2.0

Module Contents

Functions

simulate_z_term(qubit_list, coef, t)	QPanda Algorithm API
simulate_one_term(qubit_list, hamiltonian_term, t)	Simulate a single term of Hamilonian like "X0 Y1 Z2" with
simulate_pauliZ_hamiltonian(qubit_list, PauliOperator, t)	Simulate hamiltonian consists of pauli-Z operators
simulate_hamiltonian(qubit_list, PauliOperator, t[, ...])	Simulate a general case of hamiltonian by Trotter-Suzuki
adiabatic_simulation_with_configuration(qn_, Hp_, Hd_, ...)	simulate hamiltonian with configuration and return result.
ising_model(qubit_list, graph, gamma_)
pauliX_model(qubit_list, beta_)
weight(graph, distribution)
get_qn_from_graph(graph)
quantum_approximate_optimization_algorithm(graph, ...)	quantum approximate optimization algorithm
binding(graph, shots)
qaoa_in_list(arguments, graph[, use_prob_run, ...])
qaoa(graph[, step_, shots_, method])

pyqpanda.Algorithm.hamiltonian_simulation.simulate_z_term(qubit_list, coef, t)

QPanda Algorithm API

Simulating z-only term like H=coef * (Z0..Zn-1)

U=exp(-iHt)

list<Qubit>, float, float -> QCircuit

Note: Z-Hamiltonian spreads over the qubit_list

pyqpanda.Algorithm.hamiltonian_simulation.simulate_one_term(qubit_list, hamiltonian_term, t)

Simulate a single term of Hamilonian like "X0 Y1 Z2" with coefficient and time. U=exp(-it*coef*H) @param

qubit_list: qubit needed to simulate the hamiltonian hamiltonian_term: tuple like ("X0 Y1 Z2",2.3) t: time

@return: QCircuit

pyqpanda.Algorithm.hamiltonian_simulation.simulate_pauliZ_hamiltonian(qubit_list, PauliOperator, t)

Simulate hamiltonian consists of pauli-Z operators @param

qubit_list: qubit needed to simulate the hamiltonian PauliOperator: PauliOperator object from c++ t: time

@return: QCircuit

pyqpanda.Algorithm.hamiltonian_simulation.simulate_hamiltonian(qubit_list, PauliOperator, t, slices=3)

Simulate a general case of hamiltonian by Trotter-Suzuki approximation. U=exp(-iHt)=(exp(-i H1 t/n)*exp(-i H2 t/n))^n @param:

qubit_list: the qubit needed to simulate the Hamiltonian pauliOperator: the Hamiltonian (PauliOperator type) t: time slices: the approximate slices.

@return: QCircuit

pyqpanda.Algorithm.hamiltonian_simulation.adiabatic_simulation_with_configuration(qn_, Hp_, Hd_, step_, slices_, t_, shots_=1000)

simulate hamiltonian with configuration and return result. @param

qn_ : number of qubits Hp_ : problem hamiltonian Hd_ : driver hamiltonian step_ : number of step in adiabatic simulation slices_ : number of slices in trotter-suzuki approximation t_ : total time for adiabatic simulation shots_ : number of shots

pyqpanda.Algorithm.hamiltonian_simulation.ising_model(qubit_list, graph, gamma_)

pyqpanda.Algorithm.hamiltonian_simulation.pauliX_model(qubit_list, beta_)

pyqpanda.Algorithm.hamiltonian_simulation.weight(graph, distribution)

pyqpanda.Algorithm.hamiltonian_simulation.get_qn_from_graph(graph)

pyqpanda.Algorithm.hamiltonian_simulation.quantum_approximate_optimization_algorithm(graph, gamma_, beta_, use_prob_run=True, use_quick_measure=True, multiProcessing=False, shots_=100, dataType='list')

quantum approximate optimization algorithm @param

graph: origin graph gamma_: problem hamiltonian parameter beta_: driver hamiltonian parameter use_prob_run : Use prob_run instead of repeatly measurement multiProcessing: no implemented yet shot_: execution times

(the following only enabled when "use_prob_run=True") use_quick_measure : use quick measure instead of output probabilites dataType : chosen data type for the prob_run

pyqpanda.Algorithm.hamiltonian_simulation.binding(graph, shots)

pyqpanda.Algorithm.hamiltonian_simulation.qaoa_in_list(arguments, graph, use_prob_run=True, multiProcessing=False, shots=100, dataType='list')

pyqpanda.Algorithm.hamiltonian_simulation.qaoa(graph, step_=1, shots_=1000, method='Nelder-Mead')