# Source code for pennylane.optimize.rotosolve

# Copyright 2018-2021 Xanadu Quantum Technologies Inc.

# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at

# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# pylint: disable=too-many-branches,cell-var-from-loop

from inspect import signature
import numpy as np
from scipy.optimize import brute, shgo

import pennylane as qml

def _brute_optimizer(fun, num_steps, bounds=None, **kwargs):
r"""Brute force optimizer, wrapper of scipy.optimize.brute that repeats it
num_steps times. Signature is as expected by RotosolveOptimizer._min_numeric
below, returning a scalar minimal position and the function value at that position."""
Ns = kwargs.pop("Ns")
width = bounds[0][1] - bounds[0][0]
center = (bounds[0][1] + bounds[0][0]) / 2
for _ in range(num_steps):
range_ = (center - width / 2, center + width / 2)
center, y_min, *_ = brute(fun, ranges=(range_,), full_output=True, Ns=Ns, **kwargs)
# We only ever use this function for 1D optimization
center = center[0]
width /= Ns

return center, y_min

def _shgo_optimizer(fun, **kwargs):
r"""Wrapper for scipy.optimize.shgo (Simplicial Homology global optimizer).
Signature is as expected by RotosolveOptimizer._min_numeric below, providing
a scalar minimal position and the function value at that position."""
opt_res = shgo(fun, **kwargs)
return opt_res.x[0], opt_res.fun

"""Checks that for each trainable argument either the number of
frequencies or the frequency spectrum is given."""

raise ValueError(
"Found no parameters to optimize. The parameters to optimize "
"have to be marked as trainable."
)
_nums_frequency = nums_frequency.get(arg_name, {})
_spectra = spectra.get(arg_name, {})
all_keys = set(_nums_frequency) | set(_spectra)

shape = qml.math.shape(arg)
indices = np.ndindex(shape) if len(shape) > 0 else [()]
for par_idx in indices:
if par_idx not in all_keys:
raise ValueError(
"Neither the number of frequencies nor the frequency spectrum "
f"was provided for the entry {par_idx} of argument {arg_name}."
)

def _restrict_to_univariate(fn, arg_idx, par_idx, args, kwargs):
r"""Restrict a function to a univariate function for given argument
and parameter indices.

Args:
fn (callable): Multivariate function
arg_idx (int): Index of the argument that contains the parameter to restrict
par_idx (tuple[int]): Index of the parameter to restrict to within the argument
args (tuple): Arguments at which to restrict the function.
kwargs (dict): Keyword arguments at which to restrict the function.

Returns:
callable: Univariate restriction of fn. That is, this callable takes
a single float value as input and has the same return type as fn.
All arguments are set to the given args and the input value to this
function is added to the marked parameter.
"""
the_arg = args[arg_idx]
if len(qml.math.shape(the_arg)) == 0:
shift_vec = qml.math.ones_like(the_arg)
else:
shift_vec = qml.math.zeros_like(the_arg)

def _univariate_fn(x):
return fn(*args[:arg_idx], the_arg + shift_vec * x, *args[arg_idx + 1 :], **kwargs)

return _univariate_fn

[docs]class RotosolveOptimizer:

The Rotosolve optimizer minimizes an objective function with respect to the parameters of a
quantum circuit without the need for calculating the gradient of the function. The algorithm
updates the parameters :math:\boldsymbol{\theta} = \theta_1, \dots, \theta_D by
separately reconstructing the cost function with respect to each circuit parameter,
while keeping all other parameters fixed.

Args:
substep_optimizer (str or callable): Optimizer to use for the substeps of Rotosolve
that carries out a univariate (i.e., single-parameter) global optimization.
*Only used if there are more than one frequency for a given parameter.*
It must take as inputs:

- A function fn that maps scalars to scalars,

- the (keyword) argument bounds, and

- optional keyword arguments.

It must return two scalars:

- The input value x_min for which fn is minimal, and

- the minimal value y_min=fn(x_min) or None.

Alternatively, the following optimizers are built-in and can be chosen by
passing their name:

- "brute": An iterative version of
SciPy's brute force optimizer <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brute.html>_.
It evaluates the function at Ns equidistant points across the range
:math:[-\pi, \pi] and iteratively refines the range around the point
with the smallest cost value for num_steps times.

