pyqpanda.pyQPanda

Module Contents

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
QCloudService	origin quantum cloud machine
QCloudTaskConfig
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
QPilotMachine	pliot machine
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

Functions

BARRIER(…)	Create a BARRIER gate
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 a classical quantum IfProg
CreateWhileProg(→ QWhileProg)	Create a WhileProg
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 an 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 prob list
accumulate_probabilities(→ List[float])	Accumulate the probability from a prob list
accumulate_probability(→ List[float])	Accumulate the probability from a prob list
acos(→ var)
add(…)
all_cut_of_graph(→ float)	Generate graph of maxcut problem
amplitude_encode(…)	Encode the input double data to the amplitude of qubits
apply_QGate(…)	Apply QGate to qubits
asin(→ var)
assign(…)
atan(→ var)
average_gate_fidelity(…)	compare two quantum states , Get the state fidelity
bin_to_prog(→ bool)	Parse binary data transfor to 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
calculate_quantum_volume(…)	calculate quantum volume
cast_qprog_qcircuit(→ QCircuit)	Cast QProg to QCircuit
cast_qprog_qgate(→ QGate)	Cast QProg to QGate
cast_qprog_qmeasure(→ QMeasure)	Cast QProg to QMeasure
circuit_layer(→ list)	Quantum circuit layering
circuit_optimizer(→ QProg)	Optimize QCircuit
circuit_optimizer_by_config(→ QProg)	QCircuit optimizer
comm_protocol_decode(→ Tuple[List[QProg], ...)	decode binary data to comm protocol prog list
comm_protocol_encode(…)	encode comm protocol data to binary data
constModAdd(→ QCircuit)	Args:
constModExp(→ QCircuit)	Args:
constModMul(→ QCircuit)	Args:
convert_binary_data_to_qprog(→ QProg)	Parse binary data to quantum program
convert_originir_str_to_qprog(→ list)	Trans OriginIR to QProg
convert_originir_to_qprog(→ list)	Read OriginIR file and trans to QProg
convert_qasm_string_to_qprog(→ list)	Trans QASM to QProg
convert_qasm_to_qprog(→ list)	Read QASM file and trans to QProg
convert_qprog_to_binary(…)	Store quantum program in binary file
convert_qprog_to_originir(→ str)	Args:
convert_qprog_to_qasm(→ str)	Convert QProg to QASM instruction string
convert_qprog_to_quil(→ str)	convert QProg to Quil instruction
cos(→ var)
count_gate(…)	Count quantum gate num under quantum program, quantum circuit
count_prog_info(…)	count quantum program info
count_qgate_num(…)	Count quantum gate num under quantum program
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(…)
del_weak_edge(→ None)	Delete weakly connected edges
del_weak_edge2(→ list)	Delete weakly connected edges
del_weak_edge3(→ list)	Delete weakly connected edges
destroy_quantum_machine(→ None)	Destroy a quantum machine
directly_run() → Dict[str, bool])	Directly run quantum prog
div(…)
dot(→ var)
double_gate_xeb(…)	double gate xeb
double_qubit_rb(…)	double qubit rb with origin chip
draw_qprog_latex(, itr_end)	Convert a quantum prog/circuit to latex source code, and save the source code to file in current path with name QCircuit.tex
draw_qprog_latex_with_clock(, itr_end)	Convert a quantum prog/circuit to latex source code with time sequence, and save the source code to file in current path with name QCircuit.tex
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(…)
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 QProg by I gate, return a new quantum program
finalize(→ None)	Finalize the environment and destory global unique quantum machine.
fit_to_gbk(→ str)	Special character conversion
flatten(…)	Flatten quantum circuit
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's(the front one and the back one) typeinfo from QProg
get_all_used_qubits(→ QVec)	Get all the used quantum bits in the input prog
get_all_used_qubits_to_int(→ List[int])	Get all the used quantum bits addr in the input prog
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(→ QVec)	Get allocated qubits of QuantumMachine
get_bin_data(→ List[int])	Get quantum program binary data
get_bin_str(→ str)	Transfor quantum program to string
get_circuit_optimal_topology(→ List[List[int]])	Get the optimal topology of the input circuit
get_clock_cycle(→ int)	Get quantum program clock cycle
get_complex_points(→ List[int])	Get complex points
get_double_gate_block_topology(→ List[List[int]])	get double gate block topology
get_matrix(, nodeitr_end)	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 quantum gate num under quantum program
get_qprog_clock_cycle(→ int)	Get Quantum Program Clock Cycle
get_qstate(…)
get_sub_graph(→ List[int])	Get sub graph
get_tuple_list(→ List[Tuple[int, float]])	Get pmeasure result as tuple list
get_unitary(, nodeitr_end)	Get the target matrix between the input two Nodeiters
get_unsupport_qgate_num(→ int)	Count quantum program unsupported gate numner
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 global unique quantum machine
inverse(→ var)
isCarry(→ QCircuit)	Construct a circuit to determine if there is a carry
is_match_topology(→ bool)	Judge the QGate if match the target topologic structure of quantum circuit
is_supported_qgate_type(→ bool)	Judge if the target node is a QGate type
is_swappable(→ bool)	Judge the specialed two NodeIters in qprog whether can be exchanged
iterative_amplitude_estimation(→ float)	estimate the probability corresponding to the ground state |1> of the last bit
ldd_decompose(→ QProg)	Decompose multiple control QGate
log(→ var)
matrix_decompose(…)	Matrix decomposition
matrix_decompose_paulis(…)	decompose matrix into paulis combination
measure_all(…)	Create a list of measure node
mul(…)
originir_to_qprog(→ QProg)	Read OriginIR file and trans to QProg
pauli_combination_replace(→ List[Tuple[float, QCircuit]])
planarity_testing(→ bool)	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 element
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)
prog_to_dag(→ QProgDAG)
qAlloc(…)	Allocate a qubits
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)	Quantum chip adaptive conversion
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 random quantum circuit
random_qprog(→ QProg)	Generate random quantum program
recover_edges(→ List[List[int]])	Recover edges from the candidate edges
remap(→ QProg)	Source qunatum program is mapped to the target qubits
replace_complex_points(→ None)	Replacing complex points with subgraphs
run_with_configuration(…)	Run quantum program with configuration
sabre_mapping(…)	sabre mapping
sigmoid(→ var)
sin(→ var)
single_qubit_rb(…)	Single qubit rb with origin chip
softmax(→ var)
split_complex_points(→ List[Tuple[int, List[List[int]]]])	Splitting complex points into multiple points
stack(→ var)
state_fidelity(…)	compare two quantum states , Get the state fidelity
sub(…)
sum(→ var)
tan(→ var)
to_Quil(→ str)	Transform QProg to Quil instruction
to_originir(…)	Transform QProg to OriginIR string
topology_match(→ list)	Judge QProg/QCircuit matches the topology of the physical qubits
transform_binary_data_to_qprog(→ QProg)	Parse binary data trans to quantum program
transform_originir_to_qprog(→ QProg)	Transform OriginIR to QProg
transform_qprog_to_binary(…)	Save quantum program to file as binary data
transform_qprog_to_originir(→ str)	Quantum program transform to OriginIR string
transform_qprog_to_quil(→ str)	Transform QProg to Quil instruction
transform_to_base_qgate(…)	Basic quantum - gate conversion
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)	Inner product of vector x and y
virtual_z_transform(→ QProg)	virtual z transform

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

quantum AbstractOptimizer class

exec() → None

getResult(*args, **kwargs) → Any

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

setAdaptive(arg0: bool) → None

setCacheFile(arg0: str) → None

setDisp(arg0: bool) → None

setFatol(arg0: float) → None

setMaxFCalls(arg0: int) → None

setMaxIter(arg0: int) → None

setRestoreFromCacheFile(arg0: bool) → None

setXatol(arg0: float) → None

class pyqpanda.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.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.pyQPanda.Ansatz

class pyqpanda.pyQPanda.Ansatz(arg0: QGate)

class pyqpanda.pyQPanda.Ansatz(arg0: AnsatzGate)

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

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

class pyqpanda.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.pyQPanda.AnsatzGate(arg0: AnsatzGateType, arg1: int)

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

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

ansatz gate struct

control: int

target: int

theta: float

type: AnsatzGateType

class pyqpanda.pyQPanda.AnsatzGateType(value: int)

Quantum ansatz gate type

Members:

AGT_X

AGT_H

AGT_RX

AGT_RY

AGT_RZ

property name: str

property value: int

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

class pyqpanda.pyQPanda.BackendType(value: int)

Quantum machine backend type

Members:

CPU

GPU

CPU_SINGLE_THREAD

NOISE

MPS

property name: str

property value: int

CPU: ClassVar[BackendType] = Ellipsis

CPU_SINGLE_THREAD: ClassVar[BackendType] = Ellipsis

GPU: ClassVar[BackendType] = Ellipsis

MPS: ClassVar[BackendType] = Ellipsis

NOISE: ClassVar[BackendType] = Ellipsis

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

quantum classical bit

getName() → str

class pyqpanda.pyQPanda.CPUQVM

Bases: QuantumMachine

quantum machine cpu

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

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

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

init_qvm(arg0: bool) → None

init_qvm() → None

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

Get the probability distribution over qubits

pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits

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]

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]

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]]

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

set_max_threads(size: int) → None

set CPUQVM max thread size

class pyqpanda.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_prob_list(qubit_list: QVec, select_max: int = -1) → List[float]

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

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

Get the probability distribution over qubits

pmeasure_no_index(qubit_list: QVec) → List[float]

Get the probability distribution over qubits

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]

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]

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]]

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

class pyqpanda.pyQPanda.ChipID(value: int)

origin quantum real chip type

Members:

Simulation

WUYUAN_1

WUYUAN_2

WUYUAN_3

property name: str

property value: int

Simulation: ClassVar[ChipID] = Ellipsis

WUYUAN_1: ClassVar[ChipID] = Ellipsis

WUYUAN_2: ClassVar[ChipID] = Ellipsis

WUYUAN_3: ClassVar[ChipID] = Ellipsis

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

Classical condition class Proxy class of cexpr class

c_and(arg0: int) → ClassicalCondition

c_and(arg0: ClassicalCondition) → ClassicalCondition

c_not() → ClassicalCondition

c_or(arg0: int) → ClassicalCondition

c_or(arg0: ClassicalCondition) → ClassicalCondition

get_val() → int

get value

set_val(arg0: int) → None

set value

class pyqpanda.pyQPanda.ClassicalProg(arg0: ClassicalCondition)

quantum ClassicalProg

class pyqpanda.pyQPanda.CommProtocolConfig

circuits_num: int

open_error_mitigation: bool

open_mapping: bool

optimization_level: int

shots: int

class pyqpanda.pyQPanda.ComplexVertexSplitMethod(value: int)

quantum complex vertex split method

Members:

METHOD_UNDEFINED

LINEAR

RING

property name: str

property value: int

LINEAR: ClassVar[ComplexVertexSplitMethod] = Ellipsis

METHOD_UNDEFINED: ClassVar[ComplexVertexSplitMethod] = Ellipsis

RING: ClassVar[ComplexVertexSplitMethod] = Ellipsis

class pyqpanda.pyQPanda.DAGNodeType(value: int)

Quantum dag node type

Members:

NUKNOW_SEQ_NODE_TYPE

MAX_GATE_TYPE

MEASURE

QUBIT

RESET

property name: str

property value: int

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

class pyqpanda.pyQPanda.DecompositionMode(value: int)

Quantum matrix decomposition mode

Members:

QR

HOUSEHOLDER_QR

QSDecomposition

CSDecomposition

property name: str

property value: int

CSDecomposition: ClassVar[DecompositionMode] = Ellipsis

HOUSEHOLDER_QR: ClassVar[DecompositionMode] = Ellipsis

QR: ClassVar[DecompositionMode] = Ellipsis

