pyqpanda

QPanda Python

Copyright (C) Origin Quantum 2017-2018

Licensed Under Apache Licence 2.0

Submodules

• pyqpanda.OriginService
• pyqpanda.Visualization
• pyqpanda.pyQPanda
• pyqpanda.utils

Classes

AbstractOptimizer	quantum AbstractOptimizer class
AdaGradOptimizer	variational quantum AdaGradOptimizer
AdamOptimizer	variational quantum AdamOptimizer
Ansatz	quantum ansatz class
AnsatzGate	ansatz gate struct
AnsatzGateType	Quantum ansatz gate type
BackendType	Quantum machine backend type
CBit	quantum classical bit
CPUQVM	quantum machine cpu
CPUSingleThreadQVM	quantum machine class for cpu single thread
ChipID	origin quantum real chip type
ClassicalCondition	Classical condition class Proxy class of cexpr class
ClassicalProg	quantum ClassicalProg
CommProtocolConfig
ComplexVertexSplitMethod	quantum complex vertex split method
DAGNodeType	Quantum dag node type
DecompositionMode	Quantum matrix decomposition mode
DensityMatrixSimulator	simulator for density matrix
DoubleGateTransferType	Quantum double gate transfer type
Encode	quantum amplitude encode
ErrorCode	pliot error code
Fusion	quantum fusion operation
GateType	quantum gate type
HHLAlg	quantum hhl algorithm class
LATEX_GATE_TYPE	Quantum latex gate type
LatexMatrix	Generate quantum circuits latex src code can be compiled on latex package 'qcircuit'
MPSQVM	quantum matrix product state machine class
MomentumOptimizer	variational quantum MomentumOptimizer
NodeInfo	Detailed information of a QProg node
NodeIter	quantum node iter
NodeType	quantum node type
Noise	Quantum machine for noise simulation
NoiseModel	noise model type
NoiseQVM	quantum machine class for simulate noise prog
Optimizer	variational quantum Optimizer class
OptimizerFactory	quantum OptimizerFactory class
OptimizerMode	variational quantum OptimizerMode
OptimizerType	quantum OptimizerType
OriginCMem	origin quantum cmem
OriginCollection	A relatively free data collection class for saving data
OriginQubitPool	quantum qubit pool
PartialAmpQVM	quantum partial amplitude machine class
PhysicalQubit	Physical Qubit abstract class
PilotNoiseParams	pliot noise simulate params
ProgCount
QCircuit	quantum circuit node
QCircuitOPtimizerMode	Quantum circuit optimize mode
QError	Quantum QError Type
QGate	quantum gate node
QITE	quantum imaginary time evolution
QIfProg	quantum if prog node
QMachineType	Quantum machine type
QMeasure	quantum measure node
QOperator	quantum operator class
QOptimizationResult	quantum QOptimizationResult class
QPilotOSService	origin quantum pilot OS Machine
QProg	Quantum program,can construct quantum circuit,data struct is linked list
QProgDAG	quantum prog dag class
QProgDAGEdge	quantum prog dag edge
QProgDAGVertex	quantum prog dag vertex node
QReset	quantum reset node
QResult	QResult abstract class, this class contains the result of the quantum measurement
QVec	Qubit vector basic class
QWhileProg	quantum while node
QuantumMachine	quantum machine base class
QuantumStateTomography	quantum state tomography class
Qubit	Qubit abstract class
RMSPropOptimizer	variational quantum RMSPropOptimizer
SingleAmpQVM	quantum single amplitude machine class
SingleGateTransferType	Quantum single gate transfer type
SparseQVM	quantum sparse machine class
Stabilizer	simulator for basic clifford simulator
UpdateMode	quantum imaginary time evolution update mode
VanillaGradientDescentOptimizer	variational quantum VanillaGradientDescentOptimizer
VariationalQuantumCircuit	variational quantum CIRCUIT class
VariationalQuantumGate	variational quantum gate base class
VariationalQuantumGate_CNOT	variational quantum CNOT gate class
VariationalQuantumGate_CR	variational quantum CR gate class
VariationalQuantumGate_CRX	variational quantum CRX gate class
VariationalQuantumGate_CRY	variational quantum CRY gate class
VariationalQuantumGate_CRZ	variational quantum CRZ gate class
VariationalQuantumGate_CU	variational quantum CU gate class
VariationalQuantumGate_CZ	variational quantum CZ gate class
VariationalQuantumGate_H	variational quantum H gate class
VariationalQuantumGate_I	variational quantum I gate class
VariationalQuantumGate_RX	variational quantum RX gate class
VariationalQuantumGate_RY	variational quantum RY gate class
VariationalQuantumGate_RZ	variational quantum RZ gate class
VariationalQuantumGate_S	variational quantum S gate class
VariationalQuantumGate_SWAP	variational quantum SWAP gate class
VariationalQuantumGate_SqiSWAP	variational quantum SqiSWAP gate class
VariationalQuantumGate_T	variational quantum T gate class
VariationalQuantumGate_U1	variational quantum U1 gate class
VariationalQuantumGate_U2	variational quantum U2 gate class
VariationalQuantumGate_U3	variational quantum U3 gate class
VariationalQuantumGate_U4	variational quantum U4 gate class
VariationalQuantumGate_X	variational quantum X gate class
VariationalQuantumGate_X1	variational quantum X1 gate class
VariationalQuantumGate_Y	variational quantum Y gate class
VariationalQuantumGate_Y1	variational quantum Y1 gate class
VariationalQuantumGate_Z	variational quantum Z gate class
VariationalQuantumGate_Z1	variational quantum Z1 gate class
VariationalQuantumGate_iSWAP	variational quantum iSWAP gate class
em_method	origin quantum real chip error_mitigation type
expression	variational quantum expression class
hadamard_circuit	hadamard circuit class
real_chip_type	origin quantum real chip type enum
var	quantum variational class
QPilotOSMachine	This class can submit Quantum Program to PilotOS.

Functions

BARRIER(…)	Create a BARRIER gate for a list of qubit addresses.
CNOT(…)	Returns:
CP(…)	Returns:
CR(…)	Returns:
CU(…)	Create a CU gate.
CZ(…)	Returns:
CreateEmptyCircuit(→ QCircuit)	Create an empty QCircuit container.
CreateEmptyQProg(→ QProg)	Create an empty QProg container.
CreateIfProg(…)	Create an IfProg that executes one of two quantum operations based on a classical condition.
CreateWhileProg(→ QWhileProg)	Create a WhileProg that executes while a classical condition is true.
Grover(→ Any)	Quantum grover circuit
Grover_search(…)	use Grover algorithm to search target data, return QProg and search_result
H(…)	Create a H gate
HHL_solve_linear_equations(→ List[complex])	Use HHL algorithm to solve the target linear systems of equations : Ax = b
I(…)	Create a I gate
MAJ(→ QCircuit)	Quantum adder MAJ module
MAJ2(→ QCircuit)	Quantum adder MAJ2 module
MS(…)	Returns:
Measure(…)	Create a measure node.
OBMT_mapping(…)	OPT_BMT mapping
P(…)	Create a P gate
PMeasure(→ List[Tuple[int, float]])	Deprecated, use pmeasure instead.
PMeasure_no_index(→ List[float])	Deprecated, use pmeasure_no_index instead.
QAdd(→ QCircuit)	Quantum adder that supports signed operations, but ignore carry
QAdder(→ QCircuit)	Quantum adder with carry
QAdderIgnoreCarry(→ QCircuit)	Args:
QComplement(→ QCircuit)	Convert quantum state to binary complement representation
QDiv(→ QProg)	Quantum division
QDivWithAccuracy(→ QProg)	Args:
QDivider(→ QProg)	Quantum division, only supports positive division, and the highest position of a and b and c is sign bit
QDividerWithAccuracy(→ QProg)	Args:
QDouble(…)	Returns:
QFT(→ QCircuit)	Build QFT quantum circuit
QMul(→ QCircuit)	Quantum multiplication
QMultiplier(→ QCircuit)	Quantum multiplication, only supports positive multiplication
QOracle(→ QGate)	Generate QOracle Gate.
QPE(→ QCircuit)	Quantum phase estimation
QSub(→ QCircuit)	Quantum subtraction
RX(…)	Create a RX gate
RXX(…)	Create a RXX gate
RY(…)	Create a RY gate
RYY(…)	Create a RYY gate
RZ(…)	Create a RZ gate
RZX(…)	Create a RZX gate
RZZ(…)	Create a RZZ gate
Reset(…)	Create a Reset node.
S(…)	Create a S gate
SWAP(…)	Returns:
Shor_factorization(→ Tuple[bool, Tuple[int, int]])	Use Shor factorize integer num
SqiSWAP(…)	Returns:
T(…)	Create a T gate
Toffoli(…)	Create a Toffoli gate.
U1(…)	Create a U1 gate
U2(…)	Create a U2 gate
U3(…)	Create a U3 gate
U4(…)	Create a U4 gate.
UMA(→ QCircuit)	Quantum adder UMA module
VQG_CNOT_batch(→ Any)	variational quantum CNOT batch gates
VQG_CU_batch(→ Any)	variational quantum CU batch gates
VQG_CZ_batch(→ Any)	variational quantum CZ batch gates
VQG_H_batch(→ Any)	variational quantum H batch gates
VQG_I_batch(→ Any)	variational quantum I batch gates
VQG_SWAP_batch(→ Any)	variational quantum SWAP batch gates
VQG_S_batch(→ Any)	variational quantum S batch gates
VQG_SqiSWAP_batch(→ Any)	variational quantum SqiSWAP batch gates
VQG_T_batch(→ Any)	variational quantum T batch gates
VQG_U1_batch(→ Any)	variational quantum U1 batch gates
VQG_U2_batch(→ Any)	variational quantum U2 batch gates
VQG_U3_batch(→ Any)	variational quantum U3 batch gates
VQG_U4_batch(→ Any)	variational quantum U4 batch gates
VQG_X1_batch(→ Any)	variational quantum X1 batch gates
VQG_X_batch(→ Any)	variational quantum X batch gates
VQG_Y1_batch(→ Any)	variational quantum Y1 batch gates
VQG_Y_batch(→ Any)	variational quantum Y batch gates
VQG_Z1_batch(→ Any)	variational quantum Z1 batch gates
VQG_Z_batch(→ Any)	variational quantum Z batch gates
VQG_iSWAP_batch(→ Any)	variational quantum iSWAP batch gates
X(…)	Create a X gate
X1(…)	Create a X1 gate
Y(…)	Create a Y gate
Y1(…)	Create a Y1 gate
Z(…)	Create a Z gate
Z1(…)	Create a Z1 gate
accumulateProbability(→ List[float])	Accumulate the probability from a probability list.
accumulate_probabilities(→ List[float])	Accumulate the probability from a probability list.
accumulate_probability(→ List[float])	Accumulate the probability from a probability list.
acos(→ var)
add(…)	Add a bit size and a ClassicalCondition.
all_cut_of_graph(→ float)	Generate a graph representation for the max cut problem.
amplitude_encode(…)	Encode the input double data to the amplitude of qubits
apply_QGate(…)	Apply a quantum gate operation to a list of qubit addresses.
asin(→ var)
assign(…)	Assign a bit size value to a ClassicalCondition.
atan(→ var)
average_gate_fidelity(…)	Calculate the average gate fidelity between two quantum operation matrices.
bin_to_prog(→ bool)	Parse binary data to transform into a quantum program.
bind_data(→ QCircuit)	Args:
bind_nonnegative_data(→ QCircuit)	Args:
build_HHL_circuit(→ QCircuit)	build the quantum circuit for HHL algorithm to solve the target linear systems of equations : Ax = b
cAlloc(…)	Allocate a CBit
cAlloc_many(→ List[ClassicalCondition])	Allocate several CBits
cFree(→ None)	Free a CBit
cFree_all(…)	Free all CBits
cast_qprog_qcircuit(→ QCircuit)	Cast a quantum program into a quantum circuit.
cast_qprog_qgate(→ QGate)	Cast a quantum program into a quantum gate.
cast_qprog_qmeasure(→ QMeasure)	Cast a quantum program into a quantum measurement.
circuit_layer(→ list)	Quantum circuit layering.
circuit_optimizer(→ QProg)	Optimize a quantum circuit.
circuit_optimizer_by_config(→ QProg)	Optimize a quantum circuit using configuration data.
comm_protocol_decode(→ Tuple[List[QProg], ...)	Decode binary data into a list of quantum programs using the communication protocol.
comm_protocol_encode(…)	Encode a list of quantum programs into binary communication protocol data.
constModAdd(→ QCircuit)	Args:
constModExp(→ QCircuit)	Args:
constModMul(→ QCircuit)	Args:
convert_binary_data_to_qprog(→ QProg)	Parse binary data into a quantum program.
convert_originir_str_to_qprog(→ list)	Transform OriginIR string into QProg.
convert_originir_to_qprog(→ list)	Read an OriginIR file and transform it into QProg.
convert_qasm_string_to_qprog(→ list)	Transform QASM string into QProg.
convert_qasm_to_qprog(→ list)	Read a QASM file and transform it into QProg.
convert_qprog_to_binary(…)	Store the quantum program in a binary file.
convert_qprog_to_originir(→ Any)	Convert QProg to OriginIR string.
convert_qprog_to_qasm(→ str)	Convert a quantum program to a QASM instruction string.
convert_qprog_to_quil(→ str)	Convert QProg to Quil instruction.
cos(→ var)
count_gate(…)	Count quantum gate number in the quantum circuit.
count_prog_info(…)	Count quantum program information.
count_qgate_num(…)	Count quantum gate number in the quantum circuit.
create_empty_circuit(→ QCircuit)	Create an empty QCircuit container.
create_empty_qprog(→ QProg)	Create an empty QProg container.
create_if_prog(…)	Create a classical quantum IfProg.
create_while_prog(→ QWhileProg)	Create a WhileProg.
crossEntropy(→ var)
decompose_multiple_control_qgate(…)	Decompose multiple control QGate.
deep_copy(…)	Create a deep copy of the given quantum program node.
del_weak_edge(→ None)	Delete weakly connected edges from the quantum program topology.
del_weak_edge2(→ list)	Delete weakly connected edges from the quantum program topology.
del_weak_edge3(→ list)	Delete weakly connected edges based on specified parameters.
destroy_quantum_machine(→ None)	Destroy a quantum machine.
directly_run() → Dict[str, bool])	Directly run a quantum program
div(…)	Divide a bit size by a ClassicalCondition.
dot(→ var)
draw_qprog_latex(, itr_end)	Convert a quantum prog/circuit to LaTeX representation,
draw_qprog_latex_with_clock(, itr_end)	Convert a quantum prog/circuit to LaTeX source code with time sequence,
draw_qprog_text(, itr_end)	Convert a quantum prog/circuit to text-pic (UTF-8 code),
draw_qprog_text_with_clock(, itr_end)	Convert a quantum prog/circuit to text-pic (UTF-8 code) with time sequence,
dropout(→ var)
equal(…)	Check if a bit size is equal to a ClassicalCondition.
estimate_topology(→ float)	Evaluate topology performance.
eval(…)
exp(→ var)
expMat(→ numpy.ndarray[numpy.complex128[m, n]])	Calculate the matrix power of e.
expand_linear_equations(…)	Extending linear equations to N dimension, N = 2 ^ n
fill_qprog_by_I(→ QProg)	Fill the input quantum program with I gates and return a new quantum program.
finalize(→ None)	Finalize the environment and destroy global unique quantum machine.
fit_to_gbk(→ str)	Special character conversion.
flatten(…)	Flatten a quantum circuit in place.
getAllocateCMem(→ int)	Deprecated, use get_allocate_cmem_num instead.
getAllocateQubitNum(→ int)	Deprecated, use get_allocate_qubit_num instead.
get_adjacent_qgate_type(→ List[NodeInfo])	Get the adjacent quantum gates' (the front one and the back one) type info from QProg.
get_all_used_qubits(→ List[Qubit])	Get all the quantum bits used in the input program.
get_all_used_qubits_to_int(→ List[int])	Get the addresses of all used quantum bits in the input program.
get_allocate_cbits(→ List[ClassicalCondition])	Get allocated cbits of QuantumMachine
get_allocate_cmem_num(→ int)	Get allocate cmem num.
get_allocate_qubit_num(→ int)	Get allocate qubit num.
get_allocate_qubits(→ List[Qubit])	Get allocated qubits of QuantumMachine
get_bin_data(→ List[int])	Get quantum program binary data.
get_bin_str(→ str)	Transform a quantum program into a string representation.
get_circuit_optimal_topology(→ List[List[int]])	Retrieve the optimal topology of the input quantum circuit.
get_clock_cycle(→ int)	Get quantum program clock cycle.
get_complex_points(→ List[int])	Retrieve complex points from the given topology data.
get_double_gate_block_topology(→ List[List[int]])	Retrieve the double gate block topology from the input quantum program.
get_matrix(→ Any)	Get the target matrix between the input two NodeIters.
get_prob_dict(→ Dict[str, float])	Get pmeasure result as dict
get_prob_list(→ List[float])	Get pmeasure result as list
get_qgate_num(…)	Count the number of quantum gates in a quantum program.
get_qprog_clock_cycle(→ int)	Get Quantum Program Clock Cycle.
get_qstate(…)
get_sub_graph(→ List[int])	Retrieve a subgraph from the provided topology data.
get_tuple_list(→ List[Tuple[int, float]])	Get pmeasure result as tuple list
get_unitary(→ Any)	Get the target unitary matrix between the input two NodeIters.
get_unsupport_qgate_num(→ int)	Count the number of unsupported gates in a quantum program.
getstat(→ Any)	Get the status of the Quantum machine
iSWAP(…)	Returns:
init(→ bool)	Init the global unique quantum machine at background.
init_quantum_machine(→ QuantumMachine)	Create and initialize a new quantum machine, and let it be a globally unique quantum machine.
inverse(→ var)
isCarry(→ QCircuit)	Construct a circuit to determine if there is a carry
is_match_topology(→ bool)	Judge if the QGate matches the target topologic structure of the quantum circuit.
is_supported_qgate_type(→ bool)	Judge if the target node is a QGate type.
is_swappable(→ bool)	Judge whether the specified two NodeIters in the quantum program can be exchanged.
iterative_amplitude_estimation(→ float)	estimate the probability corresponding to the ground state |1> of the last bit
ldd_decompose(→ QProg)	Decompose a multiple control quantum gate using LDD.
log(→ var)
matrix_decompose(…)	Matrix decomposition
matrix_decompose_paulis(…)	decompose matrix into paulis combination
measure_all(…)	Create a list of measure nodes.
mul(…)	Multiply a bit size by a ClassicalCondition.
originir_to_qprog(→ QProg)	Read an OriginIR file and transform it into QProg.
pauli_combination_replace(→ List[Tuple[float, QCircuit]])
planarity_testing(→ bool)	Perform planarity testing.
pmeasure(→ List[Tuple[int, float]])	Get the probability distribution over qubits.
pmeasure_no_index(→ List[float])	Get the probability distribution over qubits.
poly(→ var)
print_matrix(→ str)	Print matrix elements.
prob_run_dict(→ Dict[str, float])	Run quantum program and get pmeasure result as dict
prob_run_list(→ List[float])	Run quantum program and get pmeasure result as list
prob_run_tuple_list(→ List[Tuple[int, float]])	Run quantum program and get pmeasure result as tuple list
prog_layer(→ Any)	Process the given quantum program layer.
prog_to_dag(→ QProgDAG)	Convert a quantum program into a directed acyclic graph (DAG).
qAlloc(…)	Allocate a qubit
qAlloc_many(→ List[Qubit])	Allocate several qubits
qFree(→ None)	Free a qubit
qFree_all(…)	Free a list of qubits
qop(…)
qop_pmeasure(→ var)
quantum_chip_adapter(→ list)	Perform adaptive conversion for the quantum chip.
quantum_walk_alg(→ Any)	Build quantum-walk algorithm quantum circuit
quantum_walk_search(→ quantum_walk_search.list)	Use Quantum-walk Algorithm to search target data, return QProg and search_result
quick_measure(→ Dict[str, int])	Quick measure.
random_qcircuit(→ QCircuit)	Generate a random quantum circuit.
random_qprog(→ QProg)	Generate a random quantum program.
recover_edges(→ List[List[int]])	Recover edges using the specified candidate edges.
remap(→ QProg)	Map the source quantum program to the target qubits.
replace_complex_points(→ None)	Replace complex points in the source topology with subgraphs.
run_with_configuration(→ Any)
sabre_mapping(…)	sabre mapping
sigmoid(→ var)
sin(→ var)
softmax(→ var)
split_complex_points(→ List[Tuple[int, List[List[int]]]])	Split complex points into multiple discrete points.
stack(→ var)
state_fidelity(…)	Compare a quantum state matrix with a quantum state and calculate their fidelity.
sub(…)	Subtract a ClassicalCondition from a bit size.
sum(→ var)
tan(→ var)
to_Quil(→ str)	Transform QProg to Quil instruction.
to_originir(…)	Transform QProg to OriginIR string.
topology_match(→ list)	Judge whether a quantum program matches the topology of the physical qubits.
transform_binary_data_to_qprog(→ QProg)	Parse binary data to transform it into a quantum program.
transform_originir_to_qprog(→ QProg)	Transform OriginIR instruction from a file into a QProg.
transform_qprog_to_binary(…)	Save quantum program to file as binary data.
transform_qprog_to_originir(→ str)	Transform a quantum program into an OriginIR instruction string.
transform_qprog_to_quil(→ str)	Transform QProg to Quil instruction.
transform_to_base_qgate(…)	Convert quantum gates to basic gates.
transfrom_pauli_operator_to_matrix(→ List[complex])	transfrom pauli operator to matrix
transpose(→ var)
validate_double_qgate_type(→ list)	Get valid QGates and valid double bit QGate type.
validate_single_qgate_type(→ list)	Get valid QGates and valid single bit QGate type.
vector_dot(→ float)	Compute the inner product of two vectors.
virtual_z_transform(→ QProg)	virtual z transform
single_gate_apply_to_all(gate, qubit_list)	Applies a specified quantum gate to each qubit within the provided list.
single_gate(gate, qubit[, angle])	Constructs a quantum gate operation on a specified qubit.
meas_all(qubits, cbits)	Constructs a quantum program by measuring specified qubits and mapping their outcomes to classical bits.
get_fidelity(result, shots, target_result)	Calculate the fidelity between a given quantum state and a target state.
draw_qprog(prog[, output, scale, fold, filename, ...])	Visualizes a quantum circuit in various formats based on the specified output type.
show_prog_info_count(prog)	Visualizes the distribution of nodes and layers within a quantum circuit represented by prog.
draw_probability(list)	Generate a bar plot visualizing the probabilities of a quantum state.
draw_probability_dict(prob_dict)	Generate a bar plot representing the probabilities of a quantum state from a given dictionary.
plot_state_city(state[, title, figsize, color, ...])	Plots the real and imaginary parts of a quantum state in a 3D bar plot.
plot_density_matrix(M[, xlabels, ylabels, title, ...])	Plots the density matrix of a quantum state as a 3D bar plot, visualizing the
state_to_density_matrix(quantum_state)	Converts a given quantum state into its corresponding density matrix representation.
plot_bloch_circuit(circuit[, trace, saveas, fps, ...])	Visualizes the evolution of a quantum circuit on a Bloch sphere.
plot_bloch_vector(bloch[, title, axis_obj, fig_size])	Visualizes the evolution of a quantum circuit on a Bloch sphere.
plot_bloch_multivector(state[, title, fig_size])	Visualizes a quantum state on a Bloch sphere.

Package Contents

class pyqpanda.AbstractOptimizer(*args, **kwargs)

quantum AbstractOptimizer class

exec() → None

Execute the optimization process.

Args:

None: This method takes no parameters.

Returns:

result: The result of the optimization process.

getResult(*args, **kwargs) → Any

Retrieve the result of the last optimization.

Args:

None: This method takes no parameters.

Returns:

result: The result of the last optimization.

registerFunc(arg0: Callable[[List[float], List[float], int, int], Tuple[str, float]], arg1: List[float]) → None

Register an optimization function.

Args:

func: The optimization function to be registered.

Returns:

None

setAdaptive(arg0: bool) → None

Set whether the optimizer should use adaptive methods.

Args:

adaptive: A boolean indicating whether to enable adaptive optimization.

Returns:

None

setCacheFile(arg0: str) → None

Set the path for the cache file used in optimization.

Args:

cache_file: A string representing the path to the cache file.

Returns:

None

setDisp(arg0: bool) → None

Set the display flag for the optimizer.

Args:

disp: A boolean indicating whether to display optimization progress.

Returns:

None

setFatol(arg0: float) → None

Set the function absolute tolerance for optimization.

Args:

fatol: The function absolute tolerance value to be set.

Returns:

None

setMaxFCalls(arg0: int) → None

Set the maximum number of function calls allowed during optimization.

Args:

max_calls: The maximum number of function calls to be set.

Returns:

None

setMaxIter(arg0: int) → None

Set the maximum number of iterations allowed during optimization.

Args:

max_iter: The maximum number of iterations to be set.

Returns:

None

setRestoreFromCacheFile(arg0: bool) → None

Set whether to restore the optimization state from a cache file. Args:

cache_file: A string representing the path to the cache file.

Returns:

None

setXatol(arg0: float) → None

Set the absolute tolerance for optimization.

Args:

atol: The absolute tolerance value to be set.

Returns:

None

class pyqpanda.AdaGradOptimizer(arg0: var, arg1: float, arg2: float, arg3: float)

variational quantum AdaGradOptimizer

get_loss() → float

get_variables() → List[var]

minimize(arg0: float, arg1: float, arg2: float) → Optimizer

run(arg0: List[var], arg1: int) → bool

class pyqpanda.AdamOptimizer(arg0: var, arg1: float, arg2: float, arg3: float, arg4: float)

variational quantum AdamOptimizer

get_loss() → float

get_variables() → List[var]

minimize(arg0: float, arg1: float, arg2: float, arg3: float) → Optimizer

run(arg0: List[var], arg1: int) → bool

class pyqpanda.Ansatz

class pyqpanda.Ansatz(arg0: QGate)

class pyqpanda.Ansatz(arg0: AnsatzGate)

class pyqpanda.Ansatz(ansatz: List[AnsatzGate], thetas: List[float] = [])

class pyqpanda.Ansatz(ansatz_circuit: Ansatz, thetas: List[float] = [])

class pyqpanda.Ansatz(circuit: QCircuit, thetas: List[float] = [])

quantum ansatz class

get_ansatz_list() → List[AnsatzGate]

get_thetas_list() → List[float]

insert(gate: QGate) → None

insert(gate: AnsatzGate) → None

insert(gate: List[AnsatzGate]) → None

insert(gate: QCircuit) → None

insert(gate: Ansatz, thetas: List[float] = []) → None

set_thetas(thetas: List[float]) → None

class pyqpanda.AnsatzGate(arg0: AnsatzGateType, arg1: int)

class pyqpanda.AnsatzGate(arg0: AnsatzGateType, arg1: int, arg2: float)

class pyqpanda.AnsatzGate(arg0: AnsatzGateType, arg1: int, arg2: float, arg3: int)

ansatz gate struct

control: int

target: int

theta: float

type: AnsatzGateType

class pyqpanda.AnsatzGateType(value: int)

Quantum ansatz gate type

Members:

AGT_X

AGT_H

AGT_RX

AGT_RY

AGT_RZ

AGT_H: ClassVar[AnsatzGateType] = Ellipsis

AGT_RX: ClassVar[AnsatzGateType] = Ellipsis

AGT_RY: ClassVar[AnsatzGateType] = Ellipsis

AGT_RZ: ClassVar[AnsatzGateType] = Ellipsis