- "shgo": SciPy's SHGO optimizer <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.shgo.html>_.

substep_kwargs (dict): Keyword arguments to be passed to the substep_optimizer
callable. For substep_optimizer="shgo", the original keyword arguments of
the SciPy implementation are available, for substep_optimizer="brute" the
keyword arguments ranges, Ns and num_steps are useful.
*Only used if there are more than one frequency for a given parameter.*

For each parameter, a purely classical one-dimensional global optimization over the
interval :math:(-\pi,\pi] is performed, which is replaced automatically by a
closed-form expression for the optimal value if the :math:d\text{th} parametrized
gate has only two eigenvalues. This means that substep_optimizer and
substep_kwargs will not be used for these parameters.
In this case, the optimal value :math:\theta^*_d is given analytically by

.. math::

\theta^*_d &= \underset{\theta_d}{\text{argmin}}\left<H\right>_{\theta_d}\\
&= -\frac{\pi}{2} - \text{arctan2}\left(2\left<H\right>_{\theta_d=0}
- \left<H\right>_{\theta_d=\pi/2} - \left<H\right>_{\theta_d=-\pi/2},
\left<H\right>_{\theta_d=\pi/2} - \left<H\right>_{\theta_d=-\pi/2}\right),

where :math:\left<H\right>_{\theta_d} is the expectation value of the objective function
restricted to only depend on the parameter :math:\theta_d.

.. warning::

The built-in one-dimensional optimizers "brute" and "shgo" for the substeps
of a Rotosolve optimization step use the interval :math:(-\pi,\pi], rescaled with
the inverse smallest frequency as default domain to optimize over. For complicated
cost functions, this domain might not be suitable for the substep optimization and
an appropriate range should be passed via bounds in substep_kwargs.

The algorithm is described in further detail in
Vidal and Theis (2018) <https://arxiv.org/abs/1812.06323>_,
Nakanishi, Fujii and Todo (2019) <https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.2.043158>_,
Parrish et al. (2019) <https://arxiv.org/abs/1904.03206>_,
and
Ostaszewski et al. (2019) <https://quantum-journal.org/papers/q-2021-01-28-391/>_,
and the reconstruction method used for more general operations is described in
Wierichs et al. (2022) <https://doi.org/10.22331/q-2022-03-30-677>_.

.. warning::

RotosolveOptimizer will only update parameters that are *explicitly*
marked as trainable. This can be done via requires_grad if using Autograd
or PyTorch. RotosolveOptimizer is not yet implemented to work in a stable
manner with TensorFlow or JAX.

**Example:**

Initialize the optimizer and set the number of steps to optimize over.
Recall that the optimization with RotosolveOptimizer uses global optimization substeps
of univariate functions. The optimization technique for these substeps can be chosen via the
substep_optimizer and substep_kwargs keyword arguments.
Here we use the built-in iterative version of
SciPy's brute force optimizer <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brute.html>_
with four iterations.
We will run Rotosolve itself for three iterations.

>>> opt_kwargs = {"num_steps": 4}
>>> opt = qml.optimize.RotosolveOptimizer(substep_optimizer="brute", substep_kwargs=opt_kwargs)
>>> num_steps = 3

Next, we create a QNode we wish to optimize:

.. code-block :: python

dev = qml.device('default.qubit', wires=3, shots=None)

@qml.qnode(dev)
def cost_function(rot_param, layer_par, crot_param, rot_weights=None, crot_weights=None):
for i, par in enumerate(rot_param * rot_weights):
qml.RX(par, wires=i)
for w in dev.wires:
qml.RX(layer_par, wires=w)
for i, par in enumerate(crot_param*crot_weights):
qml.CRY(par, wires=[i, (i+1)%3])
return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1) @ qml.PauliZ(2))

This QNode is defined simply by measuring the expectation value of the tensor
product of PauliZ operators on all qubits.
It takes three parameters:

- rot_param controls three Pauli rotations with three parameters, multiplied with rot_weights,
- layer_par feeds into a layer of rotations with a single parameter, and
- crot_param feeds three parameters, multiplied with crot_weights, into
three controlled Pauli rotations.