QSDecomposition: ClassVar[DecompositionMode] = Ellipsis

class pyqpanda.pyQPanda.DensityMatrixSimulator

Bases: QuantumMachine

simulator for density matrix

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

Run quantum program and get full density matrix

Args:

prog: quantum program

Returns:

full density matrix

Raises:

run_fail: An error occurred in get_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 quantum program and hamiltonian expection for current qubits

Args:

prog: quantum program hamiltonian: QHamiltonian qubits: select qubits

Returns:

hamiltonian expection for current qubits

Raises:

run_fail: An error occurred in get_expectation

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 quantum program and get all indices probabilities for current binary indices

Args:

prog: quantum program indices: select binary indices

Returns:

probabilities result of quantum program

Raises:

run_fail: An error occurred in get_probabilities

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

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

Run quantum program and get index probability

Args:

prog: quantum program index: measure index in [0,2^N - 1]

Returns:

probability result of quantum program

Raises:

run_fail: An error occurred in get_probability

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 density matrix for current qubits

Args:

prog: quantum program qubits: quantum program select qubits

Returns:

density matrix

Raises:

run_fail: An error occurred in get_reduced_density_matrix

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

class pyqpanda.pyQPanda.DoubleGateTransferType(value: int)

Quantum double gate transfer type

Members:

DOUBLE_GATE_INVALID

DOUBLE_BIT_GATE

property name: str

property value: int

DOUBLE_BIT_GATE: ClassVar[DoubleGateTransferType] = Ellipsis

DOUBLE_GATE_INVALID: ClassVar[DoubleGateTransferType] = Ellipsis

class pyqpanda.pyQPanda.Encode

quantum amplitude encode

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

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

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

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

Encode by amplitude recursive

Args:

QVec: qubits QStat: amplitude

Returns:

circuit

Raises:

run_fail: An error occurred in get amplitude_encode_recursive

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

Raises:

run_fail: An error occurred in get angle_encode

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

approx mps encode

Args:

Qubit: qubits data: std::vector<qcomplex_t> int: layer int: step

Returns:

circuit

Raises:

run_fail: An error occurred in approx_mps

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

basic_encode

Args:

QVec: qubits string: data

Returns:

circuit

Raises:

run_fail: An error occurred in basic_encode

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

Encode by bid

Args:

QVec: qubits QStat: amplitude split: int

Returns:

circuit

Raises:

run_fail: An error occurred in bid_amplitude_encode

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

Encode by dc amplitude

Args:

QVec: qubits QStat: amplitude

Returns:

circuit

Raises:

run_fail: An error occurred in dc_amplitude_encode

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

Encode by dense angle

Args:

QVec: qubits prob_vec: data

Returns:

circuit

Raises:

run_fail: An error occurred in dense_angle_encode

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

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

get_circuit() → QCircuit

get_fidelity(data: List[float]) → float

get_fidelity(data: List[complex]) → float

get_fidelity(data: List[float]) → float

get_out_qubits() → QVec

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

Raises:

run_fail: An error occurred in iqp_encode

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

Encode by schmidt

Args:

QVec: qubits QStat: amplitude double: cut_off

Returns:

circuit

Raises:

run_fail: An error occurred in schmidt_encode

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

class pyqpanda.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

property name: str

property value: int

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

class pyqpanda.pyQPanda.Fusion

quantum fusion operation

aggregate_operations(circuit: QCircuit) → None

aggregate_operations(qprog: QProg) → None

class pyqpanda.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

property name: str

property value: int

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

class pyqpanda.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.pyQPanda.LATEX_GATE_TYPE(value: int)

Quantum latex gate type

Members:

GENERAL_GATE

CNOT_GATE

SWAP_GATE

property name: str

property value: int

CNOT_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

GENERAL_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

SWAP_GATE: ClassVar[LATEX_GATE_TYPE] = Ellipsis

class pyqpanda.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

Args:

rows: rows need be barriered, may not continus

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 circute

Args:

target_rows: gate targets row of latex matrix ctrl_rows from_col: gate wanted col pos, but there may be not enough zone to put gate gate_type: enum type of LATEX_GATE_TYPE gate_name dagger: dagger flag param: gate param str

Returns:

int: real col num. if there is no enough zone to put gate at 'from_col', we will find suitable col to put gate after 'from_col'

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

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

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

Beware we do not check col num, may cause overwrite. user must take care col num self

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

Set Label at left most head col or right most tail col label can be reseted at any time

Args:

qubit_label: label for qwire left most head label, at row, in latex syntax. not given row will keep empty

eg. {0: 'q_{1}', 2:'q_{2}'}

cbit_label: classic label string, support latex str time_seq_label: if given, set time squence lable head: if true, label append head; false, append at tail

set_logo(logo: str = '') → None

Add a logo string

str(with_time: bool = False) → str

return final latex source code, can be called at any time

class pyqpanda.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

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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_dict

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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_list

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

Get pmeasure result as list

Args:

qubit_list: pmeasure qubits list select_max: max returned element num in returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_tuple_list

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

Get the probability distribution over qubits

Args:

qubit_list: qubit list to measure select_max: max returned element num in returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine in tuple form

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

pmeasure bin index quantum state amplitude

Args:

string : bin string

Returns:

complex : bin amplitude

Raises:

run_fail: An error occurred in pmeasure_bin_index

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

pmeasure quantum state amplitude subset

Args:

list : bin state string list

Returns:

list : bin amplitude result list

Raises:

run_fail: An error occurred in pmeasure_bin_subset

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

pmeasure dec index quantum state amplitude

Args:

string : dec string

Returns:

complex : dec amplitude

Raises:

run_fail: An error occurred in pmeasure_dec_index

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

pmeasure quantum state amplitude subset

Args:

list : dec state string list

Returns:

list : dec amplitude result list

Raises:

run_fail: An error occurred in pmeasure_dec_subset

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

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:

qprog: quantum program qubit_list: pmeasure qubits list select_max: max returned element num in returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

