Adding a bunch of gates from the lab

mrmustard/lab_dev/states/__init__.py

@@ -20,8 +20,10 @@
 from .ket import Ket
 from .dm import DM
 
+from .bargmann_eigenstate import BargmannEigenstate
 from .coherent import Coherent
 from .displaced_squeezed import DisplacedSqueezed
+from .gstate import Gket, Gdm
 from .number import Number
 from .quadrature_eigenstate import QuadratureEigenstate
 from .squeezed_vacuum import SqueezedVacuum

mrmustard/lab_dev/states/bargmann_eigenstate.py

@@ -0,0 +1,67 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The class representing a Bargmann eigenstate.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from mrmustard.physics.ansatz import PolyExpAnsatz
+from mrmustard.physics import triples
+from .ket import Ket
+from ..utils import make_parameter
+
+__all__ = ["BargmannEigenstate"]
+
+
+class BargmannEigenstate(Ket):
+    r"""
+    The `N`-mode Bargmann eigenstate.
+
+    .. code-block ::
+
+        >>> from mrmustard.lab_dev import BargmannEigenstate
+
+        >>> state = BargmannEigenstate([1, 2], [0.1, 0.5j])
+        >>> assert state.modes == [1, 2]
+
+    Args:
+        modes: A list of modes.
+        alpha: The displacement of the state (i.e., the eigen-value).
+
+    .. details::
+        Its ``(A,b,c)`` triple is given by
+        .. math::
+            A = 0 , b = alpha, c = 1.
+    """
+
+    short_name = "Be"
+
+    def __init__(
+        self,
+        modes: Sequence[int],
+        alpha: float | Sequence[float] = 0.0,
+        alpha_trainable: bool = False,
+        alpha_bounds: tuple[float | None, float | None] = (None, None),
+    ):
+        super().__init__(name="BargmannEigenstate")
+
+        self._add_parameter(make_parameter(alpha_trainable, alpha, "alpha", alpha_bounds))
+        self._representation = self.from_ansatz(
+            modes=modes,
+            ansatz=PolyExpAnsatz.from_function(fn=triples.bargmann_eigenstate_Abc, x=self.alpha),
+        ).representation

mrmustard/lab_dev/states/gstate.py

@@ -0,0 +1,116 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Classes that are initialized by a symplectic matrix and possibly thermal states if we have a DM.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from mrmustard import math
+from mrmustard.math.parameters import update_symplectic
+from mrmustard.physics.ansatz import PolyExpAnsatz
+from mrmustard.physics import triples
+from mrmustard.utils.typing import RealMatrix
+from .ket import Ket
+from .dm import DM
+from ..utils import make_parameter
+
+__all__ = ["Gket", "Gdm"]
+
+
+class Gket(Ket):
+    r"""
+    The `N`-mode pure state described by a Gaussian gate that acts on Vacuum.
+    """
+
+    short_name = "Gk"
+
+    def __init__(
+        self,
+        modes: Sequence[int],
+        symplectic: RealMatrix = None,
+        symplectic_trainable: bool = False,
+    ) -> None:
+        super().__init__(name="Gket")
+        m = len(modes)
+        if symplectic is None:
+            symplectic = math.random_symplectic(m)
+
+        self._add_parameter(
+            make_parameter(
+                symplectic_trainable,
+                symplectic,
+                "symplectic",
+                (None, None),
+                update_symplectic,
+            )
+        )
+
+        self._representation = self.from_ansatz(
+            modes=modes,
+            ansatz=PolyExpAnsatz.from_function(
+                fn=triples.gket_state_Abc, symplectic=self.symplectic
+            ),
+        ).representation
+
+
+class Gdm(DM):
+    r"""
+    The `N`-mode mixed state described by a Gaussian gate that acts on a given thermal state.
+    """
+
+    short_name = "Gd"
+
+    def __init__(
+        self,
+        modes: Sequence[int],
+        betas: float | Sequence[float],
+        symplectic: RealMatrix = None,
+        symplectic_trainable: bool = False,
+        betas_trainable: bool = False,
+    ) -> None:
+        super().__init__(name="Gdm")
+        m = len(modes)
+
+        if symplectic is None:
+            symplectic = math.random_symplectic(m)
+
+        self._add_parameter(
+            make_parameter(
+                symplectic_trainable,
+                symplectic,
+                "symplectic",
+                (None, None),
+                update_symplectic,
+            )
+        )
+
+        self._add_parameter(
+            make_parameter(
+                betas_trainable,
+                math.astensor(betas),
+                "betas",
+                (0, None),
+            )
+        )
+
+        self._representation = self.from_ansatz(
+            modes=modes,
+            ansatz=PolyExpAnsatz.from_function(
+                fn=triples.gdm_state_Abc, betas=self.betas, symplectic=symplectic
+            ),
+        ).representation

mrmustard/lab_dev/states/ket.py