We also initialize a set of parameters for all these operations, and start with
uniform weights, i.e., all rot_weights and crot_weights are set to one.
This means that all frequencies with which the parameters in rot_param and
crot_param enter the QNode are integer-valued.
The number of frequencies per parameter are summarized in nums_frequency.

.. code-block :: python

init_param = (
)
rot_weights = np.ones(3)
crot_weights = np.ones(3)

nums_frequency = {
"rot_param": {(0,): 1, (1,): 1, (2,): 1},
"layer_par": {(): 3},
"crot_param": {(0,): 2, (1,): 2, (2,): 2},
}

The keyword argument requires_grad can be used to determine whether the respective
parameter should be optimized or not, following the behaviour of gradient computations and
With TensorFlow, a tf.Variable inside a tf.GradientTape may be used to
mark variables as trainable.

Now we carry out the optimization.
The minimized cost of the intermediate univariate reconstructions can
be read out via full_output, including the cost *after* the full Rotosolve step:

>>> param = init_param
>>> cost_rotosolve = []
>>> for step in range(num_steps):
...     param, cost, sub_cost = opt.step_and_cost(
...         cost_function,
...         *param,
...         nums_frequency=nums_frequency,
...         full_output=True,
...         rot_weights=rot_weights,
...         crot_weights=crot_weights,
...     )
...     print(f"Cost before step: {cost}")
...     print(f"Minimization substeps: {np.round(sub_cost, 6)}")
...     cost_rotosolve.extend(sub_cost)
Cost before step: 0.04200821039253547
Minimization substeps: [-0.230905 -0.863336 -0.980072 -0.980072 -1.       -1.       -1.      ]
Cost before step: -0.9999999990681161
Minimization substeps: [-1. -1. -1. -1. -1. -1. -1.]
Cost before step: -0.9999999999999996
Minimization substeps: [-1. -1. -1. -1. -1. -1. -1.]

The optimized values for the parameters are now stored in param
and the optimization behaviour can be assessed by plotting cost_rotosolve,
which include the substeps of the Rotosolve optimization.
The full_output feature is available for both, step and step_and_cost.

In general, the frequencies in a QNode will not be integer-valued, requiring us
to provide the RotosolveOptimizer not only with the number of frequencies
but their concrete values. For the example QNode above, this happens if the
weights are no longer one:

>>> rot_weights = np.array([0.4, 0.8, 1.2], requires_grad=False)
>>> crot_weights = np.array([0.5, 1.0, 1.5], requires_grad=False)
>>> spectrum_fn = qml.fourier.qnode_spectrum(cost_function)
>>> spectra = spectrum_fn(*param, rot_weights=rot_weights, crot_weights=crot_weights)
>>> spectra["rot_param"]
{(0,): [-0.4, 0.0, 0.4], (1,): [-0.8, 0.0, 0.8], (2,): [-1.2, 0.0, 1.2]}
>>> spectra["crot_param"]
{(0,): [-0.5, -0.25, 0.0, 0.25, 0.5], (1,): [-1.0, -0.5, 0.0, 0.5, 1.0], (2,): [-1.5, -0.75, 0.0, 0.75, 1.5]}

We may provide these spectra instead of nums_frequency to Rotosolve to
enable the optimization of the QNode at these weights:

>>> param = init_param
>>> for step in range(num_steps):
...     param, cost, sub_cost = opt.step_and_cost(
...         cost_function,
...         *param,
...         spectra=spectra,
...         full_output=True,
...         rot_weights = rot_weights,
...         crot_weights = crot_weights,
...     )
...     print(f"Cost before step: {cost}")
...     print(f"Minimization substeps: {np.round(sub_cost, 6)}")
Cost before step: 0.09299359486191039
Minimization substeps: [-0.268008 -0.713209 -0.24993  -0.871989 -0.907672 -0.907892 -0.940474]
Cost before step: -0.9404742138557066
Minimization substeps: [-0.940474 -1.       -1.       -1.       -1.       -1.       -1.      ]
Cost before step: -1.0
Minimization substeps: [-1. -1. -1. -1. -1. -1. -1.]

