Kyulacs

CausalConeSimulator

DensityMatrix

GeneralQuantumOperator

GradCalculator

NoiseSimulator

Observable

ParametricQuantumCircuit

PauliOperator

QuantumCircuit

QuantumCircuitSimulator

QuantumGateBase

QuantumGateMatrix

QuantumGate_SingleParameter

QuantumState

QuantumStateBase

StateVector(arg0: int) -> qulacs_core.QuantumState

StateVector

Adaptive(*args, **kwargs)
Overloaded function.

1. Adaptive(gate: qulacs_core.QuantumGateBase, condition: Callable[[List[int]], bool]) -> qulacs_core.QuantumGateBase

Create adaptive gate

2. Adaptive(gate: qulacs_core.QuantumGateBase, condition: Callable[[List[int], int], bool], id: int) -> qulacs_core.QuantumGateBase

AmplitudeDampingNoise(index: int, prob: float) -> qulacs_core.QuantumGate_CPTP

Create amplitude damping noise

BitFlipNoise(index: int, prob: float) -> qulacs_core.QuantumGate_Probabilistic

Create bit-flip noise

CNOT(control: int, target: int) -> qulacs_core.ClsOneControlOneTargetGate

Create CNOT gate

CP(kraus_list: List[qulacs_core.QuantumGateBase], state_normalize: bool, probability_normalize: bool, assign_zero_if_not_matched: bool) -> qulacs_core.QuantumGateBase

Create completely-positive map

CPTP(kraus_list: List[qulacs_core.QuantumGateBase]) -> qulacs_core.QuantumGateBase

Create completely-positive trace preserving map

CZ(control: int, target: int) -> qulacs_core.ClsOneControlOneTargetGate

Create CZ gate

DenseMatrix(*args, **kwargs)
Overloaded function.

1. DenseMatrix(index: int, matrix: numpy.ndarray[numpy.complex128[m, n]]) -> qulacs_core.QuantumGateMatrix

Create dense matrix gate

2. DenseMatrix(index_list: List[int], matrix: numpy.ndarray[numpy.complex128[m, n]]) -> qulacs_core.QuantumGateMatrix

DephasingNoise(index: int, prob: float) -> qulacs_core.QuantumGate_Probabilistic

Create dephasing noise

DepolarizingNoise(index: int, prob: float) -> qulacs_core.QuantumGate_Probabilistic

Create depolarizing noise

DiagonalMatrix(index_list: List[int], diagonal_element: numpy.ndarray[numpy.complex128[m, 1]]) -> qulacs_core.QuantumGateDiagonalMatrix

Create diagonal matrix gate

FREDKIN(control: int, target1: int, target2: int) -> qulacs_core.QuantumGateMatrix

Create FREDKIN gate

H(index: int) -> qulacs_core.ClsOneQubitGate

Create Hadamard gate

Identity(index: int) -> qulacs_core.ClsOneQubitGate

Create identity gate

IndependentXZNoise(index: int, prob: float) -> qulacs_core.QuantumGate_Probabilistic

Create independent XZ noise

Instrument(kraus_list: List[qulacs_core.QuantumGateBase], register: int) -> qulacs_core.QuantumGateBase

Create instruments

Measurement(index: int, register: int) -> qulacs_core.QuantumGate_CPTP

Create measurement gate

NoisyEvolution(hamiltonian: qulacs_core.Observable, c_ops: List[qulacs_core.GeneralQuantumOperator], time: float, dt: float) -> qulacs_core.ClsNoisyEvolution

Create noisy evolution

NoisyEvolution_fast(hamiltonian: qulacs_core.Observable, c_ops: List[qulacs_core.GeneralQuantumOperator], time: float) -> qulacs_core.ClsNoisyEvolution_fast

Create noisy evolution fast version

P0(index: int) -> qulacs_core.ClsOneQubitGate

Create projection gate to |0> subspace

P1(index: int) -> qulacs_core.ClsOneQubitGate

Create projection gate to |1> subspace

ParametricPauliRotation(index_list: List[int], pauli_ids: List[int], angle: float) -> qulacs_core.QuantumGate_SingleParameter

Create parametric multi-qubit Pauli rotation gate

ParametricRX(index: int, angle: float) -> qulacs_core.QuantumGate_SingleParameter

Create parametric Pauli-X rotation gate

ParametricRY(index: int, angle: float) -> qulacs_core.QuantumGate_SingleParameter

Create parametric Pauli-Y rotation gate

ParametricRZ(index: int, angle: float) -> qulacs_core.QuantumGate_SingleParameter

Create parametric Pauli-Z rotation gate

Pauli(index_list: List[int], pauli_ids: List[int]) -> qulacs_core.ClsPauliGate

Create multi-qubit Pauli gate

PauliRotation(index_list: List[int], pauli_ids: List[int], angle: float) -> qulacs_core.ClsPauliRotationGate

Create multi-qubit Pauli rotation

Probabilistic(prob_list: List[float], gate_list: List[qulacs_core.QuantumGateBase]) -> qulacs_core.QuantumGateBase

Create probabilistic gate

ProbabilisticInstrument(prob_list: List[float], gate_list: List[qulacs_core.QuantumGateBase], register: int) -> qulacs_core.QuantumGateBase

Create probabilistic instrument gate