@@ -172,7 +172,7 @@ def random(cls, modes: Sequence[int], max_r: float = 1.0) -> Ket:
         S = math.random_symplectic(m, max_r)
         transformation = (
             1
-            / np.sqrt(2)
+            / math.sqrt(complex(2))
             * math.block(
                 [
                     [

mrmustard/lab_dev/transformations/__init__.py

@@ -21,12 +21,18 @@
 from .base import *
 from .bsgate import *
 from .cft import *
+from .cxgate import *
+from .czgate import *
 from .dgate import *
 from .fockdamping import *
 from .ggate import *
 from .gaussrandnoise import *
 from .identity import *
+from .interferometer import *
+from .mzgate import *
+from .pgate import *
 from .phasenoise import *
+from .realinterferometer import *
 from .rgate import *
 from .s2gate import *
 from .sgate import *

mrmustard/lab_dev/transformations/cxgate.py

@@ -0,0 +1,81 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The class representing a controlled-X gate.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+from mrmustard import math
+from mrmustard.physics.ansatz import PolyExpAnsatz
+
+from .base import Unitary
+from ..utils import make_parameter
+
+__all__ = ["CXgate"]
+
+
+class CXgate(Unitary):
+    r"""Controlled X gate.
+
+    It applies to a single pair of modes. One can optionally set bounds for each parameter, which
+    the optimizer will respect.
+
+    .. math::
+
+        C_X = \exp(is q_1 \otimes p_2).
+
+    Reference: https://arxiv.org/pdf/2110.03247.pdf, Equation 9.
+
+
+    Args:
+        modes (optional, Sequance[int]): the list of modes this gate is applied to
+        s (float): control parameter
+        s_bounds (float, float): bounds for the control angle
+        s_trainable (bool): whether s is a trainable variable
+    """
+
+    short_name = "CX"
+
+    def __init__(
+        self,
+        modes: Sequence[int],
+        s: float = 0.0,
+        s_trainable: bool = False,
+        s_bounds: tuple[float | None, float | None] = (None, None),
+    ):
+        if len(modes) != 2:
+            raise ValueError(
+                f"The number of modes for a CXgate must be 2 (your input has {len(modes)} many modes)."
+            )
+        super().__init__(name="CXgate")
+        self._add_parameter(make_parameter(s_trainable, s, "s", s_bounds))
+        symplectic = math.astensor(
+            [
+                [1, 0, 0, 0],
+                [s, 1, 0, 0],
+                [0, 0, 1, -s],
+                [0, 0, 0, 1],
+            ],
+            dtype="complex128",
+        )
+        self._representation = self.from_ansatz(
+            modes_in=modes,
+            modes_out=modes,
+            ansatz=PolyExpAnsatz.from_function(
+                fn=lambda sym: Unitary.from_symplectic(modes, sym).bargmann_triple(), sym=symplectic
+            ),
+        ).representation

mrmustard/lab_dev/transformations/czgate.py

@@ -0,0 +1,82 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The class representing a controlled-phase gate.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+from mrmustard import math
+from mrmustard.physics.ansatz import PolyExpAnsatz
+
+from .base import Unitary
+from ..utils import make_parameter
+
+__all__ = ["CZgate"]
+
+
+class CZgate(Unitary):
+    r"""Controlled Z gate.
+
+    It applies to a single pair of modes. One can optionally set bounds for each parameter, which
+    the optimizer will respect.
+
+    .. math::
+
+        C_Z = \exp(ig q_1 \otimes q_2 / \hbar).
+
+
+    Reference: https://arxiv.org/pdf/2110.03247.pdf, Equation 8.
+    https://arxiv.org/pdf/1110.3234.pdf, Equation 161.
+
+
+    Args:
+        modes (optional, Sequence[int]): the list of modes this gate is applied to
+        s (float): control parameter
+        s_bounds (float, float): bounds for the control angle
+        s_trainable (bool): whether s is a trainable variable
+    """
+
+    short_name = "CZ"
+
+    def __init__(
+        self,
+        modes: Sequence[int],
+        s: float = 0.0,
+        s_trainable: bool = False,
+        s_bounds: tuple[float | None, float | None] = (None, None),
+    ):
+        if len(modes) != 2:
+            raise ValueError(
+                f"The number of modes for a CZgate must be 2 (your input has {len(modes)} many modes)."
+            )
+        super().__init__(name="CZgate")
+        self._add_parameter(make_parameter(s_trainable, s, "s", s_bounds))
+        symplectic = math.astensor(
+            [
+                [1, 0, 0, 0],
+                [0, 1, 0, 0],
+                [0, s, 1, 0],
+                [s, 0, 0, 1],
+            ]
+        )
+        self._representation = self.from_ansatz(
+            modes_in=modes,
+            modes_out=modes,
+            ansatz=PolyExpAnsatz.from_function(
+                fn=lambda sym: Unitary.from_symplectic(modes, sym).bargmann_triple(), sym=symplectic
+            ),
+        ).representation