prob_run_list(program: 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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

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:

qprog: quantum program qubit_list: pmeasure qubits list select_max: max returned element num in returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in prob_run_tuple_list

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

Quick measure

Args:

qubit_list: qubit list to measure shots: the repeat num of measure operate

Returns:

result of quantum program

Raises:

run_fail: An error occurred in measure quantum program

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

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

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_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_readout_error(readout_params: List[List[float]], qubits: QVec) → None

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

set_rotation_error(param: float) → None

class pyqpanda.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.pyQPanda.NodeInfo

class pyqpanda.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

class pyqpanda.pyQPanda.NodeIter

quantum node iter

get_next() → NodeIter

get_node_type() → NodeType

get_pre() → NodeIter

class pyqpanda.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

property name: str

property value: int

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

class pyqpanda.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_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

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_readout_error(prob_list: List[List[float]], qubits: QVec = ...) → None

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

set_rotation_error(error: float) → None

class pyqpanda.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

property name: str

property value: int

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

class pyqpanda.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 NoiseQVM max thread size

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_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_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_readout_error(probs_list: List[List[float]], qubits: QVec = ...) → None

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

set_rotation_error(arg0: float) → None

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

variational quantum Optimizer class

get_loss() → float

get_variables() → List[var]

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

class pyqpanda.pyQPanda.OptimizerFactory

quantum OptimizerFactory class

makeOptimizer() → AbstractOptimizer

makeOptimizer() → AbstractOptimizer

Please input the Optimizer's name(string)

class pyqpanda.pyQPanda.OptimizerMode(value: int)

variational quantum OptimizerMode

Members:

property name: str

property value: int

class pyqpanda.pyQPanda.OptimizerType(value: int)

quantum OptimizerType

Members:

NELDER_MEAD

POWELL

GRADIENT

property name: str

property value: int

GRADIENT: ClassVar[OptimizerType] = Ellipsis

NELDER_MEAD: ClassVar[OptimizerType] = Ellipsis

POWELL: ClassVar[OptimizerType] = Ellipsis

class pyqpanda.pyQPanda.OriginCMem

origin quantum cmem

Allocate_CBit() → CBit

Allocate_CBit(cbit_num: int) → CBit

Free_CBit(cbit: CBit) → None

cAlloc() → CBit

cAlloc(cbit_num: int) → CBit

cAlloc_many(count: int) → List[ClassicalCondition]

cFree(classical_cond: ClassicalCondition) → None

cFree_all(classical_cond_list: List[ClassicalCondition]) → None

cFree_all() → None

clearAll() → None

getIdleMem() → int

getMaxMem() → int

get_allocate_cbits() → List[ClassicalCondition]

Get allocate cbits

get_capacity() → int

get_cbit_by_addr(cbit_addr: int) → CBit

set_capacity(arg0: int) → None

class pyqpanda.pyQPanda.OriginCollection

class pyqpanda.pyQPanda.OriginCollection(file_name: str)

class pyqpanda.pyQPanda.OriginCollection(arg0: OriginCollection)

A relatively free data collection class for saving data

getFilePath() → str

Get file path

getJsonString() → str

Get Json String

getKeyVector() → List[str]

Get key vector

getValue(key_name: str) → List[str]

Get value by Key name

getValueByKey(key_value: str) → str

getValueByKey(key_value: int) → str

Get Value by key value

insertValue(key: str, *args) → None

open(file_name: str) → bool

Read the json file of the specified path

setNames(*args) → None

write() → bool

write json file

class pyqpanda.pyQPanda.OriginQubitPool

quantum qubit pool

allocateQubitThroughPhyAddress(qubit_addr: int) → Qubit

allocateQubitThroughVirAddress(qubit_num: int) → Qubit

clearAll() → None

getIdleQubit() → int

getMaxQubit() → int

getPhysicalQubitAddr(qubit: Qubit) → int

getVirtualQubitAddress(qubit: Qubit) → int

get_allocate_qubits() → QVec

get allocate qubits

get_capacity() → int

get_max_usedqubit_addr() → int

get_qubit_by_addr(qubit_addr: int) → Qubit

qAlloc() → Qubit

qAlloc_many(qubit_num: int) → List[Qubit]

Allocate a list of qubits

qFree(arg0: Qubit) → None

qFree_all(arg0: QVec) → None

qFree_all() → None

set_capacity(arg0: int) → None

class pyqpanda.pyQPanda.PartialAmpQVM

Bases: QuantumMachine

quantum partial amplitude machine class

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

Get pmeasure result as dict

Args:

qubit_list: pmeasure qubits list

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_dict

init_qvm(backend_type: int = 0) → None

pmeasure_bin_index(bin_index: str) → complex

pmeasure bin index quantum state amplitude

Args:

string : bin string

Returns:

complex : bin amplitude

Raises:

run_fail: An error occurred in pmeasure_bin_index

pmeasure_dec_index(dec_index: str) → complex

pmeasure dec index quantum state amplitude

Args:

string : dec string

Returns:

complex : dec amplitude

Raises:

run_fail: An error occurred in pmeasure_dec_index

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

pmeasure quantum state amplitude subset

Args:

list : dec state string list

Returns:

list : dec amplitude result list

Raises:

run_fail: An error occurred in pmeasure_dec_index

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program qubit_list: pmeasure qubits list

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

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

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

run the quantum program

Args:

QProg: quantum prog size_t : NoiseModel

Returns:

none

Raises:

run_fail: An error occurred in run

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

Physical Qubit abstract class

getQubitAddr() → int

class pyqpanda.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.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.pyQPanda.QCircuit

class pyqpanda.pyQPanda.QCircuit(arg0: NodeIter)

quantum circuit node

begin() → NodeIter

control(control_qubits: QVec) → QCircuit

dagger() → QCircuit

end() → NodeIter

head() → NodeIter

insert(arg0: QCircuit) → QCircuit

insert(arg0: QGate) → QCircuit

is_empty() → bool

last() → NodeIter

set_control(control_qubits: QVec) → None

set_dagger(arg0: bool) → None

class pyqpanda.pyQPanda.QCircuitOPtimizerMode(value: int)

Quantum circuit optimize mode

Members:

Merge_H_X

Merge_U3

Merge_RX

Merge_RY

Merge_RZ

property name: str

property value: int

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

class pyqpanda.pyQPanda.QCloudService

Bases: QuantumMachine

origin quantum cloud machine

batch_compute_url: str

batch_inquire_url: str

big_data_batch_compute_url: str

compute_url: str

configuration_header_data: str

estimate_url: str

inquire_url: str

measure_qubits_num: List[int]

pqc_batch_compute_url: str

pqc_batch_inquire_url: str

pqc_compute_url: str

pqc_init_url: str

pqc_inquire_url: str

pqc_keys_url: str

use_compress_data: bool

user_token: str

batch_cyclic_query(arg0: str) → Tuple[bool, List[str]]

build_error_mitigation(shots: int, chip_id: int, expectations: List[str], noise_strength: List[float], qemMethod: em_method) → str

build_full_amplitude_measure(shots: int) → str

build_full_amplitude_pmeasure(qubit_vec: List[int]) → str

build_get_expectation(hamiltonian: List[Tuple[Dict[int, str], float]], qubits: List[int]) → str

build_get_state_fidelity(shot: int, chip_id: int = 2, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True) → str

build_get_state_tomography_density(shot: int, chip_id: int = 2, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True) → str

build_init_object(arg0: QProg, arg1: str, arg2: int) → None

build_init_object(arg0: str, arg1: str, arg2: int) → None

build_noise_measure(shots: int) → str

build_partial_amplitude_pmeasure(amplitudes: List[str]) → str

build_read_out_mitigation(shots: int, chip_id: int, expectations: List[str], noise_strength: List[float], qem_method: em_method) → str

build_real_chip_measure(shots: int, chip_id: int = 2, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True) → str

build_real_chip_measure_batch(prog_list: List[str], shots: int, chip_id: int = 2, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, enable_compress_check: bool = False, batch_id: str = '', task_from: int = 4) → str

build_real_chip_measure_batch(prog_list: List[QProg], shots: int, chip_id: int = 2, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, enable_compress_check: bool = False, batch_id: str = '', task_from: int = 4) → str

build_single_amplitude_pmeasure(amplitude: str) → str

cyclic_query(arg0: str) → Tuple[bool, str]

init(user_token: str, is_logged: bool = False) → None

parse_get_task_id(arg0: str) → str

query_comolex_result(arg0: str) → complex

query_prob_dict_result(arg0: str) → Dict[str, float]

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

query_prob_result(arg0: str) → float

query_prob_vec_result(arg0: str) → List[float]

query_qst_result(arg0: str) → List[List[complex]]

query_state_dict_result(arg0: str) → Dict[str, complex]

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

set_qcloud_url(cloud_url: str) → None

class pyqpanda.pyQPanda.QCloudTaskConfig

chip_id: real_chip_type

cloud_token: str

open_amend: bool

open_mapping: bool

open_optimization: bool

shots: int

class pyqpanda.pyQPanda.QError(value: int)

Quantum QError Type

Members:

UndefineError

qErrorNone

qParameterError

qubitError

loadFileError

initStateError

destroyStateError

setComputeUnitError

runProgramError

getResultError

getQStateError

property name: str

property value: int

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

class pyqpanda.pyQPanda.QGate(arg0: NodeIter)

quantum gate node

control(control_qubits: QVec) → QGate

Get a control quantumgate base on current quantum gate node

dagger() → QGate

gate_matrix() → List[complex]

gate_type() → int

get_control_qubit_num() → int

get_control_qubits(control_qubits: QVec) → int

Get control vector fron current quantum gate node

Args:

qvec: control qubits output

Returns:

int: size of control qubits

get_qubits(qubits: QVec) → int

Get qubit vector inside this quantum gate

Args:

qvec: qubits output

Returns:

int: size of qubits

get_target_qubit_num() → int

is_dagger() → bool

set_control(arg0: QVec) → bool

set_dagger(arg0: bool) → bool

class pyqpanda.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.pyQPanda.QIfProg(arg0: NodeIter)

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

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

quantum if prog node

get_classical_condition() → ClassicalCondition

get_false_branch() → QProg

get_true_branch() → QProg

class pyqpanda.pyQPanda.QMachineType(value: int)

Quantum machine type

Members:

CPU

GPU

CPU_SINGLE_THREAD

NOISE

property name: str

property value: int

CPU: ClassVar[QMachineType] = Ellipsis

CPU_SINGLE_THREAD: ClassVar[QMachineType] = Ellipsis

GPU: ClassVar[QMachineType] = Ellipsis

NOISE: ClassVar[QMachineType] = Ellipsis

class pyqpanda.pyQPanda.QMeasure(arg0: NodeIter)

quantum measure node

class pyqpanda.pyQPanda.QOperator

class pyqpanda.pyQPanda.QOperator(arg0: QGate)

class pyqpanda.pyQPanda.QOperator(arg0: QCircuit)

quantum operator class

get_matrix() → List[complex]

to_instruction(arg0: str) → str

class pyqpanda.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.pyQPanda.QPilotMachine

pliot machine

build_noise_params(nose_model_type: int, single_params: List[float], double_params: List[float]) → PilotNoiseParams

execute_callback_full_amplitude_expectation(prog_str: str, hamiltonian: List[Tuple[Dict[int, str], float]], qubit_vec: List[int], cb_func: Callable[[ErrorCode, float], None], chip_id: int = 33554433) → ErrorCode

execute_callback_full_amplitude_measure_task(prog_str: str, cb_func: Callable[[ErrorCode, Dict[str, float]], None], chip_id: int = 33554433, shots: int = 1000) → ErrorCode

execute_callback_full_amplitude_pmeasure_task(prog_str: str, qubit_vec: List[int], cb_func: Callable[[ErrorCode, Dict[str, float]], None], chip_id: int = 33554433) → ErrorCode

execute_callback_measure_task(prog_str: str, cb_func: Callable[[ErrorCode, Dict[str, float]], None], chip_id: int = 33554432, b_mapping: bool = True, b_optimization: bool = True, shots: int = 1000, specified_block: List[int] = []) → ErrorCode

execute_callback_noise_measure_task(prog_str: str, noise_params: PilotNoiseParams, cb_func: Callable[[ErrorCode, Dict[str, float]], None], chip_id: int = 33554433, shots: int = 1000) → ErrorCode

execute_callback_partial_amplitude_task(prog_str: str, target_amplitude_vec: List[str], cb_func: Callable[[ErrorCode, Dict[str, complex]], None], chip_id: int = 33554433) → ErrorCode

execute_callback_single_amplitude_task(prog_str: str, target_amplitude: str, cb_func: Callable[[ErrorCode, complex], None], chip_id: int = 33554433) → ErrorCode

execute_full_amplitude_expectation(prog_str: str, hamiltonian: List[Tuple[Dict[int, str], float]], qubit_vec: List[int], chip_id: int = 33554433) → float

execute_full_amplitude_measure_task(prog_str: str, chip_id: int = 33554433, shots: int = 1000) → Dict[str, float]

execute_full_amplitude_pmeasure_task(prog_str: str, qubit_vec: List[int], chip_id: int = 33554433) → Dict[str, float]

execute_measure_task(prog_str: str, chip_id: int = 33554432, b_mapping: bool = True, b_optimization: bool = True, shots: int = 1000, specified_block: List[int] = []) → List[Dict[str, float]]

execute_noise_measure_task(prog_str: str, noise_params: PilotNoiseParams, chip_id: int = 33554433, shots: int = 1000) → Dict[str, float]

execute_partial_amplitude_task(prog_str: str, target_amplitude_vec: List[str], chip_id: int = 33554433) → Dict[str, complex]

execute_single_amplitude_task(prog_str: str, target_amplitude: str, chip_id: int = 33554433) → complex

init(pilot_url: str, log_cout: bool = False) → bool

init_withconfig(config_path: str = 'pilotmachine.conf') → bool

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

Bases: QuantumMachine

origin quantum pilot OS Machine

async_em_compute(parameter_json: str) → str

async_real_chip_expectation(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] = [], describe: str = '') → str

async_real_chip_measure(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] = [], is_prob_counts: bool = True, describe: str = '') → str

async_real_chip_measure(ir: str, shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], is_prob_counts: bool = True, describe: str = '') → str

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

async_real_chip_measure(ir: List[str], shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], is_prob_counts: bool = True, describe: str = '') → str

async_real_chip_measure(prog: List[QProg], config_str: str) → str

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

async_real_chip_measure_vec(ir: List[str], shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], is_prob_counts: bool = True, describe: str = '') → str

async_real_chip_qst(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] = [], describe: str = '') → str

async_real_chip_qst_density(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] = [], describe: str = '') → str

async_real_chip_qst_fidelity(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] = [], describe: str = '') → str

build_init_msg(api_key: str) → str

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

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

em_compute(parameter_json: str) → List[float]

finalize() → None

finalize

get_expectation_result(task_id: str) → list

get_measure_result(task_id: str) → list

get_measure_result(task_id: str) → list

get_qst_density_result(task_id: str) → list

get_qst_fidelity_result(task_id: str) → list

get_qst_result(task_id: str) → list

get_token(rep_json: str) → ErrorCode

init() → None

init(url: str, log_cout: bool = False, api_key: str = None) → None

init(url: str, log_cout: bool = False, username: str = None, password: str = None) → None

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

noise_learning(parameter_json: str = True) → str

output_version() → str

pMeasureBinindex(prog: QProg, index: str, backendID: int = 33554433) → float

pMeasureDecindex(prog: QProg, index: str, backendID: int = 33554433) → float

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_sync_result(json_str: str) → list

pmeasure_subset(prog: QProg, amplitude: List[str], backendID: int = 33554433) → Dict[str, complex]

probRunDict(prog: QProg, qubit_vec: List[int], backendID: int = 33554433) → Dict[str, float]

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

query_compile_prog(task_id: str, without_compensate: bool = True) → list

Query Task compile prog by task_id Args:

without_compensate: whether return the prog without angle compensate

Returns:

bool: whether find compile prog success

Raises:

none

query_task_state(task_id: str) → list

query_task_state(task_id: str, is_save: bool, file_path: str = '') → list

query_task_state_vec(task_id: str) → list

Query Task State by task_id Args:

task_id: Taeget task id, got by async_real_chip_measure

Returns:

string: task state: 2: Running; 3: Finished; 4: Failed array: task result array

Raises:

none

real_chip_expectation(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] = [], describe: str = '') → float

real_chip_measure(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] = [], describe: str = '') → Dict[str, float]