As we can see, while the optimization got a bit harder and the optimizer takes a bit longer
to converge than previously, Rotosolve was able to adapt to the more complicated
dependence on the input arguments and still found the global minimum successfully.
"""
# pylint: disable=too-few-public-methods

def __init__(self, substep_optimizer="brute", substep_kwargs=None):
self.substep_kwargs = {} if substep_kwargs is None else substep_kwargs
if substep_optimizer == "brute":
self.substep_optimizer = _brute_optimizer
self.substep_kwargs.setdefault("num_steps", 4)
self.substep_kwargs.setdefault("Ns", 100)
elif substep_optimizer == "shgo":
self.substep_optimizer = _shgo_optimizer
else:
self.substep_optimizer = substep_optimizer

[docs]    def step_and_cost(
self,
objective_fn,
*args,
nums_frequency=None,
spectra=None,
shifts=None,
full_output=False,
**kwargs,
):
r"""Update args with one step of the optimizer and return the corresponding objective
function value prior to the step. Each step includes multiple substeps, one per
parameter.

Args:
objective_fn (function): the objective function for optimization. It should take a
sequence of the values *args and a list of the gates generators as inputs,
and return a single value.
*args (Sequence): variable length sequence containing the initial values of the
variables to be optimized over or a single float with the initial value.
nums_frequency (dict[dict]): The number of frequencies in the objective_fn per
parameter. The keys must correspond to argument names of the objective
function, the values must be dictionaries that map parameter indices (tuple)
in the argument to the number of frequencies with which it enters the objective
function (int).
The parameter index for a scalar QNode argument is (), for
one-dimensional array QNode arguments, it takes the form (i,) for the
i-th parameter in the argument.
spectra (dict[dict]): Frequency spectra in the objective_fn per parameter.
The formatting is the same as for nums_frequency, but the values
of the inner dictionaries must be sequences of frequencies
(Sequence[float]).
For each parameter, num_frequency take precedence over spectra.
shifts (dict[dict]): Shift angles for the reconstruction per QNode parameter.
The keys have to be argument names of qnode and the inner dictionaries have to
be mappings from parameter indices to the respective shift angles to be used for
that parameter. For :math:R non-zero frequencies, there must be :math:2R+1
shifts given. Ignored if nums_frequency gives a number of frequencies
for the respective parameter in the QNode argument.
full_output (bool): whether to return the intermediate minimized energy values from
the univariate optimization substeps.
**kwargs : variable length keyword arguments for the objective function.

Returns:
list [array] or array: the new variable values :math:x^{(t+1)}.
If a single arg is provided, list [array] is replaced by array.
float: the objective function output prior to the step.
list [float]: the intermediate objective values, only returned if
full_output=True.

The optimization step consists of multiple substeps.

For each substep,
one of the parameters in one of the QNode arguments is singled out, and the
objective function is considered as univariate function (i.e., function that
depends on a single scalar) of that parameter.

If nums_frequency states that there is only a single frequency, or spectra
only contains one positive frequency, for a parameter, an analytic formula is
used to return the minimum of the univariate restriction.

For multiple frequencies, :func:.fourier.reconstruct is used to reconstruct
the univariate restriction and a numeric minimization is performed instead.
The latter minimization is performed using the substep_optimizer passed to
RotosolveOptimizer at initialization.

.. note::

One of nums_frequency and spectra must contain information
about each parameter that is to be trained with RotosolveOptimizer.
For each univariate reconstruction, the data in nums_frequency takes
precedence over the information in spectra.