AGT_X: ClassVar[AnsatzGateType] = Ellipsis

property name: str

property value: int

class pyqpanda.BackendType(value: int)

Quantum machine backend type

Members:

CPU

GPU

CPU_SINGLE_THREAD

NOISE

MPS

CPU: ClassVar[BackendType] = Ellipsis

CPU_SINGLE_THREAD: ClassVar[BackendType] = Ellipsis

GPU: ClassVar[BackendType] = Ellipsis

MPS: ClassVar[BackendType] = Ellipsis

NOISE: ClassVar[BackendType] = Ellipsis

property name: str

property value: int

class pyqpanda.CBit(*args, **kwargs)

quantum classical bit

getName() → str

Retrieve the name of the classical bit.

Args:

None

Returns:

The name of the CBit as a string.

class pyqpanda.CPUQVM

Bases: QuantumMachine

quantum machine cpu

get_prob_dict(qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Get a dictionary of probabilities for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of entries to return (default: -1).

Returns:

Dictionary of probabilities as a reference.

get_prob_list(qubit_list: QVec, select_max: int = -1) → List[float]

Get a list of probabilities for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of probabilities to return (default: -1).

Returns:

List of probabilities as a reference.

get_prob_tuple_list(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get a list of probability tuples for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of tuples to return (default: -1).

Returns:

List of probability tuples as a reference.

init_qvm(arg0: bool) → None

init_qvm() → None

Initialize the quantum virtual machine (QVM).

This method sets up the necessary environment for the QVM to execute quantum programs.

Returns:

None: This method does not return a value.

pmeasure(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get the probability distribution over qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of results to select (default: -1).

Returns:

Probability distribution as a reference.

pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits without index.

Args:

qubit_list: List of qubits to measure.

Returns:

Probability distribution as a reference.

prob_run_dict(program: QProg, qubit_list: QVec, select_max: int = -1) → Dict[str, float]

prob_run_dict(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → Dict[str, float]

Execute a quantum program and retrieve a dictionary of probabilities using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of entries in the dictionary to return (default: -1).

Returns:

Dictionary of probabilities.

prob_run_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[float]

prob_run_list(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → List[float]

Execute a quantum program and retrieve a list of probabilities using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of probabilities to return (default: -1).

Returns:

List of probabilities.

prob_run_tuple_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

prob_run_tuple_list(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → List[Tuple[int, float]]

Execute a quantum program and get a list of probability tuples using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of tuples to return (default: -1).

Returns:

List of probability tuples.

quick_measure(qubit_list: QVec, shots: int) → Dict[str, int]

Perform a quick measurement on the specified qubits.

Args:

qubit_list: List of qubits to measure.

shots: Number of measurement shots to perform.

Returns:

Reference to the measurement results.

set_max_threads(size: int) → None

Set the maximum number of threads for the CPU quantum virtual machine (QVM).

Args:

size: The maximum number of threads to use.

Returns:

None: This method does not return a value.

class pyqpanda.CPUSingleThreadQVM

Bases: QuantumMachine

quantum machine class for cpu single thread

get_prob_dict(qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Get a dictionary of probabilities for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of entries to return (default: -1).

Returns:

Dictionary of probabilities as a reference.

get_prob_list(qubit_list: QVec, select_max: int = -1) → List[float]

Get a list of probabilities for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of probabilities to return (default: -1).

Returns:

List of probabilities as a reference.

get_prob_tuple_list(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get a list of probability tuples for the specified qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of tuples to return (default: -1).

Returns:

List of probability tuples as a reference.

pmeasure(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get the probability distribution over qubits.

Args:

qubit_list: List of qubits to measure.

select_max: int, optional, maximum number of results to select (default: -1).

Returns:

Probability distribution as a reference.

pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits without index.

Args:

qubit_list: List of qubits to measure.

Returns:

Probability distribution as a reference.

prob_run_dict(program: QProg, qubit_list: QVec, select_max: int = -1) → Dict[str, float]

prob_run_dict(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → Dict[str, float]

Execute a quantum program and retrieve a dictionary of probabilities using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of entries in the dictionary to return (default: -1).

Returns:

Dictionary of probabilities.

prob_run_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[float]

prob_run_list(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → List[float]

Execute a quantum program and retrieve a list of probabilities using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of probabilities to return (default: -1).

Returns:

List of probabilities.

prob_run_tuple_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

prob_run_tuple_list(program: QProg, qubit_addr_list: List[int], select_max: int = -1) → List[Tuple[int, float]]

Execute a quantum program and get a list of probability tuples using qubit addresses.

Args:

program: The quantum program to execute.

qubit_addr_list: List of qubit addresses to measure.

select_max: int, optional, maximum number of tuples to return (default: -1).

Returns:

List of probability tuples.

quick_measure(qubit_list: QVec, shots: int) → Dict[str, int]

Perform a quick measurement on the specified qubits.

Args:

qubit_list: List of qubits to measure.

shots: Number of measurement shots to perform.

Returns:

Reference to the measurement results.

class pyqpanda.ChipID(value: int)

origin quantum real chip type

Members:

Simulation

WUYUAN_1

WUYUAN_2

WUYUAN_3

Simulation: ClassVar[ChipID] = Ellipsis

WUYUAN_1: ClassVar[ChipID] = Ellipsis

WUYUAN_2: ClassVar[ChipID] = Ellipsis

WUYUAN_3: ClassVar[ChipID] = Ellipsis

property name: str

property value: int

class pyqpanda.ClassicalCondition(*args, **kwargs)

Classical condition class Proxy class of cexpr class

c_and(arg0: int) → ClassicalCondition

c_and(arg0: ClassicalCondition) → ClassicalCondition

Perform a logical AND operation with another ClassicalCondition.

Args:

other: Another ClassicalCondition to perform AND with.

Returns:

The result of the AND operation.

c_not() → ClassicalCondition

Perform a logical NOT operation on the classical condition.

Args:

None

Returns:

The result of the NOT operation.

c_or(arg0: int) → ClassicalCondition

c_or(arg0: ClassicalCondition) → ClassicalCondition

Perform a logical OR operation with another ClassicalCondition.

Args:

other: Another ClassicalCondition to perform OR with.

Returns:

The result of the OR operation.

get_val() → int

Retrieve the current value of the classical condition.

Args:

None

Returns:

The value of the ClassicalCondition.

set_val(arg0: int) → None

Set a new value for the classical condition.

Args:

value: The new value to set.

Returns:

None

class pyqpanda.ClassicalProg(arg0: ClassicalCondition)

quantum ClassicalProg

class pyqpanda.CommProtocolConfig

circuits_num: int

open_error_mitigation: bool

open_mapping: bool

optimization_level: int

shots: int

class pyqpanda.ComplexVertexSplitMethod(value: int)

quantum complex vertex split method

Members:

METHOD_UNDEFINED

LINEAR

RING

LINEAR: ClassVar[ComplexVertexSplitMethod] = Ellipsis

METHOD_UNDEFINED: ClassVar[ComplexVertexSplitMethod] = Ellipsis

RING: ClassVar[ComplexVertexSplitMethod] = Ellipsis

property name: str

property value: int

class pyqpanda.DAGNodeType(value: int)

Quantum dag node type

Members:

NUKNOW_SEQ_NODE_TYPE

MAX_GATE_TYPE

MEASURE

QUBIT

RESET

MAX_GATE_TYPE: ClassVar[DAGNodeType] = Ellipsis

MEASURE: ClassVar[DAGNodeType] = Ellipsis

NUKNOW_SEQ_NODE_TYPE: ClassVar[DAGNodeType] = Ellipsis

QUBIT: ClassVar[DAGNodeType] = Ellipsis

RESET: ClassVar[DAGNodeType] = Ellipsis

property name: str

property value: int

class pyqpanda.DecompositionMode(value: int)

Quantum matrix decomposition mode

Members:

QR

HOUSEHOLDER_QR

QSDecomposition

CSDecomposition

CSDecomposition: ClassVar[DecompositionMode] = Ellipsis

HOUSEHOLDER_QR: ClassVar[DecompositionMode] = Ellipsis

QR: ClassVar[DecompositionMode] = Ellipsis

QSDecomposition: ClassVar[DecompositionMode] = Ellipsis

property name: str

property value: int

class pyqpanda.DensityMatrixSimulator

Bases: QuantumMachine

simulator for density matrix

get_density_matrix(prog: QProg) → numpy.ndarray[numpy.complex128[m, n]]

Run quantum program and get the full density matrix.

Args:

prog: The quantum program to execute.

Returns:

The full density matrix.

get_expectation(prog: QProg, hamiltonian: List[Tuple[Dict[int, str], float]], qubits: QVec) → float

get_expectation(prog: QProg, hamiltonian: List[Tuple[Dict[int, str], float]], qubits: List[int]) → float

Run the quantum program and calculate the Hamiltonian expectation for the specified qubits.

Args:

prog: The quantum program to execute.

hamiltonian: The QHamiltonian to use for the expectation value.

qubits: The selected qubits for measurement.

Returns:

The Hamiltonian expectation for the specified qubits.

get_probabilities(prog: QProg) → List[float]

get_probabilities(prog: QProg, qubits: QVec) → List[float]

get_probabilities(prog: QProg, qubits: List[int]) → List[float]

get_probabilities(prog: QProg, indices: List[str]) → List[float]

Run the quantum program and get the probabilities for the specified binary indices.

Args:

prog: The quantum program to execute.

indices: The selected binary indices for measurement.

Returns:

The probabilities result of the quantum program.

get_probability(prog: QProg, index: int) → float

get_probability(prog: QProg, index: str) → float

Run the quantum program and get the probability for the specified index.

Args:

prog: The quantum program to execute.

index: The measurement index in [0, 2^N 1].

Returns:

The probability result of the quantum program.

get_reduced_density_matrix(prog: QProg, qubits: QVec) → numpy.ndarray[numpy.complex128[m, n]]

get_reduced_density_matrix(prog: QProg, qubits: List[int]) → numpy.ndarray[numpy.complex128[m, n]]

Run quantum program and get the density matrix for current qubits.

Args:

prog: The quantum program to execute.

qubits: The selected qubits from the quantum program.

Returns:

The density matrix for the specified qubits.

init_qvm(is_double_precision: bool = True) → None

set_noise_model(arg0: numpy.ndarray[numpy.complex128[m, n]]) → None

set_noise_model(arg0: numpy.ndarray[numpy.complex128[m, n]], arg1: List[GateType]) → None

set_noise_model(arg0: List[numpy.ndarray[numpy.complex128[m, n]]]) → None

set_noise_model(arg0: List[numpy.ndarray[numpy.complex128[m, n]]], arg1: List[GateType]) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: List[QVec]) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: float, arg4: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float, arg5: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: float, arg4: float, arg5: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float, arg5: List[QVec]) → None

Set a specific noise model for the density matrix simulator with a given gate type, probability, duration, temperature, and multiple target qubits.

Args:

noise_model: The noise model to apply.

gate_type: The specific gate type associated with the noise model.

probability: The probability of the noise occurring.

duration: The duration for which the noise model is applied.

temperature: The temperature affecting the noise characteristics.

target_qubits: A vector of qubits targeted by the noise model.

Returns:

None.

class pyqpanda.DoubleGateTransferType(value: int)

Quantum double gate transfer type

Members:

DOUBLE_GATE_INVALID

DOUBLE_BIT_GATE

DOUBLE_BIT_GATE: ClassVar[DoubleGateTransferType] = Ellipsis

DOUBLE_GATE_INVALID: ClassVar[DoubleGateTransferType] = Ellipsis

property name: str

property value: int

class pyqpanda.Encode

quantum amplitude encode

amplitude_encode(qubit: QVec, data: List[float]) → None

amplitude_encode(qubit: QVec, data: List[complex]) → None

Perform amplitude encoding using complex numbers on the given qubits.

Args:

qubit: The quantum vector to be encoded.

data: The classical complex data to be encoded.

Returns:

An encoded quantum state.

amplitude_encode_recursive(qubit: QVec, data: List[float]) → None

amplitude_encode_recursive(qubit: QVec, data: List[complex]) → None

Encode by amplitude recursively.

Args:

QVec: qubits

QStat: amplitude

Returns:

circuit

angle_encode(qubit: QVec, data: List[float], gate_type: GateType = GateType.RY_GATE) → None

Encode by angle.

Args:

QVec: qubits

prob_vec: data

Returns:

circuit.

approx_mps(qubit: QVec, data: List[float], layers: int = 3, sweeps: int = 100, double2float: bool = False) → None

approx_mps(qubit: QVec, data: List[complex], layers: int = 3, sweeps: int = 100) → None

Approximate Matrix Product State encoding.

Args:

QVec: qubits

std::vector<qcomplex_t>: input data

int: number of layers (default: 3)

int: number of steps (default: 100)

Returns:

Encoded circuit.

basic_encode(qubit: QVec, data: str) → None

Basic encoding.

Args:

QVec: qubits

string: data

Returns:

circuit

bid_amplitude_encode(qubit: QVec, data: List[float], split: int = 0) → None

Encode by bid.

Args:

QVec: qubits

QStat: amplitude

split: int

Returns:

circuit

dc_amplitude_encode(qubit: QVec, data: List[float]) → None

Encode by DC amplitude.

Args:

QVec: qubits

QStat: amplitude

Returns:

circuit

dense_angle_encode(qubit: QVec, data: List[float]) → None

Encode by dense angle.

Args:

QVec: qubits

prob_vec: data

Returns:

circuit

ds_quantum_state_preparation(qubit: QVec, data: Dict[str, float]) → None

ds_quantum_state_preparation(qubit: QVec, data: Dict[str, complex]) → None

ds_quantum_state_preparation(qubit: QVec, data: List[float]) → None

ds_quantum_state_preparation(qubit: QVec, data: List[complex]) → None

Prepare a quantum state.

Args:

QVec: qubits

std::vector<std::complex<double>>: state parameters

Returns:

circuit

efficient_sparse(qubit: QVec, data: Dict[str, float]) → None

efficient_sparse(qubit: QVec, data: Dict[str, complex]) → None

efficient_sparse(qubit: QVec, data: List[float]) → None

efficient_sparse(qubit: QVec, data: List[complex]) → None

Perform an efficient sparse operation.

Args:

QVec: qubits

std::vector<std::complex<double>>: parameters for the operation

Returns:

circuit

get_circuit() → QCircuit

Retrieve the circuit from the encoder.

Returns:

The corresponding circuit object.

get_fidelity(data: List[float]) → float

get_fidelity(data: List[complex]) → float

get_fidelity(data: List[float]) → float

Calculate the fidelity based on the provided float data.

Args:

data: A vector of floats representing the input data.

Returns:

The calculated fidelity value.

get_out_qubits() → QVec

Retrieve the output qubits from the encoder.

Returns:

A vector of output qubits.

iqp_encode(qubit: QVec, data: List[float], control_list: List[Tuple[int, int]] = [], bool_inverse: bool = False, repeats: int = 1) → None

Encode by IQP.

Args:

QVec: qubits

prob_vec: data

list: control_list

bool: bool_inverse

int: repeats

Returns:

circuit.

schmidt_encode(qubit: QVec, data: List[float], cutoff: float) → None

Encode by schmidt.

Args:

QVec: qubits

QStat: amplitude

double: cutoff

Returns:

circuit

sparse_isometry(qubit: QVec, data: Dict[str, float]) → None

sparse_isometry(qubit: QVec, data: Dict[str, complex]) → None

sparse_isometry(qubit: QVec, data: List[float]) → None

sparse_isometry(qubit: QVec, data: List[complex]) → None

Perform a sparse isometry operation.

Args:

QVec: qubits

std::vector<std::complex<double>>: parameters for the isometry

Returns:

circuit

class pyqpanda.ErrorCode(value: int)

pliot error code

Members:

NO_ERROR_FOUND

DATABASE_ERROR

ORIGINIR_ERROR

JSON_FIELD_ERROR

BACKEND_CALC_ERROR

ERR_TASK_BUF_OVERFLOW

EXCEED_MAX_QUBIT

ERR_UNSUPPORT_BACKEND_TYPE

EXCEED_MAX_CLOCK

ERR_UNKNOW_TASK_TYPE

ERR_QVM_INIT_FAILED

ERR_QCOMPILER_FAILED

ERR_PRE_ESTIMATE

ERR_MATE_GATE_CONFIG

ERR_FIDELITY_MATRIX

ERR_QST_PROG

ERR_EMPTY_PROG

ERR_QUBIT_SIZE

ERR_QUBIT_TOPO

ERR_QUANTUM_CHIP_PROG

ERR_REPEAT_MEASURE

ERR_OPERATOR_DB

ERR_TASK_STATUS_BUF_OVERFLOW

ERR_BACKEND_CHIP_TASK_SOCKET_WRONG

CLUSTER_SIMULATE_CALC_ERR

ERR_SCHEDULE_CHIP_TOPOLOGY_SUPPORTED

ERR_TASK_CONFIG

ERR_NOT_FOUND_APP_ID

ERR_NOT_FOUND_TASK_ID

ERR_PARSER_SUB_TASK_RESULT

ERR_SYS_CALL_TIME_OUT

ERR_TASK_TERMINATED

ERR_INVALID_URL

ERR_PARAMETER

ERR_QPROG_LENGTH

ERR_CHIP_OFFLINE

UNDEFINED_ERROR

ERR_SUB_GRAPH_OUT_OF_RANGE

ERR_TCP_INIT_FATLT

ERR_TCP_SERVER_HALT

CLUSTER_BASE

BACKEND_CALC_ERROR: ClassVar[ErrorCode] = Ellipsis

CLUSTER_BASE: ClassVar[ErrorCode] = Ellipsis

CLUSTER_SIMULATE_CALC_ERR: ClassVar[ErrorCode] = Ellipsis

DATABASE_ERROR: ClassVar[ErrorCode] = Ellipsis

ERR_BACKEND_CHIP_TASK_SOCKET_WRONG: ClassVar[ErrorCode] = Ellipsis

ERR_CHIP_OFFLINE: ClassVar[ErrorCode] = Ellipsis

ERR_EMPTY_PROG: ClassVar[ErrorCode] = Ellipsis

ERR_FIDELITY_MATRIX: ClassVar[ErrorCode] = Ellipsis

ERR_INVALID_URL: ClassVar[ErrorCode] = Ellipsis

ERR_MATE_GATE_CONFIG: ClassVar[ErrorCode] = Ellipsis

ERR_NOT_FOUND_APP_ID: ClassVar[ErrorCode] = Ellipsis

ERR_NOT_FOUND_TASK_ID: ClassVar[ErrorCode] = Ellipsis

ERR_OPERATOR_DB: ClassVar[ErrorCode] = Ellipsis

ERR_PARAMETER: ClassVar[ErrorCode] = Ellipsis

ERR_PARSER_SUB_TASK_RESULT: ClassVar[ErrorCode] = Ellipsis

ERR_PRE_ESTIMATE: ClassVar[ErrorCode] = Ellipsis

ERR_QCOMPILER_FAILED: ClassVar[ErrorCode] = Ellipsis

ERR_QPROG_LENGTH: ClassVar[ErrorCode] = Ellipsis

ERR_QST_PROG: ClassVar[ErrorCode] = Ellipsis

ERR_QUANTUM_CHIP_PROG: ClassVar[ErrorCode] = Ellipsis

ERR_QUBIT_SIZE: ClassVar[ErrorCode] = Ellipsis

ERR_QUBIT_TOPO: ClassVar[ErrorCode] = Ellipsis

ERR_QVM_INIT_FAILED: ClassVar[ErrorCode] = Ellipsis

ERR_REPEAT_MEASURE: ClassVar[ErrorCode] = Ellipsis

ERR_SCHEDULE_CHIP_TOPOLOGY_SUPPORTED: ClassVar[ErrorCode] = Ellipsis

ERR_SUB_GRAPH_OUT_OF_RANGE: ClassVar[ErrorCode] = Ellipsis

ERR_SYS_CALL_TIME_OUT: ClassVar[ErrorCode] = Ellipsis

ERR_TASK_BUF_OVERFLOW: ClassVar[ErrorCode] = Ellipsis

ERR_TASK_CONFIG: ClassVar[ErrorCode] = Ellipsis

ERR_TASK_STATUS_BUF_OVERFLOW: ClassVar[ErrorCode] = Ellipsis

ERR_TASK_TERMINATED: ClassVar[ErrorCode] = Ellipsis

ERR_TCP_INIT_FATLT: ClassVar[ErrorCode] = Ellipsis

ERR_TCP_SERVER_HALT: ClassVar[ErrorCode] = Ellipsis

ERR_UNKNOW_TASK_TYPE: ClassVar[ErrorCode] = Ellipsis

ERR_UNSUPPORT_BACKEND_TYPE: ClassVar[ErrorCode] = Ellipsis

EXCEED_MAX_CLOCK: ClassVar[ErrorCode] = Ellipsis

EXCEED_MAX_QUBIT: ClassVar[ErrorCode] = Ellipsis

JSON_FIELD_ERROR: ClassVar[ErrorCode] = Ellipsis

NO_ERROR_FOUND: ClassVar[ErrorCode] = Ellipsis

ORIGINIR_ERROR: ClassVar[ErrorCode] = Ellipsis

UNDEFINED_ERROR: ClassVar[ErrorCode] = Ellipsis

property name: str

property value: int

class pyqpanda.Fusion

quantum fusion operation

aggregate_operations(circuit: QCircuit) → None

aggregate_operations(qprog: QProg) → None

Aggregate operations into the provided quantum program.

Args:

qprog: The quantum program to which operations will be added.

Returns:

A reference to the modified program.

class pyqpanda.GateType(value: int)

quantum gate type

Members:

GATE_NOP

GATE_UNDEFINED

P0_GATE

P1_GATE

PAULI_X_GATE

PAULI_Y_GATE

PAULI_Z_GATE

X_HALF_PI

Y_HALF_PI

Z_HALF_PI

HADAMARD_GATE

T_GATE

S_GATE

P_GATE

CP_GATE

RX_GATE

RY_GATE

RZ_GATE

RXX_GATE

RYY_GATE

RZZ_GATE

RZX_GATE

U1_GATE

U2_GATE

U3_GATE

U4_GATE

CU_GATE

CNOT_GATE

CZ_GATE

MS_GATE

CPHASE_GATE

ISWAP_THETA_GATE

ISWAP_GATE

SQISWAP_GATE

SWAP_GATE

TWO_QUBIT_GATE

P00_GATE

P11_GATE

TOFFOLI_GATE

ORACLE_GATE

I_GATE

BARRIER_GATE

RPHI_GATE

BARRIER_GATE: ClassVar[GateType] = Ellipsis

CNOT_GATE: ClassVar[GateType] = Ellipsis

CPHASE_GATE: ClassVar[GateType] = Ellipsis

CP_GATE: ClassVar[GateType] = Ellipsis

CU_GATE: ClassVar[GateType] = Ellipsis

CZ_GATE: ClassVar[GateType] = Ellipsis

GATE_NOP: ClassVar[GateType] = Ellipsis

GATE_UNDEFINED: ClassVar[GateType] = Ellipsis

HADAMARD_GATE: ClassVar[GateType] = Ellipsis

ISWAP_GATE: ClassVar[GateType] = Ellipsis

ISWAP_THETA_GATE: ClassVar[GateType] = Ellipsis

I_GATE: ClassVar[GateType] = Ellipsis

MS_GATE: ClassVar[GateType] = Ellipsis

ORACLE_GATE: ClassVar[GateType] = Ellipsis

P00_GATE: ClassVar[GateType] = Ellipsis

P0_GATE: ClassVar[GateType] = Ellipsis

P11_GATE: ClassVar[GateType] = Ellipsis

P1_GATE: ClassVar[GateType] = Ellipsis

PAULI_X_GATE: ClassVar[GateType] = Ellipsis

PAULI_Y_GATE: ClassVar[GateType] = Ellipsis

PAULI_Z_GATE: ClassVar[GateType] = Ellipsis

P_GATE: ClassVar[GateType] = Ellipsis

RPHI_GATE: ClassVar[GateType] = Ellipsis

RXX_GATE: ClassVar[GateType] = Ellipsis

RX_GATE: ClassVar[GateType] = Ellipsis

RYY_GATE: ClassVar[GateType] = Ellipsis

RY_GATE: ClassVar[GateType] = Ellipsis

RZX_GATE: ClassVar[GateType] = Ellipsis

RZZ_GATE: ClassVar[GateType] = Ellipsis

RZ_GATE: ClassVar[GateType] = Ellipsis

SQISWAP_GATE: ClassVar[GateType] = Ellipsis

SWAP_GATE: ClassVar[GateType] = Ellipsis

S_GATE: ClassVar[GateType] = Ellipsis

TOFFOLI_GATE: ClassVar[GateType] = Ellipsis

TWO_QUBIT_GATE: ClassVar[GateType] = Ellipsis

T_GATE: ClassVar[GateType] = Ellipsis

U1_GATE: ClassVar[GateType] = Ellipsis

U2_GATE: ClassVar[GateType] = Ellipsis

U3_GATE: ClassVar[GateType] = Ellipsis

U4_GATE: ClassVar[GateType] = Ellipsis

X_HALF_PI: ClassVar[GateType] = Ellipsis

Y_HALF_PI: ClassVar[GateType] = Ellipsis

Z_HALF_PI: ClassVar[GateType] = Ellipsis

property name: str

property value: int

class pyqpanda.HHLAlg(arg0: QuantumMachine)

quantum hhl algorithm class

check_QPE_result() → str

check QPE result

get_amplification_factor() → float

get_amplification_factor

get_ancillary_qubit() → QVec

get_ancillary_qubit

get_hhl_circuit(matrix_A: List[complex], data_b: List[float], precision_cnt: int = 0) → QCircuit

get_qubit_for_QFT() → List[Qubit]

get_qubit_for_QFT

get_qubit_for_b() → List[Qubit]

get_qubit_for_b

query_uesed_qubit_num() → int

query_uesed_qubit_num

class pyqpanda.LATEX_GATE_TYPE(value: int)

Quantum latex gate type

Members:

GENERAL_GATE

CNOT_GATE

SWAP_GATE

CNOT_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

GENERAL_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

SWAP_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

property name: str

property value: int

class pyqpanda.LatexMatrix

Generate quantum circuits latex src code can be compiled on latex package ‘qcircuit’ circuits element treated as matrix element in latex syntax

qcircuit package tutorial [https://physics.unm.edu/CQuIC/Qcircuit/Qtutorial.pdf]

insert_barrier(rows: List[int], from_col: int) → int

Insert a barrier into the circuit.

Args:

rows: The rows of the LaTeX matrix where the barrier is applied.

from_col: Desired column position for the barrier; if space is insufficient, a suitable column will be found.

Returns:

int: Actual column number where the barrier is placed.

insert_gate(target_rows: List[int], ctrl_rows: List[int], from_col: int, gate_type: LATEX_GATE_TYPE, gate_name: str = '', dagger: bool = False, param: str = '') → int

Insert a gate into the circuit.

Args:

target_rows: Gate target rows of the LaTeX matrix.

ctrl_rows: Control rows for the gate.

from_col: Desired column position for the gate; if space is insufficient, a suitable column will be found.

gate_type: Enum type of LATEX_GATE_TYPE.

gate_name: Name of the gate (default: ‘’).

dagger: Flag indicating if the gate is a dagger (default: false).

param: Parameter string for the gate (default: ‘’).

Returns:

int: Actual column number where the gate is placed.

insert_measure(q_row: int, c_row: int, from_col: int) → int

Insert a measurement operation into the circuit.

Args:

q_row: The row of the qubit being measured.

c_row: The row of the classical bit that will store the measurement result.

from_col: The desired column position for the measurement.

Returns:

None, as the function modifies the matrix in place.

insert_reset(q_row: int, from_col: int) → int

Insert a reset operation into the circuit.

Args:

q_row: The row of the qubit to be reset.

from_col: The desired column position for the reset.

Returns:

None, as the function modifies the matrix in place.

insert_timeseq(t_col: int, time_seq: int) → None

Insert a time sequence into the circuit.

Args:

t_col: The column position where the time sequence will be inserted.

time_seq: The time sequence data to be inserted.

Warning:

This function does not check for column number validity, which may cause overwriting.

Users must ensure the column number is managed correctly to avoid conflicts.

set_label(qubit_label: Dict[int, str], cbit_label: Dict[int, str] = {}, time_seq_label: str = '', head: bool = True) → None

Set label at the leftmost head column or rightmost tail column. Labels can be reset at any time.

Args:

qubit_label: Label for the qubit wire’s leftmost head label, specified in LaTeX syntax.If not given, the row will remain empty (e.g., {0: ‘q_{1}’, 2:’q_{2}’}).

cbit_label: Classic label string, supports LaTeX formatting.

time_seq_label: If given, sets the time sequence label.

head: If true, appends the label at the head; if false, appends at the tail.

Returns:

None, as the function modifies the matrix in place.

set_logo(logo: str = '') → None

Add a logo string.

Args:

logo: The logo string to be added. If not provided, the logo will be set to an empty string.

Returns:

None, as the function modifies the matrix in place.

str(with_time: bool = False) → str

Return the final LaTeX source code representation of the matrix.

Args:

with_time: A boolean flag indicating whether to include timing information in the output.

Returns:

str: The LaTeX source code as a string. This method can be called at any time to obtain the current state of the matrix.

class pyqpanda.MPSQVM

Bases: QuantumMachine

quantum matrix product state machine class

add_single_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float) → None

add_single_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float) → None

Add a noise model to a specific gate with multiple error rates.

Args:

noise_model: NOISE_MODEL, the type of noise model to apply.

gate_type: GateType, the type of gate affected by the noise.

error_rate_1: float, the first error rate.

error_rate_2: float, the second error rate.

error_rate_3: float, the third error rate.

Returns:

None.

get_prob_dict(qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Get pmeasure result as dict.

Args:

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result tuple; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

get_prob_list(qubit_list: QVec, select_max: int = -1) → List[float]

Get pmeasure result as list.

Args:

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result tuple; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

get_prob_tuple_list(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get pmeasure result as list.

Args:

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result tuple; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

pmeasure(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get the probability distribution over qubits.

Args:

qubit_list: List of qubits to measure.

select_max: Maximum number of returned elements in the result tuple; should be in [-1, 1<<len(qubit_list)]. Default is -1, which means no limit.

Returns:

Measure result of the quantum machine in tuple form.

pmeasure_bin_index(program: QProg, string: str) → complex

Get pmeasure bin index quantum state amplitude.

Args:

string: Bin string.

Returns:

Complex: Bin amplitude.

pmeasure_bin_subset(program: QProg, string_list: List[str]) → List[complex]

Get pmeasure quantum state amplitude subset.

Args:

list: List of bin state strings.

Returns:

List: Bin amplitude result list.

pmeasure_dec_index(program: QProg, string: str) → complex

Get pmeasure decimal index quantum state amplitude.

Args:

string: Decimal string.

Returns:

Complex: Decimal amplitude.

pmeasure_dec_subset(program: QProg, string_list: List[str]) → List[complex]

Get pmeasure quantum state amplitude subset.

Args:

list: List of decimal state strings.

Returns:

List: Decimal amplitude result list.

pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits.

Args:

qubit_list: List of qubits to measure.

Returns:

Measure result of the quantum machine in list form.

prob_run_dict(program: QProg, qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Run quantum program and get pmeasure result as dict. Args:

program: Quantum program to run.

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

prob_run_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[float]

Run quantum program and get pmeasure result as list.

Args:

program: Quantum program to run.

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

prob_run_tuple_list(program: QProg, qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Run quantum program and get pmeasure result as tuple list.

Args:

program: Quantum program to run.

qubit_list: List of qubits for pmeasure.

select_max: Maximum number of returned elements in the result tuple; should be in [-1, 1<<len(qubit_list)]. Default is -1, meaning no limit.

Returns:

Measure result of the quantum machine.

quick_measure(qubit_list: QVec, shots: int) → Dict[str, int]

Quick measure.

Args:

qubit_list: List of qubits to measure.

shots: The number of repetitions for the measurement operation.

Returns:

Result of the quantum program.

set_measure_error(arg0: NoiseModel, arg1: float) → None

set_measure_error(arg0: NoiseModel, arg1: float, arg2: float, arg3: float) → None

Set the measurement error with multiple error rates for the specified noise model.

Args:

noise_model: The type of noise model to apply.

error_rate1: First error rate.

error_rate2: Second error rate.

error_rate3: Third error rate.

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[QVec]) → None

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[float], arg3: List[QVec]) → None

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]]) → None

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[float]) → None

Set mixed unitary errors with associated probabilities for the specified gate type.

Args:

gate_type: Type of gate affected by the error.

unitary_errors: List of unitary error matrices.

probabilities: Probabilities associated with each unitary error.

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: List[QVec]) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float, arg5: List[QVec]) → None

Set the noise model for the quantum simulation with specific noise levels and qubits.

Args:

noise_model: Type of noise model (bit-flip, phase-flip, etc.).

gate_type: Type of gate affected by the noise.

noise_level_1: First noise level to apply.

noise_level_2: Second noise level to apply.

noise_level_3: Third noise level to apply.

qubits: List of qubits to which the noise model will be applied.

set_readout_error(readout_params: List[List[float]], qubits: QVec) → None

Set readout error parameters for the specified qubits.

Args:

readout_params: Parameters defining the readout errors.

qubits: List of qubits to which the readout errors apply.

set_reset_error(reset_0_param: float, reset_1_param: float) → None

Set the reset error for the quantum state.

Args:

reset_0_param: float, error probability for resetting qubit to 0.

reset_1_param: float, error probability for resetting qubit to 1.

Returns:

None.

set_rotation_error(param: float) → None

Set the rotation error parameters.

Args:

param: The parameters defining the rotation error.

Returns:

A reference to the updated instance of the class.

class pyqpanda.MomentumOptimizer(arg0: var, arg1: float, arg2: float)

variational quantum MomentumOptimizer

get_loss() → float

get_variables() → List[var]

minimize(arg0: float, arg1: float) → Optimizer

run(arg0: List[var], arg1: int) → bool

class pyqpanda.NodeInfo

class pyqpanda.NodeInfo(iter: NodeIter, target_qubits: QVec, control_qubits: QVec, type: int, dagger: bool)

Detailed information of a QProg node

m_cbits: List[int]

m_control_qubits: QVec

m_gate_type: GateType

m_is_dagger: bool

m_iter: NodeIter

m_name: str

m_node_type: NodeType

m_params: List[float]

m_target_qubits: QVec

reset() → None

Reset the NodeInfo instance to its initial state. This function clears any current data in the NodeInfo and prepares it for reuse.

Args:

None

Returns:

None

class pyqpanda.NodeIter

quantum node iter

get_next() → NodeIter

Get the next node iterator.

Args:

None

Returns:

The next NodeIter instance.

get_node_type() → NodeType

Retrieve the type of the current node.

Args:

None

Returns:

The type of the node.

get_pre() → NodeIter

Get the previous node iterator.

Args:

None

Returns:

The previous NodeIter instance.

class pyqpanda.NodeType(value: int)

quantum node type

Members:

NODE_UNDEFINED

GATE_NODE

CIRCUIT_NODE

PROG_NODE

MEASURE_GATE

WHILE_START_NODE

QIF_START_NODE

CLASS_COND_NODE

RESET_NODE

CIRCUIT_NODE: ClassVar[NodeType] = Ellipsis

CLASS_COND_NODE: ClassVar[NodeType] = Ellipsis

GATE_NODE: ClassVar[NodeType] = Ellipsis

MEASURE_GATE: ClassVar[NodeType] = Ellipsis

NODE_UNDEFINED: ClassVar[NodeType] = Ellipsis

PROG_NODE: ClassVar[NodeType] = Ellipsis

QIF_START_NODE: ClassVar[NodeType] = Ellipsis

RESET_NODE: ClassVar[NodeType] = Ellipsis

WHILE_START_NODE: ClassVar[NodeType] = Ellipsis

property name: str

property value: int

class pyqpanda.Noise

Quantum machine for noise simulation

add_mixed_unitary_error(gate_types: GateType, unitary_matrices: List[List[complex]], probs: List[float]) → None

add_mixed_unitary_error(gate_types: GateType, unitary_matrices: List[List[complex]], probs: List[float], qubits: QVec) → None

add_mixed_unitary_error(gate_types: GateType, unitary_matrices: List[List[complex]], probs: List[float], qubits: List[QVec]) → None

Add mixed unitary errors to specified gate types for multiple qubits.

Args:

gate_types: The type of gates to which the mixed unitary errors apply.

unitary_matrices: A vector of unitary matrices representing the errors.

probs: A vector of probabilities corresponding to each unitary matrix.

qubits: A vector of QVec instances indicating which qubits the errors affect.

Returns:

None.

add_noise_model(noise_model: NoiseModel, gate_type: GateType, prob: float) → None

add_noise_model(noise_model: NoiseModel, gate_types: List[GateType], prob: float) → None

add_noise_model(noise_model: NoiseModel, gate_type: GateType, prob: float, qubits: QVec) → None

add_noise_model(noise_model: NoiseModel, gate_types: List[GateType], prob: float, qubits: QVec) → None

add_noise_model(noise_model: NoiseModel, gate_type: GateType, prob: float, qubits: List[QVec]) → None

add_noise_model(noise_model: NoiseModel, gate_type: GateType, t1: float, t2: float, t_gate: float) → None

add_noise_model(noise_model: NoiseModel, gate_types: List[GateType], t1: float, t2: float, t_gate: float) → None

add_noise_model(noise_model: NoiseModel, gate_type: GateType, t1: float, t2: float, t_gate: float, qubits: QVec) → None

add_noise_model(noise_model: NoiseModel, gate_types: List[GateType], t1: float, t2: float, t_gate: float, qubits: QVec) → None

add_noise_model(noise_model: NoiseModel, gate_type: GateType, t1: float, t2: float, t_gate: float, qubits: List[QVec]) → None

Add a noise model to a specific gate with specified time parameters and targeted qubits.

Args:

noise_model: An instance of NOISE_MODEL to be added.

gate_type: The type of gate to which the noise model applies.

t1: The time constant for relaxation (T1).

t2: The time constant for dephasing (T2).

t_gate: The duration of the gate operation.

qubits: A vector of vectors of qubit indices that the noise affects.

Returns:

None.

set_measure_error(noise_model: NoiseModel, prob: float, qubits: QVec = ...) → None

set_measure_error(noise_model: NoiseModel, t1: float, t2: float, t_gate: float, qubits: QVec = ...) → None

Set the measurement error using time parameters for the specified qubits.

Args:

noise_model: An instance of NOISE_MODEL to be used.

t1: The time constant for relaxation (T1).

t2: The time constant for dephasing (T2).

t_gate: The duration of the gate operation.

qubits: A vector of qubit indices to which the measurement error applies. Defaults to an empty QVec.

Returns:

None.

set_readout_error(prob_list: List[List[float]], qubits: QVec = ...) → None

Set readout errors for specified qubits.

Args:

prob_list: A list of probabilities for readout errors.

qubits: A vector of qubit indices that the readout errors apply to (default is all qubits).

Returns:

None.

set_reset_error(p0: float, p1: float, qubits: QVec) → None

Set reset errors for specified qubits.

Args:

p0: The probability of resetting to state |0>.

p1: The probability of resetting to state |1>.

qubits: A vector of qubit indices that the reset errors apply to.

Returns:

None.

set_rotation_error(error: float) → None

Set rotation error for gates.

Args:

error: The error model for rotation operations.

Returns:

None.

class pyqpanda.NoiseModel(value: int)

noise model type

Members:

DAMPING_KRAUS_OPERATOR

DECOHERENCE_KRAUS_OPERATOR

DEPHASING_KRAUS_OPERATOR

PAULI_KRAUS_MAP

BITFLIP_KRAUS_OPERATOR

DEPOLARIZING_KRAUS_OPERATOR

BIT_PHASE_FLIP_OPRATOR

PHASE_DAMPING_OPRATOR

BITFLIP_KRAUS_OPERATOR: ClassVar[NoiseModel] = Ellipsis

BIT_PHASE_FLIP_OPRATOR: ClassVar[NoiseModel] = Ellipsis

DAMPING_KRAUS_OPERATOR: ClassVar[NoiseModel] = Ellipsis

DECOHERENCE_KRAUS_OPERATOR: ClassVar[NoiseModel] = Ellipsis

DEPHASING_KRAUS_OPERATOR: ClassVar[NoiseModel] = Ellipsis

DEPOLARIZING_KRAUS_OPERATOR: ClassVar[NoiseModel] = Ellipsis

PAULI_KRAUS_MAP: ClassVar[NoiseModel] = Ellipsis

PHASE_DAMPING_OPRATOR: ClassVar[NoiseModel] = Ellipsis

property name: str

property value: int

class pyqpanda.NoiseQVM

Bases: QuantumMachine

quantum machine class for simulate noise prog

initQVM(arg0: dict) → None

init quantum virtual machine

init_qvm(json_config: dict) → None

init_qvm() → None

init quantum virtual machine

set_max_threads(size: int) → None

Set the maximum number of threads for the noise quantum virtual machine (NoiseQVM).

Args:

size: The maximum number of threads to utilize.

Returns:

None: This method does not return a value.

set_measure_error(model: NoiseModel, prob: float, qubits: QVec = ...) → None

set_measure_error(model: NoiseModel, T1: float, T2: float, t_gate: float, qubits: QVec = ...) → None

Set the measurement error model in the quantum virtual machine with specific error parameters.

Args:

model: The noise model to be applied for measurement errors.

T1: A double representing the relaxation time constant for the qubits.

T2: A double representing the dephasing time constant for the qubits.

t_gate: A double representing the time duration of the gate operation.

qubits: A specific qubit vector (QVec) for which the measurement error applies (default is an empty QVec).

Returns:

None, as the function configures the measurement error model in place for the specified qubit vector.

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[float]) → None

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[float], arg3: QVec) → None

set_mixed_unitary_error(arg0: GateType, arg1: List[List[complex]], arg2: List[float], arg3: List[QVec]) → None

Set a mixed unitary error model for a specific gate type in the quantum virtual machine, targeting multiple qubits.

Args:

gate_type: The type of gate for which the mixed unitary error model applies.

unitary_ops: A vector of unitary operations (QStat) representing the error model.

probabilities: A vector of doubles representing the probabilities associated with each unitary operation.

qubit_groups: A vector of qubit vectors (QVec) specifying the qubits affected by the error model.

Returns:

None, as the function configures the mixed unitary error model in place for the specified gate type and qubit groups.

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: List[QVec]) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: float, arg4: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float, arg5: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: float, arg4: float, arg5: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: float, arg4: float, arg5: List[QVec]) → None

Set the noise model for a specific gate type with multiple noise parameters affecting a vector of qubit vectors in the quantum virtual machine.

Args:

noise_model: The noise model to be applied.

gate_type: The type of gate for which the noise model is relevant.

noise_level1: A double representing the first level of noise to apply.

noise_level2: A double representing the second level of noise to apply.

noise_level3: A double representing the third level of noise to apply.

qubits_list: A vector of qubit vectors (QVec) affected by the noise model.

Returns:

None, as the function configures the noise model in place for the specified gate type and qubit vectors.

set_readout_error(probs_list: List[List[float]], qubits: QVec = ...) → None

Set a readout error model for the quantum virtual machine.

Args:

probs_list: A list of probabilities for readout errors associated with each qubit.

qubits: A vector of qubits (QVec) for which the readout error model applies. Defaults to all qubits if not specified.

Returns:

None, as this function configures the readout error model in place for the specified qubits.

set_reset_error(p0: float, p1: float, qubits: QVec = ...) → None

Set a reset error model for the quantum virtual machine.

Args:

p0: Probability of the qubit resetting to state 0.

p1: Probability of the qubit resetting to state 1.

qubits: A vector of qubits (QVec) for which the reset error model applies. Defaults to all qubits if not specified.

Returns:

None, as this function configures the reset error model in place for the specified qubits.

set_rotation_error(arg0: float) → None

Set a rotation error model for the quantum virtual machine.

Args:

None specified in the function signature, but typically would include error parameters for the rotation.

Returns:

None, as this function configures the rotation error model in place for the quantum operations.

class pyqpanda.Optimizer(*args, **kwargs)

variational quantum Optimizer class

get_loss() → float

get_variables() → List[var]

run(arg0: List[var], arg1: int) → bool

class pyqpanda.OptimizerFactory

quantum OptimizerFactory class

makeOptimizer() → AbstractOptimizer

makeOptimizer() → AbstractOptimizer

Create an optimizer using its name.

Args:

optimizer_name: A string representing the name of the desired optimizer.

Returns:

An instance of the created optimizer.

class pyqpanda.OptimizerMode(value: int)

variational quantum OptimizerMode

Members:

property name: str

property value: int

class pyqpanda.OptimizerType(value: int)

quantum OptimizerType

Members:

NELDER_MEAD

POWELL

GRADIENT

GRADIENT: ClassVar[OptimizerType] = Ellipsis

NELDER_MEAD: ClassVar[OptimizerType] = Ellipsis

POWELL: ClassVar[OptimizerType] = Ellipsis

property name: str

property value: int

class pyqpanda.OriginCMem

origin quantum cmem

Allocate_CBit() → CBit

Allocate_CBit(cbit_num: int) → CBit

Allocate a specified number of classical bits.

Args:

cbit_num: The number of classical bits to allocate.

Returns:

A reference to the allocated classical bits.

Free_CBit(cbit: CBit) → None

Free a previously allocated classical bit.

Args:

cbit: The classical bit to be freed.

cAlloc() → CBit

cAlloc(arg0: int) → CBit

Allocate memory for classical bits. This method initializes or resets the memory allocation for classical bits.

cAlloc_many(count: int) → List[ClassicalCondition]

Allocate memory for multiple classical bits.

Args:

count: The number of classical bits to allocate.

cFree(classical_cond: ClassicalCondition) → None

Free the allocated memory for a classical condition.

Args:

classical_cond: The classical condition to be freed.

cFree_all(classical_cond_list: List[ClassicalCondition]) → None

cFree_all() → None

Free all allocated classical memory. This method releases all memory associated with classical conditions.

clearAll() → None

Clear all allocated classical bits. This method releases all resources associated with classical bits.

getIdleMem() → int

Get the amount of idle memory currently available.

Returns:

The amount of idle memory in terms of qubits.

getMaxMem() → int

Get the maximum memory capacity.

Returns:

The maximum memory capacity in terms of qubits.

get_allocate_cbits() → List[ClassicalCondition]

Retrieve allocated classical bits. Returns a vector of ClassicalCondition representing the allocated cbits.

get_capacity() → int

Get the capacity of the memory.

Returns:

The total capacity of the memory in terms of qubits.

get_cbit_by_addr(cbit_addr: int) → CBit

Get a classical bit by its address.

Args:

cbit_addr: The address of the classical bit.

Returns:

A reference to the classical bit associated with the given address

.

set_capacity(arg0: int) → None

Set the capacity of the memory.

Args:

capacity: The new capacity for the memory in terms of qubits.

class pyqpanda.OriginCollection

class pyqpanda.OriginCollection(file_name: str)

class pyqpanda.OriginCollection(arg0: OriginCollection)

A relatively free data collection class for saving data

getFilePath() → str

Retrieve the file path associated with the OriginCollection. This function returns the path to the file linked to the collection.

Returns:

A string containing the file path.

getJsonString() → str

Retrieve the JSON string representation of the OriginCollection. This function converts the collection’s data into a JSON format string.

Returns:

A string containing the JSON representation of the collection.

getKeyVector() → List[str]

Retrieve the vector of keys associated with the OriginCollection. This function returns a vector containing all the keys in the collection.

Returns:

A vector of keys.

getValue(key_name: str) → List[str]

Get the value associated with the specified key name. This function retrieves the value stored in the OriginCollection for the given key.

Args:

key_name: The name of the key whose value is to be retrieved.

Returns:

The value associated with the specified key.

getValueByKey(key_value: str) → str

getValueByKey(key_value: int) → str

Retrieve the value associated with a specified key. This function returns the value that corresponds to the given key.

Args:

key_value: The key for which to retrieve the associated value.

Returns:

The value associated with the specified key.

insertValue(key: str, *args) → None

Insert values into the OriginCollection under the specified key. This function adds the first value associated with the provided key and then inserts additional values from the provided arguments.

Args:

key: The key under which to insert the values.

args: A variable number of values to be inserted.

Returns:

None.

open(file_name: str) → bool

Open and read the JSON file at the specified path. This function reads the contents of the JSON file provided.

Args:

file_name: The path to the JSON file to be read.

Returns:

None.

setNames(*args) → None

Set names in the OriginCollection. This function accepts a variable number of name arguments and sets them in the OriginCollection.

Args:

args: A variable number of name strings to be set.

Returns:

None.

write() → bool

Write the current data to a JSON file. This function saves the current contents to a specified JSON file.

Args:

None.

Returns:

None.

class pyqpanda.OriginQubitPool

quantum qubit pool

allocateQubitThroughPhyAddress(qubit_addr: int) → Qubit

Allocate a qubit using its physical address.

Args:

qubit_addr: The physical address of the qubit to allocate.

Returns:

A reference to the allocated qubit.

allocateQubitThroughVirAddress(qubit_num: int) → Qubit

Allocate a qubit using its virtual address.

Args:

qubit_num: The virtual address of the qubit to allocate.

Returns:

A reference to the allocated qubit.

clearAll() → None

Clear all qubits from the OriginQubitPool. This method removes all qubits, resetting the pool to its initial state.

getIdleQubit() → int

Retrieve an idle qubit from the OriginQubitPool.

Returns:

An idle qubit if available, otherwise may return a null reference or indicate no idle qubits.

getMaxQubit() → int

Retrieve the maximum qubit from the OriginQubitPool.

Returns:

The maximum qubit available in the pool.

getPhysicalQubitAddr(qubit: Qubit) → int

Retrieve the physical address of a specified qubit.

Args:

qubit: The qubit for which to retrieve the physical address.

Returns:

The physical address of the specified qubit.

getVirtualQubitAddress(qubit: Qubit) → int

Retrieve the virtual address of a specified qubit.

Args:

qubit: The qubit for which to retrieve the virtual address.

Returns:

The virtual address of the specified qubit.

get_allocate_qubits() → QVec

Retrieve currently allocated qubits.

Returns:

A reference to the vector of currently allocated qubits.

get_capacity() → int

Get the capacity of the OriginQubitPool.

Returns:

An integer representing the capacity of the pool.

get_max_usedqubit_addr() → int

Retrieve the address of the maximum used qubit in the OriginQubitPool.

Returns:

The address of the maximum used qubit, or an indication if no qubits are in use.

get_qubit_by_addr(qubit_addr: int) → Qubit

Retrieve a qubit from the pool using its address.

Args:

qubit_addr: The address of the qubit to retrieve.

Returns:

A reference to the requested qubit.

qAlloc() → Qubit

Allocate a qubit.

Returns:

A reference to the allocated qubit.

qAlloc_many(qubit_num: int) → List[Qubit]

Allocate a list of qubits.

Args:

qubit_num: The number of qubits to allocate.

Returns:

A reference to the vector of allocated qubits.

qFree(arg0: Qubit) → None

Free a previously allocated qubit.

Args:

qubit: The qubit to be freed.

qFree_all(arg0: QVec) → None

qFree_all() → None

Free all allocated qubits in the pool. This method releases all qubits that have been allocated previously.

set_capacity(arg0: int) → None

Set the capacity of the OriginQubitPool.

Args:

capacity: An integer representing the new capacity to be set.

class pyqpanda.PartialAmpQVM

Bases: QuantumMachine

quantum partial amplitude machine class

get_prob_dict(arg0: QVec) → Dict[str, float]

Get the measurement results as a dictionary.

Args:

qubit_list: A list of qubits to measure.

Returns:

A dictionary containing the measurement results of the quantum machine.

init_qvm(backend_type: int = 0) → None

pmeasure_bin_index(bin_index: str) → complex

Get the amplitude of the quantum state for the specified bin index.

Args:

bin_index: A string representing the bin.

Returns:

A complex number representing the amplitude of the bin.

pmeasure_dec_index(dec_index: str) → complex

Get the amplitude of the quantum state for the specified decimal index.

Args:

dec_index: A string representing the decimal.

Returns:

A complex number representing the amplitude of the decimal.

pmeasure_subset(index_list: List[str]) → Dict[str, complex]

Get the amplitudes of the quantum state for a subset of indices.

Args:

index_list: A list of strings representing decimal states.

Returns:

A list of complex numbers representing the amplitude results.

prob_run_dict(arg0: QProg, arg1: QVec) → Dict[str, float]

Run the quantum program and get the measurement results as a dictionary.

Args:

qprog: The quantum program to execute.

qubit_list: A list of qubits to measure.

Returns:

A dictionary containing the measurement results of the quantum machine.

run(qprog: QProg, noise_model: Noise = NoiseModel()) → None

run(qprog: QCircuit, noise_model: Noise = NoiseModel()) → None

Run the quantum program.

Args:

qprog: The quantum circuit to execute.

noise_model: An optional noise model (default is NoiseModel()).

Returns:

None.

class pyqpanda.PhysicalQubit(*args, **kwargs)

Physical Qubit abstract class

getQubitAddr() → int

Retrieve the address of the physical qubit.

This function returns the address of the physical qubit associated with the instance.

Args:

None

Returns:

The address of the physical qubit.

class pyqpanda.PilotNoiseParams(*args, **kwargs)

pliot noise simulate params

double_gate_param: float

double_p2: float

double_pgate: float

noise_model: str

single_gate_param: float

single_p2: float

single_pgate: float

class pyqpanda.ProgCount

double_gate_layer_num: int

double_gate_num: int

gate_num: int

layer_num: int

multi_control_gate_num: int

node_num: int

selected_gate_nums: Dict[GateType, int]

single_gate_layer_num: int

single_gate_num: int

class pyqpanda.QCircuit

class pyqpanda.QCircuit(arg0: NodeIter)

quantum circuit node

begin() → NodeIter

Get an iterator to the first node in the circuit.

Returns:

Iterator: An iterator pointing to the first node.

control(control_qubits: QVec) → QCircuit

Apply a control operation to the circuit.

Args:

control_qubits (list): A list of qubits that will act as control qubits.

Returns:

QCircuit: The circuit with the control operation applied.

dagger() → QCircuit

Compute the adjoint (dagger) of the circuit.

Returns:

QCircuit: The adjoint of this circuit.

end() → NodeIter

Get an iterator to the end of the circuit.

Returns:

Iterator: An iterator pointing to the end of the nodes.

head() → NodeIter

Get an iterator to the head of the circuit.

Returns:

Iterator: An iterator pointing to the head node.

insert(arg0: QCircuit) → QCircuit

insert(arg0: QGate) → QCircuit

Insert a QGate into this circuit.

Args:

gate (QGate): The gate to be inserted.

Returns:

QCircuit: A reference to this circuit after the gate insertion.

is_empty() → bool

Check if the circuit is empty.

Returns:

bool: True if the circuit has no gates; otherwise, False.

last() → NodeIter

Get an iterator to the last node in the circuit.

Returns:

Iterator: An iterator pointing to the last node.

set_control(control_qubits: QVec) → None

Set control qubits for the circuit.

Args:

control_qubits (list): A list of qubits to be set as control qubits.

set_dagger(arg0: bool) → None

Set the dagger property of the circuit.

This method modifies the circuit to represent its adjoint.

class pyqpanda.QCircuitOPtimizerMode(value: int)

Quantum circuit optimize mode

Members:

Merge_H_X

Merge_U3

Merge_RX

Merge_RY

Merge_RZ

Merge_H_X: ClassVar[QCircuitOPtimizerMode] = Ellipsis

Merge_RX: ClassVar[QCircuitOPtimizerMode] = Ellipsis

Merge_RY: ClassVar[QCircuitOPtimizerMode] = Ellipsis

Merge_RZ: ClassVar[QCircuitOPtimizerMode] = Ellipsis

Merge_U3: ClassVar[QCircuitOPtimizerMode] = Ellipsis

property name: str

property value: int

class pyqpanda.QError(value: int)

Quantum QError Type

Members:

UndefineError

qErrorNone

qParameterError

qubitError

loadFileError

initStateError

destroyStateError

setComputeUnitError

runProgramError

getResultError

getQStateError

UndefineError: ClassVar[QError] = Ellipsis

destroyStateError: ClassVar[QError] = Ellipsis

getQStateError: ClassVar[QError] = Ellipsis

getResultError: ClassVar[QError] = Ellipsis

initStateError: ClassVar[QError] = Ellipsis

loadFileError: ClassVar[QError] = Ellipsis

qErrorNone: ClassVar[QError] = Ellipsis

qParameterError: ClassVar[QError] = Ellipsis

qubitError: ClassVar[QError] = Ellipsis

runProgramError: ClassVar[QError] = Ellipsis

setComputeUnitError: ClassVar[QError] = Ellipsis

property name: str

property value: int

class pyqpanda.QGate(arg0: NodeIter)

quantum gate node

control(control_qubits: QVec) → QGate

Get a controlled quantum gate based on the current QGate instance. This function creates a control version of the quantum gate using the specified control qubits.

Args:

control_qubits: A list of qubits that serve as control qubits for the gate.

Returns:

A new QGate instance representing the controlled gate.

dagger() → QGate

dagger() → Any

gate_matrix() → List[complex]

Get the matrix representation of the quantum gate.

Args:

qgate: The quantum gate instance.

Returns:

QStat: The matrix representation of the quantum gate.

gate_type() → int

Get the type of the quantum gate.

Args:

qgate: The quantum gate instance.

Returns:

The type of the quantum gate.

get_control_qubit_num() → int

Retrieve the number of control qubits for the QGate instance. This function returns the count of qubits that act as control qubits for the gate.

Args:

None

Returns:

An integer representing the number of control qubits.

get_control_qubits(control_qubits: QVec) → int

Get the control vector from the current quantum gate node.

Args:

control_qubits: The control qubits output vector.

Returns:

int: Size of the control qubits.

get_qubits(qubits: QVec) → int

Get the qubit vector inside this quantum gate.

Args:

qubits: The qubits output vector.

Returns:

int: Size of the qubits.

get_target_qubit_num() → int

Retrieve the number of target qubits for the QGate instance. This function returns the count of qubits that the quantum gate affects.

Args:

None

Returns:

An integer representing the number of target qubits.

is_dagger() → bool

Check if the QGate instance is a dagger (Hermitian conjugate) of another gate. This function determines whether the current gate is the adjoint of its corresponding gate.

Args:

None

Returns:

A boolean indicating whether the current gate is a dagger.

set_control(arg0: QVec) → bool

Set the control qubits for the QGate instance. This function specifies which qubits will act as control qubits for the gate.

Args:

control_qubits: A list of qubits that will serve as control qubits.

Returns:

None

set_dagger(arg0: bool) → bool

Set the QGate instance to be a dagger (Hermitian conjugate) of another gate. This function configures the current gate to represent its adjoint.

Args:

None

Returns:

None

class pyqpanda.QITE

quantum imaginary time evolution

exec(is_optimization: bool = True) → int

get_all_exec_result(reverse: bool = False, sort: bool = False) → List[List[Tuple[int, float]]]

get_ansatz_list(*args, **kwargs) → Any

get_ansatz_theta_list() → List[List[float]]

get_arbitary_cofficient(arg0: float) → None

get_exec_result(reverse: bool = False, sort: bool = False) → List[Tuple[int, float]]

get_result() → List[Tuple[int, float]]

set_Hamiltonian(arg0) → None

set_ansatz_gate(arg0) → None

set_convergence_factor_Q(arg0: float) → None

set_delta_tau(arg0: float) → None

set_iter_num(arg0: int) → None

set_log_file(arg0: str) → None

set_para_update_mode(arg0: UpdateMode) → None

set_pauli_matrix(arg0: QuantumMachine, arg1: numpy.ndarray[numpy.float64[m, n]]) → None

set_quantum_machine_type(arg0: QMachineType) → None

set_upthrow_num(arg0: int) → None

class pyqpanda.QIfProg(arg0: NodeIter)

class pyqpanda.QIfProg(classical_cond: ClassicalCondition, true_branch_qprog: QProg)

class pyqpanda.QIfProg(classical_cond: ClassicalCondition, true_branch_qprog: QProg, false_branch_qprog: QProg)

quantum if prog node

get_classical_condition() → ClassicalCondition

Retrieve the classical condition associated with the quantum if program.

Returns:

The classical condition object used in the if statement.

get_false_branch() → QProg

Get the quantum program corresponding to the false branch.

Returns:

QProg: The quantum program for the false branch, or an empty QProg if null.

Raises:

runtime_error: If the false branch has an incorrect node type.

get_true_branch() → QProg

Get the quantum program corresponding to the true branch.

Returns:

QProg: The quantum program for the true branch.

Raises:

runtime_error: If the true branch is null or has an incorrect node type.

class pyqpanda.QMachineType(value: int)

Quantum machine type

Members:

CPU

GPU

CPU_SINGLE_THREAD

NOISE

CPU: ClassVar[QMachineType] = Ellipsis

CPU_SINGLE_THREAD: ClassVar[QMachineType] = Ellipsis

GPU: ClassVar[QMachineType] = Ellipsis

NOISE: ClassVar[QMachineType] = Ellipsis

property name: str

property value: int

class pyqpanda.QMeasure(arg0: NodeIter)

quantum measure node

class pyqpanda.QOperator

class pyqpanda.QOperator(arg0: QGate)

class pyqpanda.QOperator(arg0: QCircuit)

quantum operator class

get_matrix() → List[complex]

Retrieve the matrix representation of the QOperator.

Args:

None

Returns:

The matrix representation of the QOperator.

to_instruction(arg0: str) → str

Convert the QOperator to an instruction representation.

Args:

None

Returns:

The instruction representation of the QOperator.

class pyqpanda.QOptimizationResult(arg0: str, arg1: int, arg2: int, arg3: str, arg4: float, arg5: List[float])

quantum QOptimizationResult class

fcalls: int

fun_val: float

iters: int

key: str

message: str

para: List[float]

class pyqpanda.QPilotOSService(machine_type: str = 'CPU')

Bases: QuantumMachine

origin quantum pilot OS Machine

build_expectation_task_msg(prog: QProg, hamiltonian: str, qubits: List[int] = [], shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], task_describe: str = '') → str

