#
# Copyright 2021 Keysight Technologies Inc.
#

"""
Defining Custom Compilers
=========================
"""

#%%
# A :py:class:`~trueq.compilation.Compiler` instance contains a list of
# :py:class:`~trueq.compilation.base.Pass` instances. During compilation of a circuit,
# each of these passes are executed, in order, to mutate a copy of the circuit. See the
# :doc:`compiler API page<../../api/compilation>` for a complete list of
# built-in passes and their documentation.

#%%
# Predefined Pass Lists
# ---------------------
# Several useful combinations of pass classes are provided as members of the
# compiler class: :py:attr:`~trueq.compilation.Compiler.HARDWARE_PASSES`\,
# :py:attr:`~trueq.compilation.Compiler.SIMPLIFY_PASSES`\,
# :py:attr:`~trueq.compilation.Compiler.RC_PASSES`\, and
# :py:attr:`~trueq.compilation.Compiler.NATIVE2Q_PASSES`\. See their documentation for
# further details.
#
# Note that these pass classes need to be instantiated before they can be given to the
# compiler constructor. For certain types of advanced usage, directly invoking the
# constructor may be the preferred method. However, the compiler also has two static
# covenience methods to automate pass instantiation:
# :py:meth:`~trueq.compilation.Compiler.from_config` and
# :py:meth:`~trueq.compilation.Compiler.basic`\. The first of these uses a
# :py:class:`~trueq.Config` object to pass relevant gate factories to each pass, and the
# second is a further specialization that auto-instantiates these factories based on
# a desired entangling gate and mode (which may not be relevant to all passes).

import trueq as tq

# a compiler to simplify circuits
compiler1 = tq.Compiler.basic(passes=tq.Compiler.SIMPLIFY_PASSES)

# a compiler that does randomized compiling
compiler2 = tq.Compiler.basic(passes=tq.Compiler.RC_PASSES)

# a compiler that decomposes two-qubit gates into the specified entangling gate,
# then randomly compiles, and then converts all gates into hardware compatable gates.
# for this example, we use the maximally entangling cross-resonance gate.
passes = (
    tq.Compiler.NATIVE2Q_PASSES + tq.Compiler.RC_PASSES + tq.Compiler.HARDWARE_PASSES
)
compiler3 = tq.Compiler.basic(entangler=tq.Gate.rp("ZX", 90), passes=passes)

#%%
# We demonstrate the last of these compilers by defining the following circuit:

circuit = tq.Circuit(
    [{range(4): tq.Gate.h}, {(0, 1): tq.Gate.rp("ZZ", 22), (2, 3): tq.Gate.cz}]
).measure_all()
circuit

#%%
# We see that the compiled circuit contains only CNOT gates, Z rotations, and X90
# rotations. Adjacent single qubit gates have been merged together on each qubit.
compiler3.compile(circuit)

#%%
# Custom Pass Lists
# -----------------
# Custom lists of passes can be used if none of the predifined lists have the desired
# behaviour. We can pass lists of these classes to
# :py:meth:`~trueq.compilation.Compiler.from_config` or
# :py:meth:`~trueq.compilation.Compiler.basic`\, as discussed above, or we can use the
# compiler constructor directly, as in the following example.
#
# First, we define a device configuration. Here, we use the Berkeley gate as the
# entangling operation.
b = tq.Gate.from_generators("XX", 90, "YY", 45)
config = tq.Config(
    factories=[
        tq.config.GateFactory.from_matrix("B", b),
        tq.config.GateFactory.from_hamiltonian("x90", [["X", 90]]),
        tq.config.GateFactory.from_hamiltonian("z", [["Z", "phi"]]),
    ],
    mode="ZXZXZ",
)


#%%
# Next, we define a compiler. Unlike,
# :py:attr:`~trueq.compilation.Compiler.HARDWARE_PASSES`, this compiler starts by
# merging adjacent two-qubit gates. Also, we know that any two qubit gate can be
# decomposed into two Berkeley gates interleaved with single qubit gates. We use
# :py:class:`tq.compilation.NativeDecomp` fixed at ``depth=2`` to force every
# two-qubit gate to decompose into two Berkeley gates, even if only one is required.
decomposer = tq.compilation.NativeDecomp(depth=2, factories=config.factories)
compiler = tq.Compiler(
    [
        tq.compilation.Merge(n_labels=2),
        tq.compilation.Parallel(decomposer),
        tq.compilation.Merge(),
        tq.compilation.Native1Q(config.factories),
        tq.compilation.RemoveEmptyCycle(),
    ]
)

#%%
# Next, we define a circuit to test this compiler on.
circuit = tq.Circuit(
    [
        {range(4): tq.Gate.h},
        {(0, 1): tq.Gate.rp("ZZ", 22)},
        {(0, 1): tq.Gate.cnot, (2, 3): tq.Gate.swap},
    ]
).measure_all()
circuit

#%%
# The resulting compiled circuit is as follows.
compiler.compile(circuit)