_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q230100 | Frame.add_children | train | def add_children(self, frames, after=None):
'''
Convenience method to add multiple frames at once.
'''
if after is not None:
# if there's an 'after' parameter, add the frames in reverse so the order is
# preserved.
for frame in reversed(frames):
... | python | {
"resource": ""
} |
q230101 | Frame.file_path_short | train | def file_path_short(self):
""" Return the path resolved against the closest entry in sys.path """
if not hasattr(self, '_file_path_short'):
if self.file_path:
result = None
for path in sys.path:
# On Windows, if self.file_path and path are... | python | {
"resource": ""
} |
q230102 | FrameGroup.exit_frames | train | def exit_frames(self):
'''
Returns a list of frames whose children include a frame outside of the group
'''
if self._exit_frames is None:
exit_frames = []
for frame in self.frames:
if any(c.group != self for c in frame.children):
... | python | {
"resource": ""
} |
q230103 | Profiler.first_interesting_frame | train | def first_interesting_frame(self):
"""
Traverse down the frame hierarchy until a frame is found with more than one child
"""
root_frame = self.root_frame()
frame = root_frame
while len(frame.children) <= 1:
if frame.children:
frame = frame.chi... | python | {
"resource": ""
} |
q230104 | aggregate_repeated_calls | train | def aggregate_repeated_calls(frame, options):
'''
Converts a timeline into a time-aggregate summary.
Adds together calls along the same call stack, so that repeated calls appear as the same
frame. Removes time-linearity - frames are sorted according to total time spent.
Useful for outputs that dis... | python | {
"resource": ""
} |
q230105 | merge_consecutive_self_time | train | def merge_consecutive_self_time(frame, options):
'''
Combines consecutive 'self time' frames
'''
if frame is None:
return None
previous_self_time_frame = None
for child in frame.children:
if isinstance(child, SelfTimeFrame):
if previous_self_time_frame:
... | python | {
"resource": ""
} |
q230106 | remove_unnecessary_self_time_nodes | train | def remove_unnecessary_self_time_nodes(frame, options):
'''
When a frame has only one child, and that is a self-time frame, remove that node, since it's
unnecessary - it clutters the output and offers no additional information.
'''
if frame is None:
return None
if len(frame.children) ==... | python | {
"resource": ""
} |
q230107 | HTMLRenderer.open_in_browser | train | def open_in_browser(self, session, output_filename=None):
"""
Open the rendered HTML in a webbrowser.
If output_filename=None (the default), a tempfile is used.
The filename of the HTML file is returned.
"""
if output_filename is None:
output_file = tempfil... | python | {
"resource": ""
} |
q230108 | BuildPyCommand.run | train | def run(self):
'''compile the JS, then run superclass implementation'''
if subprocess.call(['npm', '--version']) != 0:
raise RuntimeError('npm is required to build the HTML renderer.')
self.check_call(['npm', 'install'], cwd=HTML_RENDERER_DIR)
self.check_call(['npm', 'run',... | python | {
"resource": ""
} |
q230109 | deprecated | train | def deprecated(func, *args, **kwargs):
''' Marks a function as deprecated. '''
warnings.warn(
'{} is deprecated and should no longer be used.'.format(func),
DeprecationWarning,
stacklevel=3
)
return func(*args, **kwargs) | python | {
"resource": ""
} |
q230110 | deprecated_option | train | def deprecated_option(option_name, message=''):
''' Marks an option as deprecated. '''
def caller(func, *args, **kwargs):
if option_name in kwargs:
warnings.warn(
'{} is deprecated. {}'.format(option_name, message),
DeprecationWarning,
stacklev... | python | {
"resource": ""
} |
q230111 | AppSettings.THUMBNAIL_OPTIONS | train | def THUMBNAIL_OPTIONS(self):
"""
Set the size as a 2-tuple for thumbnailed images after uploading them.
"""
from django.core.exceptions import ImproperlyConfigured
size = self._setting('DJNG_THUMBNAIL_SIZE', (200, 200))
if not (isinstance(size, (list, tuple)) and len(siz... | python | {
"resource": ""
} |
q230112 | NgWidgetMixin.get_context | train | def get_context(self, name, value, attrs):
"""
Some widgets require a modified rendering context, if they contain angular directives.
"""
context = super(NgWidgetMixin, self).get_context(name, value, attrs)
if callable(getattr(self._field, 'update_widget_rendering_context', None)... | python | {
"resource": ""
} |
q230113 | NgBoundField.errors | train | def errors(self):
"""
Returns a TupleErrorList for this field. This overloaded method adds additional error lists
to the errors as detected by the form validator.
"""
if not hasattr(self, '_errors_cache'):
self._errors_cache = self.form.get_field_errors(self)
... | python | {
"resource": ""
} |
q230114 | NgBoundField.css_classes | train | def css_classes(self, extra_classes=None):
"""
Returns a string of space-separated CSS classes for the wrapping element of this input field.
"""
if hasattr(extra_classes, 'split'):
extra_classes = extra_classes.split()
extra_classes = set(extra_classes or [])
... | python | {
"resource": ""
} |
q230115 | NgFormBaseMixin.get_field_errors | train | def get_field_errors(self, field):
"""
Return server side errors. Shall be overridden by derived forms to add their
extra errors for AngularJS.
"""
identifier = format_html('{0}[\'{1}\']', self.form_name, field.name)
errors = self.errors.get(field.html_name, [])
r... | python | {
"resource": ""
} |
q230116 | NgFormBaseMixin.update_widget_attrs | train | def update_widget_attrs(self, bound_field, attrs):
"""
Updated the widget attributes which shall be added to the widget when rendering this field.
"""
if bound_field.field.has_subwidgets() is False:
widget_classes = getattr(self, 'widget_css_classes', None)
if wid... | python | {
"resource": ""
} |
q230117 | NgFormBaseMixin.rectify_multipart_form_data | train | def rectify_multipart_form_data(self, data):
"""
If a widget was converted and the Form data was submitted through a multipart request,
then these data fields must be converted to suit the Django Form validation
"""
for name, field in self.base_fields.items():
try:
... | python | {
"resource": ""
} |
q230118 | NgFormBaseMixin.rectify_ajax_form_data | train | def rectify_ajax_form_data(self, data):
"""
If a widget was converted and the Form data was submitted through an Ajax request,
then these data fields must be converted to suit the Django Form validation
"""
for name, field in self.base_fields.items():
try:
... | python | {
"resource": ""
} |
q230119 | djng_locale_script | train | def djng_locale_script(context, default_language='en'):
"""
Returns a script tag for including the proper locale script in any HTML page.
This tag determines the current language with its locale.
Usage:
<script src="{% static 'node_modules/angular-i18n/' %}{% djng_locale_script %}"></script>
... | python | {
"resource": ""
} |
q230120 | DefaultFieldMixin.update_widget_attrs | train | def update_widget_attrs(self, bound_field, attrs):
"""
Update the dictionary of attributes used while rendering the input widget
"""
bound_field.form.update_widget_attrs(bound_field, attrs)
widget_classes = self.widget.attrs.get('class', None)
if widget_classes:
... | python | {
"resource": ""
} |
q230121 | MultipleChoiceField.implode_multi_values | train | def implode_multi_values(self, name, data):
"""
Due to the way Angular organizes it model, when Form data is sent via a POST request,
then for this kind of widget, the posted data must to be converted into a format suitable
for Django's Form validation.
"""
mkeys = [k for... | python | {
"resource": ""
} |
q230122 | MultipleChoiceField.convert_ajax_data | train | def convert_ajax_data(self, field_data):
"""
Due to the way Angular organizes it model, when this Form data is sent using Ajax,
then for this kind of widget, the sent data has to be converted into a format suitable
for Django's Form validation.
"""
data = [key for key, va... | python | {
"resource": ""
} |
q230123 | AngularUrlMiddleware.process_request | train | def process_request(self, request):
"""
Reads url name, args, kwargs from GET parameters, reverses the url and resolves view function
Returns the result of resolved view function, called with provided args and kwargs
Since the view function is called directly, it isn't ran through middle... | python | {
"resource": ""
} |
q230124 | NgCRUDView.ng_delete | train | def ng_delete(self, request, *args, **kwargs):
"""
Delete object and return it's data in JSON encoding
The response is build before the object is actually deleted
so that we can still retrieve a serialization in the response
even with a m2m relationship
"""
if 'pk... | python | {
"resource": ""
} |
q230125 | NgModelFormMixin._post_clean | train | def _post_clean(self):
"""
Rewrite the error dictionary, so that its keys correspond to the model fields.
"""
super(NgModelFormMixin, self)._post_clean()
if self._errors and self.prefix:
self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._... | python | {
"resource": ""
} |
q230126 | ProgressBar.percentage | train | def percentage(self):
'''Return current percentage, returns None if no max_value is given
>>> progress = ProgressBar()
>>> progress.max_value = 10
>>> progress.min_value = 0
>>> progress.value = 0
>>> progress.percentage
0.0
>>>
>>> progress.value... | python | {
"resource": ""
} |
q230127 | example | train | def example(fn):
'''Wrap the examples so they generate readable output'''
@functools.wraps(fn)
def wrapped():
try:
sys.stdout.write('Running: %s\n' % fn.__name__)
fn()
sys.stdout.write('\n')
except KeyboardInterrupt:
sys.stdout.write('\nSkippi... | python | {
"resource": ""
} |
q230128 | load_stdgraphs | train | def load_stdgraphs(size: int) -> List[nx.Graph]:
"""Load standard graph validation sets
For each size (from 6 to 32 graph nodes) the dataset consists of
100 graphs drawn from the Erdős-Rényi ensemble with edge
probability 50%.
"""
from pkg_resources import resource_stream
if size < 6 or si... | python | {
"resource": ""
} |
q230129 | load_mnist | train | def load_mnist(size: int = None,
border: int = _MNIST_BORDER,
blank_corners: bool = False,
nums: List[int] = None) \
-> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
"""Download and rescale the MNIST database of handwritten digits
MNIST is a dataset... | python | {
"resource": ""
} |
q230130 | astensor | train | def astensor(array: TensorLike) -> BKTensor:
"""Covert numpy array to tensorflow tensor"""
tensor = tf.convert_to_tensor(value=array, dtype=CTYPE)
return tensor | python | {
"resource": ""
} |
q230131 | inner | train | def inner(tensor0: BKTensor, tensor1: BKTensor) -> BKTensor:
"""Return the inner product between two states"""
# Note: Relying on fact that vdot flattens arrays
N = rank(tensor0)
axes = list(range(N))
return tf.tensordot(tf.math.conj(tensor0), tensor1, axes=(axes, axes)) | python | {
"resource": ""
} |
q230132 | graph_cuts | train | def graph_cuts(graph: nx.Graph) -> np.ndarray:
"""For the given graph, return the cut value for all binary assignments
of the graph.
"""
N = len(graph)
diag_hamiltonian = np.zeros(shape=([2]*N), dtype=np.double)
for q0, q1 in graph.edges():
for index, _ in np.ndenumerate(diag_hamiltonia... | python | {
"resource": ""
} |
q230133 | DAGCircuit.depth | train | def depth(self, local: bool = True) -> int:
"""Return the circuit depth.
Args:
local: If True include local one-qubit gates in depth
calculation. Else return the multi-qubit gate depth.
"""
G = self.graph
if not local:
def remove_local(da... | python | {
"resource": ""
} |
q230134 | DAGCircuit.components | train | def components(self) -> List['DAGCircuit']:
"""Split DAGCircuit into independent components"""
comps = nx.weakly_connected_component_subgraphs(self.graph)
return [DAGCircuit(comp) for comp in comps] | python | {
"resource": ""
} |
q230135 | zero_state | train | def zero_state(qubits: Union[int, Qubits]) -> State:
"""Return the all-zero state on N qubits"""
N, qubits = qubits_count_tuple(qubits)
ket = np.zeros(shape=[2] * N)
ket[(0,) * N] = 1
return State(ket, qubits) | python | {
"resource": ""
} |
q230136 | w_state | train | def w_state(qubits: Union[int, Qubits]) -> State:
"""Return a W state on N qubits"""
N, qubits = qubits_count_tuple(qubits)
ket = np.zeros(shape=[2] * N)
for n in range(N):
idx = np.zeros(shape=N, dtype=int)
idx[n] += 1
ket[tuple(idx)] = 1 / sqrt(N)
return State(ket, qubits) | python | {
"resource": ""
} |
q230137 | ghz_state | train | def ghz_state(qubits: Union[int, Qubits]) -> State:
"""Return a GHZ state on N qubits"""
N, qubits = qubits_count_tuple(qubits)
ket = np.zeros(shape=[2] * N)
ket[(0, ) * N] = 1 / sqrt(2)
ket[(1, ) * N] = 1 / sqrt(2)
return State(ket, qubits) | python | {
"resource": ""
} |
q230138 | random_state | train | def random_state(qubits: Union[int, Qubits]) -> State:
"""Return a random state from the space of N qubits"""
N, qubits = qubits_count_tuple(qubits)
ket = np.random.normal(size=([2] * N)) \
+ 1j * np.random.normal(size=([2] * N))
return State(ket, qubits).normalize() | python | {
"resource": ""
} |
q230139 | join_states | train | def join_states(*states: State) -> State:
"""Join two state vectors into a larger qubit state"""
vectors = [ket.vec for ket in states]
vec = reduce(outer_product, vectors)
return State(vec.tensor, vec.qubits) | python | {
"resource": ""
} |
q230140 | print_state | train | def print_state(state: State, file: TextIO = None) -> None:
"""Print a state vector"""
state = state.vec.asarray()
for index, amplitude in np.ndenumerate(state):
ket = "".join([str(n) for n in index])
print(ket, ":", amplitude, file=file) | python | {
"resource": ""
} |
q230141 | print_probabilities | train | def print_probabilities(state: State, ndigits: int = 4,
file: TextIO = None) -> None:
"""
Pretty print state probabilities.
Args:
state:
ndigits: Number of digits of accuracy
file: Output stream (Defaults to stdout)
"""
prob = bk.evaluate(state.probab... | python | {
"resource": ""
} |
q230142 | mixed_density | train | def mixed_density(qubits: Union[int, Qubits]) -> Density:
"""Returns the completely mixed density matrix"""
N, qubits = qubits_count_tuple(qubits)
matrix = np.eye(2**N) / 2**N
return Density(matrix, qubits) | python | {
"resource": ""
} |
q230143 | join_densities | train | def join_densities(*densities: Density) -> Density:
"""Join two mixed states into a larger qubit state"""
vectors = [rho.vec for rho in densities]
vec = reduce(outer_product, vectors)
memory = dict(ChainMap(*[rho.memory for rho in densities])) # TESTME
return Density(vec.tensor, vec.qubits, memory... | python | {
"resource": ""
} |
q230144 | State.normalize | train | def normalize(self) -> 'State':
"""Normalize the state"""
tensor = self.tensor / bk.ccast(bk.sqrt(self.norm()))
return State(tensor, self.qubits, self._memory) | python | {
"resource": ""
} |
q230145 | State.sample | train | def sample(self, trials: int) -> np.ndarray:
"""Measure the state in the computational basis the the given number
of trials, and return the counts of each output configuration.
"""
# TODO: Can we do this within backend?
probs = np.real(bk.evaluate(self.probabilities()))
r... | python | {
"resource": ""
} |
q230146 | State.expectation | train | def expectation(self, diag_hermitian: bk.TensorLike,
trials: int = None) -> bk.BKTensor:
"""Return the expectation of a measurement. Since we can only measure
our computer in the computational basis, we only require the diagonal
of the Hermitian in that basis.
If the... | python | {
"resource": ""
} |
q230147 | State.measure | train | def measure(self) -> np.ndarray:
"""Measure the state in the computational basis.
Returns:
A [2]*bits array of qubit states, either 0 or 1
"""
# TODO: Can we do this within backend?
probs = np.real(bk.evaluate(self.probabilities()))
indices = np.asarray(list(... | python | {
"resource": ""
} |
q230148 | State.asdensity | train | def asdensity(self) -> 'Density':
"""Convert a pure state to a density matrix"""
matrix = bk.outer(self.tensor, bk.conj(self.tensor))
return Density(matrix, self.qubits, self._memory) | python | {
"resource": ""
} |
q230149 | benchmark | train | def benchmark(N, gates):
"""Create and run a circuit with N qubits and given number of gates"""
qubits = list(range(0, N))
ket = qf.zero_state(N)
for n in range(0, N):
ket = qf.H(n).run(ket)
for _ in range(0, (gates-N)//3):
qubit0, qubit1 = random.sample(qubits, 2)
ket = qf... | python | {
"resource": ""
} |
q230150 | sandwich_decompositions | train | def sandwich_decompositions(coords0, coords1, samples=SAMPLES):
"""Create composite gates, decompose, and return a list
of canonical coordinates"""
decomps = []
for _ in range(samples):
circ = qf.Circuit()
circ += qf.CANONICAL(*coords0, 0, 1)
circ += qf.random_gate([0])
c... | python | {
"resource": ""
} |
q230151 | sX | train | def sX(qubit: Qubit, coefficient: complex = 1.0) -> Pauli:
"""Return the Pauli sigma_X operator acting on the given qubit"""
return Pauli.sigma(qubit, 'X', coefficient) | python | {
"resource": ""
} |
q230152 | sY | train | def sY(qubit: Qubit, coefficient: complex = 1.0) -> Pauli:
"""Return the Pauli sigma_Y operator acting on the given qubit"""
return Pauli.sigma(qubit, 'Y', coefficient) | python | {
"resource": ""
} |
q230153 | sZ | train | def sZ(qubit: Qubit, coefficient: complex = 1.0) -> Pauli:
"""Return the Pauli sigma_Z operator acting on the given qubit"""
return Pauli.sigma(qubit, 'Z', coefficient) | python | {
"resource": ""
} |
q230154 | pauli_sum | train | def pauli_sum(*elements: Pauli) -> Pauli:
"""Return the sum of elements of the Pauli algebra"""
terms = []
key = itemgetter(0)
for term, grp in groupby(heapq.merge(*elements, key=key), key=key):
coeff = sum(g[1] for g in grp)
if not isclose(coeff, 0.0):
terms.append((term, c... | python | {
"resource": ""
} |
q230155 | pauli_product | train | def pauli_product(*elements: Pauli) -> Pauli:
"""Return the product of elements of the Pauli algebra"""
result_terms = []
for terms in product(*elements):
coeff = reduce(mul, [term[1] for term in terms])
ops = (term[0] for term in terms)
out = []
key = itemgetter(0)
... | python | {
"resource": ""
} |
q230156 | pauli_pow | train | def pauli_pow(pauli: Pauli, exponent: int) -> Pauli:
"""
Raise an element of the Pauli algebra to a non-negative integer power.
"""
if not isinstance(exponent, int) or exponent < 0:
raise ValueError("The exponent must be a non-negative integer.")
if exponent == 0:
return Pauli.iden... | python | {
"resource": ""
} |
q230157 | pauli_commuting_sets | train | def pauli_commuting_sets(element: Pauli) -> Tuple[Pauli, ...]:
"""Gather the terms of a Pauli polynomial into commuting sets.
Uses the algorithm defined in (Raeisi, Wiebe, Sanders,
arXiv:1108.4318, 2011) to find commuting sets. Except uses commutation
check from arXiv:1405.5749v2
"""
if len(ele... | python | {
"resource": ""
} |
q230158 | astensor | train | def astensor(array: TensorLike) -> BKTensor:
"""Converts a numpy array to the backend's tensor object
"""
array = np.asarray(array, dtype=CTYPE)
return array | python | {
"resource": ""
} |
q230159 | productdiag | train | def productdiag(tensor: BKTensor) -> BKTensor:
"""Returns the matrix diagonal of the product tensor""" # DOCME: Explain
N = rank(tensor)
tensor = reshape(tensor, [2**(N//2), 2**(N//2)])
tensor = np.diag(tensor)
tensor = reshape(tensor, [2]*(N//2))
return tensor | python | {
"resource": ""
} |
q230160 | tensormul | train | def tensormul(tensor0: BKTensor, tensor1: BKTensor,
indices: typing.List[int]) -> BKTensor:
r"""
Generalization of matrix multiplication to product tensors.
A state vector in product tensor representation has N dimension, one for
each contravariant index, e.g. for 3-qubit states
:math... | python | {
"resource": ""
} |
q230161 | invert_map | train | def invert_map(mapping: dict, one_to_one: bool = True) -> dict:
"""Invert a dictionary. If not one_to_one then the inverted
map will contain lists of former keys as values.
"""
if one_to_one:
inv_map = {value: key for key, value in mapping.items()}
else:
inv_map = {}
for key,... | python | {
"resource": ""
} |
q230162 | bitlist_to_int | train | def bitlist_to_int(bitlist: Sequence[int]) -> int:
"""Converts a sequence of bits to an integer.
>>> from quantumflow.utils import bitlist_to_int
>>> bitlist_to_int([1, 0, 0])
4
"""
return int(''.join([str(d) for d in bitlist]), 2) | python | {
"resource": ""
} |
q230163 | int_to_bitlist | train | def int_to_bitlist(x: int, pad: int = None) -> Sequence[int]:
"""Converts an integer to a binary sequence of bits.
Pad prepends with sufficient zeros to ensures that the returned list
contains at least this number of bits.
>>> from quantumflow.utils import int_to_bitlist
>>> int_to_bitlist(4, 4))
... | python | {
"resource": ""
} |
q230164 | spanning_tree_count | train | def spanning_tree_count(graph: nx.Graph) -> int:
"""Return the number of unique spanning trees of a graph, using
Kirchhoff's matrix tree theorem.
"""
laplacian = nx.laplacian_matrix(graph).toarray()
comatrix = laplacian[:-1, :-1]
det = np.linalg.det(comatrix)
count = int(round(det))
retu... | python | {
"resource": ""
} |
q230165 | rationalize | train | def rationalize(flt: float, denominators: Set[int] = None) -> Fraction:
"""Convert a floating point number to a Fraction with a small
denominator.
Args:
flt: A floating point number
denominators: Collection of standard denominators. Default is
1, 2, 3, 4, 5, 6, 7, 8... | python | {
"resource": ""
} |
q230166 | symbolize | train | def symbolize(flt: float) -> sympy.Symbol:
"""Attempt to convert a real number into a simpler symbolic
representation.
Returns:
A sympy Symbol. (Convert to string with str(sym) or to latex with
sympy.latex(sym)
Raises:
ValueError: If cannot simplify float
"""
try... | python | {
"resource": ""
} |
q230167 | pyquil_to_image | train | def pyquil_to_image(program: pyquil.Program) -> PIL.Image: # pragma: no cover
"""Returns an image of a pyquil circuit.
See circuit_to_latex() for more details.
"""
circ = pyquil_to_circuit(program)
latex = circuit_to_latex(circ)
img = render_latex(latex)
return img | python | {
"resource": ""
} |
q230168 | circuit_to_pyquil | train | def circuit_to_pyquil(circuit: Circuit) -> pyquil.Program:
"""Convert a QuantumFlow circuit to a pyQuil program"""
prog = pyquil.Program()
for elem in circuit.elements:
if isinstance(elem, Gate) and elem.name in QUIL_GATES:
params = list(elem.params.values()) if elem.params else []
... | python | {
"resource": ""
} |
q230169 | pyquil_to_circuit | train | def pyquil_to_circuit(program: pyquil.Program) -> Circuit:
"""Convert a protoquil pyQuil program to a QuantumFlow Circuit"""
circ = Circuit()
for inst in program.instructions:
# print(type(inst))
if isinstance(inst, pyquil.Declare): # Ignore
continue
if isinst... | python | {
"resource": ""
} |
q230170 | quil_to_program | train | def quil_to_program(quil: str) -> Program:
"""Parse a quil program and return a Program object"""
pyquil_instructions = pyquil.parser.parse(quil)
return pyquil_to_program(pyquil_instructions) | python | {
"resource": ""
} |
q230171 | state_to_wavefunction | train | def state_to_wavefunction(state: State) -> pyquil.Wavefunction:
"""Convert a QuantumFlow state to a pyQuil Wavefunction"""
# TODO: qubits?
amplitudes = state.vec.asarray()
# pyQuil labels states backwards.
amplitudes = amplitudes.transpose()
amplitudes = amplitudes.reshape([amplitudes.size])
... | python | {
"resource": ""
} |
q230172 | QuantumFlowQVM.load | train | def load(self, binary: pyquil.Program) -> 'QuantumFlowQVM':
"""
Load a pyQuil program, and initialize QVM into a fresh state.
Args:
binary: A pyQuil program
"""
assert self.status in ['connected', 'done']
prog = quil_to_program(str(binary))
self._pr... | python | {
"resource": ""
} |
q230173 | QuantumFlowQVM.run | train | def run(self) -> 'QuantumFlowQVM':
"""Run a previously loaded program"""
assert self.status in ['loaded']
self.status = 'running'
self._ket = self._prog.run()
# Should set state to 'done' after run complete.
# Makes no sense to keep status at running. But pyQuil's
... | python | {
"resource": ""
} |
q230174 | QuantumFlowQVM.wavefunction | train | def wavefunction(self) -> pyquil.Wavefunction:
"""
Return the wavefunction of a completed program.
"""
assert self.status == 'done'
assert self._ket is not None
wavefn = state_to_wavefunction(self._ket)
return wavefn | python | {
"resource": ""
} |
q230175 | evaluate | train | def evaluate(tensor: BKTensor) -> TensorLike:
"""Return the value of a tensor"""
if isinstance(tensor, _DTYPE):
if torch.numel(tensor) == 1:
return tensor.item()
if tensor.numel() == 2:
return tensor[0].cpu().numpy() + 1.0j * tensor[1].cpu().numpy()
return tensor... | python | {
"resource": ""
} |
q230176 | rank | train | def rank(tensor: BKTensor) -> int:
"""Return the number of dimensions of a tensor"""
if isinstance(tensor, np.ndarray):
return len(tensor.shape)
return len(tensor[0].size()) | python | {
"resource": ""
} |
q230177 | state_fidelity | train | def state_fidelity(state0: State, state1: State) -> bk.BKTensor:
"""Return the quantum fidelity between pure states."""
assert state0.qubits == state1.qubits # FIXME
tensor = bk.absolute(bk.inner(state0.tensor, state1.tensor))**bk.fcast(2)
return tensor | python | {
"resource": ""
} |
q230178 | state_angle | train | def state_angle(ket0: State, ket1: State) -> bk.BKTensor:
"""The Fubini-Study angle between states.
Equal to the Burrs angle for pure states.
"""
return fubini_study_angle(ket0.vec, ket1.vec) | python | {
"resource": ""
} |
q230179 | states_close | train | def states_close(state0: State, state1: State,
tolerance: float = TOLERANCE) -> bool:
"""Returns True if states are almost identical.
Closeness is measured with the metric Fubini-Study angle.
"""
return vectors_close(state0.vec, state1.vec, tolerance) | python | {
"resource": ""
} |
q230180 | purity | train | def purity(rho: Density) -> bk.BKTensor:
"""
Calculate the purity of a mixed quantum state.
Purity, defined as tr(rho^2), has an upper bound of 1 for a pure state,
and a lower bound of 1/D (where D is the Hilbert space dimension) for a
competently mixed state.
Two closely related measures are ... | python | {
"resource": ""
} |
q230181 | bures_distance | train | def bures_distance(rho0: Density, rho1: Density) -> float:
"""Return the Bures distance between mixed quantum states
Note: Bures distance cannot be calculated within the tensor backend.
"""
fid = fidelity(rho0, rho1)
op0 = asarray(rho0.asoperator())
op1 = asarray(rho1.asoperator())
tr0 = np... | python | {
"resource": ""
} |
q230182 | bures_angle | train | def bures_angle(rho0: Density, rho1: Density) -> float:
"""Return the Bures angle between mixed quantum states
Note: Bures angle cannot be calculated within the tensor backend.
"""
return np.arccos(np.sqrt(fidelity(rho0, rho1))) | python | {
"resource": ""
} |
q230183 | density_angle | train | def density_angle(rho0: Density, rho1: Density) -> bk.BKTensor:
"""The Fubini-Study angle between density matrices"""
return fubini_study_angle(rho0.vec, rho1.vec) | python | {
"resource": ""
} |
q230184 | densities_close | train | def densities_close(rho0: Density, rho1: Density,
tolerance: float = TOLERANCE) -> bool:
"""Returns True if densities are almost identical.
Closeness is measured with the metric Fubini-Study angle.
"""
return vectors_close(rho0.vec, rho1.vec, tolerance) | python | {
"resource": ""
} |
q230185 | entropy | train | def entropy(rho: Density, base: float = None) -> float:
"""
Returns the von-Neumann entropy of a mixed quantum state.
Args:
rho: A density matrix
base: Optional logarithm base. Default is base e, and entropy is
measures in nats. For bits set base to 2.
Returns:
... | python | {
"resource": ""
} |
q230186 | mutual_info | train | def mutual_info(rho: Density,
qubits0: Qubits,
qubits1: Qubits = None,
base: float = None) -> float:
"""Compute the bipartite von-Neumann mutual information of a mixed
quantum state.
Args:
rho: A density matrix of the complete system
qubits... | python | {
"resource": ""
} |
q230187 | gate_angle | train | def gate_angle(gate0: Gate, gate1: Gate) -> bk.BKTensor:
"""The Fubini-Study angle between gates"""
return fubini_study_angle(gate0.vec, gate1.vec) | python | {
"resource": ""
} |
q230188 | channel_angle | train | def channel_angle(chan0: Channel, chan1: Channel) -> bk.BKTensor:
"""The Fubini-Study angle between channels"""
return fubini_study_angle(chan0.vec, chan1.vec) | python | {
"resource": ""
} |
q230189 | inner_product | train | def inner_product(vec0: QubitVector, vec1: QubitVector) -> bk.BKTensor:
""" Hilbert-Schmidt inner product between qubit vectors
The tensor rank and qubits must match.
"""
if vec0.rank != vec1.rank or vec0.qubit_nb != vec1.qubit_nb:
raise ValueError('Incompatibly vectors. Qubits and rank must ma... | python | {
"resource": ""
} |
q230190 | outer_product | train | def outer_product(vec0: QubitVector, vec1: QubitVector) -> QubitVector:
"""Direct product of qubit vectors
The tensor ranks must match and qubits must be disjoint.
"""
R = vec0.rank
R1 = vec1.rank
N0 = vec0.qubit_nb
N1 = vec1.qubit_nb
if R != R1:
raise ValueError('Incompatibly... | python | {
"resource": ""
} |
q230191 | vectors_close | train | def vectors_close(vec0: QubitVector, vec1: QubitVector,
tolerance: float = TOLERANCE) -> bool:
"""Return True if vectors in close in the projective Hilbert space.
Similarity is measured with the Fubini–Study metric.
"""
if vec0.rank != vec1.rank:
return False
if vec0.qubi... | python | {
"resource": ""
} |
q230192 | QubitVector.flatten | train | def flatten(self) -> bk.BKTensor:
"""Return tensor with with qubit indices flattened"""
N = self.qubit_nb
R = self.rank
return bk.reshape(self.tensor, [2**N]*R) | python | {
"resource": ""
} |
q230193 | QubitVector.relabel | train | def relabel(self, qubits: Qubits) -> 'QubitVector':
"""Return a copy of this vector with new qubits"""
qubits = tuple(qubits)
assert len(qubits) == self.qubit_nb
vec = copy(self)
vec.qubits = qubits
return vec | python | {
"resource": ""
} |
q230194 | QubitVector.H | train | def H(self) -> 'QubitVector':
"""Return the conjugate transpose of this tensor."""
N = self.qubit_nb
R = self.rank
# (super) operator transpose
tensor = self.tensor
tensor = bk.reshape(tensor, [2**(N*R//2)] * 2)
tensor = bk.transpose(tensor)
tensor = bk.r... | python | {
"resource": ""
} |
q230195 | QubitVector.norm | train | def norm(self) -> bk.BKTensor:
"""Return the norm of this vector"""
return bk.absolute(bk.inner(self.tensor, self.tensor)) | python | {
"resource": ""
} |
q230196 | QubitVector.partial_trace | train | def partial_trace(self, qubits: Qubits) -> 'QubitVector':
"""
Return the partial trace over some subset of qubits"""
N = self.qubit_nb
R = self.rank
if R == 1:
raise ValueError('Cannot take trace of vector')
new_qubits: List[Qubit] = list(self.qubits)
... | python | {
"resource": ""
} |
q230197 | fit_zyz | train | def fit_zyz(target_gate):
"""
Tensorflow 2.0 example. Given an arbitrary one-qubit gate, use
gradient descent to find corresponding parameters of a universal ZYZ
gate.
"""
steps = 1000
dev = '/gpu:0' if bk.DEVICE == 'gpu' else '/cpu:0'
with tf.device(dev):
t = tf.Variable(tf.r... | python | {
"resource": ""
} |
q230198 | Program.run | train | def run(self, ket: State = None) -> State:
"""Compiles and runs a program. The optional program argument
supplies the initial state and memory. Else qubits and classical
bits start from zero states.
"""
if ket is None:
qubits = self.qubits
ket = zero_state... | python | {
"resource": ""
} |
q230199 | Gate.relabel | train | def relabel(self, qubits: Qubits) -> 'Gate':
"""Return a copy of this Gate with new qubits"""
gate = copy(self)
gate.vec = gate.vec.relabel(qubits)
return gate | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.