use C++ to build a expectation task body.

build_init_msg(api_key: str) → str

build_qst_task_msg(prog: QProg, shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], task_describe: str = '') → str

use C++ to build ordinary qst task msg body

build_query_msg(task_id: str) → str

build_task_msg(prog: List[QProg], shot: int, chip_id: int, is_amend: bool, is_mapping: bool, is_optimization: bool, specified_block: List[int], task_describe: str) → str

use c++ to build real chip measure task msg body.

cAlloc() → ClassicalCondition

cAlloc(cbit: int) → ClassicalCondition

Allocate a cbit

cAlloc_many(cbit_num: int) → List[ClassicalCondition]

Allocate a list of cbits

cFree(arg0: ClassicalCondition) → None

Free a cbit

cFree_all(cbit_list: List[ClassicalCondition]) → None

cFree_all() → None

Free all of cbits

finalize() → None

finalize

get_token(rep_json: str) → ErrorCode

init() → None

init_config(url: str, log_cout: bool) → None

parse_prob_counts_result(result_str: List[str]) → List[Dict[str, int]]

Parse result str to map<string, double> Args:

result_str: Taeget result string

Returns:

array: vector<map<string, double>>

Raises:

none

parse_probability_result(result_str: List[str]) → List[Dict[str, float]]

