Sample Test

The answer is a.

Pauli('IZ') corresponds to $I \otimes Z$. Since $Z=\mathrm{diag}(1,-1)$ and $I=\mathrm{diag}(1,1)$, we get

which matches the given matrix.

b:'-II' → $-I\otimes I=\mathrm{diag}(-1,-1,-1,-1)$
c:'-ZI' → $-Z\otimes I=\mathrm{diag}(-1,-1,1,1)$
d: 'ZZ' → $Z\otimes Z=\mathrm{diag}(1,-1,-1,1)$

The answer is d.
T gate induces a π/4 phase.

The answer is d.

On the Bloch sphere, the state $|0\rangle$ is at the north pole.
The operation $R_y(\pi/2)$ rotates the state vector by 90° around the y-axis.
This moves the vector from the north pole to a point on the equator of the Bloch sphere.

On the equator, the probabilities of measuring $|0\rangle$ and $|1\rangle$ are equal.
Thus, the probability of getting $|1\rangle$ is:

The answer is a.

The answer is c.

What is a Statevector?¶

In Qiskit, a Statevector represents the quantum state of an $n$-qubit system as a complex vector of length $2^n$. Each entry corresponds to the amplitude of one computational basis state (e.g., $|000\rangle, |001\rangle, …, |111\rangle$). The squared magnitude of each amplitude gives the probability of measuring that basis state.

Ordering of the List¶

The list follows lexicographic ordering of basis states, where the index of the list corresponds to the integer value of the basis bitstring:

• Index $i$ → basis state $|i\rangle$, written in binary.
• Qubit 0 is the least significant bit (rightmost), and qubit $n-1$ is the most significant bit (leftmost).

Thus, for 3 qubits:

• index 0 → $|000\rangle$
• index 1 → $|001\rangle$
• …
• index 7 → $|111\rangle$.

The answer is d.

The answer is b.

Parameter('theta') creates a symbolic parameter, which represents an angle with an initially undefined value that can be assigned later when executing the circuit.

The answer is c.

• a. Ancillary register → Used as extra helper qubits, not for storing measurement results.
• b. Quantum register → Holds qubits, which collapse after measurement, so results are not stored here.
• c. Classical register → Stores the outcomes of measurements as classical bits.
• d. Circuit register → Not an actual register type in Qiskit.

The answer is a.

Here are concise descriptions of the parameters in qiskit.transpiler.generate_preset_pass_manager

The answer is b, e, f.

There are three execution modes: job, session, and batch.

Job mode¶

A single primitive request of the estimator or the sampler made without a context manager. Circuits and inputs are packaged as primitive unified blocs (PUBs) and submitted as an execution task on the quantum computer.

Batch mode¶

A multi-job manager for efficiently running experiments comprising multi-job workloads. These workloads are made up of independently executable jobs that have no conditional relationship with each other. With batch mode, users submit their jobs all at once. The system parallelizes or threads the pre-processing step of each primitive job to more tightly package quantum execution across jobs, and then runs the quantum execution of each job in quick succession to deliver the most efficient results.

Session mode¶

A dedicated window for running a multi-job workload. During this window, the user has exclusive access of the system and no other jobs can run - including calibration jobs. This allows users to experiment with variational algorithms in a more predictable way and even run multiple experiments simultaneously, taking advantage of parallelism in the stack. Using sessions helps avoid delays caused by queuing each job separately, which can be particularly useful for iterative tasks that require frequent communication between classical and quantum resources.

Workloads on the Open Plan can run only in job mode or batch mode.

The answer is c.

See the document “Run jobs in a session”

The answer is a.

An array broadcasting primitive is a fundamental operation that allows arrays of different shapes to participate in element-wise operations by automatically expanding dimensions without copying data.

• It aligns array shapes according to broadcasting rules (match or size-1).
• It enables efficient, memory-safe, multidimensional computations.
• In Qiskit, this is used to combine parameter sweeps with observables into expectation value arrays.

a. Standard multidimensional array generalization ✅

• This exactly matches the NumPy-style broadcasting rule: expand size-1 dimensions to align arrays.
• The example (3,6) + (2,3,1) → (2,3,6) is a textbook case.

b. All-to-all ❌

• Would imply computing every combination in a Cartesian product sense.
• Not the case here: dimensions are aligned, not cross-multiplied.

c. Extended dimensional variation ❌

• Sounds like adding extra dimensions, but it’s not the standard term.
• The process shown is standard broadcasting, not a special variation.

d. Best effort broadcasting ❌