"""
# todo: does this signature call cover all cases?
sign_fn = objective_fn.func if isinstance(objective_fn, qml.QNode) else objective_fn
arg_names = list(signature(sign_fn).parameters.keys())
arg_name: qml.math.requires_grad(arg) for arg_name, arg in zip(arg_names, args)
}
nums_frequency = nums_frequency or {}
spectra = spectra or {}

# we will single out one arg to change at a time
# the following hold the arguments not getting updated
before_args = []
after_args = list(args)

# Prepare intermediate minimization results cache
if full_output:
y_output = []
# Compute the very first evaluation in order to be able to cache it
fun_at_zero = objective_fn(*args, **kwargs)
first_substep_in_step = True

for arg_idx, (arg, arg_name) in enumerate(zip(args, arg_names)):
del after_args[0]

before_args.append(arg)
continue
shape = qml.math.shape(arg)
indices = np.ndindex(shape) if len(shape) > 0 else [()]
for par_idx in indices:
_fun_at_zero = fun_at_zero if first_substep_in_step else None
# Set a single parameter in a single argument to be reconstructed
num_freq = nums_frequency.get(arg_name, {}).get(par_idx, None)
spectrum = spectra.get(arg_name, {}).get(par_idx, None)
if spectrum is not None:
spectrum = np.array(spectrum)

if num_freq == 1 or (spectrum is not None and len(spectrum[spectrum > 0])) == 1:
_args = before_args + [arg] + after_args
univariate = _restrict_to_univariate(
objective_fn, arg_idx, par_idx, _args, kwargs
)
freq = 1.0 if num_freq is not None else spectrum[spectrum > 0][0]
x_min, y_min = self.min_analytic(univariate, freq, _fun_at_zero)

else:
ids = {arg_name: (par_idx,)}
_nums_frequency = (
{arg_name: {par_idx: num_freq}} if num_freq is not None else None
)
_spectra = {arg_name: {par_idx: spectrum}} if spectrum is not None else None

# Set up the reconstruction function
recon_fn = qml.fourier.reconstruct(
objective_fn, ids, _nums_frequency, _spectra, shifts
)
# Perform the reconstruction
recon = recon_fn(*before_args, arg, *after_args, f0=_fun_at_zero, **kwargs)[
arg_name
][par_idx]
if spectrum is None:
spectrum = list(range(num_freq + 1))
x_min, y_min = self._min_numeric(recon, spectrum)

# Update the currently treated argument
arg = qml.math.scatter_element_add(arg, par_idx, x_min - arg[par_idx])
first_substep_in_step = False

if full_output:
y_output.append(y_min)

# updating before_args for next argument
before_args.append(arg)

# All arguments have been updated and/or passed to before_args
args = before_args
# unwrap arguments if only one, backward compatible and cleaner
if len(args) == 1:
args = args[0]

if full_output:
return args, fun_at_zero, y_output

return args, fun_at_zero

[docs]    def step(
self,
objective_fn,
*args,
nums_frequency=None,
spectra=None,
shifts=None,
full_output=False,
**kwargs,
):
r"""Update args with one step of the optimizer. Each step includes
multiple substeps, one per parameter.

Args:
objective_fn (function): the objective function for optimization. It should take a
sequence of the values *args and a list of the gates generators as inputs,
and return a single value.
*args (Sequence): variable length sequence containing the initial values of the
variables to be optimized over or a single float with the initial value.
nums_frequency (dict[dict]): The number of frequencies in the objective_fn per
parameter. The keys must correspond to argument names of the objective
function, the values must be dictionaries that map parameter indices (tuple)
in the argument to the number of frequencies with which it enters the objective
function (int).
The parameter index for a scalar QNode argument is (), for
one-dimensional array QNode arguments, it takes the form (i,) for the
i-th parameter in the argument.
spectra (dict[dict]): Frequency spectra in the objective_fn per parameter.
The formatting is the same as for nums_frequency, but the values
of the inner dictionaries must be sequences of frequencies
(Sequence[float]).
For each parameter, num_frequency take precedence over spectra.
shifts (dict[dict]): Shift angles for the reconstruction per QNode parameter.
The keys have to be argument names of qnode and the inner dictionaries have to
be mappings from parameter indices to the respective shift angles to be used for
that parameter. For :math:R non-zero frequencies, there must be :math:2R+1
shifts given. Ignored if nums_frequency gives a number of frequencies
for the respective parameter in the QNode argument.
full_output (bool): whether to return the intermediate minimized energy values from
the univariate optimization substeps.
**kwargs : variable length keyword arguments for the objective function.

Returns:
list [array] or array: the new variable values :math:x^{(t+1)}.
If a single arg is provided, list [array] is replaced by array.
list [float]: the intermediate objective values, only returned if
full_output=True.

The optimization step consists of multiple substeps.

For each substep,
one of the parameters in one of the QNode arguments is singled out, and the
objective function is considered as univariate function (i.e., function that
depends on a single scalar) of that parameter.