Parse result str to map<string, double> Args:

result_str: Taeget result string

Returns:

array: vector<map<string, double>>

Raises:

none

parse_task_result(result_str: str) → Dict[str, float]

Parse result str to map<string, double> Args:

result_str: Taeget result string

Returns:

dict: map<string, double>

Raises:

none

parser_expectation_result(json_str: str) → list

deprecated, use Python’s json lib.

parser_sync_result(json_str: str) → list

qAlloc() → Qubit

Allocate a qubit

qAlloc_many(qubit_num: int) → List[Qubit]

Allocate a list of qubits

qFree(qubit: Qubit) → None

Free a qubit

qFree_all(qubit_list: QVec) → None

qFree_all(arg0: QVec) → None

Free all of qubits

set_config(max_qubit: int, max_cbit: int) → None

set QVM max qubit and max cbit

Args:

max_qubit: quantum machine max qubit num max_cbit: quantum machine max cbit num

Returns:

none

Raises:

run_fail: An error occurred in set_configure

tcp_recv(ip: str, port: int, task_id: str) → list

class pyqpanda.QProg

class pyqpanda.QProg(arg0: QProg)

class pyqpanda.QProg(arg0: QCircuit)

class pyqpanda.QProg(arg0: QIfProg)

class pyqpanda.QProg(arg0: QWhileProg)

class pyqpanda.QProg(arg0: QGate)

class pyqpanda.QProg(arg0: QMeasure)

class pyqpanda.QProg(arg0: QReset)

class pyqpanda.QProg(arg0: ClassicalCondition)

class pyqpanda.QProg(arg0: NodeIter)

Quantum program,can construct quantum circuit,data struct is linked list

begin() → NodeIter

Get an iterator to the first node in the program.

Returns:

A reference to the iterator pointing to the first node.

end() → NodeIter

Get an iterator to the end of the program.

Returns:

A reference to the iterator pointing past the last node.

get_max_qubit_addr() → int

get_qgate_num() → int

get_used_cbits(cbit_vector: List[ClassicalCondition]) → List[ClassicalCondition]

Get a list of classical bits used in the program.

Args:

cbit_vector: The vector to store the used classical bits.

Returns:

A reference to the updated classical bit vector.

get_used_qubits(qubit_vector: QVec) → QVec

Get a list of qubits used in the program.

Args:

qubit_vector: The vector to store the used qubits.

Returns:

A reference to the updated qubit vector.

head() → NodeIter

Get an iterator to the head node of the program.

Returns:

A reference to the iterator pointing to the head node.

insert(arg0: QProg) → QProg

insert(arg0: QGate) → QProg

insert(arg0: QCircuit) → QProg

insert(arg0: QIfProg) → QProg

insert(arg0: QWhileProg) → QProg

insert(arg0: QMeasure) → QProg

insert(arg0: QReset) → QProg

insert(arg0: ClassicalCondition) → QProg

Insert a ClassicalCondition into the program.

Args:

condition_op: The classical condition operation to be inserted.

Returns:

A reference to the updated program.

is_empty() → bool

is_measure_last_pos() → bool

Check if the last operation in the program is a measurement.

Returns:

True if the last operation is a measurement, otherwise False.

last() → NodeIter

Get an iterator to the last node in the program.

Args:

None

Returns:

A reference to the iterator pointing to the last node.

class pyqpanda.QProgDAG

quantum prog dag class

get_edges() → List[QProgDAGEdge]

Retrieve the set of edges in the quantum program DAG.

Returns:

List[QProgDAGEdge]: A list of edges in the DAG.

get_target_vertex(vertice_num: int) → QProgDAGVertex

Retrieve a target vertex from the quantum program DAG.

Args:

vertice_num: The index of the vertex to retrieve.

Returns:

QVertex: A reference to the specified vertex in the DAG.

get_vertex_set() → List[QProgDAGVertex]

Retrieve the set of vertices in the quantum program DAG.

Args:

QVec: The set of vertices.

Returns:

QVec: A reference to the vector of vertices in the DAG.

class pyqpanda.QProgDAGEdge(from_arg: int, to_arg: int, qubit_arg: int)

quantum prog dag edge

m_from: int

m_qubit: int

m_to: int

class pyqpanda.QProgDAGVertex

quantum prog dag vertex node

m_id: int

m_layer: int

m_pre_node: List[int]

m_succ_node: List[int]

m_type: DAGNodeType

get_control_vec() → QVec

Retrieve the vector of control qubits associated with the vertex.

get_iter() → NodeIter

Retrieve the iterator associated with the vertex.

get_qubits_vec() → QVec

Retrieve the vector of qubits associated with the vertex.

is_dagger() → bool

Check if the vertex is a dagger operation.

class pyqpanda.QReset(arg0: NodeIter)

quantum reset node

class pyqpanda.QResult(*args, **kwargs)

QResult abstract class, this class contains the result of the quantum measurement

getResultMap() → Dict[str, bool]

class pyqpanda.QVec

class pyqpanda.QVec(qubit_list: List[Qubit])

class pyqpanda.QVec(qvec: QVec)

class pyqpanda.QVec(qubit: Qubit)

Qubit vector basic class

append(qubit: Qubit) → None

Add a qubit to the end of the QVec.

Args:

qubit: A pointer to the Qubit to be added.

Returns:

None.

pop() → None

Remove and return the last qubit from the QVec.

Args:

None

Returns:

A pointer to the removed Qubit.

to_list() → List[Qubit]

Convert the QVec to a standard vector of qubit pointers.

Args:

None

Returns:

A vector containing pointers to the qubits in the QVec.

class pyqpanda.QWhileProg(arg0: NodeIter)

class pyqpanda.QWhileProg(arg0: ClassicalCondition, arg1: QProg)

quantum while node

get_classical_condition() → ClassicalCondition

Retrieve the classical condition associated with the while program.

Returns:

The classical condition object used in the while statement.

get_true_branch() → QProg

Retrieve the quantum program corresponding to the true branch.

Returns:

QProg: The quantum program for the true branch.

Raises:

runtime_error: If the true branch is null or has an incorrect node type.

class pyqpanda.QuantumMachine(*args, **kwargs)

quantum machine base class

allocate_qubit_through_phy_address(address: int) → Qubit

Allocate qubits through physical address.

This function allocates qubits using the specified physical address.

Args:

address: The physical address of the qubit.

Returns:

The allocated qubit.

allocate_qubit_through_vir_address(address: int) → Qubit

Allocate a qubit using its physical address.

This function allocates a qubit based on the specified physical address.

Args:

address: The physical address of the qubit to allocate.

Returns:

A reference to the allocated Qubit.

async_run(qprog: QProg, noise_model: Noise = NoiseModel()) → None

Execute the quantum program asynchronously in the background.

This function runs the specified quantum program without blocking the main thread.

You can check the progress using get_processed_qgate_num(), determine if the process

is finished with is_async_finished(), and retrieve results with get_async_result().

Args:

qprog: The quantum program to run.

noise_model: (optional) The noise model to apply (default is NoiseModel()).

Returns:

A reference indicating the status of the asynchronous operation.

cAlloc() → ClassicalCondition

cAlloc(cbit: int) → ClassicalCondition

Allocate a classical bit (CBit) in the QuantumMachine.

This function allocates a CBit after the quantum machine has been initialized.

Args:

cbit_addr: The address of the CBit to allocate, which should be in the range [0, 29).

Returns:

Reference to the allocated CBit.

cAlloc_many(cbit_num: int) → List[ClassicalCondition]

Allocate multiple classical bits (CBits).

This function must be called after init().

Args:

cbit_num: The number of classical bits to allocate.

Returns:

list[CBit]: A list of allocated classical bits.

cFree(arg0: ClassicalCondition) → None

Free a classical bit (CBit).

This function deallocates a previously allocated classical bit.

Args:

CBit: The classical bit to be freed.

Returns:

None: This function does not return a value.

cFree_all(cbit_list: List[ClassicalCondition]) → None

cFree_all() → None

Free all classical bits (CBits).

This function deallocates all classical bits that have been previously allocated.

Args:

None

Returns:

None: This function does not return a value.

directly_run(qprog: QProg, noise_model: Noise = NoiseModel()) → Dict[str, bool]

Directly execute the quantum program.

This function runs the specified quantum program immediately after the

initialization (init()). It supports an optional noise model, which is

currently only applicable to CPUQVM.

Args:

qprog: The quantum program to run.

noise_model: (optional) The noise model to apply (default is no noise).

Returns:

A dictionary with the execution results:

The final qubit register state. The measurement probabilities.

finalize() → None

Finalize the quantum machine.

Args:

None

Returns:

None

getAllocateCMem() → int

Get the list of allocated classical bits (cbits) in the QuantumMachine.

This function retrieves the cbits that have been allocated for use in the quantum machine.

Args:

None

Returns:

List of allocated cbits.

getAllocateQubitNum() → int

Get the list of allocated qubits in the QuantumMachine.

This function retrieves the qubits that have been allocated for use in the quantum machine.

Args:

None

Returns:

List of allocated qubits.

getStatus(*args, **kwargs) → Any

Get the status of the Quantum machine.

This function retrieves the current status of the Quantum machine.

Args:

None

Returns:

QMachineStatus: The status of the Quantum machine.

get_allocate_cbits() → List[ClassicalCondition]

Retrieve the list of allocated cbits in the QuantumMachine.

This function returns a list of currently allocated cbits.

Args:

None

Returns:

A list of allocated cbits.

get_allocate_cmem_num() → int

Retrieve the list of allocated cbits in the QuantumMachine.

This function returns the currently allocated cbits.

Args:

None

Returns:

A list of allocated cbits.

get_allocate_qubit_num() → int

Retrieve the list of allocated qubits in the QuantumMachine.

This function returns the currently allocated qubits.

Args:

None

Returns:

A list of allocated qubits.

get_allocate_qubits() → List[Qubit]

Retrieve the list of allocated qubits in the QuantumMachine.

This function returns a list of currently allocated qubits.

Args:

None

Returns:

A list of allocated qubits.

get_async_result() → Dict[str, bool]

Retrieve the result of the asynchronous quantum program execution.

This function blocks the current code until the asynchronous process initiated

by async_run() is complete, then returns the results.

Returns:

The result of the asynchronous execution.

get_expectation(qprog: QProg, hamiltonian: List[Tuple[Dict[int, str], float]], qubit_list: QVec) → float

get_expectation(qprog: QProg, hamiltonian: List[Tuple[Dict[int, str], float]], qubit_list: QVec, shots: int) → float

Calculate the expectation value of the given Hamiltonian with specified measurement shots.

This function computes the expectation value based on the provided quantum program,

Hamiltonian, list of qubits to measure, and the number of measurement shots.

Args:

qprog: The quantum program to execute.

hamiltonian: The Hamiltonian for which the expectation is calculated.

qubit_list: A list of qubits to measure.

shots: The number of measurement shots to perform.

Returns:

A double representing the expectation value of the current Hamiltonian.

get_gate_time_map() → Dict[GateType, int]

Retrieve the gate time mapping for the QuantumMachine.

This function returns a map of gates to their corresponding execution times.

Args:

None

Returns:

A reference to the gate time map.

get_processed_qgate_num() → int

Retrieve the number of processed quantum gates.

This function returns the total count of quantum gates that have been processed

by the QuantumMachine.

Returns:

An integer representing the number of processed quantum gates.

get_qstate() → List[complex]

Get the status of the quantum machine.

Args:

None

Returns:

QMachineStatus: The current status of the quantum machine.

get_status(*args, **kwargs) → Any

Retrieve the status of the QuantumMachine.

This function returns the current status of the quantum machine.

Args:

None

Returns:

The status of the Quantum machine, represented as a QMachineStatus.

initQVM() → None

Initialize the global unique quantum machine in the background.

This function sets up the quantum machine based on the specified type.

Args:

machine_type: The type of quantum machine to initialize, as defined in pyQPanda.QMachineType.

Returns:

bool: True if the initialization is successful, otherwise false.

init_qvm() → None

Initialize the global unique quantum machine in the background.

This function sets up the quantum machine based on the specified type.

Args:

machine_type: The type of quantum machine to initialize, as defined in pyQPanda.QMachineType.

Returns:

bool: True if the initialization is successful, otherwise false.

init_sparse_state(*args, **kwargs) → Any

Initialize a sparse quantum state for the QuantumMachine.

This function sets the initial sparse state of the quantum machine.

Args:

state: A map representing the sparse state, where keys are state identifiers and values are qcomplex_t. Defaults to an empty map.

qlist: The list of qubits to which the sparse state will be applied, represented as a QVec object. Defaults to QVec().

Returns:

Reference to the updated quantum machine.

init_state(state: List[complex] = QStat(), qlist: QVec = QVec()) → None

Initialize the quantum state of the QuantumMachine.

This function sets the initial state of the quantum machine.

Args:

state: The initial quantum state, represented as a QStat object. Defaults to QStat().

qlist: The list of qubits to which the state will be applied, represented as a QVec object. Defaults to QVec().

Returns:

Reference to the updated quantum machine.

is_async_finished() → bool

Check if the asynchronous quantum program execution is complete.

This function returns a boolean indicating whether the asynchronous process

initiated by async_run() has finished.

Returns:

True if the process is complete, False otherwise.

qAlloc() → Qubit

Allocate a qubit.

This function must be called after init().

Args:

qubit_addr: The physical address of the qubit, should be in the range [0, 29).

qAlloc_many(qubit_num: int) → List[Qubit]

Allocate multiple qubits.

This function must be called after init().

Args:

qubit_num: The number of qubits to allocate.

Returns:

list[Qubit]: A list of allocated qubits.

qFree(qubit: Qubit) → None

Free a qubit.

This function deallocates a previously allocated qubit.

Args:

qubit: The Qubit to be freed.

Returns:

None: This function does not return a value.

qFree_all(qubit_list: QVec) → None

qFree_all(arg0: QVec) → None

Free all qubits.

This function deallocates all qubits provided in the input vector.

Args:

None

Returns:

None: This function does not return a value.

run_with_configuration(qprog: QProg, cbit_list: List[ClassicalCondition], data: dict, noise_model: Noise = NoiseModel()) → Dict[str, int]

run_with_configuration(qprog: QProg, cbit_list: List[ClassicalCondition], shot: int, noise_model: Noise = NoiseModel()) → Dict[str, int]

run_with_configuration(qprog: QProg, shot: int, noise_model: Noise = NoiseModel()) → Dict[str, int]

run_with_configuration(qprog: QProg, cbit_list: List[int], shot: int, noise_model: Noise = NoiseModel()) → Dict[str, int]

Execute the quantum program with a specified configuration.

This function runs the quantum program using the provided classical bits,

the number of shots for repeated execution, and an optional noise model.

Args:

qprog: The quantum program to execute.

cbit_list: The list of classical bits.

shot: The number of times to repeat the execution.

noise_model: (optional) The noise model to apply (default is no noise). Note: Noise models currently work only on CPUQVM.

Returns:

A tuple containing the execution results over the specified shots:

The final qubit register state. The count of hits for each outcome.

set_configure(max_qubit: int, max_cbit: int) → None

Set the maximum qubit and cbit numbers for the QVM.

Args:

max_qubit: Maximum number of qubits in the quantum machine.

max_cbit: Maximum number of cbits in the quantum machine.

Returns:

None

class pyqpanda.QuantumStateTomography

quantum state tomography class

caculate_tomography_density() → List[List[complex]]

Calculate the tomography density.

Returns:

A reference to the calculated density matrix.

combine_qprogs(circuit: QProg, qlist: QVec) → List[QProg]

combine_qprogs(circuit: QCircuit, qlist: QVec) → List[QProg]

combine_qprogs(circuit: QProg, qlist: List[int]) → List[QProg]

combine_qprogs(circuit: QCircuit, qlist: List[int]) → List[QProg]

Return a list of quantum state tomography quantum programs.

Args:

circuit: The quantum circuit to be combined.

qlist: A vector of indices representing the qubits involved.

Returns:

A reference to the combined quantum programs.

exec(qm, shots: int) → List[List[complex]]

Run state tomography quantum programs.

Args:

qm: The quantum machine to execute the programs on.

shots: The number of shots for the execution.

Returns:

A reference to the execution results.

set_qprog_results(qlist: int, results: List[Dict[str, float]]) → None

Set the results of combined quantum programs.

Args:

qlist: The index of the qubit list.

results: A vector of maps containing the result data.

Returns:

A reference to the updated state.

Raises:

run_fail: An error occurred while setting the results.

class pyqpanda.Qubit(*args, **kwargs)

Qubit abstract class

getPhysicalQubitPtr() → PhysicalQubit

Retrieve a pointer to the associated physical qubit.

This function returns a pointer to the physical qubit that corresponds to this qubit instance.

Args:

None

Returns:

A pointer to the associated physical qubit.

get_phy_addr() → int

Retrieve the physical address of the qubit.

This function returns the physical address associated with this qubit instance.

Args:

None

Returns:

The physical address of the qubit.

class pyqpanda.RMSPropOptimizer(arg0: var, arg1: float, arg2: float, arg3: float)

variational quantum RMSPropOptimizer

get_loss() → float

get_variables() → List[var]

minimize(arg0: float, arg1: float, arg2: float) → Optimizer

run(arg0: List[var], arg1: int) → bool

class pyqpanda.SingleAmpQVM

Bases: QuantumMachine

quantum single amplitude machine class

get_prob_dict(arg0: QVec) → Dict[str, float]

get_prob_dict(arg0: List[int]) → Dict[str, float]

Get the pmeasure result as a dictionary.

Args:

qubit_list: A list of qubits for pmeasure.

Returns:

A dictionary containing the measurement results of the quantum machine.

get_quick_map_vertice(arg0: List[Tuple[int, int]]) → None

Get the quick map vertices.

Returns:

A reference to the quick map vertices.

get_sequence(arg0: List[int], arg1: List[List[Tuple[int, bool]]]) → int

Get the program sequence.

Returns:

A reference to the current program sequence.

pmeasure_bin_amplitude(arg0: str) → complex

Measure the bin amplitude of the quantum state.

Args:

bin_string: A string representing the bin.

Returns:

A complex number representing the bin amplitude.

pmeasure_bin_index(arg0: str) → float

Measure the bin index of the quantum state amplitude.

Args:

bin_string: A string representing the bin.

Returns:

A double representing the amplitude probability of the bin.

pmeasure_dec_amplitude(arg0: str) → complex

Measure the dec amplitude of the quantum state.

Args:

dec_string: A string representing the dec.

Returns:

A complex number representing the dec amplitude.

pmeasure_dec_index(arg0: str) → float

Measure the dec index of the quantum state amplitude.

Args:

dec_string: A string representing the dec.

Returns:

A double representing the amplitude probability of the dec.

prob_run_dict(arg0: QProg, arg1: QVec) → Dict[str, float]

prob_run_dict(arg0: QProg, arg1: List[int]) → Dict[str, float]

Run the quantum program and get the pmeasure result as a dictionary.

Args:

qprog: The quantum program to run.

qubit_list: A list of qubits for pmeasure.

Returns:

A dictionary containing the measurement results of the quantum machine.

run(prog: QProg, qv: QVec, max_rank: int = 30, alloted_time: int = 5) → None

run(arg0: QProg, arg1: QVec, arg2: int, arg3: List[List[Tuple[int, bool]]]) → None

Run the quantum program.

Args:

prog: A quantum program (QProg) to be executed.

