Quantum++  v1.0-rc2
A modern C++11 quantum computing library
states.h
Go to the documentation of this file.
1 /*
2  * Quantum++
3  *
4  * Copyright (c) 2013 - 2017 Vlad Gheorghiu (vgheorgh@gmail.com)
5  *
6  * This file is part of Quantum++.
7  *
8  * Quantum++ is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * Quantum++ is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with Quantum++. If not, see <http://www.gnu.org/licenses/>.
20  */
21 
27 #ifndef CLASSES_STATES_H_
28 #define CLASSES_STATES_H_
29 
30 namespace qpp
31 {
36 class States final : public internal::Singleton<const States> // const Singleton
37 {
38  friend class internal::Singleton<const States>;
39 
40 public:
41  // Pauli eigen-states
42  ket x0{ket::Zero(2)};
43  ket x1{ket::Zero(2)};
44  ket y0{ket::Zero(2)};
45  ket y1{ket::Zero(2)};
46  ket z0{ket::Zero(2)};
47  ket z1{ket::Zero(2)};
48 
49  // projectors onto Pauli eigen-states
50  cmat px0{cmat::Zero(2, 2)};
52  cmat px1{cmat::Zero(2, 2)};
54  cmat py0{cmat::Zero(2, 2)};
56  cmat py1{cmat::Zero(2, 2)};
58  cmat pz0{cmat::Zero(2, 2)};
60  cmat pz1{cmat::Zero(2, 2)};
62 
63  // Bell states
64  ket b00{ket::Zero(4)};
66  ket b01{ket::Zero(4)};
68  ket b10{ket::Zero(4)};
70  ket b11{ket::Zero(4)};
72 
73  // projectors onto Bell states
74  cmat pb00{cmat::Zero(4, 4)};
75  cmat pb01{cmat::Zero(4, 4)};
76  cmat pb10{cmat::Zero(4, 4)};
77  cmat pb11{cmat::Zero(4, 4)};
78 
79  // W and GHZ states
80  ket GHZ{ket::Zero(8)};
81  ket W{ket::Zero(8)};
82 
83  // projectors onto GHZ and W
84  cmat pGHZ{cmat::Zero(8, 8)};
85  cmat pW{cmat::Zero(8, 8)};
86 
94  ket mes(idx d = 2) const
95  {
96  // EXCEPTION CHECKS
97 
98  // check valid dims
99  if (d == 0)
100  throw exception::DimsInvalid("qpp::States::mes()");
101  // END EXCEPTION CHECKS
102 
103  ket psi = mket({0, 0}, {d, d});
104  for (idx i = 1; i < d; ++i)
105  {
106  psi += mket({i, i}, {d, d});
107  }
108 
109  return psi / std::sqrt(d);
110  }
111 
119  ket zero(idx n, idx d = 2) const
120  {
121  // EXCEPTION CHECKS
122 
123  // check out of range
124  if (n == 0)
125  throw exception::OutOfRange("qpp::States::zero()");
126  // check valid dims
127  if (d == 0)
128  throw exception::DimsInvalid("qpp::States::zero()");
129  // END EXCEPTION CHECKS
130 
131  idx D = static_cast<idx>(std::pow(d, n));
132  ket result = ket::Zero(D);
133  result(0) = 1;
134 
135  return result;
136  }
137 
145  ket one(idx n, idx d = 2) const
146  {
147  // EXCEPTION CHECKS
148 
149  // check out of range
150  if (n == 0)
151  throw exception::OutOfRange("qpp::States::one()");
152  // check valid dims
153  if (d == 0)
154  throw exception::DimsInvalid("qpp::States::one()");
155  // END EXCEPTION CHECKS
156 
157  ket result = ket::Zero(static_cast<ket::Index>(std::pow(d, n)));
158  result(multiidx2n(std::vector<idx>(n, 1), std::vector<idx>(n, d))) = 1;
159 
160  return result;
161  }
162 
171  ket jn(idx j, idx n, idx d = 2) const
172  {
173  // EXCEPTION CHECKS
174 
175  // check out of range
176  if (n == 0)
177  throw exception::OutOfRange("qpp::States::jn()");
178  // check valid subsystem
179  if (j >= d)
180  throw exception::SubsysMismatchDims("qpp::States::jn()");
181 
182  // check valid dims
183  if (d == 0)
184  throw exception::DimsInvalid("qpp::States::jn()");
185  // END EXCEPTION CHECKS
186 
187  ket result = ket::Zero(static_cast<ket::Index>(std::pow(d, n)));
188  result(multiidx2n(std::vector<idx>(n, j), std::vector<idx>(n, d))) = 1;
189 
190  return result;
191  }
192 
199  ket plus(idx n) const
200  {
201  // EXCEPTION CHECKS
202 
203  // check out of range
204  if (n == 0)
205  throw exception::OutOfRange("qpp::States::plus()");
206  // END EXCEPTION CHECKS
207 
208  idx D = static_cast<idx>(std::pow(2, n));
209  ket result = ket::Ones(D);
210 
211  return result / std::sqrt(D);
212  }
213 
220  ket minus(idx n) const
221  {
222  // EXCEPTION CHECKS
223 
224  // check out of range
225  if (n == 0)
226  throw exception::OutOfRange("qpp::States::minus()");
227  // END EXCEPTION CHECKS
228 
229  return kronpow(this->x1, n);
230  }
231 
232 private:
237  {
238  // initialize
239  x0 << 1 / std::sqrt(2.), 1 / std::sqrt(2.);
240  x1 << 1 / std::sqrt(2.), -1 / std::sqrt(2.);
241  y0 << 1 / std::sqrt(2.), 1_i / std::sqrt(2.);
242  y1 << 1 / std::sqrt(2.), -1_i / std::sqrt(2.);
243  z0 << 1, 0;
244  z1 << 0, 1;
245  px0 = x0 * x0.adjoint();
246  px1 = x1 * x1.adjoint();
247  py0 = y0 * y0.adjoint();
248  py1 = y1 * y1.adjoint();
249  pz0 = z0 * z0.adjoint();
250  pz1 = z1 * z1.adjoint();
251 
252  // Bell states, following convention from Nielsen & Chuang
253  // |ij> -> |b_{ij}> by the CNOT*(H x Id) circuit
254 
255  b00 << 1 / std::sqrt(2.), 0, 0, 1 / std::sqrt(2.);
256  // (|00> + |11>) / sqrt(2)
257  b01 << 0, 1 / std::sqrt(2.), 1 / std::sqrt(2.), 0;
258  // (|01> + |10>) / sqrt(2)
259  b10 << 1 / std::sqrt(2.), 0, 0, -1 / std::sqrt(2.);
260  // (|00> - |11>) / sqrt(2)
261  b11 << 0, 1 / std::sqrt(2.), -1 / std::sqrt(2.), 0;
262  // (|01> - |10>) / sqrt(2)
263 
264  pb00 = b00 * b00.adjoint();
265  pb01 = b01 * b01.adjoint();
266  pb10 = b10 * b10.adjoint();
267  pb11 = b11 * b11.adjoint();
268 
269  GHZ << 1, 0, 0, 0, 0, 0, 0, 1;
270  GHZ = GHZ / std::sqrt(2.);
271  W << 0, 1, 1, 0, 1, 0, 0, 0;
272  W = W / std::sqrt(3.);
273 
274  pGHZ = GHZ * GHZ.adjoint();
275  pW = W * W.adjoint();
276  }
277 
281  ~States() = default;
282 }; /* class States */
283 
284 } /* namespace qpp */
285 
286 #endif /* CLASSES_STATES_H_ */
ket zero(idx n, idx d=2) const
Zero state of n qudits.
Definition: states.h:119
ket minus(idx n) const
Minus state of n qubits.
Definition: states.h:220
ket W
W state.
Definition: states.h:81
cmat pb01
Projector onto the Bell-01 state.
Definition: states.h:75
ket GHZ
GHZ state.
Definition: states.h:80
cmat pb11
Projector onto the Bell-11 state.
Definition: states.h:77
Singleton policy class, used internally to implement the singleton pattern via CRTP (Curiously recurr...
Definition: singleton.h:76
Subsystems mismatch dimensions exception.
Definition: exception.h:395
Eigen::VectorXcd ket
Complex (double precision) dynamic Eigen column vector.
Definition: types.h:50
ket y0
Pauli Sigma-Y 0-eigenstate |y+>
Definition: states.h:44
Quantum++ main namespace.
Definition: codes.h:30
const Singleton class that implements most commonly used states
Definition: states.h:36
Invalid dimension(s) exception.
Definition: exception.h:287
cmat pb00
Projector onto the Bell-00 state.
Definition: states.h:74
ket z1
Pauli Sigma-Z 1-eigenstate |1>
Definition: states.h:47
ket b01
Bell-01 state (following the convention in Nielsen and Chuang)
Definition: states.h:66
ket b00
Bell-00 state (following the convention in Nielsen and Chuang)
Definition: states.h:64
cmat pb10
Projector onto the Bell-10 state.
Definition: states.h:76
cmat pW
Projector onto the W state.
Definition: states.h:85
idx multiidx2n(const std::vector< idx > &midx, const std::vector< idx > &dims)
Multi-index to non-negative integer index.
Definition: functions.h:1437
~States()=default
Default destructor.
cmat py0
Projector onto the Pauli Sigma-Y 0-eigenstate |y+><y+|.
Definition: states.h:54
dyn_mat< typename Derived::Scalar > kronpow(const Eigen::MatrixBase< Derived > &A, idx n)
Kronecker power.
Definition: functions.h:980
cmat px0
Projector onto the Pauli Sigma-X 0-eigenstate |+><+|.
Definition: states.h:50
ket x1
Pauli Sigma-X 1-eigenstate |->
Definition: states.h:43
ket y1
Pauli Sigma-Y 1-eigenstate |y->
Definition: states.h:45
ket z0
Pauli Sigma-Z 0-eigenstate |0>
Definition: states.h:46
ket b11
Bell-11 state (following the convention in Nielsen and Chuang)
Definition: states.h:70
Parameter out of range exception.
Definition: exception.h:567
ket mes(idx d=2) const
Maximally entangled state of 2 qudits.
Definition: states.h:94
ket jn(idx j, idx n, idx d=2) const
state of n qudits
Definition: states.h:171
ket plus(idx n) const
Plus state of n qubits.
Definition: states.h:199
ket one(idx n, idx d=2) const
One state of n qudits.
Definition: states.h:145
cmat pz0
Projector onto the Pauli Sigma-Z 0-eigenstate |0><0|.
Definition: states.h:58
cmat pGHZ
Projector onto the GHZ state.
Definition: states.h:84
Eigen::MatrixXcd cmat
Complex (double precision) dynamic Eigen matrix.
Definition: types.h:60
ket mket(const std::vector< idx > &mask, const std::vector< idx > &dims)
Multi-partite qudit ket.
Definition: functions.h:1465
std::size_t idx
Non-negative integer index.
Definition: types.h:35
ket b10
Bell-10 state (following the convention in Nielsen and Chuang)
Definition: states.h:68
ket x0
Pauli Sigma-X 0-eigenstate |+>
Definition: states.h:42
cmat py1
Projector onto the Pauli Sigma-Y 1-eigenstate |y-><y-|.
Definition: states.h:56
cmat px1
Projector onto the Pauli Sigma-X 1-eigenstate |-><-|.
Definition: states.h:52
cmat pz1
Projector onto the Pauli Sigma-Z 1-eigenstate |1><1|.
Definition: states.h:60
States()
Definition: states.h:236