If nums_frequency states that there is only a single frequency, or spectra
only contains one positive frequency, for a parameter, an analytic formula is
used to return the minimum of the univariate restriction.

For multiple frequencies, :func:.fourier.reconstruct is used to reconstruct
the univariate restriction and a numeric minimization is performed instead.
The latter minimization is performed using the substep_optimizer passed to
RotosolveOptimizer at initialization.

.. note::

One of nums_frequency and spectra must contain information
about each parameter that is to be trained with RotosolveOptimizer.
For each univariate reconstruction, the data in nums_frequency takes
precedence over the information in spectra.

"""
x_new, _, *y_output = self.step_and_cost(
objective_fn,
*args,
nums_frequency=nums_frequency,
spectra=spectra,
shifts=shifts,
full_output=full_output,
**kwargs,
)
if full_output:
# For full_output=True, y_output was wrapped in an outer list due
# to the dynamic unpacking
return x_new, y_output[0]

return x_new

def _min_numeric(self, objective_fn, spectrum):
r"""Numerically minimize a trigonometric function that depends on a
single parameter. Uses potentially large numbers of function evaluations,
depending on the used substep_optimizer. The optimization method and
options are stored in RotosolveOptimizer.substep_optimizer
and RotosolveOptimizer.substep_kwargs.

Args:
objective_fn (callable): Trigonometric function to minimize

Returns:
float: Position of the minimum of objective_fn
float: Value of the minimum of objective_fn

The returned position is guaranteed to lie within :math:(-\pi, \pi].
"""
opt_kwargs = self.substep_kwargs.copy()
if "bounds" not in self.substep_kwargs:
spectrum = qml.math.array(spectrum)
half_width = np.pi / qml.math.min(spectrum[spectrum > 0])
opt_kwargs["bounds"] = ((-half_width, half_width),)

x_min, y_min = self.substep_optimizer(objective_fn, **opt_kwargs)
if y_min is None:
y_min = objective_fn(x_min)

return x_min, y_min

[docs]    @staticmethod
def min_analytic(objective_fn, freq, f0):
r"""Analytically minimize a trigonometric function that depends on a
single parameter and has a single frequency. Uses two or
three function evaluations.

Args:
objective_fn (callable): Trigonometric function to minimize
freq (float): Frequency :math:f in the objective_fn
f0 (float): Value of the objective_fn at zero. Reduces the
number of calls to the function from three to two if given.

Returns:
float: Position of the minimum of objective_fn
float: Value of the minimum of objective_fn

The closed form expression used here was derived in
Vidal & Theis (2018) <https://arxiv.org/abs/1812.06323>__ ,
Parrish et al (2019) <https://arxiv.org/abs/1904.03206>__ and
Ostaszewski et al (2021) <https://doi.org/10.22331/q-2021-01-28-391>__.
We use the notation of Appendix A of the last of these references,
although we allow for an arbitrary frequency instead of restricting
to :math:f=1.
The returned position is guaranteed to lie within :math:(-\pi/f, \pi/f].

The used formula for the minimization of the :math:d-\text{th}

.. math::

\theta^*_d &= \underset{\theta_d}{\text{argmin}}\left<H\right>_{\theta_d}\\
&= -\frac{\pi}{2f} - \frac{1}{f}\text{arctan2}\left(2\left<H\right>_{\theta_d=0}
- \left<H\right>_{\theta_d=\pi/(2f)} - \left<H\right>_{\theta_d=-\pi/(2f)},
\left<H\right>_{\theta_d=\pi/(2f)} - \left<H\right>_{\theta_d=-\pi/(2f)}\right),

"""
if f0 is None:
f0 = objective_fn(0.0)
shift = 0.5 * np.pi / freq
fp = objective_fn(shift)
fm = objective_fn(-shift)
C = 0.5 * (fp + fm)
B = np.arctan2(2 * f0 - fp - fm, fp - fm)
x_min = -shift - B / freq
A = np.sqrt((f0 - C) ** 2 + 0.25 * (fp - fm) ** 2)
y_min = -A + C

if x_min <= -2 * shift:
x_min = x_min + 4 * shift

return x_min, y_min


Using PennyLane

Development

API