qv: A list of qubits (QVec) involved in the program.

max_rank: The maximum rank to consider during execution.

sequences: A list of sequences (std::vector<qprog_sequence_t>).

Returns:

None, as the function executes the program in place.

class pyqpanda.SingleGateTransferType(value: int)

Quantum single gate transfer type

Members:

SINGLE_GATE_INVALID

ARBITRARY_ROTATION

DOUBLE_CONTINUOUS

SINGLE_CONTINUOUS_DISCRETE

DOUBLE_DISCRETE

ARBITRARY_ROTATION: ClassVar[SingleGateTransferType] = Ellipsis

DOUBLE_CONTINUOUS: ClassVar[SingleGateTransferType] = Ellipsis

DOUBLE_DISCRETE: ClassVar[SingleGateTransferType] = Ellipsis

SINGLE_CONTINUOUS_DISCRETE: ClassVar[SingleGateTransferType] = Ellipsis

SINGLE_GATE_INVALID: ClassVar[SingleGateTransferType] = Ellipsis

property name: str

property value: int

class pyqpanda.SparseQVM

Bases: QuantumMachine

quantum sparse machine class

directlyRun(arg0: QProg) → Dict[str, bool]

Run the quantum program and get the measurement results as a dictionary.

Args:

qprog: The quantum program to execute.

Returns:

Dict[str, bool]: The result of the quantum program execution in one shot.

directly_run(arg0: QProg) → Dict[str, bool]

Run the quantum program and get the measurement results as a dictionary.

Args:

qprog: The quantum program to execute.

Returns:

The measurement results of the quantum machine.

init_qvm() → None

init quantum virtual machine

prob_run_dict(arg0: QProg) → Dict[str, float]

Run the quantum program and get the measurement results as a dictionary.

Args:

qprog: The quantum program to execute.

Returns:

A dictionary containing the measurement results of the quantum machine.

run_with_configuration(arg0: QProg, arg1: List[ClassicalCondition], arg2: int) → Dict[str, int]

Run the quantum program with the specified configuration and get the measurement results as a dictionary.

Args:

qprog: The quantum program to execute.

cbits: The quantum classical bits.

shots: The number of sample shots.

Returns:

The measurement results of the quantum machine.

class pyqpanda.Stabilizer

Bases: QuantumMachine

simulator for basic clifford simulator

init_qvm() → None

init quantum virtual machine

prob_run_dict(qprog: QProg, qubits: QVec, select_max: int = -1) → Dict[str, float]

Run quantum program and get probabilities.

Args:

qprog: Quantum program to execute.

qubits: Qubits to be measured for probabilities.

select_max: Optional, selects the maximum number of probabilities to return.

Returns:

Probabilities result of the quantum program.

run_with_configuration(qprog: QProg, shot: int) → Dict[str, int]

Run quantum program and get shots result.

Args:

qprog: Quantum program to execute.

shot: Number of measurement shots.

Returns:

Shots result of the quantum program.

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: List[GateType], arg2: float, arg3: QVec) → None

set_noise_model(arg0: NoiseModel, arg1: GateType, arg2: float, arg3: List[QVec]) → None

Set a noise model for the Stabilizer simulator with a specific gate type, probability, and multiple targeted qubits.

Args:

noise_model: The noise model to apply (e.g., bit-flip, phase-flip, etc.).

gate_type: The specific gate type associated with the noise model.

probability: The probability of the noise occurring.

target_qubits: A vector of qubit vectors targeted by the noise model.

Returns:

None.

class pyqpanda.UpdateMode(value: int)

quantum imaginary time evolution update mode

Members:

GD_VALUE

GD_DIRECTION

GD_DIRECTION: ClassVar[UpdateMode] = Ellipsis

GD_VALUE: ClassVar[UpdateMode] = Ellipsis

property name: str

property value: int

class pyqpanda.VanillaGradientDescentOptimizer(arg0: var, arg1: float, arg2: float, arg3: OptimizerMode)

variational quantum VanillaGradientDescentOptimizer

get_loss() → float

get_variables() → List[var]

minimize(arg0: float, arg1: float) → Optimizer

run(arg0: List[var], arg1: int) → bool

class pyqpanda.VariationalQuantumCircuit

class pyqpanda.VariationalQuantumCircuit(arg0: QCircuit)

variational quantum CIRCUIT class

control(arg0: QVec) → VariationalQuantumCircuit

dagger() → VariationalQuantumCircuit

feed() → QCircuit

feed(arg0) → QCircuit

get_control_qubit() → QVec

insert(arg0: VariationalQuantumGate_I) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_H) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_X) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_Y) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_T) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_S) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_Z) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_X1) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_Y1) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_Z1) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_U1) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_U2) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_U3) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_U4) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_RX) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_RY) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_RZ) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CNOT) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CR) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CZ) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CRX) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CRY) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_CRZ) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_SWAP) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_iSWAP) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumGate_SqiSWAP) → VariationalQuantumCircuit

insert(arg0: VariationalQuantumCircuit) → VariationalQuantumCircuit

insert(arg0: QCircuit) → VariationalQuantumCircuit

insert(arg0: QGate) → VariationalQuantumCircuit

is_dagger() → bool

set_control(arg0: QVec) → bool

set_dagger(arg0: bool) → bool

class pyqpanda.VariationalQuantumGate(*args, **kwargs)

variational quantum gate base class

feed(arg0: Dict[int, float]) → QGate

get_constants() → List[float]

get_control_qubit() → QVec

get_vars() → List[var]

is_dagger() → bool

set_control(arg0: QVec) → bool

set_dagger(arg0: bool) → bool

