LinearMapper
Extends:
Maps a quantum circuit to a linear chain of nearest neighbour interactions.
Maps a quantum circuit to a linear chain of qubits with nearest neighbour interactions using Swap gates. It supports open or cyclic boundary conditions.
Attributes: current_mapping: Stores the mapping: key is logical qubit id, value is mapped qubit id from 0,...,this.num_qubits cyclic (Bool): If chain is cyclic or not storage (int): Number of gate it caches before mapping. num_mappings (int): Number of times the mapper changed the mapping depth_of_swaps (dict): Key are circuit depth of swaps, value is the number of such mappings which have been applied num_of_swaps_per_mapping (dict): Key are the number of swaps per mapping, value is the number of such mappings which have been applied
Note: 1) Gates are cached and only mapped from time to time. A FastForwarding gate doesn't empty the cache, only a FlushGate does. 2) Only 1 and two qubit gates allowed. 3) Does not optimize for dirty qubits.
Static Method Summary
Static Public Methods | ||
public static |
returnNewMapping(num_qubits: number, cyclic: boolean, currently_allocated_ids: Set<Number>, stored_commands: Command[], current_mapping: Object): Object |
Static Private Methods | ||
private static |
_processTwoQubitGate(num_qubits: number, cyclic: boolean, qubit0: number, qubit1: number, active_qubits: Set<Number>, segments: Array, neighbour_ids: Object) Processes a two qubit gate. |
|
private static |
_returnNewMappingFromSegments(num_qubits: number, segments: Array, allocated_qubits: Object, current_mapping: Object): * |
Constructor Summary
Public Constructor | ||
public |
constructor(num_qubits: number, cyclic: boolean, storage: number) |
Member Summary
Public Members | ||
public |
currentMapping: {} |
|
public |
cyclic: * |
|
public |
depth_of_swaps: {} |
|
public |
|
|
public |
|
|
public |
num_qubits: * |
|
public |
storage: * |
Private Members | ||
private |
|
|
private |
_stored_commands: *[] |
Method Summary
Public Methods | ||
public |
isAvailable(cmd: *): * |
|
public |
Receives a command list and, for each command, stores it until we do a mapping (FlushGate or Cache of stored commands is full). |
Private Methods | ||
private |
_oddEvenTranspositionSortSwaps(old_mapping: Object, new_mapping: Object): Array Returns the swap operation for an odd-even transposition sort. |
|
private |
_run() Creates a new mapping and executes possible gates. |
|
private |
Sends the stored commands possible without changing the mapping. |
Inherited Summary
From class BasicEngine | ||
public |
|
|
public |
allocateQubit(dirty: boolean): Qureg Return a new qubit as a list containing 1 qubit object (quantum register of size 1). |
|
public |
allocateQureg(n: number): Qureg Allocate n qubits and return them as a quantum register, which is a list of qubit objects. |
|
public |
deallocateQubit(qubit: BasicQubit) Deallocate a qubit (and sends the deallocation command down the pipeline). |
|
public |
isAvailable(cmd: Command): boolean Default implementation of isAvailable: Ask the next engine whether a command is available, i.e., whether it can be executed by the next engine(s). |
|
public |
isMetaTagSupported(metaTag: function): boolean Check if there is a compiler engine handling the meta tag |
|
public |
receive() |
|
public |
Forward the list of commands to the next engine in the pipeline. |
From class BasicMapperEngine | ||
public get |
|
|
public set |
|
|
private |
|
|
public |
sendCMDWithMappedIDs(cmd: Command) Send this Command using the mapped qubit ids of this.current_mapping. |
Static Public Methods
public static returnNewMapping(num_qubits: number, cyclic: boolean, currently_allocated_ids: Set<Number>, stored_commands: Command[], current_mapping: Object): Object source
Params:
Name | Type | Attribute | Description |
num_qubits | number | Total number of qubits in the linear chain |
|
cyclic | boolean | If linear chain is a cycle. |
|
currently_allocated_ids | Set<Number> | Logical qubit ids for which the Allocate gate has already been processed and sent to the next engine but which are not yet deallocated and hence need to be included in the new mapping. |
|
stored_commands | Command[] | Future commands which should be applied next. |
|
current_mapping | Object | A current mapping as a dict. key is logical qubit id, value is placement id. If there are different possible maps, this current mapping is used to minimize the swaps to go to the new mapping by a heuristic. |
Static Private Methods
private static _processTwoQubitGate(num_qubits: number, cyclic: boolean, qubit0: number, qubit1: number, active_qubits: Set<Number>, segments: Array, neighbour_ids: Object) source
Processes a two qubit gate.
It either removes the two qubits from active_qubits if the gate is not possible or updates the segements such that the gate is possible.
Params:
Name | Type | Attribute | Description |
num_qubits | number | Total number of qubits in the chain |
|
cyclic | boolean | If linear chain is a cycle |
|
qubit0 | number | qubit.id of one of the qubits |
|
qubit1 | number | qubit.id of the other qubit |
|
active_qubits | Set<Number> | contains all qubit ids which for which gates can be applied in this cycle before the swaps |
|
segments | Array | List of segments. A segment is a list of neighbouring qubits. |
|
neighbour_ids | Object | Key: qubit.id Value: qubit.id of neighbours |
private static _returnNewMappingFromSegments(num_qubits: number, segments: Array, allocated_qubits: Object, current_mapping: Object): * source
Params:
Name | Type | Attribute | Description |
num_qubits | number | Total number of qubits in the linear chain |
|
segments | Array | List of segments. A segment is a list of qubit ids which should be nearest neighbour in the new map. Individual qubits are in allocated_qubits but not in any segment |
|
allocated_qubits | Object | A set of all qubit ids which need to be present in the new map |
|
current_mapping | Object | A current mapping as a dict. key is logical qubit id, value is placement id. If there are different possible maps, this current mapping is used to minimize the swaps to go to the new mapping by a heuristic. |
Return:
* | A new mapping as a dict. key is logical qubit id, value is placement id |
Public Constructors
public constructor(num_qubits: number, cyclic: boolean, storage: number) source
Override:
BasicMapperEngine#constructorPublic Members
public cyclic: * source
public depth_of_swaps: {} source
public num_of_swaps_per_mapping: {} source
public num_qubits: * source
public storage: * source
Private Members
private _currently_allocated_ids: * source
private _stored_commands: *[] source
Public Methods
public isAvailable(cmd: *): * source
Default implementation of isAvailable: Ask the next engine whether a command is available, i.e., whether it can be executed by the next engine(s).
Override:
BasicEngine#isAvailableParams:
Name | Type | Attribute | Description |
cmd | * |
Return:
* |
public receive(command_list: Command[]) source
Receives a command list and, for each command, stores it until we do a mapping (FlushGate or Cache of stored commands is full).
Override:
BasicEngine#receiveParams:
Name | Type | Attribute | Description |
command_list | Command[] | list of commands to receive. |
Private Methods
private _oddEvenTranspositionSortSwaps(old_mapping: Object, new_mapping: Object): Array source
Returns the swap operation for an odd-even transposition sort.
Return:
Array | List of tuples. Each tuple is a swap operation which needs to be applied. Tuple contains the two MappedQubit ids for the Swap. |
private _run() source
Creates a new mapping and executes possible gates.
It first allocates all 0, ..., this.num_qubits-1 mapped qubit ids, if they are not already used because we might need them all for the swaps. Then it creates a new map, swaps all the qubits to the new map, executes all possible gates, and finally deallocates mapped qubit ids which don't store any information.
private _sendPossibleCommands() source
Sends the stored commands possible without changing the mapping.
Note: this.currentMapping must exist already