• Suggests a heuristic or partial match when rules fail.
• Here, broadcasting succeeds cleanly under standard rules, no “best effort” needed.

The answer is c.

Here is the documentation of SamplerOptions.

The default number of shots to use if none are specified in the PUBs or in the run method.

The answer is a.

Here is the documentation of SamplerV2.

Parameters

• pubs (Iterable[SamplerPubLike]) – An iterable of pub-like objects. For example, a list of circuits or tuples (circuit, parameter_values).
• shots (int | None) – The total number of shots to sample for each sampler pub that does not specify its own shots. If None, the primitive’s default shots value will be used, which can vary by implementation.

The answer is d.

The required number of shots is inversely proportional to the square of the precision:

When the precision parameter increases from 0.015625 (1/64) to 0.03125 (1/32), the allowed error becomes larger. This means fewer shots are needed. In fact, doubling the precision reduces the required shots by a factor of 4.

The answer is c.

a. Pauli twirling → A noise tailoring technique, not a resilience option.
b. Dynamical decoupling → A circuit scheduling technique, not in resilience options.
c. Zero Noise Extrapolation → ✅ This is directly available as a resilience option.
d. Full quantum error correction → Not yet practical and not part of resilience options.

The answer is b.

This page gives an overview of the inputs and outputs of the Qiskit Runtime primitives that execute workloads on IBM Quantum® compute resources. These primitives provide you with the ability to efficiently define vectorized workloads by using a data structure known as a Primitive Unified Bloc (PUB). These PUBs are the fundamental unit of work a QPU needs to execute these workloads. They are used as inputs to the run() method for the Sampler and Estimator primitives, which execute the defined workload as a job. Then, after the job has completed, the results are returned in a format that is dependent on both the PUBs used as well as the runtime options specified from the Sampler or Estimator primitives.

Estimator PUB¶

For the Estimator primitive, the format of the PUB should contain at most four values:

• A single QuantumCircuit, which may contain one or more Parameter objects
• A list of one or more observables, which specify the expectation values to estimate, arranged into an array (for example, a single observable represented as a 0-d array, a list of observables as a 1-d array, and so on). The data can be in any one of the ObservablesArrayLike format such as Pauli, SparsePauliOp, PauliList, or str.
• A collection of parameter values to bind the circuit against. This can be specified as a single array-like object where the last index is over circuit Parameter objects, or omitted (or equivalently, set to None) if the circuit has no Parameter objects.
• (Optionally) a target precision for expectation values to estimate

Sampler PUB¶

For the Sampler primitive, the format of the PUB tuple contains at most three values:

• A single QuantumCircuit, which may contain one or more Parameter objects
• A collection of parameter values to bind the circuit against $\theta_k$ (only needed if any Parameter objects are used that must be bound at runtime)
• (Optionally) a number of shots to measure the circuit with

The answer is c.

a. some kind of AI-driven or template-based algorithm generation
b. Qiskit Visualization
c. Qiskit Runtime session
d. Qiskit transpiler

The answer is b, c.

session.details() method returns a dictionary with the sessions details.

• id: id of the session.
• backend_name: backend used for the session.
• interactive_timeout: The maximum idle time (in seconds) between jobs that is allowed to occur before the session is deactivated.
• max_time: Maximum allowed time (in seconds) for the session, subject to plan limits.
• active_timeout: The maximum time (in seconds) a session can stay active.
• state: State of the session - open, active, inactive, or closed.
• accepting_jobs: Whether or not the session is accepting jobs.
• last_job_started: Timestamp of when the last job in the session started.
• last_job_completed: Timestamp of when the last job in the session completed.
• started_at: Timestamp of when the session was started.
• closed_at: Timestamp of when the session was closed.
• activated_at: Timestamp of when the session state was changed to active.
• mode: Execution mode of the session.
• usage_time: The usage time, in seconds, of this Session or Batch. Usage is defined as the time a quantum system is committed to complete a job.

The answer is a.

OpenQASM 3 supports several classical types, including:

• int (signed integers)
• uint (unsigned integers)
• bool (boolean values)
• bit (classical bit register)
• float (floating-point numbers)
• angle (special type for representing angles)
• complex (complex numbers, added in OpenQASM 3)
• array, struct, enum (for composite data structures)

The answer is b.

The high-level functions are simply dump() and dumps(), which respectively export to a file (given as a filename) and to a Python string.

• dump(): Serialize a QuantumCircuit object as an OpenQASM 3 stream to file-like object.
• dumps(): Serialize a QuantumCircuit object in an OpenQASM 3 string.