class pyqpanda.VariationalQuantumGate_CNOT(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum CNOT gate class

control(arg0: QVec) → VariationalQuantumGate_CNOT

dagger() → VariationalQuantumGate_CNOT

class pyqpanda.VariationalQuantumGate_CR(arg0: Qubit, arg1: Qubit, arg2: float)

class pyqpanda.VariationalQuantumGate_CR(arg0: Qubit, arg1: Qubit, arg2: var)

class pyqpanda.VariationalQuantumGate_CR(arg0: VariationalQuantumGate_CR)

Bases: VariationalQuantumGate

variational quantum CR gate class

control(arg0: QVec) → VariationalQuantumGate_CR

dagger() → VariationalQuantumGate_CR

class pyqpanda.VariationalQuantumGate_CRX(arg0: Qubit, arg1: QVec, arg2: float)

class pyqpanda.VariationalQuantumGate_CRX(arg0: Qubit, arg1: QVec, arg2: var)

class pyqpanda.VariationalQuantumGate_CRX(arg0: VariationalQuantumGate_CRX)

Bases: VariationalQuantumGate

variational quantum CRX gate class

control(arg0: QVec) → VariationalQuantumGate_CRX

dagger() → VariationalQuantumGate_CRX

class pyqpanda.VariationalQuantumGate_CRY(arg0: Qubit, arg1: QVec, arg2: float)

class pyqpanda.VariationalQuantumGate_CRY(arg0: Qubit, arg1: QVec, arg2: var)

class pyqpanda.VariationalQuantumGate_CRY(arg0: VariationalQuantumGate_CRY)

Bases: VariationalQuantumGate

variational quantum CRY gate class

control(arg0: QVec) → VariationalQuantumGate_CRY

dagger() → VariationalQuantumGate_CRY

class pyqpanda.VariationalQuantumGate_CRZ(arg0: Qubit, arg1: QVec, arg2: float)

class pyqpanda.VariationalQuantumGate_CRZ(arg0: Qubit, arg1: QVec, arg2: var)

class pyqpanda.VariationalQuantumGate_CRZ(arg0: VariationalQuantumGate_CRZ)

Bases: VariationalQuantumGate

variational quantum CRZ gate class

control(arg0: QVec) → VariationalQuantumGate_CRZ

dagger() → VariationalQuantumGate_CRZ

class pyqpanda.VariationalQuantumGate_CU(arg0: Qubit, arg1: Qubit, arg2: float, arg3: float, arg4: float, arg5: float)

class pyqpanda.VariationalQuantumGate_CU(arg0: Qubit, arg1: Qubit, arg2: var, arg3: var, arg4: var, arg5: var)

class pyqpanda.VariationalQuantumGate_CU(arg0: VariationalQuantumGate_CU)

Bases: VariationalQuantumGate

variational quantum CU gate class

control(arg0: QVec) → VariationalQuantumGate_CU

dagger() → VariationalQuantumGate_CU

class pyqpanda.VariationalQuantumGate_CZ(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum CZ gate class

control(arg0: QVec) → VariationalQuantumGate_CZ

dagger() → VariationalQuantumGate_CZ

class pyqpanda.VariationalQuantumGate_H(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum H gate class

control(arg0: QVec) → VariationalQuantumGate_H

dagger() → VariationalQuantumGate_H

class pyqpanda.VariationalQuantumGate_I(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum I gate class

control(arg0: QVec) → VariationalQuantumGate_I

dagger() → VariationalQuantumGate_I

class pyqpanda.VariationalQuantumGate_RX(arg0: Qubit, arg1: var)

class pyqpanda.VariationalQuantumGate_RX(arg0: Qubit, arg1: float)

Bases: VariationalQuantumGate

variational quantum RX gate class

control(arg0: QVec) → VariationalQuantumGate_RX

dagger() → VariationalQuantumGate_RX

class pyqpanda.VariationalQuantumGate_RY(arg0: Qubit, arg1: var)

class pyqpanda.VariationalQuantumGate_RY(arg0: Qubit, arg1: float)

Bases: VariationalQuantumGate

variational quantum RY gate class

control(arg0: QVec) → VariationalQuantumGate_RY

dagger() → VariationalQuantumGate_RY

class pyqpanda.VariationalQuantumGate_RZ(arg0: Qubit, arg1: var)

class pyqpanda.VariationalQuantumGate_RZ(arg0: Qubit, arg1: float)

Bases: VariationalQuantumGate

variational quantum RZ gate class

control(arg0: QVec) → VariationalQuantumGate_RZ

dagger() → VariationalQuantumGate_RZ

class pyqpanda.VariationalQuantumGate_S(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum S gate class

control(arg0: QVec) → VariationalQuantumGate_S

dagger() → VariationalQuantumGate_S

class pyqpanda.VariationalQuantumGate_SWAP(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum SWAP gate class

control(arg0: QVec) → VariationalQuantumGate_SWAP

dagger() → VariationalQuantumGate_SWAP

class pyqpanda.VariationalQuantumGate_SqiSWAP(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum SqiSWAP gate class

control(arg0: QVec) → VariationalQuantumGate_SqiSWAP

dagger() → VariationalQuantumGate_SqiSWAP

class pyqpanda.VariationalQuantumGate_T(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum T gate class

control(arg0: QVec) → VariationalQuantumGate_T

dagger() → VariationalQuantumGate_T

class pyqpanda.VariationalQuantumGate_U1(arg0: Qubit, arg1: var)

class pyqpanda.VariationalQuantumGate_U1(arg0: Qubit, arg1: float)

Bases: VariationalQuantumGate

variational quantum U1 gate class

control(arg0: QVec) → VariationalQuantumGate_U1

dagger() → VariationalQuantumGate_U1

class pyqpanda.VariationalQuantumGate_U2(arg0: Qubit, arg1: var, arg2: var)

class pyqpanda.VariationalQuantumGate_U2(arg0: Qubit, arg1: float, arg2: float)

Bases: VariationalQuantumGate

variational quantum U2 gate class

control(arg0: QVec) → VariationalQuantumGate_U2

dagger() → VariationalQuantumGate_U2

class pyqpanda.VariationalQuantumGate_U3(arg0: Qubit, arg1: var, arg2: var, arg3: var)

class pyqpanda.VariationalQuantumGate_U3(arg0: Qubit, arg1: float, arg2: float, arg3: float)

Bases: VariationalQuantumGate

variational quantum U3 gate class

control(arg0: QVec) → VariationalQuantumGate_U3

dagger() → VariationalQuantumGate_U3

class pyqpanda.VariationalQuantumGate_U4(arg0: Qubit, arg1: var, arg2: var, arg3: var, arg4: var)

class pyqpanda.VariationalQuantumGate_U4(arg0: Qubit, arg1: float, arg2: float, arg3: float, arg4: float)

Bases: VariationalQuantumGate

variational quantum U4 gate class

control(arg0: QVec) → VariationalQuantumGate_U4

dagger() → VariationalQuantumGate_U4

class pyqpanda.VariationalQuantumGate_X(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum X gate class

control(arg0: QVec) → VariationalQuantumGate_X

dagger() → VariationalQuantumGate_X

class pyqpanda.VariationalQuantumGate_X1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum X1 gate class

control(arg0: QVec) → VariationalQuantumGate_X1

dagger() → VariationalQuantumGate_X1

class pyqpanda.VariationalQuantumGate_Y(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Y gate class

control(arg0: QVec) → VariationalQuantumGate_Y

dagger() → VariationalQuantumGate_Y

class pyqpanda.VariationalQuantumGate_Y1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Y1 gate class

control(arg0: QVec) → VariationalQuantumGate_Y1

dagger() → VariationalQuantumGate_Y1

class pyqpanda.VariationalQuantumGate_Z(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Z gate class

control(arg0: QVec) → VariationalQuantumGate_Z

dagger() → VariationalQuantumGate_Z

class pyqpanda.VariationalQuantumGate_Z1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Z1 gate class

control(arg0: QVec) → VariationalQuantumGate_Z1

dagger() → VariationalQuantumGate_Z1

class pyqpanda.VariationalQuantumGate_iSWAP(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum iSWAP gate class

control(arg0: QVec) → VariationalQuantumGate_iSWAP

dagger() → VariationalQuantumGate_iSWAP

class pyqpanda.em_method(value: int)

origin quantum real chip error_mitigation type

Members:

ZNE

PEC

READ_OUT

PEC: ClassVar[em_method] = Ellipsis

READ_OUT: ClassVar[em_method] = Ellipsis

ZNE: ClassVar[em_method] = Ellipsis

property name: str

property value: int

class pyqpanda.expression(arg0: var)

variational quantum expression class

backprop(arg0: Dict[var, numpy.ndarray[numpy.float64[m, n]]]) → None

backprop(arg0: Dict[var, numpy.ndarray[numpy.float64[m, n]]], arg1: List[var]) → None

find_leaves() → List[var]

find_non_consts(arg0: List[var]) → List[var]

get_root() → var

propagate() → numpy.ndarray[numpy.float64[m, n]]

propagate(arg0: List[var]) → numpy.ndarray[numpy.float64[m, n]]

class pyqpanda.hadamard_circuit(arg0: QVec)

Bases: QCircuit

hadamard circuit class

class pyqpanda.real_chip_type(value: int)

origin quantum real chip type enum

Members:

origin_wuyuan_d3

origin_wuyuan_d4

origin_wuyuan_d5

origin_72

origin_72: ClassVar[real_chip_type] = Ellipsis

origin_wuyuan_d3: ClassVar[real_chip_type] = Ellipsis

origin_wuyuan_d4: ClassVar[real_chip_type] = Ellipsis

origin_wuyuan_d5: ClassVar[real_chip_type] = Ellipsis

property name: str

property value: int

class pyqpanda.var(arg0: float)

class pyqpanda.var(arg0: numpy.ndarray[numpy.float64[m, n], flags.writeable])

class pyqpanda.var(arg0: float, arg1: bool)

class pyqpanda.var(arg0: numpy.ndarray[numpy.float64[m, n], flags.writeable], arg1: bool)

quantum variational class

clone() → var

get_value() → numpy.ndarray[numpy.float64[m, n]]

set_value(arg0: numpy.ndarray[numpy.float64[m, n]]) → None

set_value(arg0: float) → None

pyqpanda.BARRIER(qubit: Qubit) → QGate

pyqpanda.BARRIER(qubit_list: int) → QGate

pyqpanda.BARRIER(qubit_list: QVec) → QGate

pyqpanda.BARRIER(qubit_addr_list: List[int]) → QGate

Create a BARRIER gate for a list of qubit addresses.

Args:

qubit_addr_list: a list of integers representing the addresses of the qubits.

Returns:

A BARRIER node representing the operation.

pyqpanda.CNOT(control_qubit: Qubit, target_qubit: Qubit) → QGate

pyqpanda.CNOT(control_qubit_list: QVec, target_qubit_list: QVec) → QCircuit

pyqpanda.CNOT(control_qubit_addr: int, target_qubit_addr: int) → QGate

pyqpanda.CNOT(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int]) → QCircuit

Returns:

a CNOT gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.CP(control_qubit: Qubit, target_qubit: Qubit, theta_angle: float) → QGate

pyqpanda.CP(control_qubit_list: QVec, target_qubit_list: QVec, theta_angle: float) → QCircuit

pyqpanda.CP(control_qubit_addr: int, target_qubit_addr: int, theta_angle: float) → QGate

pyqpanda.CP(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], theta_angle: float) → QCircuit

Returns:

a CP gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.CR(control_qubit: Qubit, target_qubit: Qubit, theta_angle: float) → QGate

pyqpanda.CR(control_qubit_list: QVec, target_qubit_list: QVec, theta_angle: float) → QCircuit

pyqpanda.CR(control_qubit_addr: int, target_qubit_addr: int, theta_angle: float) → QGate

pyqpanda.CR(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], theta_angle: float) → QCircuit

Returns:

a CR gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.CU(alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float, control_qubit: Qubit, target_qubit: Qubit) → QGate

pyqpanda.CU(alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float, control_qubit_list: QVec, target_qubi_list: QVec) → QCircuit

pyqpanda.CU(matrix: List[complex], control_qubit: Qubit, target_qubit: Qubit) → QGate

pyqpanda.CU(matrix: List[complex], control_qubit_list: QVec, target_qubit_list: QVec) → QCircuit

pyqpanda.CU(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float) → QGate

pyqpanda.CU(control_qubit_list: QVec, target_qubit_list: QVec, alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float) → QCircuit

pyqpanda.CU(control_qubit_addr: int, target_qubit_addr: int, alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float) → QGate

pyqpanda.CU(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float) → QCircuit

pyqpanda.CU(control_qubit: Qubit, target_qubit: Qubit, matrix: List[complex]) → QGate

pyqpanda.CU(control_qubit_list: QVec, target_qubit_list: QVec, matrix: List[complex]) → QCircuit

pyqpanda.CU(control_qubit_addr: int, target_qubit_addr: int, matrix: List[complex]) → QGate

pyqpanda.CU(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], matrix: List[complex]) → QCircuit

Create a CU gate.

Args:

control_qubit_addr_list (const std::vector<int> &): List of control qubit addresses.

target_qubit_addr_list (const std::vector<int> &): List of target qubit addresses.

matrix (QStat &): The CU gate matrix.

Returns:

A CU node representing the operation.

pyqpanda.CZ(control_qubit: Qubit, target_qubit: Qubit) → QGate

pyqpanda.CZ(control_qubit_list: QVec, target_qubit_list: QVec) → QCircuit

pyqpanda.CZ(control_qubit_addr: int, target_qubit_addr: int) → QGate

pyqpanda.CZ(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int]) → QCircuit

Returns:

a CZ gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.CreateEmptyCircuit() → QCircuit

Create an empty QCircuit container.

Args:

none

Returns:

result: An empty QCircuit.

pyqpanda.CreateEmptyQProg() → QProg

Create an empty QProg container.

Args:

none

Returns:

an empty QProg.

pyqpanda.CreateIfProg(classical_condition: ClassicalCondition, true_node: QProg) → QIfProg

pyqpanda.CreateIfProg(classical_condition: ClassicalCondition, true_node: QProg, false_node: QProg) → QIfProg

Create an IfProg that executes one of two quantum operations based on a classical condition.

Args:

classical_condition: A classical condition representing the if condition.

true_node: The quantum operations to execute if the condition is true.

false_node: The quantum operations to execute if the condition is false.

Returns:

IfProg: The program that performs the specified operations based on the condition.

pyqpanda.CreateWhileProg(classical_condition: ClassicalCondition, true_node: QProg) → QWhileProg

Create a WhileProg that executes while a classical condition is true.

Args:

classical_condition: A classical condition representing the while-loop condition.

true_node: The quantum operations to execute while the condition is true.

Returns:

WhileProg: The program that performs the specified operations while the condition holds.

pyqpanda.Grover(*args, **kwargs) → Any

Quantum grover circuit

Args:

qvec: qubit list Classical_condition: quantum Classical condition QuantumMachine: quantum machine

Returns:

result : Grover circuit

Raises:

run_fail: An error occurred in Grover

pyqpanda.Grover_search(list: List[int], Classical_condition: ClassicalCondition, QuantumMachine: Grover_search.QuantumMachine, repeat: int = 2) → Grover_search.list

pyqpanda.Grover_search(list: List[str], Classical_condition: str, QuantumMachine: Grover_search.QuantumMachine, data: int = 2) → Grover_search.list

use Grover algorithm to search target data, return QProg and search_result

pyqpanda.H(qubit: Qubit) → QGate

pyqpanda.H(qubit_list: QVec) → QCircuit

pyqpanda.H(qubit_addr: int) → QGate

pyqpanda.H(qubit_addr_list: List[int]) → QCircuit

Create a H gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a H gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.HHL_solve_linear_equations(matrix_A: List[complex], data_b: List[float], precision_cnt: int = 0) → List[complex]

Use HHL algorithm to solve the target linear systems of equations : Ax = b

Args:

matrix_A: a unitary matrix or Hermitian N*N matrix with N = 2 ^ n

data_b: a given vector

precision_cnt: The count of digits after the decimal point

default is 0, indicates that there are only integer solutions.

Returns:

QStat The solution of equation, i.e.x for Ax = b

Notes:

The higher the precision is, the more qubit number and circuit - depth will be, for example: 1 - bit precision, 4 additional qubits are required, for 2 - bit precision, we need 7 additional qubits, and so on.

pyqpanda.I(qubit: Qubit) → QGate

pyqpanda.I(qubit_list: QVec) → QCircuit

pyqpanda.I(qubit_addr: int) → QGate

pyqpanda.I(qubit_addr_list: List[int]) → QCircuit

Create a I gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a I gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.MAJ(arg0: Qubit, arg1: Qubit, arg2: Qubit) → QCircuit

Quantum adder MAJ module

pyqpanda.MAJ2(arg0: QVec, arg1: QVec, arg2: Qubit) → QCircuit

Quantum adder MAJ2 module

pyqpanda.MS(first_qubit: Qubit, second_qubit: Qubit) → QGate

pyqpanda.MS(first_qubit_list: QVec, second_qubit_list: QVec) → QCircuit

pyqpanda.MS(first_qubit_addr: int, second_qubit_addr: int) → QGate

pyqpanda.MS(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int]) → QCircuit

Returns:

a MS gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Measure(qubit: Qubit, cbit: ClassicalCondition) → QMeasure

pyqpanda.Measure(qubit: Qubit, cbit: CBit) → QMeasure

pyqpanda.Measure(qubit_addr: int, cbit_addr: int) → QMeasure

Create a measure node.

Args:

qubit_addr: address of the qubit to be measured.

cbit_addr: address of the classical bit that stores the quantum measurement result.

Returns:

a quantum measure node.

pyqpanda.OBMT_mapping(prog: QProg, quantum_machine: QuantumMachine, b_optimization: bool = False, max_partial: int = 4294967295, max_children: int = 4294967295, config_data: str = 'QPandaConfig.json') → QProg

pyqpanda.OBMT_mapping(prog: QProg, quantum_machine: QuantumMachine, b_optimization: bool, arch_matrix: numpy.ndarray[numpy.float64[m, n]]) → QProg

OPT_BMT mapping

Args:

prog: the target prog

quantum_machine: quantum machine

b_optimization: whether open the optimization

arch_matrix: arch graph matrix

Returns:

mapped quantum program

pyqpanda.P(qubit: Qubit, angle: float) → QGate

pyqpanda.P(qubit_list: QVec, angle: float) → QCircuit

pyqpanda.P(qubit_addr: int, angle: float) → QGate

pyqpanda.P(qubit_addr_list: List[int], angle: float) → QCircuit

Create a P gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a P gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.PMeasure(arg0: QVec, arg1: int) → List[Tuple[int, float]]

Deprecated, use pmeasure instead.

Args:

QVec: pmeasure qubits list.

select_num: result select num.

Returns:

result: pmeasure qubits result.

pyqpanda.PMeasure_no_index(arg0: QVec) → List[float]

Deprecated, use pmeasure_no_index instead.

Args:

QVec: pmeasure qubits list.

Returns:

result: pmeasure qubits result.

pyqpanda.QAdd(arg0: QVec, arg1: QVec, arg2: QVec) → QCircuit

Quantum adder that supports signed operations, but ignore carry

pyqpanda.QAdder(arg0: QVec, arg1: QVec, arg2: Qubit, arg3: Qubit) → QCircuit

Quantum adder with carry

pyqpanda.QAdderIgnoreCarry(arg0: QVec, arg1: QVec, arg2: Qubit) → QCircuit

Args:

QVec: qubits list a QVec: qubits list b QVec: qubits list c Qubit: qubit

Returns:

result : circuit

Raises:

run_fail: An error occurred in QAdderIgnoreCarry

pyqpanda.QComplement(arg0: QVec, arg1: QVec) → QCircuit

Convert quantum state to binary complement representation

pyqpanda.QDiv(arg0: QVec, arg1: QVec, arg2: QVec, arg3: QVec, arg4: ClassicalCondition) → QProg

Quantum division

pyqpanda.QDivWithAccuracy(arg0: QVec, arg1: QVec, arg2: QVec, arg3: QVec, arg4: QVec, arg5: List[ClassicalCondition]) → QProg

Args:

QVec: qubits list a QVec: qubits list b QVec: qubits list c QVec: qubits list k QVec: qubits list f QVec: qubits list s list: ClassicalCondition list

Returns:

result : circuit

Raises:

run_fail: An error occurred in QDivWithAccuracy

pyqpanda.QDivider(a: QVec, b: QVec, c: QVec, k: QVec, t: ClassicalCondition) → QProg

Quantum division, only supports positive division, and the highest position of a and b and c is sign bit

pyqpanda.QDividerWithAccuracy(a: QVec, b: QVec, c: QVec, k: QVec, f: QVec, s: List[ClassicalCondition]) → QProg

Args:

QVec: qubits list a QVec: qubits list b QVec: qubits list c QVec: qubits list k QVec: qubits list f QVec: qubits list s list: ClassicalCondition list

Returns:

result : circuit

Raises:

run_fail: An error occurred in QDividerWithAccuracy

pyqpanda.QDouble(first_qubit: Qubit, second_qubit: Qubit, matrix: List[complex]) → QGate

pyqpanda.QDouble(first_qubit_list: QVec, second_qubit_list: QVec, matrix: List[complex]) → QCircuit

pyqpanda.QDouble(first_qubit_addr: int, second_qubit_addr: int, matrix: List[complex]) → QGate

pyqpanda.QDouble(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int], matrix: List[complex]) → QCircuit

Returns:

a QDouble gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.QFT(qubits: QVec) → QCircuit

Build QFT quantum circuit

Args:

qvec: qubit list

Returns:

result : qft circuit

Raises:

run_fail: An error occurred in QFT

pyqpanda.QMul(arg0: QVec, arg1: QVec, arg2: QVec, arg3: QVec) → QCircuit

Quantum multiplication

pyqpanda.QMultiplier(arg0: QVec, arg1: QVec, arg2: QVec, arg3: QVec) → QCircuit

Quantum multiplication, only supports positive multiplication

pyqpanda.QOracle(qubit_list: QVec, matrix: numpy.ndarray[numpy.complex128[m, n]], tol: float = 1e-10) → QGate

Generate QOracle Gate.

Args:

qubit_list: gate in qubit list.

matrix: gate operator matrix.

Returns:

Oracle gate.

pyqpanda.QPE(control_qubits: QVec, target_qubits: QVec, matrix: List[complex], b_estimate_eigenvalue: bool = False) → QCircuit

Quantum phase estimation

Args:

control_qubits: control qubit list target_qubits: target qubit list matrix: matrix

Returns:

result : QPE circuit

Raises:

run_fail: An error occurred in QPE

pyqpanda.QSub(arg0: QVec, arg1: QVec, arg2: QVec) → QCircuit

Quantum subtraction

pyqpanda.RX(qubit: Qubit, angle: float) → QGate

pyqpanda.RX(qubit_list: QVec, angle: float) → QCircuit

pyqpanda.RX(qubit_addr: int, angle: float) → QGate

pyqpanda.RX(qubit_addr_list: List[int], angle: float) → QCircuit

Create a RX gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a RX gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RXX(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

pyqpanda.RXX(control_qubit_list: QVec, target_qubit_list: QVec, alpha_angle: float) → QCircuit

pyqpanda.RXX(control_qubit_addr: int, target_qubit_addr: int, alpha_angle: float) → QGate

pyqpanda.RXX(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], alpha_angle: float) → QCircuit

Create a RXX gate

Args:

qubit addr list : control qubit addr list qubit addr list : target qubit addr list double: gate rotation angle theta

Returns:

a RXX gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RY(qubit: Qubit, angle: float) → QGate

pyqpanda.RY(qubit_list: QVec, angle: float) → QCircuit

pyqpanda.RY(qubit_addr: int, angle: float) → QGate

pyqpanda.RY(qubit_addr_list: List[int], angle: float) → QCircuit

Create a RY gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a RY gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RYY(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

pyqpanda.RYY(control_qubit_list: QVec, target_qubit_list: QVec, alpha_angle: float) → QCircuit

pyqpanda.RYY(control_qubit_addr: int, target_qubit_addr: int, alpha_angle: float) → QGate

pyqpanda.RYY(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], alpha_angle: float) → QCircuit

Create a RYY gate

Args:

qubit addr list : control qubit addr list qubit addr list : target qubit addr list double: gate rotation angle theta

Returns:

a RYY gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RZ(qubit: Qubit, angle: float) → QGate

pyqpanda.RZ(qubit_list: QVec, angle: float) → QCircuit

pyqpanda.RZ(qubit_addr: int, angle: float) → QGate

pyqpanda.RZ(qubit_addr_list: List[int], angle: float) → QCircuit

Create a RZ gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a RZ gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RZX(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

pyqpanda.RZX(control_qubit_list: QVec, target_qubit_list: QVec, alpha_angle: float) → QCircuit

pyqpanda.RZX(control_qubit_addr: int, target_qubit_addr: int, alpha_angle: float) → QGate

pyqpanda.RZX(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], alpha_angle: float) → QCircuit

Create a RZX gate

Args:

qubit addr list : control qubit addr list qubit addr list : target qubit addr list double: gate rotation angle theta

Returns:

a RZX gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.RZZ(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

pyqpanda.RZZ(control_qubit_list: QVec, target_qubit_list: QVec, alpha_angle: float) → QCircuit

pyqpanda.RZZ(control_qubit_addr: int, target_qubit_addr: int, alpha_angle: float) → QGate

pyqpanda.RZZ(control_qubit_addr_list: List[int], target_qubit_addr_list: List[int], alpha_angle: float) → QCircuit

Create a RZZ gate

Args:

qubit addr list : control qubit addr list qubit addr list : target qubit addr list double: gate rotation angle theta

Returns:

a RZZ gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Reset(qubit: Qubit) → QReset

pyqpanda.Reset(qubit_addr: int) → QReset

Create a Reset node.

Args:

qubit_addr (int): Address of the qubit to be reset.

Returns:

A Reset node representing the operation.

pyqpanda.S(qubit: Qubit) → QGate

pyqpanda.S(qubit_list: QVec) → QCircuit

pyqpanda.S(qubit_addr: int) → QGate

pyqpanda.S(qubit_addr_list: List[int]) → QCircuit

Create a S gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a S gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.SWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

pyqpanda.SWAP(first_qubit_list: QVec, second_qubit_list: QVec) → QCircuit

pyqpanda.SWAP(first_qubit_addr: int, second_qubit_addr: int) → QGate

pyqpanda.SWAP(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int]) → QCircuit

Returns:

a SWAP gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Shor_factorization(arg0: int) → Tuple[bool, Tuple[int, int]]

Use Shor factorize integer num

Args:

int: target integer num result: Shor result

Returns:

result : Shor_factorization search result

Raises:

run_fail: An error occurred in Shor_factorization

pyqpanda.SqiSWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

pyqpanda.SqiSWAP(first_qubit_list: QVec, second_qubit_list: QVec) → QCircuit

pyqpanda.SqiSWAP(first_qubit_addr: int, second_qubit_addr: int) → QGate

pyqpanda.SqiSWAP(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int]) → QCircuit

Returns:

a SqiSWAP gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.T(qubit: Qubit) → QGate

pyqpanda.T(qubit_list: QVec) → QCircuit

pyqpanda.T(qubit_addr: int) → QGate

pyqpanda.T(qubit_addr_list: List[int]) → QCircuit

Create a T gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a T gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Toffoli(control_qubit_first: Qubit, control_qubit_second: Qubit, target_qubit: Qubit) → QGate

pyqpanda.Toffoli(control_qubit_addr_first: int, control_qubit_addr_second: int, target_qubit_addr: int) → QGate

Create a Toffoli gate.

Args:

control_qubit_addr_first (int): Address of the first control qubit.

control_qubit_addr_second (int): Address of the second control qubit.

target_qubit_addr (int): Address of the target qubit.

Returns:

A Toffoli node representing the operation.

pyqpanda.U1(qubit: Qubit, angle: float) → QGate

pyqpanda.U1(qubit_list: QVec, angle: float) → QCircuit

pyqpanda.U1(qubit_addr: int, angle: float) → QGate

pyqpanda.U1(qubit_addr_list: List[int], angle: float) → QCircuit

Create a U1 gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a U1 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.U2(qubit: Qubit, phi_angle: float, lambda_angle: float) → QGate

pyqpanda.U2(qubit_list: QVec, phi_angle: float, lambda_angle: float) → QCircuit

pyqpanda.U2(qubit_addr: int, phi_angle: float, lambda_angle: float) → QGate

pyqpanda.U2(qubit_addr_list: List[int], phi_angle: float, lambda_angle: float) → QCircuit

Create a U2 gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a U2 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.U3(qubit: Qubit, theta_angle: float, phi_angle: float, lambda_angle: float) → QGate

pyqpanda.U3(qubit_list: QVec, theta_angle: float, phi_angle: float, lambda_angle: float) → QCircuit

pyqpanda.U3(qubit_addr: int, theta_angle: float, phi_angle: float, lambda_angle: float) → QGate

pyqpanda.U3(qubit_addr_list: List[int], theta_angle: float, phi_angle: float, lambda_angle: float) → QCircuit

Create a U3 gate Args:

qubit_list_addr: quantum gate qubits list addr args : quantum gate angles

Returns:

a U3 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.U4(matrix: List[complex], qubit: Qubit) → QGate

pyqpanda.U4(alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float, qubit: Qubit) → QGate

pyqpanda.U4(qubit: Qubit, matrix: List[complex]) → QGate

pyqpanda.U4(qubit_list: QVec, matrix: List[complex]) → QCircuit

pyqpanda.U4(qubit_addr: int, matrix: List[complex]) → QGate

pyqpanda.U4(qubit_addr_list: List[int], matrix: List[complex]) → QCircuit

pyqpanda.U4(qubit: Qubit, alpha_anlge: float, beta_anlge: float, gamma_anlge: float, delta_anlge: float) → QGate

pyqpanda.U4(qubit_list: QVec, alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float) → QCircuit

pyqpanda.U4(qubit_addr: int, alpha_anlge: float, beta_anlge: float, gamma_anlge: float, delta_anlge: float) → QGate

pyqpanda.U4(qubit_addr_list: List[int], alpha_anlge: float, beta_anlge: float, gamma_anlge: float, delta_anlge: float) → QCircuit

Create a U4 gate.

Args:

qubit_addr_list: the list of addresses of target qubits for the U4 gate.

alpha_angle: the alpha angle for the U4 gate.

beta_angle: the beta angle for the U4 gate.

gamma_angle: the gamma angle for the U4 gate.

delta_angle: the delta angle for the U4 gate.

Returns:

A U4 node representing the operation.

pyqpanda.UMA(arg0: Qubit, arg1: Qubit, arg2: Qubit) → QCircuit

Quantum adder UMA module

pyqpanda.VQG_CNOT_batch(*args, **kwargs) → Any

variational quantum CNOT batch gates

pyqpanda.VQG_CU_batch(*args, **kwargs) → Any

variational quantum CU batch gates

pyqpanda.VQG_CZ_batch(*args, **kwargs) → Any

variational quantum CZ batch gates

pyqpanda.VQG_H_batch(*args, **kwargs) → Any

variational quantum H batch gates

pyqpanda.VQG_I_batch(*args, **kwargs) → Any

variational quantum I batch gates

pyqpanda.VQG_SWAP_batch(*args, **kwargs) → Any

variational quantum SWAP batch gates

pyqpanda.VQG_S_batch(*args, **kwargs) → Any

variational quantum S batch gates

pyqpanda.VQG_SqiSWAP_batch(*args, **kwargs) → Any

variational quantum SqiSWAP batch gates

pyqpanda.VQG_T_batch(*args, **kwargs) → Any

variational quantum T batch gates

pyqpanda.VQG_U1_batch(*args, **kwargs) → Any

variational quantum U1 batch gates

pyqpanda.VQG_U2_batch(*args, **kwargs) → Any

variational quantum U2 batch gates

pyqpanda.VQG_U3_batch(*args, **kwargs) → Any

variational quantum U3 batch gates

pyqpanda.VQG_U4_batch(*args, **kwargs) → Any

variational quantum U4 batch gates

pyqpanda.VQG_X1_batch(*args, **kwargs) → Any

variational quantum X1 batch gates

pyqpanda.VQG_X_batch(*args, **kwargs) → Any

variational quantum X batch gates

pyqpanda.VQG_Y1_batch(*args, **kwargs) → Any

variational quantum Y1 batch gates

pyqpanda.VQG_Y_batch(*args, **kwargs) → Any

variational quantum Y batch gates

pyqpanda.VQG_Z1_batch(*args, **kwargs) → Any

variational quantum Z1 batch gates

pyqpanda.VQG_Z_batch(*args, **kwargs) → Any

variational quantum Z batch gates

pyqpanda.VQG_iSWAP_batch(*args, **kwargs) → Any

variational quantum iSWAP batch gates

pyqpanda.X(qubit: Qubit) → QGate

pyqpanda.X(qubit_list: QVec) → QCircuit

pyqpanda.X(qubit_addr: int) → QGate

pyqpanda.X(qubit_addr_list: List[int]) → QCircuit

Create a X gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a X gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.X1(qubit: Qubit) → QGate

pyqpanda.X1(qubit_list: QVec) → QCircuit

pyqpanda.X1(qubit_addr: int) → QGate

pyqpanda.X1(qubit_addr_list: List[int]) → QCircuit

Create a X1 gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a X1 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Y(qubit: Qubit) → QGate

pyqpanda.Y(qubit_list: QVec) → QCircuit

pyqpanda.Y(qubit_addr: int) → QGate

pyqpanda.Y(qubit_addr_list: List[int]) → QCircuit

Create a Y gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a Y gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Y1(qubit: Qubit) → QGate

pyqpanda.Y1(qubit_list: QVec) → QCircuit

pyqpanda.Y1(qubit_addr: int) → QGate

pyqpanda.Y1(qubit_addr_list: List[int]) → QCircuit

Create a Y1 gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a Y1 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Z(qubit: Qubit) → QGate

pyqpanda.Z(qubit_list: QVec) → QCircuit

pyqpanda.Z(qubit_addr: int) → QGate

pyqpanda.Z(qubit_addr_list: List[int]) → QCircuit

Create a Z gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a Z gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.Z1(qubit: Qubit) → QGate

pyqpanda.Z1(qubit_list: QVec) → QCircuit

pyqpanda.Z1(qubit_addr: int) → QGate

pyqpanda.Z1(qubit_addr_list: List[int]) → QCircuit

Create a Z1 gate

Args:

qubit_list_addr: quantum gate qubits list addr

Returns:

a Z1 gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.accumulateProbability(probability_list: List[float]) → List[float]

Accumulate the probability from a probability list.

Args:

probability_list: measured result in probability list form.

Returns:

accumulated_result: accumulated result.

pyqpanda.accumulate_probabilities(probability_list: List[float]) → List[float]

Accumulate the probability from a probability list.

Args:

probability_list: measured result in probability list form.

Returns:

accumulated_result: accumulated result.

pyqpanda.accumulate_probability(probability_list: List[float]) → List[float]

Accumulate the probability from a probability list.

Args:

probability_list: measured result in probability list form.

Returns:

accumulated_result: accumulated result.

pyqpanda.acos(arg0: var) → var

pyqpanda.add(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.add(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.add(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

Add a bit size and a ClassicalCondition.

Args:

a: The bit size to be added.

b: The ClassicalCondition to which the bit size will be added.

Returns:

ClassicalCondition: The resulting ClassicalCondition after addition.

pyqpanda.all_cut_of_graph(adjacent_matrix: List[List[float]], all_cut_list: List[float], target_value_list: List[int]) → float

Generate a graph representation for the max cut problem.

Args:

adjacent_matrix: The adjacency matrix for the quantum program.

all_cut_list: A list of all cut graphs in the quantum program.

target_value_list: A list of target cut values.

Returns:

max value: The maximum value found from the cuts.

pyqpanda.amplitude_encode(qubit: QVec, data: List[float], b_need_check_normalization: bool = True) → QCircuit

pyqpanda.amplitude_encode(qubit: QVec, data: List[complex]) → QCircuit

Encode the input double data to the amplitude of qubits

Args:

qubit: quantum program qubits data: double data list

Returns:

result circuit

Raises:

run_fail: An error occurred in amplitude_encode

pyqpanda.apply_QGate(qubit_list: QVec, func_obj: Callable[[Qubit], QGate]) → QCircuit

pyqpanda.apply_QGate(qubit_addr_list: List[int], func_obj: Callable[[int], QGate]) → QCircuit

Apply a quantum gate operation to a list of qubit addresses.

Args:

qubit_addr_list: List of qubit addresses to which the gate will be applied.

func_obj: A function object that takes a qubit address (int) and returns a QGate.

Returns:

QCircuit: The resulting circuit containing the QGate operations on all qubits.

pyqpanda.asin(arg0: var) → var

pyqpanda.assign(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.assign(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

Assign a bit size value to a ClassicalCondition.

Args:

a: The ClassicalCondition to be updated (passed by reference).

b: The bit size value to assign.

Returns:

ClassicalCondition: The updated ClassicalCondition after assignment.

pyqpanda.atan(arg0: var) → var

pyqpanda.average_gate_fidelity(state1: numpy.ndarray[numpy.complex128[m, n]], state2: List[complex]) → float

pyqpanda.average_gate_fidelity(state1: numpy.ndarray[numpy.complex128[m, n]], state2: numpy.ndarray[numpy.complex128[m, n]]) → float

Calculate the average gate fidelity between two quantum operation matrices.

Args:

matrix1: the first quantum operation represented as a matrix.

matrix2: the second quantum operation represented as a matrix.

Returns:

The average gate fidelity, a value in the range [0, 1].

pyqpanda.bin_to_prog(bin_data: List[int], qubit_list: QVec, cbit_list: List[ClassicalCondition], qprog: QProg) → bool

Parse binary data to transform into a quantum program.

Args:

bin_data: binary data that stores quantum program information.

qubit_list: list of quantum qubits.

cbit_list: list of classical bits.

qprog: quantum program.

Returns:

prog: the parsed quantum program.

pyqpanda.bind_data(arg0: int, arg1: QVec) → QCircuit

Args:

int: classical data QVec: qubits list

Returns:

result : circuit

Raises:

run_fail: An error occurred in bind_data

pyqpanda.bind_nonnegative_data(arg0: int, arg1: QVec) → QCircuit

Args:

int: classical data QVec: qubits list

Returns:

result : circuit

Raises:

run_fail: An error occurred in bind_nonnegative_data

pyqpanda.build_HHL_circuit(matrix_A: List[complex], data_b: List[float], qvm: QuantumMachine, precision_cnt: int = 0) → QCircuit

build the quantum circuit for HHL algorithm to solve the target linear systems of equations : Ax = b

Args:

matrix_A: a unitary matrix or Hermitian N*N matrix with N = 2 ^ n

data_b: a given vector

qvm: quantum machine

precision_cnt: The count of digits after the decimal point,

default is 0, indicates that there are only integer solutions

Returns:

QCircuit The whole quantum circuit for HHL algorithm

Notes:

The higher the precision is, the more qubit number and circuit - depth will be, for example: 1 - bit precision, 4 additional qubits are required, for 2 - bit precision, we need 7 additional qubits, and so on. The final solution = (HHL result) * (normalization factor for b) * (1 << ceil(log2(pow(10, precision_cnt))))

pyqpanda.cAlloc() → ClassicalCondition

pyqpanda.cAlloc(cbit_addr: int) → ClassicalCondition

Allocate a CBit After init()

Args:

cbit_addr: cbit address, should be in [0,29).

Returns:

classic result cbit

pyqpanda.cAlloc_many(cbit_num: int) → List[ClassicalCondition]

Allocate several CBits After init()

Args:

cbit_num: numbers of cbit want to be created.

Returns:

list of cbit

pyqpanda.cFree(cbit: ClassicalCondition) → None

Free a CBit

Args:

CBit: The CBit to be freed.

Returns:

none

pyqpanda.cFree_all() → None

pyqpanda.cFree_all(cbit_list: List[ClassicalCondition]) → None

Free all CBits

Args:

cbit_list: a list of cbits.

Returns:

none

pyqpanda.cast_qprog_qcircuit(qprog: QProg) → QCircuit

Cast a quantum program into a quantum circuit.

Args:

qprog: The quantum program to be cast.

Returns:

QCircuit: The resulting quantum circuit.

pyqpanda.cast_qprog_qgate(qprog: QProg) → QGate

Cast a quantum program into a quantum gate.

Args:

qprog: The quantum program to be cast.

Returns:

None: This function does not return a value.

pyqpanda.cast_qprog_qmeasure(qprog: QProg) → QMeasure

Cast a quantum program into a quantum measurement.

Args:

qprog: The quantum program to be cast.

Returns:

None: This function does not return a value.

pyqpanda.circuit_layer(qprog: QProg) → list

Quantum circuit layering.

Args:

QProg: Quantum program.

Returns:

A list containing layer information and qubits/cbits in use.

pyqpanda.circuit_optimizer(qprog: QProg, optimizer_cir_vec: List[Tuple[QCircuit, QCircuit]] = [], mode_list: List[QCircuitOPtimizerMode] = []) → QProg

Optimize a quantum circuit.

Args:

qprog: the quantum program to optimize.

optimizer_cir_vec: a list of quantum circuits for optimization.

mode_list: a list of optimization modes.

Returns:

the updated quantum program after optimization.

pyqpanda.circuit_optimizer_by_config(qprog: QProg, config_file: str = 'QPandaConfig.json', mode_list: List[QCircuitOPtimizerMode] = []) → QProg

Optimize a quantum circuit using configuration data.

Args:

qprog: the quantum program to optimize.

config_file: configuration data for optimization.

mode_list: a list of optimization modes.

Returns:

the updated quantum program after optimization.

pyqpanda.comm_protocol_decode(encode_data: bytes, machine: QuantumMachine) → Tuple[List[QProg], CommProtocolConfig]

Decode binary data into a list of quantum programs using the communication protocol.

Args:

encode_data: The encoded binary data representing quantum programs.

machine: A pointer to the QuantumMachine used for decoding.

Returns:

tuple: A tuple containing the decoded program list and the communication protocol configuration.

pyqpanda.comm_protocol_encode(prog: QProg, config: CommProtocolConfig = ...) → bytes

pyqpanda.comm_protocol_encode(prog_list: List[QProg], config: CommProtocolConfig = ...) → bytes

Encode a list of quantum programs into binary communication protocol data.

Args:

prog_list: A list of quantum programs to be encoded.

config: The configuration for the communication protocol. Defaults to an empty configuration.

Returns:

bytes: The encoded binary data representing the communication protocol.

pyqpanda.constModAdd(arg0: QVec, arg1: int, arg2: int, arg3: QVec, arg4: QVec) → QCircuit

Args:

QVec qvec int base int module_Num QVec qvec1 QVec qvec2

Returns:

result circuit

Raises:

run_fail: An error occurred in constModAdd

pyqpanda.constModExp(arg0: QVec, arg1: QVec, arg2: int, arg3: int, arg4: QVec, arg5: QVec, arg6: QVec) → QCircuit

Args:

QVec qvec int base int module_Num QVec qvec1 QVec qvec2

Returns:

result circuit

Raises:

run_fail: An error occurred in constModExp

pyqpanda.constModMul(arg0: QVec, arg1: int, arg2: int, arg3: QVec, arg4: QVec, arg5: QVec) → QCircuit

Args:

QVec qvec int base int module_Num QVec qvec1 QVec qvec2

Returns:

result circuit

Raises:

run_fail: An error occurred in constModMul

pyqpanda.convert_binary_data_to_qprog(machine: QuantumMachine, data: List[int]) → QProg

Parse binary data into a quantum program.

Args:

machine: The quantum machine used for execution.

data: The binary data representing the quantum program.

Returns:

QProg: The generated quantum program.

pyqpanda.convert_originir_str_to_qprog(originir_str: str, machine: QuantumMachine) → list

Transform OriginIR string into QProg.

Args:

originir_str: OriginIR string.

machine: initialized quantum machine.

Returns:

A list containing QProg, qubit_list, and cbit_list.

pyqpanda.convert_originir_to_qprog(file_path: str, machine: QuantumMachine) → list

Read an OriginIR file and transform it into QProg.

Args:

file_path: OriginIR file path.

machine: initialized quantum machine.

Returns:

A list containing QProg, qubit_list, and cbit_list.

pyqpanda.convert_qasm_string_to_qprog(qasm_str: str, machine: QuantumMachine) → list

Transform QASM string into QProg.

Args:

qasm_str: QASM string.

machine: initialized quantum machine.

Returns:

A list containing QProg, qubit_list, and cbit_list.

pyqpanda.convert_qasm_to_qprog(file_path: str, machine: QuantumMachine) → list

Read a QASM file and transform it into QProg.

Args:

file_path: QASM file path.

machine: initialized quantum machine.

Returns:

A list containing QProg, qubit_list, and cbit_list.

pyqpanda.convert_qprog_to_binary(qprog: QProg, machine: QuantumMachine) → List[int]

pyqpanda.convert_qprog_to_binary(qprog: QProg, machine: QuantumMachine, fname: str) → None

Store the quantum program in a binary file.

Args:

qprog: quantum program.

machine: quantum machine.

fname: name of the binary data file.

Returns:

none: This function does not return a value.

pyqpanda.convert_qprog_to_originir(*args, **kwargs) → Any

Convert QProg to OriginIR string.

Args:

qprog: quantum program (QProg&).

machine: quantum machine (QuantumMachine*).

Returns:

originir: OriginIR string. For more information, see the OriginIR introduction:

https://pyqpanda-toturial.readthedocs.io/zh/latest

pyqpanda.convert_qprog_to_qasm(qprog: QProg, machine: QuantumMachine) → str

Convert a quantum program to a QASM instruction string.

Args:

qprog: The quantum program to be converted.

machine: The quantum machine used for execution.

Returns:

str: A QASM string representing the quantum program.

pyqpanda.convert_qprog_to_quil(qprog: QProg, machine: QuantumMachine) → str

Convert QProg to Quil instruction.

Args:

qprog: quantum program (QProg).

machine: quantum machine (QuantumMachine*).

Returns:

Quil instruction string.

pyqpanda.cos(arg0: var) → var

pyqpanda.count_gate(quantum_prog: QProg) → int

pyqpanda.count_gate(quantum_circuit: QCircuit) → int

Count quantum gate number in the quantum circuit.

Args:

quantum_circuit: quantum circuit.

Returns:

result: gate count.

pyqpanda.count_prog_info(node: QProg, selected_types: List[GateType] = []) → ProgCount

pyqpanda.count_prog_info(node: QCircuit, selected_types: List[GateType] = []) → ProgCount

Count quantum program information.

Args:

node: quantum circuit (QCircuit).

selected_types: vector of selected GateType (default is empty).

Returns:

ProgCount struct.

pyqpanda.count_qgate_num(prog: QProg, gate_type: int = -1) → int

pyqpanda.count_qgate_num(circuit: QCircuit, gate_type: int = -1) → int

Count quantum gate number in the quantum circuit.

Args:

circuit: quantum circuit (QCircuit&).

gate_type: type of gate to count (const GateType).

Returns:

result: number of quantum gates of the specified GateType.

pyqpanda.create_empty_circuit() → QCircuit

Create an empty QCircuit container.

Args:

none

Returns:

result: An empty QCircuit.

pyqpanda.create_empty_qprog() → QProg

Create an empty QProg container.

Args:

none.

Returns:

an empty QProg.

pyqpanda.create_if_prog(classical_condition: ClassicalCondition, true_node: QProg) → QIfProg

pyqpanda.create_if_prog(classical_condition: ClassicalCondition, true_node: QProg, false_node: QProg) → QIfProg

Create a classical quantum IfProg.

Args:

classical_condition: A quantum cbit representing the condition.

true_node: A quantum IfProg node that defines the operation to execute if the condition is true.

false_node: A quantum IfProg node that defines the operation to execute if the condition is false.

Returns:

result: A classical quantum IfProg that executes based on the specified condition.

pyqpanda.create_while_prog(classical_condition: ClassicalCondition, true_node: QProg) → QWhileProg

Create a WhileProg.

Args:

classical_condition: A quantum cbit representing the condition.

true_node: A quantum QWhile node that defines the operation to execute while the condition is true.

Returns:

result: A WhileProg that executes the specified operations based on the condition.

pyqpanda.crossEntropy(arg0: var, arg1: var) → var

pyqpanda.decompose_multiple_control_qgate(qprog: QProg, machine: QuantumMachine, config_file: str = 'QPandaConfig.json') → QProg

pyqpanda.decompose_multiple_control_qgate(qprog: QProg, machine: QuantumMachine, convert_single_gates: List[str], convert_double_gates: List[str], b_transform_to_base_qgate: bool = True) → QProg

Decompose multiple control QGate.

Args:

qprog: Quantum program.

machine: Quantum machine.

convert_single_gates: Sets of quantum single gates.

convert_double_gates: Sets of quantum double gates.

b_transform_to_base_qgate: Transform to base QGate sets.

Returns:

A new program after decomposition.

pyqpanda.deep_copy(node: QProg) → QProg

pyqpanda.deep_copy(node: QCircuit) → QCircuit

pyqpanda.deep_copy(node: QGate) → QGate

pyqpanda.deep_copy(node: QMeasure) → QMeasure

pyqpanda.deep_copy(node: ClassicalProg) → ClassicalProg

pyqpanda.deep_copy(node: QIfProg) → QIfProg

pyqpanda.deep_copy(node: QWhileProg) → QWhileProg

Create a deep copy of the given quantum program node.

Args:

node: The quantum program node to copy.

Returns:

A deep copy of the quantum program node.

pyqpanda.del_weak_edge(topo_data: List[List[int]]) → None

Delete weakly connected edges from the quantum program topology.

Args:

topo_data: The topology data of the quantum program.

Returns:

None.

pyqpanda.del_weak_edge2(topo_data: List[List[int]], max_connect_degree: int, sub_graph_set: List[int]) → list

Delete weakly connected edges from the quantum program topology.

Args:

topo_data: The topology data of the quantum program.

max_connect_degree: The maximum allowable connection degree.

sub_graph_set: A list of subgraph identifiers.

Returns:

A list containing the updated topology data, intermediary points, and candidate edges.

pyqpanda.del_weak_edge3(topo_data: List[List[int]], sub_graph_set: List[int], max_connect_degree: int, lamda1: float, lamda2: float, lamda3: float) → list

Delete weakly connected edges based on specified parameters.

Args:

topo_data: The topology data of the quantum program.

sub_graph_set: A list of subgraph identifiers.

max_connect_degree: The maximum allowable connection degree.

lamda1: Weight parameter for edge evaluation.

lamda2: Weight parameter for edge evaluation.

lamda3: Weight parameter for edge evaluation.

Returns:

A list containing the updated topology data and intermediary points.

pyqpanda.destroy_quantum_machine(machine: QuantumMachine) → None

Destroy a quantum machine.

Args:

machine: type should be one of CPUQVM, CPUSingleThreadQVM, GPUQVM, NoiseQVM.

Returns:

None.

pyqpanda.directly_run(qprog: QProg, noise_model: Noise = NoiseModel()) → Dict[str, bool]

Directly run a quantum program After init()

Args:

qprog: The quantum program to be executed.

noise_model: The noise model to be used, default is no noise. The noise model only works on CPUQVM currently.

Returns:

Dict[str, bool]: Result of the quantum program execution in one shot.

The first element is the final qubit register state, and the second is its measurement probability.

pyqpanda.div(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.div(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.div(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

Divide a bit size by a ClassicalCondition.

Args:

a: The bit size (numerator).

b: The ClassicalCondition (denominator).

Returns:

ClassicalCondition: The result of the division.

pyqpanda.dot(arg0: var, arg1: var) → var

pyqpanda.draw_qprog_latex(prog: QProg, auto_wrap_len: int = 100, output_file: str = 'QCircuit.tex', with_logo: bool = False, itr_start: NodeIter = NodeIter(), itr_end: NodeIter = NodeIter()) → str

Convert a quantum prog/circuit to LaTeX representation,

and save the output in a file named QCircuit.tex in the current path.

Args:

QProg: Quantum prog.

auto_wrap_len: Default is 100.

output_file: Result output file name.

with_logo: Include logo in the output.

itr_start: Node iterator start.

itr_end: Node iterator end.

Returns:

A tuple containing program info.

pyqpanda.draw_qprog_latex_with_clock(prog: QProg, config_data: str = 'QPandaConfig.json', auto_wrap_len: bool = 100, output_file: int = 'QCircuit.tex', with_logo: str = False, itr_start: NodeIter = NodeIter(), itr_end: NodeIter = NodeIter()) → str

Convert a quantum prog/circuit to LaTeX source code with time sequence, and save the source code to a file in the current path named QCircuit.tex.

Args:

prog: Quantum prog.

config_data: Default config file is QPandaConfig.json.

auto_wrap_len: Default is 100.

output_file: Result output file name.

with_logo: Whether to include a logo in the output.

itr_start: Node iterator start.

itr_end: Node iterator end.

Returns:

A tuple containing program info.

pyqpanda.draw_qprog_text(qprog: QProg, auto_wrap_len: int = 100, output_file: str = 'QCircuitTextPic.txt', itr_start: NodeIter = NodeIter(), itr_end: NodeIter = NodeIter()) → str

Convert a quantum prog/circuit to text-pic (UTF-8 code),

and save the text-pic in a file named QCircuitTextPic.txt in the current path.

Args:

QProg: Quantum prog.

auto_wrap_len: Default is 100.

output_file: Result output file name.

itr_start: Node iterator start.

itr_end: Node iterator end.

Returns:

A tuple containing program info.

pyqpanda.draw_qprog_text_with_clock(prog: QProg, config_data: str = 'QPandaConfig.json', auto_wrap_len: int = 100, output_file: str = 'QCircuitTextPic.txt', itr_start: NodeIter = NodeIter(), itr_end: NodeIter = NodeIter()) → str

Convert a quantum prog/circuit to text-pic (UTF-8 code) with time sequence,

and save the text-pic in a file named QCircuitTextPic.txt in the current path.

Args:

prog: Quantum prog.

config_data: Configuration data.

auto_wrap_len: Default is 100.

output_file: Result output file name.

itr_start: Node iterator start.

itr_end: Node iterator end.

Returns:

A tuple containing program info.

pyqpanda.dropout(arg0: var, arg1: var) → var

pyqpanda.equal(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.equal(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.equal(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

Check if a bit size is equal to a ClassicalCondition.

Args:

a: The bit size to compare.

b: The ClassicalCondition to compare against.

Returns:

bool: True if the bit size is equal to the ClassicalCondition, otherwise False.

pyqpanda.estimate_topology(topo_data: List[List[int]]) → float

Evaluate topology performance.

Args:

topo_data: Quantum program topology data.

Returns:

Result data.

pyqpanda.eval(arg0: var, arg1: bool) → numpy.ndarray[numpy.float64[m, n]]

pyqpanda.eval(arg0: var) → numpy.ndarray[numpy.float64[m, n]]

pyqpanda.exp(arg0: var) → var

pyqpanda.expMat(arg0: complex, arg1: numpy.ndarray[numpy.complex128[m, n]], arg2: float) → numpy.ndarray[numpy.complex128[m, n]]

Calculate the matrix power of e.

This function returns the power of matrix e.

Args:

None

Returns:

The computed matrix.

pyqpanda.expand_linear_equations(matrix: List[complex], list: List[float]) → expand_linear_equations.list

pyqpanda.expand_linear_equations(matrix: List[complex], list: List[float]) → expand_linear_equations.list

Extending linear equations to N dimension, N = 2 ^ n

Args:

matrix: the source matrix, which will be extend to N*N, N = 2 ^ n

list: the source vector b, which will be extend to 2 ^ n

pyqpanda.fill_qprog_by_I(qprog: QProg) → QProg

Fill the input quantum program with I gates and return a new quantum program.

Args:

qprog: the input quantum program.

Returns:

a new quantum program filled with I gates.

pyqpanda.finalize() → None

Finalize the environment and destroy global unique quantum machine.

Args:

none

Returns:

none

pyqpanda.fit_to_gbk(utf8_str: str) → str

Special character conversion.

Args:

utf8_str: string using utf-8 encoding.

Returns:

result: converted string.

pyqpanda.flatten(qprog: QProg) → None

pyqpanda.flatten(qcircuit: QCircuit) → None

Flatten a quantum circuit in place.

Args:

qcircuit: The quantum circuit to be flattened.

Returns:

None: The function modifies the circuit directly.

pyqpanda.getAllocateCMem() → int

Deprecated, use get_allocate_cmem_num instead.

Args:

none

Returns:

allocate qubit num.

pyqpanda.getAllocateQubitNum() → int

Deprecated, use get_allocate_qubit_num instead.

Args:

none

Returns:

allocate cbit num.

pyqpanda.get_adjacent_qgate_type(qprog: QProg, node_iter: NodeIter) → List[NodeInfo]

Get the adjacent quantum gates’ (the front one and the back one) type info from QProg.

Args:

qprog: Target quantum program.

node_iter: Gate node iterator in qprog.

Returns:

The front and back node info of node_iter in qprog.

pyqpanda.get_all_used_qubits(qprog: QProg) → List[Qubit]

Get all the quantum bits used in the input program.

Args:

qprog: A quantum program.

Returns:

result: A list of all used qubits.

pyqpanda.get_all_used_qubits_to_int(qprog: QProg) → List[int]

Get the addresses of all used quantum bits in the input program.

Args:

qprog: A quantum program.

Returns:

result: A list of addresses of all used qubits.

pyqpanda.get_allocate_cbits() → List[ClassicalCondition]

Get allocated cbits of QuantumMachine

Args:

None

Returns:

A list of allocated cbits.

pyqpanda.get_allocate_cmem_num() → int

Get allocate cmem num.

Args:

none.

Returns:

cbit_num: allocate cbit num.

pyqpanda.get_allocate_qubit_num() → int

Get allocate qubit num.

Args:

none.

Returns:

qubit_num: allocate qubit num.

pyqpanda.get_allocate_qubits() → List[Qubit]

Get allocated qubits of QuantumMachine

Args:

None

Returns:

A list of allocated qubits.

pyqpanda.get_bin_data(qprog: QProg) → List[int]

Get quantum program binary data.

Args:

qprog: quantum program (QProg).

Returns:

binary data as a list.

pyqpanda.get_bin_str(qprog: QProg, machine: QuantumMachine) → str

Transform a quantum program into a string representation.

Args:

qprog: quantum program.

machine: quantum machine.

Returns:

string: base64-encoded string of the binary representation.

pyqpanda.get_circuit_optimal_topology(qprog: QProg, machine: QuantumMachine, max_connect_degree: int, config_file: str = 'QPandaConfig.json') → List[List[int]]

Retrieve the optimal topology of the input quantum circuit.

Args:

qprog: The quantum program for which to determine the topology.

machine: The quantum machine used for execution.

max_connect_degree: The maximum allowable connection degree.

config_file: Path to the configuration file (default is CONFIG_PATH).

Returns:

The topology program data.

pyqpanda.get_clock_cycle(qpog: QProg) → int

Get quantum program clock cycle.

Args:

qprog: quantum program (QProg).

Returns:

clock_cycle.

pyqpanda.get_complex_points(topo_data: List[List[int]], max_connect_degree: int) → List[int]

Retrieve complex points from the given topology data.

Args:

topo_data: The topology data of the quantum program.

max_connect_degree: The maximum allowable connection degree.

Returns:

A list of complex points extracted from the topology data.

pyqpanda.get_double_gate_block_topology(qprog: QProg) → List[List[int]]

Retrieve the double gate block topology from the input quantum program.

Args:

qprog: The quantum program for which to extract the double gate block topology.

Returns:

The topology program data.

pyqpanda.get_matrix(*args, **kwargs) → Any

Get the target matrix between the input two NodeIters.

Args:

qprog: Quantum program.

positive_seq: Qubit order of output matrix; true for positive sequence (q0q1q2),

false for inverted order (q2q1q0), default is false.

nodeitr_start: The start NodeIter.

nodeitr_end: The end NodeIter.

Returns:

The target matrix including all the QGate’s matrices (multiplied).

pyqpanda.get_prob_dict(qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Get pmeasure result as dict

Args:

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.get_prob_list(qubit_list: QVec, select_max: int = -1) → List[float]

Get pmeasure result as list

Args:

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.get_qgate_num(quantum_prog: QProg) → int

pyqpanda.get_qgate_num(quantum_circuit: QCircuit) → int

pyqpanda.get_qgate_num(qprog: QProg) → int

Count the number of quantum gates in a quantum program.

Args:

qprog: The quantum program to analyze.

Returns:

int: The number of quantum gates in the quantum program.

pyqpanda.get_qprog_clock_cycle(qprog: QProg, machine: QuantumMachine, optimize: bool = False) → int

Get Quantum Program Clock Cycle.

Args:

qprog: quantum program (QProg).

machine: quantum machine (QuantumMachine*).

optimize: whether to optimize qprog (default is false).

Returns:

QProg time consumed, no unit, not in seconds.

pyqpanda.get_qstate() → List[complex]

pyqpanda.get_qstate() → Any

pyqpanda.get_sub_graph(topo_data: List[List[int]]) → List[int]

Retrieve a subgraph from the provided topology data.

Args:

topo_data: The topology data of the quantum program.

Returns:

sub graph: The extracted subgraph from the provided topology.

pyqpanda.get_tuple_list(qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Get pmeasure result as tuple list

Args:

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.get_unitary(*args, **kwargs) → Any

Get the target unitary matrix between the input two NodeIters.

Args:

qprog: Quantum program.

positive_seq: Qubit order of output matrix; true for positive sequence (q0q1q2),

false for inverted order (q2q1q0), default is false.

nodeitr_start: The start NodeIter.

nodeitr_end: The end NodeIter.

Returns:

The target unitary matrix including all the QGate’s matrices (multiplied).

pyqpanda.get_unsupport_qgate_num(qprog: QProg, support_gates: List[List[str]]) → int

Count the number of unsupported gates in a quantum program.

Args:

qprog: The quantum program to analyze.

support_gates: A list of supported gates.

Returns:

int: The number of unsupported gates in the quantum program.

pyqpanda.getstat(*args, **kwargs) → Any

Get the status of the Quantum machine

Args:

None

Returns:

The status of the Quantum machine, see QMachineStatus.

pyqpanda.iSWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

pyqpanda.iSWAP(first_qubit_list: QVec, second_qubit_list: QVec) → QCircuit

pyqpanda.iSWAP(first_qubit_addr: int, second_qubit_addr: int) → QGate

pyqpanda.iSWAP(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int]) → QCircuit

pyqpanda.iSWAP(first_qubit: Qubit, second_qubit: Qubit, theta_angle: float) → QGate

pyqpanda.iSWAP(first_qubit_list: QVec, second_qubit_list: QVec, theta_angle: float) → QCircuit

pyqpanda.iSWAP(first_qubit_addr: int, second_qubit_addr: int, theta_angle: float) → QGate

pyqpanda.iSWAP(first_qubit_addr_list: List[int], second_qubit_addr_list: List[int], theta_angle: float) → QCircuit

Returns:

a iSWAP gate node

Raises:

run_fail: An error occurred in construct gate node

pyqpanda.init(machine_type: QMachineType = QMachineType.CPU) → bool

Init the global unique quantum machine at background.

Args:

machine_type: quantum machine type, see pyQPanda.QMachineType

Returns:

bool: true if initialization success

pyqpanda.init_quantum_machine(machine_type: QMachineType = QMachineType.CPU) → QuantumMachine

Create and initialize a new quantum machine, and let it be a globally unique quantum machine.

Args:

machine_type: quantum machine type, see pyQPanda.QMachineType.

Returns:

object: the quantum machine, type depends on machine_type:

QMachineType.CPU –> pyQPanda.CPUQVM

QMachineType.CPU_SINGLE_THREAD –> pyQPanda.CPUSingleThreadQVM

QMachineType.GPU –> pyQPanda.GPUQVM (if pyQPanda is built with GPU)

QMachineType.NOISE –> pyQPanda.NoiseQVM

return None if initialization fails.

pyqpanda.inverse(arg0: var) → var

pyqpanda.isCarry(arg0: QVec, arg1: QVec, arg2: Qubit, arg3: Qubit) → QCircuit

Construct a circuit to determine if there is a carry

pyqpanda.is_match_topology(gate: QGate, topo: List[List[float]]) → bool

Judge if the QGate matches the target topologic structure of the quantum circuit.

Args:

gate (QGate): The quantum gate to evaluate.

topo: The target topologic structure of the quantum circuit.

Returns:

bool: True if it matches, otherwise false.

pyqpanda.is_supported_qgate_type(nodeitr: NodeIter) → bool

Judge if the target node is a QGate type.

Args:

nodeitr: Node iterator in the quantum program.

Returns:

bool: True if the target node is a QGate type, otherwise false.

pyqpanda.is_swappable(prog: QProg, nodeitr_1: NodeIter, nodeitr_2: NodeIter) → bool

Judge whether the specified two NodeIters in the quantum program can be exchanged.

Args:

prog: Target quantum program.

nodeitr_1: Node iterator 1 in the quantum program.

nodeitr_2: Node iterator 2 in the quantum program.

Returns:

bool: True if the two NodeIters can be exchanged, otherwise false.

pyqpanda.iterative_amplitude_estimation(arg0: QCircuit, arg1: QVec, arg2: float, arg3: float) → float

estimate the probability corresponding to the ground state |1> of the last bit Args:

QCircuit: quantum circuit qvec: qubit list double: epsilon double: confidence

Returns:

result iterative amplitude

Raises:

run_fail: An error occurred in iterative_amplitude_estimation

pyqpanda.ldd_decompose(qprog: QProg) → QProg

Decompose a multiple control quantum gate using LDD.

Args:

qprog: the quantum program to be decomposed.

Returns:

the updated quantum program after decomposition.

pyqpanda.log(arg0: var) → var

pyqpanda.matrix_decompose(qubits: QVec, matrix: numpy.ndarray[numpy.complex128[m, n]], mode: DecompositionMode = DecompositionMode.QSD, b_positive_seq: bool = True) → QCircuit

pyqpanda.matrix_decompose(qubits: QVec, matrix: List[complex], mode: DecompositionMode = DecompositionMode.QSD, b_positive_seq: bool = True) → QCircuit

Matrix decomposition

Args:

qubits: the used qubits

matrix: The target matrix

mode: DecompositionMode decomposition mode, default is QSD

b_positive_seq: true for positive sequence(q0q1q2), false for inverted order(q2q1q0), default is true

Returns:

QCircuit The quantum circuit for target matrix

pyqpanda.matrix_decompose_paulis(arg0: QuantumMachine, arg1: numpy.ndarray[numpy.float64[m, n]]) → List[Tuple[float, QCircuit]]

pyqpanda.matrix_decompose_paulis(arg0: QVec, arg1: numpy.ndarray[numpy.float64[m, n]]) → List[Tuple[float, QCircuit]]

decompose matrix into paulis combination

Args:

quantum_machine: quantum machine matrix: 2^N *2^N double matrix

Returns:

result : linearcom contains pauli circuit

pyqpanda.measure_all(qubit_list: QVec, cbit_list: List[ClassicalCondition]) → QProg

pyqpanda.measure_all(qubit_addr_list: List[int], cbit_addr_list: List[int]) → QProg

Create a list of measure nodes.

Args:

qubit_addr_list: list of addresses of the qubits to be measured.

cbit_addr_list: list of addresses of the classical bits that store the quantum measurement results.

Returns:

a list of measure nodes.

pyqpanda.mul(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.mul(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.mul(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

Multiply a bit size by a ClassicalCondition.

Args:

a: The bit size to be multiplied.

b: The ClassicalCondition to multiply with the bit size.

Returns:

ClassicalCondition: The resulting ClassicalCondition after multiplication.

pyqpanda.originir_to_qprog(file_path: str, machine: QuantumMachine) → QProg

Read an OriginIR file and transform it into QProg.

Args:

file_path: OriginIR file path.

machine: initialized quantum machine.

Returns:

Transformed QProg.

pyqpanda.pauli_combination_replace(arg0: List[Tuple[float, QCircuit]], arg1: QuantumMachine, arg2: str, arg3: str) → List[Tuple[float, QCircuit]]

pyqpanda.planarity_testing(topo_data: List[List[int]]) → bool

Perform planarity testing.

Args:

topo_data: Quantum program topology data.

Returns:

Result data.

pyqpanda.pmeasure(qubit_list: QVec, select_max: int) → List[Tuple[int, float]]

Get the probability distribution over qubits.

Args:

qubit_list: qubit list to measure.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)];

default is -1, means no limit.

Returns:

Measure result of quantum machine in tuple form.

pyqpanda.pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits.

Args:

qubit_list: qubit list to measure.

Returns:

Measure result of quantum machine in list form.

pyqpanda.poly(arg0: var, arg1: var) → var

pyqpanda.print_matrix(matrix: List[complex], precision: int = 8) → str

Print matrix elements.

Args:

matrix (QStat): The matrix to print.

precision (int, optional): Double value to string cutoff precision (default is 8).

Returns:

A string representation of the matrix.

pyqpanda.prob_run_dict(qprog: QProg, qubit_list: QVec, select_max: int = -1) → Dict[str, float]

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program.

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.prob_run_list(qprog: QProg, qubit_list: QVec, select_max: int = -1) → List[float]

Run quantum program and get pmeasure result as list

Args:

qprog: quantum program.

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.prob_run_tuple_list(qptog: QProg, qubit_list: QVec, select_max: int = -1) → List[Tuple[int, float]]

Run quantum program and get pmeasure result as tuple list

Args:

qprog: quantum program.

qubit_list: pmeasure qubits list.

select_max: max returned element num in returned tuple, should be in [-1, 1<<len(qubit_list)],

default is -1, meaning no limit.

Returns:

Measure result of quantum machine.

pyqpanda.prog_layer(*args, **kwargs) → Any

Process the given quantum program layer.

Args:

prog: The quantum program to be processed.

Returns:

Processed quantum program layer.

pyqpanda.prog_to_dag(prog: QProg) → QProgDAG

Convert a quantum program into a directed acyclic graph (DAG).

Args:

prog: The quantum program to be converted.

Returns:

QProgDAG: A reference to the resulting DAG.

pyqpanda.qAlloc() → Qubit

pyqpanda.qAlloc(qubit_addr: int) → Qubit

Allocate a qubit After init()

Args:

qubit_addr: The physical address of the qubit, should be in [0, 29).

Returns:

Qubit: A new qubit.

None: If qubit_addr is invalid or if the maximum number of allowed qubits has been reached.

pyqpanda.qAlloc_many(qubit_num: int) → List[Qubit]

Allocate several qubits After init()

Args:

qubit_num: The number of qubits to be created.

Returns:

list[pyQPanda.Qubit]: list of qubit.

pyqpanda.qFree(qubit: Qubit) → None

Free a qubit

Args:

qubit: a qubit

Returns:

None

pyqpanda.qFree_all() → None

pyqpanda.qFree_all(qubit_list: QVec) → None

Free a list of qubits

Args:

qubit_list: A list of qubits to be freed.

Returns:

None

pyqpanda.qop(VariationalQuantumCircuit: qop.VariationalQuantumCircuit, Hamiltonian, QuantumMachine: qop.QuantumMachine, qubitList: List[Qubit]) → var

pyqpanda.qop(VariationalQuantumCircuit: qop.VariationalQuantumCircuit, Hamiltonian, QuantumMachine: qop.QuantumMachine, qubitList: Dict[int, Qubit]) → var

pyqpanda.qop_pmeasure(arg0: VariationalQuantumCircuit, arg1: List[int], arg2: QuantumMachine, arg3: List[Qubit]) → var

pyqpanda.quantum_chip_adapter(qprog: QProg, machine: QuantumMachine, mapping: bool = True, config_file: str = 'QPandaConfig.json') → list

Perform adaptive conversion for the quantum chip.

Args:

qprog: the quantum program.

machine: the quantum machine to be used.

mapping: whether to perform the mapping operation (default is true).

config_file: configuration file path (default is CONFIG_PATH).

Returns:

a list containing the quantum program and the list of qubits after mapping; if mapping is false, the qubit list may be misoperated.

pyqpanda.quantum_walk_alg(*args, **kwargs) → Any

Build quantum-walk algorithm quantum circuit

pyqpanda.quantum_walk_search(list: List[int], Classical_condition: ClassicalCondition, QuantumMachine: quantum_walk_search.QuantumMachine, data: int = 2) → quantum_walk_search.list

Use Quantum-walk Algorithm to search target data, return QProg and search_result

Args:

list: data list Classical_condition: quantum Classical condition QuantumMachine: quantum machine repeat: search repeat times

Returns:

result : Quantum-walk search result

Raises:

run_fail: An error occurred in Quantum-walk

pyqpanda.quick_measure(qubit_list: QVec, shots: int) → Dict[str, int]

Quick measure.

Args:

qubit_list: qubit list to measure.

shots: the repeat number of measure operations.

Returns:

result: result of quantum program execution.

pyqpanda.random_qcircuit(qvec: QVec, depth: int = 100, gate_type: List[str] = []) → QCircuit

Generate a random quantum circuit.

Args:

qvec: Output circuits for the random circuit.

depth: Circuit depth (default is 100).

gate_type: Types of gates to use (default is an empty vector).

Returns:

A random quantum circuit.

pyqpanda.random_qprog(qubit_row: int, qubit_col: int, depth: int, qvm: QuantumMachine, qvec: QVec) → QProg

Generate a random quantum program.

Args:

qubit_row: Circuit qubit row value.

qubit_col: Circuit qubit column value.

depth: Circuit depth.

qvm: Quantum machine.

qvec: Output circuits for the random quantum program.

Returns:

A random quantum program.

pyqpanda.recover_edges(topo_data: List[List[int]], max_connect_degree: int, candidate_edges: List[Tuple[int, List[int]]]) → List[List[int]]

Recover edges using the specified candidate edges.

Args:

topo_data: The topology data of the quantum program.

max_connect_degree: The maximum allowed connection degree.

candidate_edges: A list of edges to consider for recovery.

Returns:

The updated topology data after recovery.

pyqpanda.remap(prog: QProg, target_qlist: QVec, target_clist: List[ClassicalCondition] = []) → QProg

Map the source quantum program to the target qubits.

Args:

prog: Source quantum program.

target_qlist: Target qubits.

target_clist: Target classical bits (default is an empty vector).

Returns:

The target quantum program.

pyqpanda.replace_complex_points(src_topo_data: List[List[int]], max_connect_degree: int, sub_topo_vec: List[Tuple[int, List[List[int]]]]) → None

Replace complex points in the source topology with subgraphs.

Args:

src_topo_data: The source topology data of the quantum program.

max_connect_degree: The maximum allowable connection degree.

sub_topo_vec: A list of sub-topologies to replace the complex points.

Returns:

None: This function modifies the source topology in place.

pyqpanda.run_with_configuration(*args, **kwargs) → Any

1. run_with_configuration(program: pyQPanda.QProg, cbit_list: List[pyQPanda.ClassicalCondition], shots: int, noise_model: pyQPanda.Noise = NoiseModel()) -> Dict[str, int]

Run quantum program with configuration

Args:

program: quantum program.

cbit_list: classical cbits list.

shots: number of times to repeat the quantum program.

noise_model: noise model; defaults to no noise. Noise model only works on CPUQVM now.

Returns:

Result of quantum program execution in shots.

First is the final qubit register state, second is its hit count.

2. run_with_configuration(program: pyQPanda.QProg, shots: int, noise_model: pyQPanda.Noise = NoiseModel()) -> Dict[str, int]

Run quantum program with configuration.

Args:

program: quantum program.

shots: repeat run quantum program times.

noise_model: noise model, default is no noise. Noise model only works on CPUQVM now.

Returns:

tuple: result of quantum program execution in shots.

First is the final qubit register state, second is its hit shot.

pyqpanda.sabre_mapping(prog: QProg, quantum_machine: QuantumMachine, init_map: List[int], max_look_ahead: int = 20, max_iterations: int = 10, config_data: str = 'QPandaConfig.json') → QProg

pyqpanda.sabre_mapping(prog: QProg, quantum_machine: QuantumMachine, init_map: List[int], max_look_ahead: int, max_iterations: int, arch_matrix: numpy.ndarray[numpy.float64[m, n]]) → QProg

pyqpanda.sabre_mapping(prog: QProg, quantum_machine: QuantumMachine, max_look_ahead: int = 20, max_iterations: int = 10, config_data: str = 'QPandaConfig.json') → QProg

pyqpanda.sabre_mapping(prog: QProg, quantum_machine: QuantumMachine, max_look_ahead: int, max_iterations: int, arch_matrix: numpy.ndarray[numpy.float64[m, n]]) → QProg

sabre mapping

Args:

prog: the target prog

quantum_machine: quantum machine

max_look_ahead: sabre_mapping max_look_ahead, default is 20

max_iterations: sabre_mapping max_iterations, default is 10

arch_matrix: arch matrix

Returns:

mapped quantum program

pyqpanda.sigmoid(arg0: var) → var

pyqpanda.sin(arg0: var) → var

pyqpanda.softmax(arg0: var) → var

pyqpanda.split_complex_points(complex_points: List[int], max_connect_degree: int, topo_data: List[List[int]], split_method: ComplexVertexSplitMethod = ComplexVertexSplitMethod.LINEAR) → List[Tuple[int, List[List[int]]]]

Split complex points into multiple discrete points.

Args:

complex_points: A list of complex points to be split.

max_connect_degree: The maximum allowable connection degree.

topo_data: The topology data of the quantum program.

split_method: Method for splitting, as defined in ComplexVertexSplitMethod. Defaults to ComplexVertexSplitMethod.LINEAR.

Returns:

None: The function modifies the input data in place.

pyqpanda.stack(arg0: int, *args) → var

pyqpanda.state_fidelity(state1: List[complex], state2: List[complex]) → float

pyqpanda.state_fidelity(matrix1: List[List[complex]], matrix2: List[List[complex]]) → float

pyqpanda.state_fidelity(state1: List[complex], state2: List[List[complex]]) → float

pyqpanda.state_fidelity(state1: List[List[complex]], state2: List[complex]) → float

Compare a quantum state matrix with a quantum state and calculate their fidelity.

Args:

matrix: a quantum state matrix.

state: a single quantum state represented as a list.

Returns:

The fidelity between the matrix and the state, a value in the range [0, 1].

pyqpanda.sub(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.sub(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.sub(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

Subtract a ClassicalCondition from a bit size.

Args:

a: The bit size to subtract from.

b: The ClassicalCondition to be subtracted.

Returns:

ClassicalCondition: The resulting ClassicalCondition after subtraction.

pyqpanda.sum(arg0: var) → var

pyqpanda.tan(arg0: var) → var

pyqpanda.to_Quil(qprog: QProg, machine: QuantumMachine) → str

Transform QProg to Quil instruction.

Args:

qprog: quantum program (QProg).

machine: quantum machine (QuantumMachine*).

Returns:

Quil instruction string.

pyqpanda.to_originir(qprog: QProg, machine: QuantumMachine) → str

pyqpanda.to_originir(qprog: QCircuit, machine: QuantumMachine) → str

pyqpanda.to_originir(qprog: QGate, machine: QuantumMachine) → str

pyqpanda.to_originir(qprog: QIfProg, machine: QuantumMachine) → str

pyqpanda.to_originir(qprog: QWhileProg, machine: QuantumMachine) → str

pyqpanda.to_originir(qprog: QMeasure, machine: QuantumMachine) → str

Transform QProg to OriginIR string.

Args:

qprog: T, the quantum program or circuit to transform.

machine: QuantumMachine*, the quantum machine being used.

Returns:

OriginIR string, the transformed representation of the quantum program.

pyqpanda.topology_match(qprog: QProg, qubit_list: QVec, machine: QuantumMachine, confing_file: str = 'QPandaConfig.json') → list

Judge whether a quantum program matches the topology of the physical qubits.

Args:

qprog: The quantum program to be evaluated.

qubit_list: The list of qubits in the quantum program.

machine: The quantum machine used for execution.

confing_file: The configuration file path for matching (default: QPandaConfig.json).

Returns:

list: Contains the resulting quantum program and the qubit list.

pyqpanda.transform_binary_data_to_qprog(machine: QuantumMachine, data: List[int]) → QProg

Parse binary data to transform it into a quantum program.

Args:

machine: quantum machine.

data: list containing binary data from transform_qprog_to_binary().

Returns:

QProg: the resulting quantum program.

pyqpanda.transform_originir_to_qprog(fname: str, machine: QuantumMachine) → QProg

Transform OriginIR instruction from a file into a QProg.

Args:

fname: file containing the OriginIR instructions.

machine: the quantum machine.

Returns:

QProg: the resulting quantum program.

pyqpanda.transform_qprog_to_binary(qprog: QProg, machine: QuantumMachine) → List[int]

pyqpanda.transform_qprog_to_binary(qprog: QProg, machine: QuantumMachine, fname: str) → None

Save quantum program to file as binary data.

Args:

qprog: quantum program (QProg).

machine: quantum machine.

fname: name of the file to save to.

pyqpanda.transform_qprog_to_originir(qprog: QProg, machine: QuantumMachine) → str

Transform a quantum program into an OriginIR instruction string.

Args:

qprog: the quantum program (QProg).

machine: the quantum machine.

Returns:

string: the resulting OriginIR instruction string.

pyqpanda.transform_qprog_to_quil(qprog: QProg, machine: QuantumMachine) → str

Transform QProg to Quil instruction.

Args:

qprog: quantum program (QProg).

machine: quantum machine (QuantumMachine*).

Returns:

Quil instruction string.

pyqpanda.transform_to_base_qgate(qprog: QProg, machine: QuantumMachine, config_file: str = 'QPandaConfig.json') → QProg

pyqpanda.transform_to_base_qgate(qprog: QProg, machine: QuantumMachine, convert_single_gates: List[str], convert_double_gates: List[str]) → QProg

Convert quantum gates to basic gates.

Args:

qprog: the quantum program to transform.

machine: the quantum machine for the transformation.

convert_single_gates: a set of quantum single gates to convert.

convert_double_gates: a set of quantum double gates to convert.

Returns:

the updated quantum program after the conversion.

pyqpanda.transfrom_pauli_operator_to_matrix(arg0) → List[complex]

transfrom pauli operator to matrix

Args:

matrix: 2^N *2^N double matrix

Returns:

result : hamiltonian

pyqpanda.transpose(arg0: var) → var

pyqpanda.validate_double_qgate_type(gate_str_list: List[str]) → list

Get valid QGates and valid double bit QGate type.

Args:

double_gates: A list of double gate strings.

Returns:

result: A list containing the validated gate type and valid double gates.

pyqpanda.validate_single_qgate_type(gate_str_list: List[str]) → list

Get valid QGates and valid single bit QGate type.

Args:

single_gates: A list of single gate strings.

Returns:

result: A list containing the validated gate type and valid single gates.

pyqpanda.vector_dot(x: List[float], y: List[float]) → float

Compute the inner product of two vectors.

Args:

x: A list representing the first vector.

y: A list representing the second vector.

Returns:

dot result: The dot product of vectors x and y.

pyqpanda.virtual_z_transform(prog: QProg, quantum_machine: QuantumMachine, b_del_rz_gate: bool = False, config_data: str = 'QPandaConfig.json') → QProg

virtual z transform

Args:

prog: the target prog

quantum_machine: quantum machine

b_del_rz_gate: whether delete the rz gate

config_data: config data, @See JsonConfigParam::load_config()

Returns:

mapped quantum program

pyqpanda.single_gate_apply_to_all(gate, qubit_list)

Applies a specified quantum gate to each qubit within the provided list.

This function is intended for use within the pyQPanda package, which facilitates quantum computing with quantum circuits and gates. It operates on a quantum circuit simulator or a quantum cloud service.

Args:

gate (pywrap.QGate):

The quantum gate instance to be applied to each qubit.

qubit_list (list of pyQPanda.Qubit):

A list of qubits to which the gate will be applied.

Returns:

pywrap.QCircuit:

A quantum circuit object with the applied gates.

pyqpanda.single_gate(gate, qubit, angle=None)

Constructs a quantum gate operation on a specified qubit.

This function applies a quantum gate to a qubit, optionally rotating the gate’s action around a specified angle for rotation gates.

Args:

gate (callable):

A quantum gate represented as a callable that takes a qubit and an optional angle.

qubit (int):

The index of the qubit to which the gate will be applied.

angle (float, optional):

The rotation angle for rotation gates. Defaults to None, which means no rotation is applied.

Returns:

pyqpanda.QGate:

The resulting quantum gate operation after applying to the qubit.

Raises:

pyqpanda.run_fail:

If an error occurs while constructing the single gate node.

pyqpanda.meas_all(qubits, cbits)

Constructs a quantum program by measuring specified qubits and mapping their outcomes to classical bits.

Args:

qubits (list):

A list of qubits to be measured.

cbits (list):

A list of classical bits where the measurement outcomes will be stored.

Returns:

QProg:

A quantum program object representing the measurement operation.

Raises:

run_fail:

If an error occurs while constructing the measure all node within the quantum program.

pyqpanda.get_fidelity(result, shots, target_result)

Calculate the fidelity between a given quantum state and a target state.

Args:

result (dict):

A dictionary representing the current quantum state, with terms as keys and probabilities as values.

shots (int):

The number of measurement shots taken to observe the current state.

target_result (dict):

A dictionary representing the target quantum state, with terms as keys and probabilities as values.

Returns:

float:

The fidelity between the current and target states, ranging from 0 to 1.

Raises:

run_fail:

An error is encountered during the computation of fidelity.

pyqpanda.draw_qprog(prog, output=None, scale=0.7, fold=30, filename=None, with_logo=False, line_length=100, NodeIter_first=None, NodeIter_second=None, console_encode_type='utf8')

Visualizes a quantum circuit in various formats based on the specified output type.

Supported output formats include: - ‘text’: ASCII art representation suitable for console output. - ‘pic’: Colorful image representation rendered in Python. - ‘latex’: LaTeX source code for the circuit, suitable for inclusion in LaTeX documents.

Args:

prog (object):

The quantum circuit object to be visualized.

scale (float, optional):

The scale factor for the image output. Defaults to 0.7.

fold (int, optional):

The maximum fold size for the image output. Defaults to 30.

filename (str, optional):

The file path to save the image output. Defaults to ‘QCircuit_pic.jpg’ for ‘pic’ output. For ‘latex’ output, defaults to ‘QCircuit_latex.tex’.

with_logo (bool, optional):

Include the pyQPanda logo in the LaTeX output. Defaults to False.

line_length (int, optional):

The length of each line in the ASCII art output. Defaults to 100.

NodeIter_first (object, optional):

The starting position of the circuit segment to be visualized.

NodeIter_second (object, optional):

The ending position of the circuit segment to be visualized.

console_encode_type (str, optional):

The console encoding type, with ‘utf8’ and ‘gbk’ supported. Defaults to ‘utf8’.

Returns:

str:

The visual representation of the quantum circuit, which is returned as a string depending on the output format.

pyqpanda.show_prog_info_count(prog)

Visualizes the distribution of nodes and layers within a quantum circuit represented by prog.

This function creates a pie chart to display the proportion of different types of nodes and layers in the quantum circuit. It utilizes the information obtained from the count_prog_info function, which provides counts for single, double, and multi-control gate nodes, as well as layer-related metrics.

Args:

prog (object):

The quantum circuit object for which the distribution is to be visualized.

Returns:

None:

This function does not return any value; it only displays the visualization.

The visualization is composed of two pie charts:

The first chart shows the distribution of node types: Single Gate, Double Gate, Multi Control Gate, and Other Nodes. The second chart illustrates the distribution of layer types: Single Gate Layer, Double Gate Layer, and Other Layers.

Note:

This function assumes that the count_prog_info function is properly implemented and that the prog object has the necessary attributes to compute the required counts.

pyqpanda.draw_probability(list)

Generate a bar plot visualizing the probabilities of a quantum state.

The function takes a dictionary containing quantum state keys and their corresponding probabilities, normalizes the probabilities, and plots them using a bar chart.

Args:

probability_dict (dict):

A dictionary where keys represent the quantum states and values represent their respective probabilities.

Returns:

None:

This function does not return a value. It plots the probabilities directly.

Notes:

The bar plot uses the Chinese font ‘SimHei’ and ensures that negative symbols are not displayed in the axes. The x-axis represents the quantum states, while the y-axis represents the probabilities. The function includes a grid on the y-axis for better readability.

pyqpanda.draw_probability_dict(prob_dict)

Generate a bar plot representing the probabilities of a quantum state from a given dictionary.

Args:

prob_dict (dict):

A dictionary where keys are quantum state labels and values are their corresponding probabilities.

Returns:

None:

This function does not return a value; it displays a bar plot.

The function configures Matplotlib to use SimHei font for better readability in Chinese characters. It filters out non-positive probabilities, calculates normalized probabilities, and then plots them as a bar chart. The plot includes a grid and labeled axes for clarity. This utility is intended for use within the pyQPanda package, which is designed for programming quantum computers.

pyqpanda.plot_state_city(state, title='', figsize=None, color=None, ax_real=None, ax_imag=None)

Plots the real and imaginary parts of a quantum state in a 3D bar plot.

Args:

state (list of complex):

The quantum state represented as a list of complex numbers.

title (str, optional):

The title of the plot. Defaults to an empty string.

figsize (tuple, optional):

The size of the figure in inches. Defaults to (15, 5).

color (list, optional):

A list of colors to use for the real and imaginary parts. Defaults to None.

ax_real (matplotlib.axes.Axes, optional):

The axes object for the real part plot. Defaults to None.

ax_imag (matplotlib.axes.Axes, optional):

The axes object for the imaginary part plot. Defaults to None.

Returns:

matplotlib.figure.Figure:

The figure object containing the plots.

Raises:

RuntimeError:

If the input ‘state’ is not a valid quantum state.

Notes:

This function utilizes the pyQPanda package for quantum computing visualization. The function assumes that the input ‘state’ is a list of complex numbers representing the density matrix of a quantum state. The real and imaginary parts of the state are plotted side by side in a single figure. The function supports custom titles, figure sizes, and color schemes. The function also supports plotting directly onto existing axes objects for integration with other visualizations.

pyqpanda.plot_density_matrix(M, xlabels=None, ylabels=None, title=None, limits=None, phase_limits=None, fig=None, axis_vals=None, threshold=None)

Plots the density matrix of a quantum state as a 3D bar plot, visualizing the density of the quantum state and its phase information.

Args:

M (list):

A list of complex numbers representing the density matrix.

xlabels (list, optional):

Labels for the x-axis ticks.

ylabels (list, optional):

Labels for the y-axis ticks.

title (str, optional):

Title for the plot.

limits (list, optional):

Limits for the z-axis.

phase_limits (list, optional):

Limits for the phase angle visualization (default: -π to π).

fig (matplotlib.figure.Figure, optional):

Existing figure object to plot on.

axis_vals (matplotlib.axes.Axes, optional):

Existing 3D axis object to plot on.

threshold (float, optional):

Threshold for highlighting density values above this value.

Returns:

tuple:

A tuple containing the fig and axis_vals objects.

Raises:

RuntimeError:

If the input M is not a valid quantum state density matrix.

pyqpanda.state_to_density_matrix(quantum_state)

Converts a given quantum state into its corresponding density matrix representation.

Args:

quantum_state (complex list):

A list of complex numbers representing the quantum state vector.

Returns:

numpy.ndarray:

The density matrix derived from the quantum state.

Raises:

RuntimeError:

If the provided quantum state is not valid (not a 2^n state vector or not complex).

pyqpanda.plot_bloch_circuit(circuit, trace=True, saveas=None, fps=20, secs_per_gate=1)

Visualizes the evolution of a quantum circuit on a Bloch sphere.

Args:

circuit (object):

The quantum circuit to be visualized.

trace (bool):

Flag to indicate whether to display the path of the state vector.

saveas (str):

The filename to save the animation. If None, the animation is displayed.

fps (int):

The frames per second for the animation.

secs_per_gate (float):

The duration in seconds for each gate operation.

Returns:

None:

The function does not return a value; it generates a visualization.

Raises:

ImportError:

If Matplotlib is not installed.

RuntimeError:

If the circuit contains no gates that can be visualized on a Bloch sphere.

pyqpanda.plot_bloch_vector(bloch, title='bloch', axis_obj=None, fig_size=None)

Visualizes the evolution of a quantum circuit on a Bloch sphere.

Args:

circuit (object):

The quantum circuit to be visualized.

trace (bool):

Flag to indicate whether to display the path of the state vector.

saveas (str):

The filename to save the animation. If None, the animation is displayed.

fps (int):

The frames per second for the animation.

secs_per_gate (float):

The duration in seconds for each gate operation.

Returns:

None:

The function does not return a value; it generates a visualization.

Raises:

ImportError:

If Matplotlib is not installed.

RuntimeError:

If the circuit contains no gates that can be visualized on a Bloch sphere.

pyqpanda.plot_bloch_multivector(state, title='', fig_size=None)

Visualizes a quantum state on a Bloch sphere.

Args:

state (list):

The quantum state vector.

title (str):

The title for the plot.

fig_size (tuple):

The size of the figure in inches.

Returns:

matplotlib.figure.Figure:

The created figure with the Bloch plot.

Raises:

ImportError:

If Matplotlib is not installed.

Description:

This function converts a quantum state vector into a Bloch sphere representation. It generates a figure showing the Bloch vector for each qubit in the state vector. The figure size can be customized, and the plot includes a title. If the backend is inline or notebook, the figure is automatically closed after display.

class pyqpanda.QPilotOSMachine(name: str)

Bases: QPilotOSService

This class can submit Quantum Program to PilotOS.

Args

PilotURLstr

Connect to the target PilotOS address.

PilotIpstr

PilotOS IP address.

PilotPortstr

PilotOS port.

PilotURL = ''

PilotIp = ''

PilotPort = ''

APIKey = ''

LogCout = ''

get_expectation_result(task_id: str) → list

get expectation task result

Args

task_idstr

expectation task id.

Returns

list

expectation task result.

get_qst_result(task_id: str) → list

get qst task result through task_id

Args

task_idstr

the task_id you want to query

Returns

list

The list contains the information of qst task.

set_config(max_qubit: int = None, max_cbit: int = None) → None

set Quantum Machine max Qubit and Cbit number function.

Args

max_qubitint

The Quantum Machine max available qubits.

max_cbitint

The Quantum Machine max available cbits.

Returns

None

Examples

>>> qm.set_config(12, 12)

init(url: str = None, log_cout: bool = False, api_key: str = None) → None

Init Quantum Machine and connect to PilotOS.

Args

urlstr

The Quantum Machine address you want to connnect.

log_coutbool

Whether record execute log.

api_keystr

The unique certificate to login PilotOS, which can get from PilotOS WebSite.

Returns

None

Examples

>>> qm.init('PilotOS_url', True, 'your_api_key')

qAlloc_many(qubit_num: int = None) → list

Get Qubits to construct Quantum Circuit.

Args

qubit_numint

The Qubits number you need to use in circuit.

Returns

List[Qubit]

Examples

>>> q = qm.qAlloc_many(6)

cAlloc_many(cbit_num: int = None) → list

Get Cbits to construct Quantum Circuit.

Args

cbit_numint

The Cbits number you need to use in circuit.

Returns

List[ClassicalCondition]

Examples

>>> c = qm.cAlloc_many(6)

real_chip_measure(prog: List[str] | List[pyqpanda.QProg] | str | pyqpanda.QProg, shot=1000, chip_id=None, is_amend=True, is_mapping=True, is_optimization=True, specified_block=[], describe='') → list

Using sync way to compute your Quantum Program .

Args

progUnion[List[str], List[QProg], str, QProg]

The quantum program you want to compute.

shotint

Repeate run quantum program times.

chip_idint

The quantum chip ID .

is_amendbool

Whether amend task result.

is_mappingbool

Whether mapping logical Qubit to Physical Qubit.

is_optimizationbool

Whether optimize your quantum program.

specified_blockList[int]

Your specifed Qubit block .

describestr

The detailed infomation to describe your quantum program, such as which kind of algorithm, what can this program compute.

Returns

list

a list of every single quantum program

Examples

>>> result = qm.real_chip_measure(prog_list, 1000, chip_id=1, is_mapping=True, describe="test1")
>>> print(result)
[{'00': 0.2456881582421773, '01': 0.2495193504871486, '10': 0.25044435129147546, '11': 0.25434813997919875}, {'00': 0.2456881582421773, '01': 0.2495193504871486, '10': 0.25044435129147546, '11': 0.25434813997919875}]

async_real_chip_measure(prog: List[str] | List[pyqpanda.QProg] | str | pyqpanda.QProg, shot=1000, chip_id=None, is_amend=True, is_mapping=True, is_optimization=True, specified_block=[], describe='') → str

Using async way to compute your Quantum Program, then you need to query task result from task_id.

Args

progUnion[List[str], List[QProg], str, QProg]

The quantum program you want to compute.

shotint

Repeate run quantum program times.

chip_idint

The quantum chip ID .

is_amendbool

Whether amend task result.

is_mappingbool

Whether mapping logical Qubit to Physical Qubit.

is_optimizationbool

Whether optimize your quantum program.

specified_blockList[int]

Your specifed Qubit block .

describestr

The detailed infomation to describe your quantum program, such as which kind of algorithm, what can this program compute.

Returns

str

your task id which can query task result

Examples

This interface will return a string that will be used to query the results of the quantum program you just submitted.

>>> task_id = qm.async_real_chip_measure(prog_list, 1000, chip_id=1, is_mapping=True, describe="test1")
>>> print (task_id)
54C64205E2AF45D393FB5E6279E14984

real_chip_expectation(prog: pyqpanda.QProg | str, hamiltonian: str, qubits: List[int] = None, shot: int = None, chip_id: int = None, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], task_describe: str = '') → float

submit Quantum expectation task, and get the expectation result.

Args

progUnion[QProg, str]

The quantum program you want to compute.

hamiltonianstr

Hamiltonian Args.

qubitsList[int]

measurement qubit

shotint

Repeate run quantum program times.

chip_idint

The quantum chip ID .

is_amendbool

Whether amend task result.

is_mappingbool

Whether mapping logical Qubit to Physical Qubit.

is_optimizationbool

Whether optimize your quantum program.

specified_blockList[int]

Your specifed Qubit block .

task_describestr

The detailed infomation to describe your quantum program, such as which kind of algorithm, what can this program compute.

Returns

float

if success, return the expectation task result. Otherwise return empty.

async_real_chip_expectation(prog: pyqpanda.QProg | str, hamiltonian: str, qubits: List[int] = None, shot: int = None, chip_id: int = None, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], task_describe: str = '') → str

async submit Quantum expectation task, and return the task id.

Args

progUnion[QProg, str]

The quantum program you want to compute.

hamiltonianstr

Hamiltonian Args.

qubitsList[int]

measurement qubit

shotint

Repeate run quantum program times.

chip_idint

The quantum chip ID .

is_amendbool

Whether amend task result.

is_mappingbool

Whether mapping logical Qubit to Physical Qubit.

is_optimizationbool

Whether optimize your quantum program.

specified_blockList[int]

Your specifed Qubit block .

task_describestr

The detailed infomation to describe your quantum program, such as which kind of algorithm, what can this program compute.

Returns

str

return expectation task id, you need query task result by using task id.

async_real_chip_qst(prog: str | pyqpanda.QProg, shot=1000, chip_id=None, is_amend=True, is_mapping=True, is_optimization=True, specified_block=[], describe='') → list

Using async way to compute QST task, then you need to query task result from task_id.

Args

progUnion[str, QProg]

The quantum program you want to compute.

shotint

Repeate run quantum program times.

chip_idint

The quantum chip ID .

is_amendbool

Whether amend task result.

is_mappingbool

Whether mapping logical Qubit to Physical Qubit.

is_optimizationbool

Whether optimize your quantum program.

specified_blockList[int]

Your specifed Qubit block .

describestr

The detailed infomation to describe your quantum program, such as which kind of algorithm, what can this program compute.

Returns

str

your task id which can query task result

query_task_state(task_id: str, file_path: str = None) → list

Query task result from task_id.

task_idstr

The task id you want to query.

file_pathstr

If the parameter is not None, task result will be saved to target path.

list

Contains task state, task result, task error code, task error info, you can decide what to do with state and error code.

This interface will return a result list, contains: task state, probability result, error code, error info(if error code not equal to 0) You can decide whether to save the results of the task to a file by entering the second parameter or not, in particular, if you enter an empty string, the file will be saved in the current path

>>> result_list = qm.query_task_state(task_id, 'D:/python_test/result/')
>>> for i in result_list: print(i)
...
3
['{"key":["0","1"],"value":[0.5,0.5]}']
0

If you enter the second parameter a path to save task result json, the json string in file will be like: {

“taskId”: “2258D6B6164F4F4FA8F85D1DA2F74370”, “endTime”: 1700466283544, “errCode”: 0, “errInfo”: “”, “startTime”: 1700466281627, “qProg”: [

“[“QINIT 72nCREG 72nX q[0]nH q[1]nMEASURE q[0]”, “c[0]nMEASURE q[1]”, “c[1]””, “ “QINIT 72nCREG 72nX q[0]nH q[1]nMEASURE q[0]”, “c[0]nMEASURE q[1]”, “c[1]”]”

], “qProgLength”: 6, “configuration”: “{“shot”:1000,”amendFlag”:false,”mappingFlag”:true,”circuitOptimization”:true,”IsProbCount”:false,”specified_block”:[]}”, “taskState”: “3”, “convertQProg”: [

“[[{“RPhi”:[2,270.0,90.0,0]},{“RPhi”:[3,0.0,180.0,0]},{“Measure”:[[2,3],30]}],[{“RPhi”:[2,270.0,90.0,0]},{“RPhi”:[3,0.0,180.0,0]},{“Measure”:[[2,3],30]}]]”

], “mappingQProg”: [

“QINIT 72

CREG 72 X q[0] H q[1] MEASURE q[0],c[0] MEASURE q[1],c[1]”,

“QINIT 72

CREG 72 X q[0] H q[1] MEASURE q[0],c[0] MEASURE q[1],c[1]”

], “mappingQubit”: [

“{“SrcQubits”:[0,1],”TargetCbits”:[0,1],”MappingQubits”:[3,2]}”, “{“SrcQubits”:[0,1],”TargetCbits”:[0,1],”MappingQubits”:[3,2]}”

], “aioExecuteTime”: 441, “queueTime”: 0, “compileTime”: 608, “totalTime”: 1229, “aioCompileTime”: 0, “aioPendingTime”: 0, “aioMeasureTime”: 0, “aioPostProcessTime”: 0, “requiredCore”: “0”, “pulseTime”: 60.0, “cirExecuteTime”: 200000.0, “taskType”: “0”, “taskResult”: [

“{“key”:[“00”,”01”,”10”,”11”],”value”:[0.017,0.5,0.017,0.466]}”, “{“key”:[“00”,”01”,”10”,”11”],”value”:[0.018,0.474,0.025,0.483]}”

]

}

get_task_list_result(task_id: list, file_path: str = None) → list

Get task result through task id list.

Args

task_idlist

The list of task id you want to query.

file_pathstr

If the parameter is not None, task result will be saved to target path.

Returns

list

This list contasins several dicts of task id and task result.

Examples

This interface will return a list, however, this list will not necessarily contain all the tasks queried, but will only return the results of the tasks that were queried to the completion of the calculation, and if the save path is set, these results will also be saved to a file.

>>> result_list = qm.get_task_list_result(task_id_list, 'D:/python_test/result/')
>>> print(result_list)
[{'task_id': '5D102BEED2714755B9B6AA082151F70E', 'task_result': ['{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}', '{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}']},
{'task_id': '18C163284EE043CAA691B201A9091891', 'task_result': ['{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}', '{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}']},
{'task_id': 'C929CE6E18374181A2E2297327CE6888', 'task_result': ['{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}', '{"key":["00","01","10","11"],"value":[0.25,0.25,0.25,0.25]}']}]

parse_probability_result(result_str: list) → list

Parse async task probability result to a list contains dict.

Args

result_strstr

The json str contains task result key and value.

Returns

list

Examples

>>> result = qm.parse_probability_result(query_str)

quantum_chip_config_query(chip_ids: str) → str

Get quantum chip config

Args

chip_idsstr

the json str contains chip id, it must be int or array, -1 represents all chips

Returns

str

return quantum chip configuration

Examples

>>> chipID_1 = {"ChipID":-1}
>>> chipID_2 = {"ChipID":[5,6,7]}
>>> config_1 = qm.quantum_chip_config_query(chipID_1)
>>> config_2 = qm.quantum_chip_config_query(chipID_2)
>>> print(config_1)
>>> print(config_2)