real_chip_measure(ir: str, shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → Dict[str, float]

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

real_chip_measure(ir: List[str], shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → List[Dict[str, float]]

real_chip_measure(prog: List[QProg], config_str: str) → str

real_chip_measure_prob_count(ir: str, shot: int = 1000, chip_id: int = 33554432, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → Dict[str, int]

real_chip_measure_prob_count(prog: QProg, shot: int = 1000, chip_id: int = 33554432, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → Dict[str, int]

real_chip_measure_prob_count(ir: List[str], shot: int = 1000, chip_id: int = 33554432, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → List[Dict[str, int]]

real_chip_measure_prob_count(prog: List[QProg], shot: int = 1000, chip_id: int = 33554432, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → List[Dict[str, int]]

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

real_chip_measure_vec(ir: List[str], shot: int = 1000, chip_id: int = 33554432, is_amend: bool = True, is_mapping: bool = True, is_optimization: bool = True, specified_block: List[int] = [], describe: str = '') → List[Dict[str, float]]

runWithConfiguration(prog: QProg, shots: int = 1000, backend_id: int = 33554433, noise_model: Noise = ...) → Dict[str, int]

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.pyQPanda.QProg

class pyqpanda.pyQPanda.QProg(arg0: QProg)

class pyqpanda.pyQPanda.QProg(arg0: QCircuit)

class pyqpanda.pyQPanda.QProg(arg0: QIfProg)

class pyqpanda.pyQPanda.QProg(arg0: QWhileProg)

class pyqpanda.pyQPanda.QProg(arg0: QGate)

class pyqpanda.pyQPanda.QProg(arg0: QMeasure)

class pyqpanda.pyQPanda.QProg(arg0: QReset)

class pyqpanda.pyQPanda.QProg(arg0: ClassicalCondition)

class pyqpanda.pyQPanda.QProg(arg0: NodeIter)

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

begin() → NodeIter

end() → NodeIter

get_max_qubit_addr() → int

get_qgate_num() → int

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

get a list cbits of prog

get_used_qubits(qubit_vector: QVec) → QVec

get a list qubits of prog

head() → NodeIter

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

is_empty() → bool

is_measure_last_pos() → bool

last() → NodeIter

class pyqpanda.pyQPanda.QProgDAG

quantum prog dag class

get_edges() → List[QProgDAGEdge]

get_target_vertex(vertice_num: int) → QProgDAGVertex

get_vertex_set() → List[QProgDAGVertex]

class pyqpanda.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.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

get_iter() → NodeIter

get_qubits_vec() → QVec

is_dagger() → bool

class pyqpanda.pyQPanda.QReset(arg0: NodeIter)

quantum reset node

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

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

getResultMap() → Dict[str, bool]

class pyqpanda.pyQPanda.QVec

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

class pyqpanda.pyQPanda.QVec(qvec: QVec)

class pyqpanda.pyQPanda.QVec(qubit: Qubit)

Qubit vector basic class

append(qubit: Qubit) → None

pop() → None

to_list() → List[Qubit]

class pyqpanda.pyQPanda.QWhileProg(arg0: NodeIter)

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

quantum while node

get_classical_condition() → ClassicalCondition

get_true_branch() → QProg

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

quantum machine base class

allocate_qubit_through_phy_address(address: int) → Qubit

allocate qubits through phy address

Args:

address: qubit phy address

Returns:

Qubit

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

allocate_qubit_through_vir_address(address: int) → Qubit

allocate qubits through vir address

Args:

address: qubit vir address

Returns:

Qubit

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

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

Run quantum prog asynchronously at background Use get_processed_qgate_num() to get check the asynchronous process progress Use is_async_finished() check whether asynchronous process finished Use get_async_result() block current code and get asynchronous process result unitll it finished

cAlloc() → ClassicalCondition

cAlloc(cbit: int) → ClassicalCondition

Allocate a CBit After init()

Args:

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

Returns:

classic result cbit

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

cFree(arg0: ClassicalCondition) → None

Free a CBit

Args:

CBit: a CBit

Returns:

none

cFree_all(cbit_list: List[ClassicalCondition]) → None

cFree_all() → None

Free all cbits

Args:

none

Returns:

none

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

Directly run quantum prog After init()

Args:

qprog: quantum program noise_model: noise model, default is no noise. noise model only work on CPUQVM now

Returns:

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

first is the final qubit register state, second is it's measure probability

finalize() → None

finalize quantum machine

Args:

none

Returns:

none

Raises:

run_fail: An error occurred in finalize

getAllocateCMem() → int

Get allocated cbits of QuantumMachine

Args:

none

Returns:

cbit list

Raises:

run_fail: An error occurred in allocated cbits of QuantumMachine

getAllocateQubitNum() → int

Get allocated qubits of QuantumMachine

Args:

none

Returns:

qubit list

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

getStatus(*args, **kwargs) → Any

Get the status of the Quantum machine

Args:

none

Returns:

the status of the Quantum machine, see QMachineStatus

Raises:

init_fail: An error occurred

get_allocate_cbits() → List[ClassicalCondition]

Get allocated cbits of QuantumMachine

Args:

none

Returns:

cbit list

Raises:

run_fail: An error occurred in allocated cbits of QuantumMachine

get_allocate_cmem_num() → int

Get allocated cbits of QuantumMachine

Args:

none

Returns:

cbit list

Raises:

run_fail: An error occurred in allocated cbits of QuantumMachine

get_allocate_qubit_num() → int

Get allocated qubits of QuantumMachine

Args:

none

Returns:

qubit list

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

get_allocate_qubits() → QVec

Get allocated qubits of QuantumMachine

Args:

none

Returns:

qubit list

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

get_async_result() → Dict[str, bool]

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

get expectation of current hamiltonian

Args:

qprog : quantum prog hamiltonian: selected hamiltonian qubit_list : measure qubit list shots : measure shots

Returns:

double : expectation of current hamiltonian

Raises:

run_fail: An error occurred in get_expectation

get_gate_time_map() → Dict[GateType, int]

get_processed_qgate_num() → int

get_qstate() → List[complex]

Get the status of the Quantum machine

Args:

none

Returns:

the status of the Quantum machine, see QMachineStatus

Raises:

init_fail: An error occurred

get_status(*args, **kwargs) → Any

Get the status of the Quantum machine

Args:

none

Returns:

the status of the Quantum machine, see QMachineStatus

Raises:

init_fail: An error occurred

initQVM() → None

Init the global unique quantum machine at background.

Args:

machine_type: quantum machine type, see pyQPanda.QMachineType

Returns:

bool: ture if initialization success

init_qvm() → None

Init the global unique quantum machine at background.

Args:

machine_type: quantum machine type, see pyQPanda.QMachineType

Returns:

bool: ture if initialization success

init_sparse_state(*args, **kwargs) → Any

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

is_async_finished() → bool

qAlloc() → Qubit

Allocate a qubits After init()

Args:

qubit_addr: qubit physic address, should in [0,29)

Returns:

pyQPanda.Qubit: None, if qubit_addr error, or reached max number of allowed qubit

qAlloc_many(qubit_num: int) → List[Qubit]

Allocate several qubits After init()

Args:

qubit_num: numbers of qubit want to be created

Returns:

list[pyQPanda.Qubit]: list of qubit

qFree(qubit: Qubit) → None

Free a CBit

Args:

CBit: a CBit

Returns:

none

qFree_all(qubit_list: QVec) → None

qFree_all(arg0: QVec) → None

Free all qubits

Args:

none

Returns:

none

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]

Run quantum program with configuration

Args:

program: quantum program cbit_list: classic cbits list shots: repeate run quantum program times noise_model: noise model, default is no noise. noise model only work on CPUQVM now

Returns:

result of quantum program execution in shots. first is the final qubit register state, second is it's hit shotRaises: run_fail: An error occurred in measure quantum program

set_configure(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

class pyqpanda.pyQPanda.QuantumStateTomography

quantum state tomography class

caculate_tomography_density() → List[List[complex]]

caculate tomography density

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.

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

run state tomography QProgs

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

set combine_qprogs result

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

Qubit abstract class

getPhysicalQubitPtr() → PhysicalQubit

get_phy_addr() → int

class pyqpanda.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.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 pmeasure result as dict

Args:

qubit_list: pmeasure qubits list

Returns:

measure result of quantum machineRaises: run_fail: An error occurred in get_prob_dict

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

get quick map vertice

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

get prog sequence

pmeasure_bin_amplitude(arg0: str) → complex

pmeasure bin index quantum state amplitude

Args:

string : bin string

Returns:

complex : bin amplitude

Raises:

run_fail: An error occurred in pmeasure_bin_index

pmeasure_bin_index(arg0: str) → float

pmeasure bin index quantum state amplitude

Args:

string : bin string

Returns:

double : bin amplitude prob

Raises:

run_fail: An error occurred in pmeasure_bin_index

pmeasure_dec_amplitude(arg0: str) → complex

pmeasure dec index quantum state amplitude

Args:

string : dec string

Returns:

complex : dec amplitude amplitude

Raises:

run_fail: An error occurred in pmeasure_dec_index

pmeasure_dec_index(arg0: str) → float

pmeasure dec index quantum state amplitude

Args:

string : dec string

Returns:

double : dec amplitude prob

Raises:

run_fail: An error occurred in pmeasure_dec_index

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

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program qubit_list: pmeasure qubits list

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

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:

QProg: quantum prog QVec: qubits list size_t: max_rank list: sequences

Returns:

none

Raises:

run_fail: An error occurred in run

class pyqpanda.pyQPanda.SingleGateTransferType(value: int)

Quantum single gate transfer type

Members:

SINGLE_GATE_INVALID

ARBITRARY_ROTATION

DOUBLE_CONTINUOUS

SINGLE_CONTINUOUS_DISCRETE

DOUBLE_DISCRETE

property name: str

property value: int

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

class pyqpanda.pyQPanda.SparseQVM

Bases: QuantumMachine

quantum sparse machine class

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program

Returns:

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

Raises:

run_fail: An error occurred in measure quantum program

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

init_qvm() → None

init quantum virtual machine

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

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

Run quantum program and get pmeasure result as dict

Args:

qprog: quantum program

Args:

cbits: quantum cbits

Args:

shots: samble shots

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

class pyqpanda.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:

prog: quantum program qubits: pmeasure qubits

Returns:

probabilities result of quantum program

Raises:

run_fail: An error occurred in prob_run_dict

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

Run quantum program and get shots result

Args:

prog: quantum program int: measure shots

Returns:

shots result of quantum program

Raises:

run_fail: An error occurred in run_with_configuration

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

class pyqpanda.pyQPanda.UpdateMode(value: int)

quantum imaginary time evolution update mode

Members:

GD_VALUE

GD_DIRECTION

property name: str

property value: int

GD_DIRECTION: ClassVar[UpdateMode] = Ellipsis

GD_VALUE: ClassVar[UpdateMode] = Ellipsis

class pyqpanda.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.pyQPanda.VariationalQuantumCircuit

class pyqpanda.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.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.pyQPanda.VariationalQuantumGate_CNOT(arg0: Qubit, arg1: Qubit)

Bases: VariationalQuantumGate

variational quantum CNOT gate class

control(arg0: QVec) → VariationalQuantumGate_CNOT

dagger() → VariationalQuantumGate_CNOT

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

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

class pyqpanda.pyQPanda.VariationalQuantumGate_CR(arg0: VariationalQuantumGate_CR)

Bases: VariationalQuantumGate

variational quantum CR gate class

control(arg0: QVec) → VariationalQuantumGate_CR

dagger() → VariationalQuantumGate_CR

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

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

class pyqpanda.pyQPanda.VariationalQuantumGate_CRX(arg0: VariationalQuantumGate_CRX)

Bases: VariationalQuantumGate

variational quantum CRX gate class

control(arg0: QVec) → VariationalQuantumGate_CRX

dagger() → VariationalQuantumGate_CRX

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

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

class pyqpanda.pyQPanda.VariationalQuantumGate_CRY(arg0: VariationalQuantumGate_CRY)

Bases: VariationalQuantumGate

variational quantum CRY gate class

control(arg0: QVec) → VariationalQuantumGate_CRY

dagger() → VariationalQuantumGate_CRY

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

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

class pyqpanda.pyQPanda.VariationalQuantumGate_CRZ(arg0: VariationalQuantumGate_CRZ)

Bases: VariationalQuantumGate

variational quantum CRZ gate class

control(arg0: QVec) → VariationalQuantumGate_CRZ

dagger() → VariationalQuantumGate_CRZ

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

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

class pyqpanda.pyQPanda.VariationalQuantumGate_CU(arg0: VariationalQuantumGate_CU)

Bases: VariationalQuantumGate

variational quantum CU gate class

control(arg0: QVec) → VariationalQuantumGate_CU

dagger() → VariationalQuantumGate_CU

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

Bases: VariationalQuantumGate

variational quantum CZ gate class

control(arg0: QVec) → VariationalQuantumGate_CZ

dagger() → VariationalQuantumGate_CZ

class pyqpanda.pyQPanda.VariationalQuantumGate_H(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum H gate class

control(arg0: QVec) → VariationalQuantumGate_H

dagger() → VariationalQuantumGate_H

class pyqpanda.pyQPanda.VariationalQuantumGate_I(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum I gate class

control(arg0: QVec) → VariationalQuantumGate_I

dagger() → VariationalQuantumGate_I

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

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

Bases: VariationalQuantumGate

variational quantum RX gate class

control(arg0: QVec) → VariationalQuantumGate_RX

dagger() → VariationalQuantumGate_RX

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

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

Bases: VariationalQuantumGate

variational quantum RY gate class

control(arg0: QVec) → VariationalQuantumGate_RY

dagger() → VariationalQuantumGate_RY

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

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

Bases: VariationalQuantumGate

variational quantum RZ gate class

control(arg0: QVec) → VariationalQuantumGate_RZ

dagger() → VariationalQuantumGate_RZ

class pyqpanda.pyQPanda.VariationalQuantumGate_S(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum S gate class

control(arg0: QVec) → VariationalQuantumGate_S

dagger() → VariationalQuantumGate_S

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

Bases: VariationalQuantumGate

variational quantum SWAP gate class

control(arg0: QVec) → VariationalQuantumGate_SWAP

dagger() → VariationalQuantumGate_SWAP

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

Bases: VariationalQuantumGate

variational quantum SqiSWAP gate class

control(arg0: QVec) → VariationalQuantumGate_SqiSWAP

dagger() → VariationalQuantumGate_SqiSWAP

class pyqpanda.pyQPanda.VariationalQuantumGate_T(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum T gate class

control(arg0: QVec) → VariationalQuantumGate_T

dagger() → VariationalQuantumGate_T

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

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

Bases: VariationalQuantumGate

variational quantum U1 gate class

control(arg0: QVec) → VariationalQuantumGate_U1

dagger() → VariationalQuantumGate_U1

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

class pyqpanda.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.pyQPanda.VariationalQuantumGate_U3(arg0: Qubit, arg1: var, arg2: var, arg3: var)

class pyqpanda.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.pyQPanda.VariationalQuantumGate_U4(arg0: Qubit, arg1: var, arg2: var, arg3: var, arg4: var)

class pyqpanda.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.pyQPanda.VariationalQuantumGate_X(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum X gate class

control(arg0: QVec) → VariationalQuantumGate_X

dagger() → VariationalQuantumGate_X

class pyqpanda.pyQPanda.VariationalQuantumGate_X1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum X1 gate class

control(arg0: QVec) → VariationalQuantumGate_X1

dagger() → VariationalQuantumGate_X1

class pyqpanda.pyQPanda.VariationalQuantumGate_Y(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Y gate class

control(arg0: QVec) → VariationalQuantumGate_Y

dagger() → VariationalQuantumGate_Y

class pyqpanda.pyQPanda.VariationalQuantumGate_Y1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Y1 gate class

control(arg0: QVec) → VariationalQuantumGate_Y1

dagger() → VariationalQuantumGate_Y1

class pyqpanda.pyQPanda.VariationalQuantumGate_Z(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Z gate class

control(arg0: QVec) → VariationalQuantumGate_Z

dagger() → VariationalQuantumGate_Z

class pyqpanda.pyQPanda.VariationalQuantumGate_Z1(arg0: Qubit)

Bases: VariationalQuantumGate

variational quantum Z1 gate class

control(arg0: QVec) → VariationalQuantumGate_Z1

dagger() → VariationalQuantumGate_Z1

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

Bases: VariationalQuantumGate

variational quantum iSWAP gate class

control(arg0: QVec) → VariationalQuantumGate_iSWAP

dagger() → VariationalQuantumGate_iSWAP

class pyqpanda.pyQPanda.em_method(value: int)

origin quantum real chip error_mitigation type

Members:

ZNE

PEC

READ_OUT

property name: str

property value: int

PEC: ClassVar[em_method] = Ellipsis

READ_OUT: ClassVar[em_method] = Ellipsis

ZNE: ClassVar[em_method] = Ellipsis

class pyqpanda.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.pyQPanda.hadamard_circuit(arg0: QVec)

Bases: QCircuit

hadamard circuit class

class pyqpanda.pyQPanda.real_chip_type(value: int)

origin quantum real chip type enum

Members:

origin_wuyuan_d3

origin_wuyuan_d4

origin_wuyuan_d5

origin_72

property name: str

property value: int

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

class pyqpanda.pyQPanda.var(arg0: float)

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

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

class pyqpanda.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.pyQPanda.BARRIER(qubit: Qubit) → QGate

pyqpanda.pyQPanda.BARRIER(qubit_list: int) → QGate

pyqpanda.pyQPanda.BARRIER(qubit_list: QVec) → QGate

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

Create a BARRIER gate

Args:

qubit_list : measure qubits list

Returns:

a BARRIER node

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

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

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

pyqpanda.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.pyQPanda.CP(control_qubit: Qubit, target_qubit: Qubit, theta_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.CR(control_qubit: Qubit, target_qubit: Qubit, theta_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.CU(alpha_angle: float, beta_angle: float, gamma_angle: float, delta_angle: float, control_qubit: Qubit, target_qubit: Qubit) → QGate

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

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

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

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

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

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

pyqpanda.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.pyQPanda.CU(control_qubit: Qubit, target_qubit: Qubit, matrix: List[complex]) → QGate

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

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

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

Create a CU gate

Args:

matrix : CU gate matrix qubit addr list: control qubit addr list qubit addr list: target qubit addr list

Returns:

a CU node

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

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

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

pyqpanda.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.pyQPanda.CreateEmptyCircuit() → QCircuit

Create an empty QCircuit Container

Args:

none

Returns:

a empty QCircuit

pyqpanda.pyQPanda.CreateEmptyQProg() → QProg

Create an empty QProg Container

Args:

none

Returns:

a empty QProg

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

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

Create a classical quantum IfProg

Args:

classical_condition: quatum cbit true_node: quantum IfProg true qnode false_node: quantum IfProg false qnode

Returns:

a classical quantum IfProg

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

Create a WhileProg Args:

classical_condition: quatum cbit true_node: quantum QWhile qnode

Returns:

a WhileProg

pyqpanda.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.pyQPanda.Grover_search(list: List[int], Classical_condition: ClassicalCondition, QuantumMachine: Grover_search.QuantumMachine, repeat: int = 2) → Grover_search.list

pyqpanda.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.pyQPanda.H(qubit: Qubit) → QGate

pyqpanda.pyQPanda.H(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.H(qubit_addr: int) → QGate

pyqpanda.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.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.pyQPanda.I(qubit: Qubit) → QGate

pyqpanda.pyQPanda.I(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.I(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.MAJ(arg0: Qubit, arg1: Qubit, arg2: Qubit) → QCircuit

Quantum adder MAJ module

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

Quantum adder MAJ2 module

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

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

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

pyqpanda.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.pyQPanda.Measure(qubit: Qubit, cbit: ClassicalCondition) → QMeasure

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

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

Create an measure node

Args:

qubit : measure qubit cbit : cbit stores quantum measure result

Returns:

a quantum measure node

pyqpanda.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.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.pyQPanda.P(qubit: Qubit, angle: float) → QGate

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

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

pyqpanda.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.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

Raises:

run_fail: An error occurred in pmeasure

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

Deprecated, use pmeasure_no_index instead

Args:

QVec : pmeasure qubits list

Returns:

result: pmeasure qubits result

Raises:

run_fail: An error occurred in pmeasure_no_index

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

Quantum adder that supports signed operations, but ignore carry

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

Quantum adder with carry

pyqpanda.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.pyQPanda.QComplement(arg0: QVec, arg1: QVec) → QCircuit

Convert quantum state to binary complement representation

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

Quantum division

pyqpanda.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.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.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.pyQPanda.QDouble(first_qubit: Qubit, second_qubit: Qubit, matrix: List[complex]) → QGate

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

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

pyqpanda.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.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.pyQPanda.QMul(arg0: QVec, arg1: QVec, arg2: QVec, arg3: QVec) → QCircuit

Quantum multiplication

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

Quantum multiplication, only supports positive multiplication

pyqpanda.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

Return:

Oracle gate

pyqpanda.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.pyQPanda.QSub(arg0: QVec, arg1: QVec, arg2: QVec) → QCircuit

Quantum subtraction

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

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

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

pyqpanda.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.pyQPanda.RXX(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.RY(qubit: Qubit, angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.RYY(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.RZ(qubit: Qubit, angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.RZX(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.RZZ(control_qubit: Qubit, target_qubit: Qubit, alpha_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.Reset(qubit: Qubit) → QReset

pyqpanda.pyQPanda.Reset(qubit_addr: int) → QReset

Create a Reset node

pyqpanda.pyQPanda.S(qubit: Qubit) → QGate

pyqpanda.pyQPanda.S(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.S(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.SWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

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

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

pyqpanda.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.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.pyQPanda.SqiSWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

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

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

pyqpanda.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.pyQPanda.T(qubit: Qubit) → QGate

pyqpanda.pyQPanda.T(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.T(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.Toffoli(control_qubit_first: Qubit, control_qubit_second: Qubit, target_qubit: Qubit) → QGate

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

Create a Toffoli gate

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

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

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

pyqpanda.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.pyQPanda.U2(qubit: Qubit, phi_angle: float, lambda_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.U3(qubit: Qubit, theta_angle: float, phi_angle: float, lambda_angle: float) → QGate

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

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

pyqpanda.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.pyQPanda.U4(matrix: List[complex], qubit: Qubit) → QGate

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

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

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

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

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

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

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

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

pyqpanda.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:

double : u4 gate alpha angle double : u4 gate beta angle double : u4 gate gamma angle double : u4 gate delta angle qubit_addr_list : U4 gate target qubit_addr_list

Returns:

a U4 node

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

Quantum adder UMA module

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

variational quantum CNOT batch gates

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

variational quantum CU batch gates

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

variational quantum CZ batch gates

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

variational quantum H batch gates

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

variational quantum I batch gates

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

variational quantum SWAP batch gates

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

variational quantum S batch gates

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

variational quantum SqiSWAP batch gates

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

variational quantum T batch gates

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

variational quantum U1 batch gates

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

variational quantum U2 batch gates

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

variational quantum U3 batch gates

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

variational quantum U4 batch gates

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

variational quantum X1 batch gates

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

variational quantum X batch gates

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

variational quantum Y1 batch gates

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

variational quantum Y batch gates

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

variational quantum Z1 batch gates

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

variational quantum Z batch gates

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

variational quantum iSWAP batch gates

pyqpanda.pyQPanda.X(qubit: Qubit) → QGate

pyqpanda.pyQPanda.X(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.X(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.X1(qubit: Qubit) → QGate

pyqpanda.pyQPanda.X1(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.X1(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.Y(qubit: Qubit) → QGate

pyqpanda.pyQPanda.Y(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.Y(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.Y1(qubit: Qubit) → QGate

pyqpanda.pyQPanda.Y1(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.Y1(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.Z(qubit: Qubit) → QGate

pyqpanda.pyQPanda.Z(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.Z(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.Z1(qubit: Qubit) → QGate

pyqpanda.pyQPanda.Z1(qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.Z1(qubit_addr: int) → QGate

pyqpanda.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.pyQPanda.accumulateProbability(probability_list: List[float]) → List[float]

Accumulate the probability from a prob list

Args:

probability_list: measured result in probability list form

Returns:

accumulated resultRaises: run_fail: An error occurred in accumulateProbability

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

Accumulate the probability from a prob list

Args:

probability_list: measured result in probability list form

Returns:

accumulated resultRaises: run_fail: An error occurred in accumulate_probabilities

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

Accumulate the probability from a prob list

Args:

probability_list: measured result in probability list form

Returns:

accumulated resultRaises: run_fail: An error occurred in accumulate_probability

pyqpanda.pyQPanda.acos(arg0: var) → var

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

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

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

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

Generate graph of maxcut problem

Args:

adjacent_matrix: adjacent_matrix for quantum prog all_cut_list: all cut graph list in quantum prog target_value_list: target cut value list

Returns:

max value

Raises:

run_fail: An error occurred in all_cut_of_graph

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

pyqpanda.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.pyQPanda.apply_QGate(qubit_list: QVec, func_obj: Callable[[Qubit], QGate]) → QCircuit

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

Apply QGate to qubits

Args:

qubit_addr_list: qubit address list func_obj: QGate(int) like function object accept Qubit address as argument

Returns:

QCircuit contain QGate operation on all qubit

pyqpanda.pyQPanda.asin(arg0: var) → var

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

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

pyqpanda.pyQPanda.atan(arg0: var) → var

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

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

compare two quantum states , Get the state fidelity

Args:

state1: quantum state matrix 1 state2: quantum state list 2

Returns:

state fidelity bewteen [0,1]

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

Parse binary data transfor to quantum program Args:

bin_data: binary data stores quantum prog information qubit_list: quantum qubits list cbit_list: quantum cbits list qprog: quantum prog

Returns:

prog

pyqpanda.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.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.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.pyQPanda.cAlloc() → ClassicalCondition

pyqpanda.pyQPanda.cAlloc(cbit_addr: int) → ClassicalCondition

Allocate a CBit After init()

Args:

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

Returns:

classic result cbit

pyqpanda.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.pyQPanda.cFree(cbit: ClassicalCondition) → None

Free a CBit

Args:

CBit: a CBit

Returns:

none

pyqpanda.pyQPanda.cFree_all() → None

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

Free all cbits

Args:

a list of cbits

Returns:

none

pyqpanda.pyQPanda.calculate_quantum_volume(noise_qvm: NoiseQVM, qubit_list: List[List[int]], ntrials: int, shots: int = 1000) → int

pyqpanda.pyQPanda.calculate_quantum_volume(cloud_qvm, qubit_list: List[List[int]], ntrials: int, shots: int = 1000) → int

pyqpanda.pyQPanda.calculate_quantum_volume(config: QCloudTaskConfig, qubit_list: List[List[int]], ntrials: int) → int

calculate quantum volume

Args:

config: QCloudTaskConfig qubit_list: qubit list ntrials: ntrials

Returns:

result data dict

Raises:

run_fail: An error occurred in calculate_quantum_volume

pyqpanda.pyQPanda.cast_qprog_qcircuit(qprog: QProg) → QCircuit

Cast QProg to QCircuit

Args:

qprog: quantum prog

Returns:

none

Raises:

run_fail: An error occurred in cast_qprog_qcircuit

pyqpanda.pyQPanda.cast_qprog_qgate(qprog: QProg) → QGate

Cast QProg to QGate

Args:

qprog: quantum prog

Returns:

none

Raises:

run_fail: An error occurred in cast_qprog_qgate

pyqpanda.pyQPanda.cast_qprog_qmeasure(qprog: QProg) → QMeasure

Cast QProg to QMeasure

Args:

qprog: quantum prog

Returns:

none

Raises:

run_fail: An error occurred in cast_qprog_qmeasure

pyqpanda.pyQPanda.circuit_layer(qprog: QProg) → list

Quantum circuit layering

Args:

QProg: quantum prog

Returns:

result data tuple contains layer info

Raises:

run_fail: An error occurred in get circuit_layer

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

Optimize QCircuit

Args:

qprog: quantum program optimizer_cir_vec: quantum circuit list mode_list: optimize mode list

Returns:

a new prog after optimize

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

QCircuit optimizer

Args:

qprog: quantum program config_file: optimize config mode_list: optimize mode list

Returns:

a new prog after optimize

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

decode binary data to comm protocol prog list

Args:

encode_data: quantum prog_list encode data

Returns:

result prog list

Raises:

run_fail: An error occurred in comm_protocol_decode

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

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

encode comm protocol data to binary data

Args:

prog_list: quantum prog_list config: comm_protocol config

Returns:

result data list

Raises:

run_fail: An error occurred in comm_protocol_encode

pyqpanda.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.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.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.pyQPanda.convert_binary_data_to_qprog(machine: QuantumMachine, data: List[int]) → QProg

Parse binary data to quantum program

Args:

machine: quantum machine data: quantum prog data

Returns:

quantum prog

Raises:

run_fail: An error occurred in convert_binary_data_to_qprog

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

Trans OriginIR to QProg

Args:

originir_str: OriginIR string machine: initialized quantum machine

Returns:

list cotains QProg, qubit_list, cbit_listRaises: run_fail: An error occurred in convert_originir_str_to_qprog

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

Read OriginIR file and trans to QProg

Args:

file_path: OriginIR file path machine: initialized quantum machine

Returns:

list cotains QProg, qubit_list, cbit_listRaises: run_fail: An error occurred in convert_originir_to_qprog

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

Trans QASM to QProg

Args:

qasm_str: QASM string machine: initialized quantum machine

Returns:

list cotains QProg, qubit_list, cbit_list

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

Read QASM file and trans to QProg

Args:

file_path: QASM file path machine: initialized quantum machine

Returns:

list cotains QProg, qubit_list, cbit_listRaises: run_fail: An error occurred in convert_qasm_to_qprog

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

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

Store quantum program in binary file Args:

machine: quantum machine qprog: quantum prog fname: binary data file name

Returns:

none

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

Args:

qprog: quantum prog machine: quantum machine

Returns:

originir : originir string , see originir indroduction :https://pyqpanda-toturial.readthedocs.io/zh/latest/QProgToOriginIR.html

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

Convert QProg to QASM instruction string

Args:

machine: quantum machine qprog: quantum prog

Returns:

qsm string stores prog

Raises:

run_fail: An error occurred in convert_qprog_to_qasm

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

convert QProg to Quil instruction

Args:

qprog: QProg machine: quantum machine

Returns:

Quil instruction string

pyqpanda.pyQPanda.cos(arg0: var) → var

pyqpanda.pyQPanda.count_gate(quantum_prog: QProg) → int

pyqpanda.pyQPanda.count_gate(quantum_circuit: QCircuit) → int

Count quantum gate num under quantum program, quantum circuit Args:

circuit : quantum_circuit

Returns:

result: gate count

Raises:

run_fail: An error occurred in get_qgate_num

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

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

count quantum program info Args:

qprog: QProg optimize: whether to enable the optimization circuit switch.

Returns:

ProgCount struct

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

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

Count quantum gate num under quantum program

Args:

quantum_circuit: QCircuit& gtype: const GateType

Returns:

this GateType quantum gate num

pyqpanda.pyQPanda.create_empty_circuit() → QCircuit

Create an empty QCircuit Container

Args:

none

Returns:

a empty QCircuit

pyqpanda.pyQPanda.create_empty_qprog() → QProg

Create an empty QProg Container

Args:

none

Returns:

a empty QProg

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

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

Create a classical quantum IfProg

Args:

classical_condition: quatum cbit true_node: quantum IfProg true qnode false_node: quantum IfProg false qnode

Returns:

a classical quantum IfProg

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

Create a WhileProg

Args:

classical_condition: quatum cbit true_node: quantum QWhile qnode

Returns:

a WhileProg

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

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

pyqpanda.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: quantum single gates sets convert_double_gates: quantum double gates sets transform_to_base_qgate: transform to base qgate sets

Returns:

a new prog after decomposition

pyqpanda.pyQPanda.deep_copy(node: QProg) → QProg

pyqpanda.pyQPanda.deep_copy(node: QCircuit) → QCircuit

pyqpanda.pyQPanda.deep_copy(node: QGate) → QGate

pyqpanda.pyQPanda.deep_copy(node: QMeasure) → QMeasure

pyqpanda.pyQPanda.deep_copy(node: ClassicalProg) → ClassicalProg

pyqpanda.pyQPanda.deep_copy(node: QIfProg) → QIfProg

pyqpanda.pyQPanda.deep_copy(node: QWhileProg) → QWhileProg

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

Delete weakly connected edges

Args:

topo_data: quantum program topo_data

Returns:

none

Raises:

run_fail: An error occurred in del_weak_edge

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

Delete weakly connected edges

Args:

topo_data: quantum program topo_data max_connect_degree: max value of connect degree sub_graph_set: sub graph set list

Returns:

result data

Raises:

run_fail: An error occurred in del_weak_edge2

pyqpanda.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

Args:

topo_data: quantum program topo_data max_connect_degree: max value of connect degree sub_graph_set: sub graph set list lamda1: lamda1 lamda2: lamda2 lamda3: lamda3

Returns:

result data

Raises:

run_fail: An error occurred in del_weak_edge3

pyqpanda.pyQPanda.destroy_quantum_machine(machine: QuantumMachine) → None

Destroy a quantum machine

Args:

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

Returns:

noneRaises: run_fail: An error occurred in destroy_quantum_machine

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

Directly run quantum prog After init()

Args:

qprog: quantum program noise_model: noise model, default is no noise. noise model only work on CPUQVM now

Returns:

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

first is the final qubit register state, second is it's measure probability

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

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

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

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

pyqpanda.pyQPanda.double_gate_xeb(config: QCloudTaskConfig, qubit0: int, qubit1: int, clifford_range: List[int], num_circuits: int, gate_type: GateType = GateType.CZ_GATE) → Dict[int, float]

pyqpanda.pyQPanda.double_gate_xeb(qvm: QuantumMachine, qubit0: Qubit, qubit1: Qubit, clifford_range: List[int], num_circuits: int, shots: int, chip_id: int = 2, gate_type: GateType = GateType.CZ_GATE) → Dict[int, float]

double gate xeb

Args:

qvm: quantum machine qubit0: double qubit 0 qubit1: double qubit 1 clifford_range: clifford range list num_circuits: the num of circuits shots: measure shots chip type: RealChipType interleaved_gates: interleaved gates list

Returns:

result data dict

Raises:

run_fail: An error occurred in double_gate_xeb

pyqpanda.pyQPanda.double_qubit_rb(qvm: QuantumMachine, qubit0: Qubit, qubit1: Qubit, clifford_range: List[int], num_circuits: int, shots: int, chip_id: int = 2, interleaved_gates: List[QGate] = []) → Dict[int, float]

pyqpanda.pyQPanda.double_qubit_rb(config: QCloudTaskConfig, qubit0: int, qubit1: int, clifford_range: List[int], num_circuits: int, interleaved_gates: List[QGate] = []) → Dict[int, float]

double qubit rb with origin chip Args:

config: QCloudTaskConfig qubit0: double qubit 0 qubit1: double qubit 1 clifford_range: clifford range list num_circuits: the num of circuits interleaved_gates: interleaved gates list

Returns:

result data dict

Raises:

run_fail: An error occurred in double_qubit_rb

pyqpanda.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 source code, and save the source code to file in current path with name QCircuit.tex Args:

QProg: quantum prog auto_wrap_len: defaut is 100 output_file: result output file name itr_start: nodeiter start itr_end: nodeiter end

Returns:

result data tuple contains prog info

Raises:

run_fail: An error occurred in get draw_qprog_text

pyqpanda.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 file in current path with name QCircuit.tex Args:

QProg: quantum prog config_data: default config file is QPandaConfig.json auto_wrap_len: defaut is 100 output_file: result output file name itr_start: nodeiter start itr_end: nodeiter end

Returns:

result data tuple contains prog info

Raises:

run_fail: An error occurred in get draw_qprog_text

pyqpanda.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 will save the text-pic in file named QCircuitTextPic.txt in the same time in current path Args:

QProg: quantum prog auto_wrap_len: defaut is 100 output_file: result output file name itr_start: nodeiter start itr_end: nodeiter end

Returns:

result data tuple contains prog info

Raises:

run_fail: An error occurred in get draw_qprog_text

pyqpanda.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 will save the text-pic in file named QCircuitTextPic.txt in the same time in current path Args:

QProg: quantum prog auto_wrap_len: defaut is 100 output_file: result output file name itr_start: nodeiter start itr_end: nodeiter end

Returns:

result data tuple contains prog info

Raises:

run_fail: An error occurred in get draw_qprog_text

pyqpanda.pyQPanda.dropout(arg0: var, arg1: var) → var

pyqpanda.pyQPanda.equal(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.equal(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.pyQPanda.equal(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.estimate_topology(topo_data: List[List[int]]) → float

Evaluate topology performance

Args:

topo_data: quantum program topo data

Returns:

result data

Raises:

run_fail: An error occurred in estimate_topology

pyqpanda.pyQPanda.eval(arg0: var, arg1: bool) → numpy.ndarray[numpy.float64[m, n]]

pyqpanda.pyQPanda.eval(arg0: var) → numpy.ndarray[numpy.float64[m, n]]

pyqpanda.pyQPanda.exp(arg0: var) → var

pyqpanda.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

pyqpanda.pyQPanda.expand_linear_equations(matrix: List[complex], list: List[float]) → expand_linear_equations.list

pyqpanda.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.pyQPanda.fill_qprog_by_I(qprog: QProg) → QProg

Fill the input QProg by I gate, return a new quantum program

Args:

prog: quantum prog

Returns:

a new quantum program

Raises:

run_fail: An error occurred in get fill_qprog_by_I

pyqpanda.pyQPanda.finalize() → None

Finalize the environment and destory global unique quantum machine.

Args:

none

Returns:

none

pyqpanda.pyQPanda.fit_to_gbk(utf8_str: str) → str

Special character conversion

Args:

utf8_str: string using utf-8 encode

Returns:

result string

Raises:

run_fail: An error occurred in get fit_to_gbk

pyqpanda.pyQPanda.flatten(qprog: QProg) → None

pyqpanda.pyQPanda.flatten(qcircuit: QCircuit) → None

Flatten quantum circuit

Args:

qprog: quantum circuit

Returns:

none

pyqpanda.pyQPanda.getAllocateCMem() → int

Deprecated, use get_allocate_cmem_num instead Args:

none

Returns:

allocate qubit num

Raises:

run_fail: An error occurred in get_allocate_cmem_num

pyqpanda.pyQPanda.getAllocateQubitNum() → int

Deprecated, use get_allocate_qubit_num instead Args:

none

Returns:

allocate cbit num

Raises:

run_fail: An error occurred in get_allocate_qubit_num

pyqpanda.pyQPanda.get_adjacent_qgate_type(qprog: QProg, node_iter: NodeIter) → List[NodeInfo]

Get the adjacent quantum gates's(the front one and the back one) typeinfo from QProg

Args:

qprog: target quantum program node_iter: gate node iter in qprog

Returns:

the front one and back node info of node_iter in qprog

pyqpanda.pyQPanda.get_all_used_qubits(qprog: QProg) → QVec

Get all the used quantum bits in the input prog Args:

qprog: quantum program

Returns:

all used qubits

pyqpanda.pyQPanda.get_all_used_qubits_to_int(qprog: QProg) → List[int]

Get all the used quantum bits addr in the input prog Args:

qprog: quantum program

Returns:

all used qubits

pyqpanda.pyQPanda.get_allocate_cbits() → List[ClassicalCondition]

Get allocated cbits of QuantumMachine

Args:

none

Returns:

cbit list

Raises:

run_fail: An error occurred in allocated cbits of QuantumMachine

pyqpanda.pyQPanda.get_allocate_cmem_num() → int

get allocate cmem num Args:

none

Returns:

qubit_num : allocate cbit num

Raises:

run_fail: An error occurred in get_allocate_cmem_num

pyqpanda.pyQPanda.get_allocate_qubit_num() → int

get allocate qubit num

Args:

none

Returns:

qubit_num : allocate qubit num

Raises:

run_fail: An error occurred in get_allocate_qubit_num

pyqpanda.pyQPanda.get_allocate_qubits() → QVec

Get allocated qubits of QuantumMachine

Args:

none

Returns:

qubit list

Raises:

run_fail: An error occurred in allocated qubits of QuantumMachine

pyqpanda.pyQPanda.get_bin_data(qprog: QProg) → List[int]

Get quantum program binary data

Args:

qprog: QProg machine: quantum machine

Returns:

binary data in list

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

Transfor quantum program to string Args:

machine: quantum machine qprog: quantum prog

Returns:

string for bin_str

pyqpanda.pyQPanda.get_circuit_optimal_topology(qprog: QProg, machine: QuantumMachine, max_connect_degree: int, config_file: str = 'QPandaConfig.json') → List[List[int]]

Get the optimal topology of the input circuit

Args:

qprog: quantum program machine: quantum machine max_connect_degree: max value of connect degree config_file: config file

Returns:

Topology prog DataRaises: run_fail: An error occurred in get_circuit_optimal_topology

pyqpanda.pyQPanda.get_clock_cycle(qpog: QProg) → int

Get quantum program clock cycle Args:

qprog: QProg

Returns:

clock_cycle

pyqpanda.pyQPanda.get_complex_points(topo_data: List[List[int]], max_connect_degree: int) → List[int]

Get complex points

Args:

topo_data: quantum program topo_data max_connect_degree: max value of connect degree

Returns:

complex points list

Raises:

run_fail: An error occurred in get_complex_points

pyqpanda.pyQPanda.get_double_gate_block_topology(qprog: QProg) → List[List[int]]

get double gate block topology

Args:

qprog: quantum program

Returns:

Topology prog DataRaises: run_fail: An error occurred in get_double_gate_block_topology

pyqpanda.pyQPanda.get_matrix(qprog: QProg, positive_seq: bool = False, nodeitr_start: NodeIter = NodeIter(), nodeitr_end: NodeIter = NodeIter()) → List[complex]

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

nodeiter_start: the start NodeIter nodeiter_end: the end NodeIter

Returns:

target matrix include all the QGate's matrix (multiply)

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_dict

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_prob_list

pyqpanda.pyQPanda.get_qgate_num(quantum_prog: QProg) → int

pyqpanda.pyQPanda.get_qgate_num(quantum_circuit: QCircuit) → int

pyqpanda.pyQPanda.get_qgate_num(qprog: QProg) → int

Count quantum gate num under quantum program

Args:

qprog: quantum prog

Returns:

quantum gate num under quantum program

pyqpanda.pyQPanda.get_qprog_clock_cycle(qprog: QProg, machine: QuantumMachine, optimize: bool = False) → int

Get Quantum Program Clock Cycle

Args:

qprog: quantum program machine: quantum machine optimize: optimize qprog

Returns:

QProg time comsume, no unit, not in seconds

pyqpanda.pyQPanda.get_qstate() → List[complex]

pyqpanda.pyQPanda.get_qstate() → Any

pyqpanda.pyQPanda.get_sub_graph(topo_data: List[List[int]]) → List[int]

Get sub graph

Args:

topo_data: quantum program topo data

Returns:

sub graph

Raises:

run_fail: An error occurred in sub graph

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in get_tuple_list

pyqpanda.pyQPanda.get_unitary(qprog: QProg, positive_seq: bool = False, nodeitr_start: NodeIter = NodeIter(), nodeitr_end: NodeIter = NodeIter()) → List[complex]

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

nodeiter_start: the start NodeIter nodeiter_end: the end NodeIter

Returns:

target matrix include all the QGate's matrix (multiply)

pyqpanda.pyQPanda.get_unsupport_qgate_num(qprog: QProg, support_gates: List[List[str]]) → int

Count quantum program unsupported gate numner

Args:

qprog: quantum prog support_gates: support_gates

Returns:

unsupported gate numner

pyqpanda.pyQPanda.getstat(*args, **kwargs) → Any

Get the status of the Quantum machine

Args:

none

Returns:

the status of the Quantum machine, see QMachineStatus

Raises:

init_fail: An error occurred

pyqpanda.pyQPanda.iSWAP(first_qubit: Qubit, second_qubit: Qubit) → QGate

pyqpanda.pyQPanda.iSWAP(first_qubit_list: QVec, second_qubit_list: QVec) → QCircuit

pyqpanda.pyQPanda.iSWAP(first_qubit_addr: int, second_qubit_addr: int) → QGate

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

pyqpanda.pyQPanda.iSWAP(first_qubit: Qubit, second_qubit: Qubit, theta_angle: float) → QGate

pyqpanda.pyQPanda.iSWAP(first_qubit_list: QVec, second_qubit_list: QVec, theta_angle: float) → QCircuit

pyqpanda.pyQPanda.iSWAP(first_qubit_addr: int, second_qubit_addr: int, theta_angle: float) → QGate

pyqpanda.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.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: ture if initialization success

pyqpanda.pyQPanda.init_quantum_machine(machine_type: QMachineType = QMachineType.CPU) → QuantumMachine

Create and initialize a new quantum machine, and let it be global unique quantum machine

Args:

machine_type: quantum machine type, see pyQPanda.QMachineType

Returns:

the quantum machine, type is depend on machine_type QMachineType.CPU --> pyQPanda.CPUQVM QMachineType.CPU_SINGLE_THREAD --> pyQPanda.CPUSingleThreadQVM QMachineType.GPU --> pyQPanda.GPUQVM (if pyQPanda is build with GPU) QMachineType.NOISE --> pyQPanda.NoiseQVM return None if initial machine faild

Raises:

init_fail: An error occurred in init_quantum_machine

pyqpanda.pyQPanda.inverse(arg0: var) → var

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

Construct a circuit to determine if there is a carry

pyqpanda.pyQPanda.is_match_topology(gate: QGate, topo: List[List[float]]) → bool

Judge the QGate if match the target topologic structure of quantum circuit

Args:

gate: QGate topo: the target topologic structure of quantum circuit

Returns:

true if match, else false

pyqpanda.pyQPanda.is_supported_qgate_type(nodeitr: NodeIter) → bool

Judge if the target node is a QGate type

Args:

node_iter: node iter in qprog

Returns:

true ir false if the target node is a QGate type

pyqpanda.pyQPanda.is_swappable(prog: QProg, nodeitr_1: NodeIter, nodeitr_2: NodeIter) → bool

Judge the specialed two NodeIters in qprog whether can be exchanged

Args:

qprog: target quantum program node_iter1: node iter 1 in qprog node_iter2: node iter 2 in qprog

Returns:

true ir false for two NodeIters in qprog whether can be exchanged

pyqpanda.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.pyQPanda.ldd_decompose(qprog: QProg) → QProg

Decompose multiple control QGate

Args:

qprog: quantum program

Returns:

a new prog after decomposition

pyqpanda.pyQPanda.log(arg0: var) → var

pyqpanda.pyQPanda.matrix_decompose(qubits: QVec, matrix: numpy.ndarray[numpy.complex128[m, n]], mode: DecompositionMode = DecompositionMode.QSD, b_positive_seq: bool = True) → QCircuit

pyqpanda.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.pyQPanda.matrix_decompose_paulis(arg0: QuantumMachine, arg1: numpy.ndarray[numpy.float64[m, n]]) → List[Tuple[float, QCircuit]]

pyqpanda.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.pyQPanda.measure_all(qubit_list: QVec, cbit_list: List[ClassicalCondition]) → QProg

pyqpanda.pyQPanda.measure_all(qubit_addr_list: List[int], cbit_addr_list: List[int]) → QProg

Create a list of measure node

Args:

qubit_list : measure qubits list cbit_list : cbits stores quantum measure result

Returns:

a list of measure node

pyqpanda.pyQPanda.mul(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.mul(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.pyQPanda.mul(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.originir_to_qprog(file_path: str, machine: QuantumMachine) → QProg

Read OriginIR file and trans to QProg

Args:

file_path: OriginIR file path machine: initialized quantum machine

Returns:

Transformed QProgRaises: run_fail: An error occurred in originir_to_qprog

pyqpanda.pyQPanda.pauli_combination_replace(arg0: List[Tuple[float, QCircuit]], arg1: QuantumMachine, arg2: str, arg3: str) → List[Tuple[float, QCircuit]]

pyqpanda.pyQPanda.planarity_testing(topo_data: List[List[int]]) → bool

planarity testing

Args:

topo_data: quantum program topo data

Returns:

result data

Raises:

run_fail: An error occurred in planarity_testing

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine in tuple form

pyqpanda.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.pyQPanda.poly(arg0: var, arg1: var) → var

pyqpanda.pyQPanda.print_matrix(matrix: List[complex], precision: int = 8) → str

Print matrix element

Args:

matrix: matrix precision: double value to string cutoff precision

Returns:

string of matrix

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in measure quantum program

pyqpanda.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 returnd tuple, should in [-1, 1<<len(qubit_list)]

default is -1, means no limit

Returns:

measure result of quantum machine

Raises:

run_fail: An error occurred in prob_run_tuple_list

pyqpanda.pyQPanda.prog_layer(*args, **kwargs) → Any

pyqpanda.pyQPanda.prog_to_dag(prog: QProg) → QProgDAG

pyqpanda.pyQPanda.qAlloc() → Qubit

pyqpanda.pyQPanda.qAlloc(qubit_addr: int) → Qubit

Allocate a qubits After init()

Args:

qubit_addr: qubit physic address, should in [0,29)

Returns:

pyQPanda.Qubit: None, if qubit_addr error, or reached max number of allowed qubit

pyqpanda.pyQPanda.qAlloc_many(qubit_num: int) → List[Qubit]

Allocate several qubits After init()

Args:

qubit_num: numbers of qubit want to be created

Returns:

list[pyQPanda.Qubit]: list of qubit

pyqpanda.pyQPanda.qFree(qubit: Qubit) → None

Free a qubit

Args:

Qubit: a qubit

Returns:

none

pyqpanda.pyQPanda.qFree_all() → None

pyqpanda.pyQPanda.qFree_all(qubit_list: QVec) → None

Free a list of qubits

Args:

a list of qubits

Returns:

none

pyqpanda.pyQPanda.qop(VariationalQuantumCircuit: qop.VariationalQuantumCircuit, Hamiltonian, QuantumMachine: qop.QuantumMachine, qubitList: List[Qubit]) → var

pyqpanda.pyQPanda.qop(VariationalQuantumCircuit: qop.VariationalQuantumCircuit, Hamiltonian, QuantumMachine: qop.QuantumMachine, qubitList: Dict[int, Qubit]) → var

pyqpanda.pyQPanda.qop_pmeasure(arg0: VariationalQuantumCircuit, arg1: List[int], arg2: QuantumMachine, arg3: List[Qubit]) → var

pyqpanda.pyQPanda.quantum_chip_adapter(qprog: QProg, machine: QuantumMachine, mapping: bool = True, config_file: str = 'QPandaConfig.json') → list

Quantum chip adaptive conversion

Args:

qprog: quantum program machine: quantum machine mapping: whether or not perform the mapping operation config_file: config file

Returns:

list contains qprog and qubit_list after mapping, if mapping is false, the qubit_list may be misoperated

pyqpanda.pyQPanda.quantum_walk_alg(*args, **kwargs) → Any

Build quantum-walk algorithm quantum circuit

pyqpanda.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.pyQPanda.quick_measure(qubit_list: QVec, shots: int) → Dict[str, int]

Quick measure

Args:

qubit_list: qubit list to measure shots: the repeat num of measure operate

Returns:

result of quantum programRaises: run_fail: An error occurred in measure quantum program

pyqpanda.pyQPanda.random_qcircuit(qvec: QVec, depth: int = 100, gate_type: List[str] = []) → QCircuit

Generate random quantum circuit

Args:

qubit_row: circuit qubit row value qubit_col: circuit qubit col value depth: circuit depth qvm: quantum machine qvec: out put circuits for random circuit

Returns:

random quantum program

Raises:

run_fail: An error occurred in generate random circuit

pyqpanda.pyQPanda.random_qprog(qubit_row: int, qubit_col: int, depth: int, qvm: QuantumMachine, qvec: QVec) → QProg

Generate random quantum program

Args:

qubit_row: circuit qubit row value qubit_col: circuit qubit col value depth: circuit depth qvm: quantum machine qvec: out put circuits for random qprog

Returns:

random quantum program

Raises:

run_fail: An error occurred in generate random qprog

pyqpanda.pyQPanda.recover_edges(topo_data: List[List[int]], max_connect_degree: int, candidate_edges: List[Tuple[int, List[int]]]) → List[List[int]]

Recover edges from the candidate edges

Args:

topo_data: quantum program topo_data max_connect_degree: max value of connect degree candidate_edges: candidate edges

Returns:

topo data

Raises:

run_fail: An error occurred in recover_edges

pyqpanda.pyQPanda.remap(prog: QProg, target_qlist: QVec, target_clist: List[ClassicalCondition] = []) → QProg

Source qunatum program is mapped to the target qubits

Args:

prog: source quantum progprom target_qlist: target qubits target_clist: target cbits

Returns:

target quantum program

pyqpanda.pyQPanda.replace_complex_points(src_topo_data: List[List[int]], max_connect_degree: int, sub_topo_vec: List[Tuple[int, List[List[int]]]]) → None

Replacing complex points with subgraphs

Args:

src_topo_data: quantum program source topo data max_connect_degree: max value of connect degree sub_topo_vec: sub topo list

Returns:

none

Raises:

run_fail: An error occurred in replace_complex_points

pyqpanda.pyQPanda.run_with_configuration(program: QProg, cbit_list: List[ClassicalCondition], shots: int, noise_model: Noise = NoiseModel()) → Dict[str, int]

pyqpanda.pyQPanda.run_with_configuration(program: QProg, shots: int, noise_model: Noise = NoiseModel()) → Dict[str, int]

Run quantum program with configuration

Args:

program: quantum program cbit_list: classic cbits list shots: repeate run quantum program times noise_model: noise model, default is no noise. noise model only work on CPUQVM now

Returns:

result of quantum program execution in shots. first is the final qubit register state, second is it's hit shotRaises: run_fail: An error occurred in measure quantum program

pyqpanda.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.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.pyQPanda.sabre_mapping(prog: QProg, quantum_machine: QuantumMachine, max_look_ahead: int = 20, max_iterations: int = 10, config_data: str = 'QPandaConfig.json') → QProg

pyqpanda.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.pyQPanda.sigmoid(arg0: var) → var

pyqpanda.pyQPanda.sin(arg0: var) → var

pyqpanda.pyQPanda.single_qubit_rb(qvm: QuantumMachine, qubit: Qubit, clifford_range: List[int], num_circuits: int, shots: int, chip_id: int = 2, interleaved_gates: List[QGate] = []) → Dict[int, float]

pyqpanda.pyQPanda.single_qubit_rb(config: QCloudTaskConfig, qubit: int, clifford_range: List[int], num_circuits: int, interleaved_gates: List[QGate] = []) → Dict[int, float]

Single qubit rb with origin chip

Args:

config: quantum QCloudTaskConfig qubit: single qubit clifford_range: clifford range list num_circuits: the num of circuits interleaved_gates: interleaved gates list

Returns:

result data dict

Raises:

run_fail: An error occurred in single_qubit_rb

pyqpanda.pyQPanda.softmax(arg0: var) → var

pyqpanda.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]]]]

Splitting complex points into multiple points

Args:

topo_data: quantum program topo_data max_connect_degree: max value of connect degree complex_points: complex points list split_method: see ComplexVertexSplitMethod, default is ComplexVertexSplitMethod.LINEAR

Returns:

none

Raises:

run_fail: An error occurred in split_complex_points

pyqpanda.pyQPanda.stack(arg0: int, *args) → var

pyqpanda.pyQPanda.state_fidelity(state1: List[complex], state2: List[complex]) → float

pyqpanda.pyQPanda.state_fidelity(matrix1: List[List[complex]], matrix2: List[List[complex]]) → float

pyqpanda.pyQPanda.state_fidelity(state1: List[complex], state2: List[List[complex]]) → float

pyqpanda.pyQPanda.state_fidelity(state1: List[List[complex]], state2: List[complex]) → float

compare two quantum states , Get the state fidelity

Args:

state1: quantum state matrix 1 state2: quantum state list 2

Returns:

state fidelity bewteen [0,1]

pyqpanda.pyQPanda.sub(arg0: ClassicalCondition, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.sub(arg0: ClassicalCondition, arg1: int) → ClassicalCondition

pyqpanda.pyQPanda.sub(arg0: int, arg1: ClassicalCondition) → ClassicalCondition

pyqpanda.pyQPanda.sum(arg0: var) → var

pyqpanda.pyQPanda.tan(arg0: var) → var

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

Transform QProg to Quil instruction

Args:

qprog: QProg machine: quantum machine

Returns:

Quil instruction string

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

pyqpanda.pyQPanda.to_originir(qprog: QCircuit, machine: QuantumMachine) → str

pyqpanda.pyQPanda.to_originir(qprog: QGate, machine: QuantumMachine) → str

pyqpanda.pyQPanda.to_originir(qprog: QIfProg, machine: QuantumMachine) → str

pyqpanda.pyQPanda.to_originir(qprog: QWhileProg, machine: QuantumMachine) → str

pyqpanda.pyQPanda.to_originir(qprog: QMeasure, machine: QuantumMachine) → str

Transform QProg to OriginIR string

Args:

qprog: QProg or QCircute machine: quantum machine

Returns:

QriginIR string

pyqpanda.pyQPanda.topology_match(qprog: QProg, qubit_list: QVec, machine: QuantumMachine, confing_file: str = 'QPandaConfig.json') → list

Judge QProg/QCircuit matches the topology of the physical qubits

Args:

qprog: quantum prog qubit_list: qubits list in quantum prog machine: quantum machine confing_file: match configfilepath, default is QPandaConfig.json

Returns:

result data

Raises:

run_fail: An error occurred in topology_match

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

Parse binary data trans to quantum program

Args:

machine: quantum machine data: list contains binary data from transform_qprog_to_binary()

Returns:

QProg

pyqpanda.pyQPanda.transform_originir_to_qprog(fname: str, machine: QuantumMachine) → QProg

Transform OriginIR to QProg

Args:

fname: file sotred OriginIR instruction machine: quantum machine

Returns:

QProg

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

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

Save quantum program to file as binary data

Args:

qprog: QProg machine: quantum machine fname: save to file name

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

Quantum program transform to OriginIR string

Args:

qprog: QProg machine: quantum machine

Returns:

OriginIR instruction string

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

Transform QProg to Quil instruction

Args:

qprog: QProg machine: quantum machine

Returns:

Quil instruction string

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

pyqpanda.pyQPanda.transform_to_base_qgate(qprog: QProg, machine: QuantumMachine, convert_single_gates: List[str], convert_double_gates: List[str]) → QProg

Basic quantum - gate conversion

Args:

qprog: quantum program machine: quantum machine convert_single_gates: quantum single gates sets convert_double_gates: quantum double gates sets

Returns:

a new prog after transform_to_base_qgate

pyqpanda.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.pyQPanda.transpose(arg0: var) → var

pyqpanda.pyQPanda.validate_double_qgate_type(gate_str_list: List[str]) → list

Get valid QGates and valid double bit QGate type

Args:

double_gates: double gates list

Returns:

result list

pyqpanda.pyQPanda.validate_single_qgate_type(gate_str_list: List[str]) → list

Get valid QGates and valid single bit QGate type

Args:

single_gates: single gates list

Returns:

result list

pyqpanda.pyQPanda.vector_dot(x: List[float], y: List[float]) → float

Inner product of vector x and y

Args:

x: list x y: list y

Returns:

dot result

Raises:

run_fail: An error occurred in vector_dot

pyqpanda.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