RX(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-X rotation gate

RY(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Y rotation gate

RZ(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Z rotation gate

RandomUnitary(*args, **kwargs)
Overloaded function.

1. RandomUnitary(index_list: List[int]) -> qulacs_core.QuantumGateMatrix

Create random unitary gate

2. RandomUnitary(index_list: List[int], seed: int) -> qulacs_core.QuantumGateMatrix

ReversibleBoolean(index_list: List[int], func: Callable[[int, int], int]) -> qulacs_core.ClsReversibleBooleanGate

Create reversible boolean gate

RotInvX(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-X rotation gate

RotInvY(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Y rotation gate

RotInvZ(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Z rotation gate

RotX(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-X rotation gate

RotY(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Y rotation gate

RotZ(index: int, angle: float) -> qulacs_core.ClsOneQubitRotationGate

Create Pauli-Z rotation gate

S(index: int) -> qulacs_core.ClsOneQubitGate

Create pi/4-phase gate

SWAP(target1: int, target2: int) -> qulacs_core.ClsTwoQubitGate

Create SWAP gate

Sdag(index: int) -> qulacs_core.ClsOneQubitGate

Create adjoint of pi/4-phase gate

SparseMatrix(index_list: List[int], matrix: scipy.sparse.csc_matrix[numpy.complex128]) -> qulacs_core.QuantumGateSparseMatrix

Create sparse matrix gate

StateReflection(state: qulacs_core.QuantumStateBase) -> qulacs_core.ClsStateReflectionGate

Create state reflection gate

T(index: int) -> qulacs_core.ClsOneQubitGate

Create pi/8-phase gate

TOFFOLI(control1: int, control2: int, target: int) -> qulacs_core.QuantumGateMatrix

Create TOFFOLI gate

Tdag(index: int) -> qulacs_core.ClsOneQubitGate

Create adjoint of pi/8-phase gate

TwoQubitDepolarizingNoise(index1: int, index2: int, prob: float) -> qulacs_core.QuantumGate_Probabilistic

Create two-qubit depolarizing noise

U1(index: int, lambda: float) -> qulacs_core.QuantumGateMatrix

Create QASM U1 gate

U2(index: int, phi: float, lambda: float) -> qulacs_core.QuantumGateMatrix

Create QASM U2 gate

U3(index: int, theta: float, phi: float, lambda: float) -> qulacs_core.QuantumGateMatrix

Create QASM U3 gate

X(index: int) -> qulacs_core.ClsOneQubitGate

Create Pauli-X gate

Y(index: int) -> qulacs_core.ClsOneQubitGate

Create Pauli-Y gate

Z(index: int) -> qulacs_core.ClsOneQubitGate

Create Pauli-Z gate

add(*args, **kwargs)
Overloaded function.

1. add(gate1: qulacs_core.QuantumGateBase, gate2: qulacs_core.QuantumGateBase) -> qulacs_core.QuantumGateMatrix

Add quantum gate matrices

2. add(gate_list: List[qulacs_core.QuantumGateBase]) -> qulacs_core.QuantumGateMatrix

Add quantum gate matrices

merge(*args, **kwargs)
Overloaded function.

1. merge(gate1: qulacs_core.QuantumGateBase, gate2: qulacs_core.QuantumGateBase) -> qulacs_core.QuantumGateMatrix

Merge two quantum gate or gate list

2. merge(gate_list: List[qulacs_core.QuantumGateBase]) -> qulacs_core.QuantumGateMatrix

sqrtX(index: int) -> qulacs_core.ClsOneQubitGate

Create pi/4 Pauli-X rotation gate

sqrtXdag(index: int) -> qulacs_core.ClsOneQubitGate

Create adjoint of pi/4 Pauli-X rotation gate

sqrtY(index: int) -> qulacs_core.ClsOneQubitGate

Create pi/4 Pauli-Y rotation gate

sqrtYdag(index: int) -> qulacs_core.ClsOneQubitGate

Create adjoint of pi/4 Pauli-Y rotation gate

to_matrix_gate(gate: qulacs_core.QuantumGateBase) -> qulacs_core.QuantumGateMatrix

Convert named gate to matrix gate

drop_qubit(state: qulacs_core.QuantumState, target: List[int], projection: List[int]) -> qulacs_core.QuantumState

Drop qubits from state

inner_product(state_bra: qulacs_core.QuantumState, state_ket: qulacs_core.QuantumState) -> complex

Get inner product

partial_trace(*args, **kwargs)
Overloaded function.

1. partial_trace(state: qulacs_core.QuantumState, target_traceout: List[int]) -> qulacs_core.DensityMatrix

Take partial trace

2. partial_trace(state: qulacs_core.DensityMatrix, target_traceout: List[int]) -> qulacs_core.DensityMatrix

permutate_qubit(*args, **kwargs)
Overloaded function.

1. permutate_qubit(state: qulacs_core.QuantumState, qubit_order: List[int]) -> qulacs_core.QuantumState

Permutate qubits from state

2. permutate_qubit(state: qulacs_core.DensityMatrix, qubit_order: List[int]) -> qulacs_core.DensityMatrix

tensor_product(*args, **kwargs)
Overloaded function.

1. tensor_product(state_left: qulacs_core.QuantumState, state_right: qulacs_core.QuantumState) -> qulacs_core.QuantumState

Get tensor product of states

2. tensor_product(state_left: qulacs_core.DensityMatrix, state_right: qulacs_core.DensityMatrix) -> qulacs_core.DensityMatrix

QuantumCircuitOptimizer

create_quantum_operator_from_openfermion_file(arg0: str) -> qulacs_core.GeneralQuantumOperator

create_quantum_operator_from_openfermion_text(arg0: str) -> qulacs_core.GeneralQuantumOperator

create_split_quantum_operator(arg0: str) -> Tuple[qulacs_core.GeneralQuantumOperator, qulacs_core.GeneralQuantumOperator]

create_observable_from_openfermion_file(file_path: str) -> qulacs_core.Observable

Create GeneralQuantumOperator from openfermion file

create_observable_from_openfermion_text(text: str) -> qulacs_core.Observable

Create GeneralQuantumOperator from openfermion text

create_split_observable(arg0: str) -> Tuple[qulacs_core.Observable, qulacs_core.Observable]