49 template<
typename Derived1,
typename Derived2>
51 const Eigen::MatrixBase<Derived1>& state,
52 const Eigen::MatrixBase<Derived2>& A,
53 const std::vector<idx>& ctrl,
54 const std::vector<idx>& subsys,
55 const std::vector<idx>& dims)
57 const typename Eigen::MatrixBase<Derived1>::EvalReturnType& rstate
64 if (!std::is_same<
typename Derived1::Scalar,
65 typename Derived2::Scalar>::value)
81 idx d = ctrl.size() > 0 ? dims[ctrl[0]] : 1;
82 for (
idx i = 1; i < ctrl.size(); ++i)
83 if (dims[ctrl[i]] != d)
95 std::vector<idx> subsys_dims(subsys.size());
96 for (
idx i = 0; i < subsys.size(); ++i)
97 subsys_dims[i] = dims[subsys[i]];
101 std::vector<idx> ctrlgate = ctrl;
102 ctrlgate.insert(std::end(ctrlgate), std::begin(subsys), std::end(subsys));
103 std::sort(std::begin(ctrlgate), std::end(ctrlgate));
112 std::vector<dyn_mat<typename Derived1::Scalar>> Ai;
113 std::vector<dyn_mat<typename Derived1::Scalar>> Aidagger;
114 for (
idx i = 0; i < std::max(d, static_cast<idx>(2)); ++i)
116 Ai.push_back(
powm(rA, i));
120 idx D =
static_cast<idx>(rstate.rows());
122 idx ctrlsize = ctrl.size();
123 idx ctrlgatesize = ctrlgate.size();
124 idx subsyssize = subsys.size();
126 idx Dctrl =
static_cast<idx>(std::llround(std::pow(d, ctrlsize)));
127 idx DA =
static_cast<idx>(rA.rows());
135 std::vector<idx> ctrlgate_bar =
complement(ctrlgate, N);
137 idx ctrlgate_barsize = ctrlgate_bar.size();
140 for (
idx i = 0; i < ctrlgate_barsize; ++i)
141 DCTRLA_bar *= dims[ctrlgate_bar[i]];
143 for (
idx k = 0; k < N; ++k)
145 for (
idx k = 0; k < subsyssize; ++k)
146 CdimsA[k] = dims[subsys[k]];
147 for (
idx k = 0; k < ctrlsize; ++k)
149 for (
idx k = 0; k < ctrlgate_barsize; ++k)
150 CdimsCTRLA_bar[k] = dims[ctrlgate_bar[k]];
154 auto coeff_idx_ket = [&](
idx i_,
idx m_,
idx r_) noexcept
155 -> std::pair<typename Derived1::Scalar, idx>
158 typename Derived1::Scalar coeff = 0;
167 for (
idx k = 0; k < ctrlsize; ++k)
174 CdimsCTRLA_bar, CmidxCTRLA_bar);
175 for (
idx k = 0; k < N - ctrlgatesize; ++k)
177 Cmidx[ctrlgate_bar[k]] = CmidxCTRLA_bar[k];
182 for (
idx k = 0; k < subsyssize; ++k)
184 Cmidx[subsys[k]] = CmidxA[k];
191 for (
idx n_ = 0; n_ < DA; ++n_)
194 for (
idx k = 0; k < subsyssize; ++k)
196 Cmidx[subsys[k]] = CmidxA[k];
198 coeff += Ai[i_](m_, n_) *
202 return std::make_pair(coeff, indx);
208 auto coeff_idx_rho = [&](
idx i1_,
idx m1_,
210 -> std::tuple<typename Derived1::Scalar, idx, idx>
214 typename Derived1::Scalar coeff = 0, lhs = 1, rhs = 1;
229 CdimsCTRL, CmidxCTRLrow);
231 CdimsCTRL, CmidxCTRLcol);
233 for (
idx k = 0; k < ctrlsize; ++k)
235 Cmidxrow[ctrl[k]] = CmidxCTRLrow[k];
236 Cmidxcol[ctrl[k]] = CmidxCTRLcol[k];
241 CdimsCTRLA_bar, CmidxCTRLA_barrow);
243 CdimsCTRLA_bar, CmidxCTRLA_barcol);
244 for (
idx k = 0; k < N - ctrlgatesize; ++k)
246 Cmidxrow[ctrlgate_bar[k]] = CmidxCTRLA_barrow[k];
247 Cmidxcol[ctrlgate_bar[k]] = CmidxCTRLA_barcol[k];
253 for (
idx k = 0; k < subsys.size(); ++k)
255 Cmidxrow[subsys[k]] = CmidxArow[k];
256 Cmidxcol[subsys[k]] = CmidxAcol[k];
264 bool all_ctrl_rows_equal =
true;
265 bool all_ctrl_cols_equal =
true;
267 idx first_ctrl_row, first_ctrl_col;
270 first_ctrl_row = CmidxCTRLrow[0];
271 first_ctrl_col = CmidxCTRLcol[0];
274 first_ctrl_row = first_ctrl_col = 1;
277 for (
idx k = 1; k < ctrlsize; ++k)
279 if (CmidxCTRLrow[k] != first_ctrl_row)
281 all_ctrl_rows_equal =
false;
285 for (
idx k = 1; k < ctrlsize; ++k)
287 if (CmidxCTRLcol[k] != first_ctrl_col)
289 all_ctrl_cols_equal =
false;
295 for (
idx n1_ = 0; n1_ < DA; ++n1_)
298 for (
idx k = 0; k < subsyssize; ++k)
300 Cmidxrow[subsys[k]] = CmidxArow[k];
304 if (all_ctrl_rows_equal)
306 lhs = Ai[first_ctrl_row](m1_, n1_);
309 lhs = (m1_ == n1_) ? 1 : 0;
312 for (
idx n2_ = 0; n2_ < DA; ++n2_)
315 for (
idx k = 0; k < subsyssize; ++k)
317 Cmidxcol[subsys[k]] = CmidxAcol[k];
320 if (all_ctrl_cols_equal)
322 rhs = Aidagger[first_ctrl_col](n2_, m2_);
325 rhs = (n2_ == m2_) ? 1 : 0;
330 coeff += lhs * rstate(idxrowtmp, idxcoltmp) * rhs;
334 return std::make_tuple(coeff, idxrow, idxcol);
349 #pragma omp parallel for collapse(2) 350 #endif // WITH_OPENMP_ 351 for (
idx m = 0; m < DA; ++m)
352 for (
idx r = 0; r < DCTRLA_bar; ++r)
356 result(coeff_idx_ket(1, m, r).second) =
357 coeff_idx_ket(1, m, r).first;
359 for (
idx i = 0; i < d; ++i)
361 result(coeff_idx_ket(i, m, r).second) =
362 coeff_idx_ket(i, m, r).first;
381 #pragma omp parallel for collapse(4) 382 #endif // WITH_OPENMP_ 383 for (
idx m1 = 0; m1 < DA; ++m1)
384 for (
idx r1 = 0; r1 < DCTRLA_bar; ++r1)
385 for (
idx m2 = 0; m2 < DA; ++m2)
386 for (
idx r2 = 0; r2 < DCTRLA_bar; ++r2)
389 auto coeff_idxes = coeff_idx_rho(1, m1, r1,
391 result(std::get<1>(coeff_idxes),
392 std::get<2>(coeff_idxes)) =
393 std::get<0>(coeff_idxes);
396 for (
idx i1 = 0; i1 < Dctrl; ++i1)
397 for (
idx i2 = 0; i2 < Dctrl; ++i2)
399 auto coeff_idxes = coeff_idx_rho(
402 result(std::get<1>(coeff_idxes),
403 std::get<2>(coeff_idxes)) =
404 std::get<0>(coeff_idxes);
430 template<
typename Derived1,
typename Derived2>
432 const Eigen::MatrixBase<Derived1>& state,
433 const Eigen::MatrixBase<Derived2>& A,
434 const std::vector<idx>& ctrl,
435 const std::vector<idx>& subsys,
438 const typename Eigen::MatrixBase<Derived1>::EvalReturnType& rstate
454 std::vector<idx> dims(N, d);
456 return applyCTRL(rstate, rA, ctrl, subsys, dims);
472 template<
typename Derived1,
typename Derived2>
474 const Eigen::MatrixBase<Derived1>& state,
475 const Eigen::MatrixBase<Derived2>& A,
476 const std::vector<idx>& subsys,
477 const std::vector<idx>& dims)
479 const typename Eigen::MatrixBase<Derived1>::EvalReturnType& rstate
486 if (!std::is_same<
typename Derived1::Scalar,
487 typename Derived2::Scalar>::value)
511 std::vector<idx> subsys_dims(subsys.size());
512 for (
idx i = 0; i < subsys.size(); ++i)
513 subsys_dims[i] = dims[subsys[i]];
525 return applyCTRL(rstate, rA, {}, subsys, dims);
535 return applyCTRL(rstate, rA, {}, subsys, dims);
555 template<
typename Derived1,
typename Derived2>
557 const Eigen::MatrixBase<Derived1>& state,
558 const Eigen::MatrixBase<Derived2>& A,
559 const std::vector<idx>& subsys,
562 const typename Eigen::MatrixBase<Derived1>::EvalReturnType& rstate
578 std::vector<idx> dims(N, d);
580 return apply(rstate, rA, subsys, dims);
591 template<
typename Derived>
593 const std::vector<cmat>& Ks)
595 const cmat& rA = A.derived();
607 if (Ks[0].rows() != rA.rows())
610 if (it.rows() != Ks[0].rows() || it.cols() != Ks[0].rows())
614 cmat result = cmat::Zero(rA.rows(), rA.rows());
617 #pragma omp parallel for 618 #endif // WITH_OPENMP_ 619 for (
idx i = 0; i < Ks.size(); ++i)
623 #endif // WITH_OPENMP_ 625 result += Ks[i] * rA *
adjoint(Ks[i]);
642 template<
typename Derived>
644 const std::vector<cmat>& Ks,
645 const std::vector<idx>& subsys,
646 const std::vector<idx>& dims)
648 const cmat& rA = A.derived();
672 std::vector<idx> subsys_dims(subsys.size());
673 for (
idx i = 0; i < subsys.size(); ++i)
674 subsys_dims[i] = dims[subsys[i]];
684 if (it.rows() != Ks[0].rows() || it.cols() != Ks[0].rows())
688 cmat result = cmat::Zero(rA.rows(), rA.rows());
690 for (
idx i = 0; i < Ks.size(); ++i)
691 result +=
apply(rA, Ks[i], subsys, dims);
706 template<
typename Derived>
708 const std::vector<cmat>& Ks,
709 const std::vector<idx>& subsys,
712 const cmat& rA = A.derived();
726 std::vector<idx> dims(N, d);
728 return apply(rA, Ks, subsys, dims);
753 if (it.rows() != Ks[0].rows() || it.cols() != Ks[0].rows())
757 idx D =
static_cast<idx>(Ks[0].rows());
759 cmat result(D * D, D * D);
760 cmat MN = cmat::Zero(D, D);
761 bra A = bra::Zero(D);
762 ket B = ket::Zero(D);
763 cmat EMN = cmat::Zero(D, D);
766 #pragma omp parallel for collapse(2) 767 #endif // WITH_OPENMP_ 768 for (
idx m = 0; m < D; ++m)
770 for (
idx n = 0; n < D; ++n)
774 #endif // WITH_OPENMP_ 778 for (
idx i = 0; i < Ks.size(); ++i)
779 EMN += Ks[i] * MN *
adjoint(Ks[i]);
782 for (
idx a = 0; a < D; ++a)
785 for (
idx b = 0; b < D; ++b)
789 result(a * D + b, m * D + n) =
790 static_cast<cmat>(A * EMN * B).value();
795 EMN = cmat::Zero(D, D);
829 if (it.rows() != Ks[0].rows() || it.cols() != Ks[0].rows())
833 idx D =
static_cast<idx>(Ks[0].rows());
837 cmat MES = cmat::Zero(D * D, 1);
838 for (
idx a = 0; a < D; ++a)
843 cmat result = cmat::Zero(D * D, D * D);
846 #pragma omp parallel for 847 #endif // WITH_OPENMP_ 848 for (
idx i = 0; i < Ks.size(); ++i)
852 #endif // WITH_OPENMP_ 854 result +=
kron(cmat::Identity(D, D), Ks[i]) * Omega
885 if (D * D != static_cast<idx>(A.rows()))
891 std::vector<cmat> result;
893 for (
idx i = 0; i < D * D; ++i)
895 if (std::abs(ev(i)) >
eps)
897 std::sqrt(std::abs(ev(i))) *
reshape(evec.col(i), D, D));
920 if (D * D != static_cast<idx>(A.rows()))
924 cmat result(D * D, D * D);
927 #pragma omp parallel for collapse(4) 928 #endif // WITH_OPENMP_ 929 for (
idx a = 0; a < D; ++a)
930 for (
idx b = 0; b < D; ++b)
931 for (
idx m = 0; m < D; ++m)
932 for (
idx n = 0; n < D; ++n)
933 result(a * D + b, m * D + n) = A(m * D + a, n * D + b);
955 if (D * D != static_cast<idx>(A.rows()))
959 cmat result(D * D, D * D);
962 #pragma omp parallel for collapse(4) 963 #endif // WITH_OPENMP_ 964 for (
idx a = 0; a < D; ++a)
965 for (
idx b = 0; b < D; ++b)
966 for (
idx m = 0; m < D; ++m)
967 for (
idx n = 0; n < D; ++n)
968 result(m * D + a, n * D + b) = A(a * D + b, m * D + n);
986 template<
typename Derived>
988 const std::vector<idx>& dims)
990 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA
1004 if (dims.size() != 2)
1021 auto worker = [&](
idx i,
idx j) noexcept ->
typename Derived::Scalar
1023 typename Derived::Scalar
sum = 0;
1024 for (
idx m = 0; m < DA; ++m)
1025 sum += rA(m * DB + i) * std::conj(rA(m * DB + j));
1031 #pragma omp parallel for collapse(2) 1032 #endif // WITH_OPENMP_ 1033 for (
idx j = 0; j < DB; ++j)
1034 for (
idx i = 0; i < DB; ++i)
1035 result(i, j) = worker(i, j);
1046 auto worker = [&](
idx i,
idx j) noexcept ->
typename Derived::Scalar
1048 typename Derived::Scalar
sum = 0;
1049 for (
idx m = 0; m < DA; ++m)
1050 sum += rA(m * DB + i, m * DB + j);
1056 #pragma omp parallel for collapse(2) 1057 #endif // WITH_OPENMP_ 1058 for (
idx j = 0; j < DB; ++j)
1059 for (
idx i = 0; i < DB; ++i)
1060 result(i, j) = worker(i, j);
1082 template<
typename Derived>
1099 std::vector<idx> dims(2, d);
1117 template<
typename Derived>
1119 const std::vector<idx>& dims)
1121 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA
1135 if (dims.size() != 2)
1152 auto worker = [&](
idx i,
idx j) noexcept ->
typename Derived::Scalar
1154 typename Derived::Scalar
sum = 0;
1155 for (
idx m = 0; m < DB; ++m)
1156 sum += rA(i * DB + m) * std::conj(rA(j * DB + m));
1162 #pragma omp parallel for collapse(2) 1163 #endif // WITH_OPENMP_ 1164 for (
idx j = 0; j < DA; ++j)
1165 for (
idx i = 0; i < DA; ++i)
1166 result(i, j) = worker(i, j);
1178 #pragma omp parallel for collapse(2) 1179 #endif // WITH_OPENMP_ 1180 for (
idx j = 0; j < DA; ++j)
1181 for (
idx i = 0; i < DA; ++i)
1182 result(i, j) =
trace(rA.block(i * DB, j * DB, DB, DB));
1204 template<
typename Derived>
1221 std::vector<idx> dims(2, d);
1240 template<
typename Derived>
1242 const std::vector<idx>& subsys,
1243 const std::vector<idx>& dims)
1245 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA
1263 idx D =
static_cast<idx>(rA.rows());
1264 idx N = dims.size();
1265 idx Nsubsys = subsys.size();
1266 idx Nsubsys_bar = N - Nsubsys;
1268 for (
idx i = 0; i < Nsubsys; ++i)
1269 Dsubsys *= dims[subsys[i]];
1270 idx Dsubsys_bar = D / Dsubsys;
1280 std::vector<idx> subsys_bar =
complement(subsys, N);
1281 std::copy(std::begin(subsys_bar), std::end(subsys_bar),
1282 std::begin(Csubsys_bar));
1284 for (
idx i = 0; i < N; ++i)
1288 for (
idx i = 0; i < Nsubsys; ++i)
1290 Csubsys[i] = subsys[i];
1291 Cdimssubsys[i] = dims[subsys[i]];
1293 for (
idx i = 0; i < Nsubsys_bar; ++i)
1295 Cdimssubsys_bar[i] = dims[subsys_bar[i]];
1308 if (subsys.size() == dims.size())
1310 result(0, 0) = (
adjoint(rA) * rA).value();
1314 if (subsys.size() == 0)
1317 auto worker = [&](
idx i) noexcept ->
typename Derived::Scalar
1328 Cdimssubsys_bar, Cmidxrowsubsys_bar);
1330 for (
idx k = 0; k < Nsubsys_bar; ++k)
1332 Cmidxrow[Csubsys_bar[k]] = Cmidxrowsubsys_bar[k];
1333 Cmidxcol[Csubsys_bar[k]] = Cmidxcolsubsys_bar[k];
1335 typename Derived::Scalar sm = 0;
1336 for (
idx a = 0; a < Dsubsys; ++a)
1341 for (
idx k = 0; k < Nsubsys; ++k)
1342 Cmidxrow[Csubsys[k]] = Cmidxcol[Csubsys[k]]
1354 for (
idx j = 0; j < Dsubsys_bar; ++j)
1358 Cdimssubsys_bar, Cmidxcolsubsys_bar);
1360 #pragma omp parallel for 1361 #endif // WITH_OPENMP_ 1362 for (
idx i = 0; i < Dsubsys_bar; ++i)
1364 result(i, j) = worker(i);
1377 if (subsys.size() == dims.size())
1379 result(0, 0) = rA.trace();
1383 if (subsys.size() == 0)
1386 auto worker = [&](
idx i) noexcept ->
typename Derived::Scalar
1397 Cdimssubsys_bar, Cmidxrowsubsys_bar);
1399 for (
idx k = 0; k < Nsubsys_bar; ++k)
1401 Cmidxrow[Csubsys_bar[k]] = Cmidxrowsubsys_bar[k];
1402 Cmidxcol[Csubsys_bar[k]] = Cmidxcolsubsys_bar[k];
1404 typename Derived::Scalar sm = 0;
1405 for (
idx a = 0; a < Dsubsys; ++a)
1410 for (
idx k = 0; k < Nsubsys; ++k)
1411 Cmidxrow[Csubsys[k]] = Cmidxcol[Csubsys[k]]
1422 for (
idx j = 0; j < Dsubsys_bar; ++j)
1426 Cdimssubsys_bar, Cmidxcolsubsys_bar);
1428 #pragma omp parallel for 1429 #endif // WITH_OPENMP_ 1430 for (
idx i = 0; i < Dsubsys_bar; ++i)
1432 result(i, j) = worker(i);
1457 template<
typename Derived>
1459 const std::vector<idx>& subsys,
1462 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA = A.derived();
1476 std::vector<idx> dims(N, d);
1478 return ptrace(rA, subsys, dims);
1494 template<
typename Derived>
1496 const Eigen::MatrixBase<Derived>& A,
1497 const std::vector<idx>& subsys,
1498 const std::vector<idx>& dims)
1500 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA = A.derived();
1517 idx D =
static_cast<idx>(rA.rows());
1518 idx N = dims.size();
1519 idx Nsubsys = subsys.size();
1525 for (
idx i = 0; i < N; ++i)
1527 for (
idx i = 0; i < Nsubsys; ++i)
1528 Csubsys[i] = subsys[i];
1539 if (subsys.size() == dims.size())
1542 if (subsys.size() == 0)
1545 auto worker = [&](
idx i) noexcept ->
typename Derived::Scalar
1551 for (
idx k = 0; k < N; ++k)
1552 midxcoltmp[k] = Cmidxcol[k];
1557 for (
idx k = 0; k < Nsubsys; ++k)
1558 std::swap(midxcoltmp[Csubsys[k]], midxrow[Csubsys[k]]);
1566 for (
idx j = 0; j < D; ++j)
1572 #pragma omp parallel for 1573 #endif // WITH_OPENMP_ 1574 for (
idx i = 0; i < D; ++i)
1575 result(i, j) = worker(i);
1587 if (subsys.size() == dims.size())
1588 return rA.transpose();
1590 if (subsys.size() == 0)
1593 auto worker = [&](
idx i) noexcept ->
typename Derived::Scalar
1599 for (
idx k = 0; k < N; ++k)
1600 midxcoltmp[k] = Cmidxcol[k];
1605 for (
idx k = 0; k < Nsubsys; ++k)
1606 std::swap(midxcoltmp[Csubsys[k]], midxrow[Csubsys[k]]);
1613 for (
idx j = 0; j < D; ++j)
1619 #pragma omp parallel for 1620 #endif // WITH_OPENMP_ 1621 for (
idx i = 0; i < D; ++i)
1622 result(i, j) = worker(i);
1645 template<
typename Derived>
1647 const Eigen::MatrixBase<Derived>& A,
1648 const std::vector<idx>& subsys,
1651 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA = A.derived();
1665 std::vector<idx> dims(N, d);
1682 template<
typename Derived>
1684 const Eigen::MatrixBase<Derived>& A,
1685 const std::vector<idx>& perm,
1686 const std::vector<idx>& dims)
1688 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA = A.derived();
1705 if (perm.size() != dims.size())
1709 idx D =
static_cast<idx>(rA.rows());
1710 idx N = dims.size();
1725 for (
idx i = 0; i < N; ++i)
1730 result.resize(D, 1);
1732 auto worker = [&Cdims, &Cperm, N](
idx i) noexcept ->
idx 1743 for (
idx k = 0; k < N; ++k)
1745 permdims[k] = Cdims[Cperm[k]];
1746 midxtmp[k] = midx[Cperm[k]];
1753 #pragma omp parallel for 1754 #endif // WITH_OPENMP_ 1755 for (
idx i = 0; i < D; ++i)
1756 result(worker(i)) = rA(i);
1771 for (
idx i = 0; i < N; ++i)
1774 Cdims[i + N] = dims[i];
1776 Cperm[i + N] = perm[i] + N;
1778 result.resize(D * D, 1);
1781 Eigen::Map<dyn_mat<typename Derived::Scalar >>(
1782 const_cast<typename Derived::Scalar*
>(rA.data()),
1785 auto worker = [&Cdims, &Cperm, N](
idx i) noexcept ->
idx 1796 for (
idx k = 0; k < 2 * N; ++k)
1798 permdims[k] = Cdims[Cperm[k]];
1799 midxtmp[k] = midx[Cperm[k]];
1806 #pragma omp parallel for 1807 #endif // WITH_OPENMP_ 1808 for (
idx i = 0; i < D * D; ++i)
1809 result(worker(i)) = rA(i);
1830 template<
typename Derived>
1832 const Eigen::MatrixBase<Derived>& A,
1833 const std::vector<idx>& perm,
1836 const typename Eigen::MatrixBase<Derived>::EvalReturnType& rA = A.derived();
1850 std::vector<idx> dims(N, d);
bool check_nonzero_size(const T &x) noexcept
Definition: util.h:129
Dimensions not equal exception.
Definition: exception.h:304
Dimension(s) mismatch matrix size exception.
Definition: exception.h:322
constexpr idx maxn
Maximum number of allowed qubits/qudits (subsystems)
Definition: constants.h:71
bool check_subsys_match_dims(const std::vector< idx > &subsys, const std::vector< idx > &dims)
Definition: util.h:221
bool check_cvector(const Eigen::MatrixBase< Derived > &A)
Definition: util.h:122
std::vector< cmat > choi2kraus(const cmat &A)
Orthogonal Kraus operators from Choi matrix.
Definition: operations.h:875
Eigen::MatrixXd dmat
Real (double precision) dynamic Eigen matrix.
Definition: types.h:65
constexpr double eps
Used to decide whether a number or expression in double precision is zero or not. ...
Definition: constants.h:64
Eigen::RowVectorXcd bra
Complex (double precision) dynamic Eigen row vector.
Definition: types.h:55
dyn_mat< typename Derived::Scalar > syspermute(const Eigen::MatrixBase< Derived > &A, const std::vector< idx > &perm, const std::vector< idx > &dims)
Subsystem permutation.
Definition: operations.h:1683
Eigen::Matrix< Scalar, Eigen::Dynamic, Eigen::Dynamic > dyn_mat
Dynamic Eigen matrix over the field specified by Scalar.
Definition: types.h:77
bool check_dims_match_mat(const std::vector< idx > &dims, const Eigen::MatrixBase< Derived > &A)
Definition: util.h:158
idx multiidx2n(const idx *const midx, idx numdims, const idx *const dims) noexcept
Definition: util.h:70
void n2multiidx(idx n, idx numdims, const idx *const dims, idx *result) noexcept
Definition: util.h:40
Subsystems mismatch dimensions exception.
Definition: exception.h:395
Eigen::VectorXcd ket
Complex (double precision) dynamic Eigen column vector.
Definition: types.h:50
dyn_mat< typename Derived1::Scalar > apply(const Eigen::MatrixBase< Derived1 > &state, const Eigen::MatrixBase< Derived2 > &A, const std::vector< idx > &subsys, const std::vector< idx > &dims)
Applies the gate A to the part subsys of the multi-partite state vector or density matrix state...
Definition: operations.h:473
Quantum++ main namespace.
Definition: codes.h:30
bool check_perm(const std::vector< idx > &perm)
Definition: util.h:278
idx get_num_subsys(idx sz, idx d)
Definition: util.h:391
Matrix is not square nor column vector exception.
Definition: exception.h:219
dyn_col_vect< double > hevals(const Eigen::MatrixBase< Derived > &A)
Hermitian eigenvalues.
Definition: functions.h:387
Invalid dimension(s) exception.
Definition: exception.h:287
cmat choi2super(const cmat &A)
Converts Choi matrix to superoperator matrix.
Definition: operations.h:910
cmat super2choi(const cmat &A)
Converts superoperator matrix to Choi matrix.
Definition: operations.h:945
std::vector< T > complement(std::vector< T > subsys, idx N)
Constructs the complement of a subsystem vector.
Definition: functions.h:1811
bool check_dims_match_cvect(const std::vector< idx > &dims, const Eigen::MatrixBase< Derived > &A)
Definition: util.h:174
Not bi-partite exception.
Definition: exception.h:532
dyn_mat< typename Derived::Scalar > ptrace1(const Eigen::MatrixBase< Derived > &A, const std::vector< idx > &dims)
Partial trace.
Definition: operations.h:987
Invalid permutation exception.
Definition: exception.h:412
dyn_mat< typename Derived::Scalar > adjoint(const Eigen::MatrixBase< Derived > &A)
Adjoint.
Definition: functions.h:81
dyn_mat< typename T::Scalar > kron(const T &head)
Kronecker product.
Definition: functions.h:899
dyn_mat< typename Derived::Scalar > ptrace2(const Eigen::MatrixBase< Derived > &A, const std::vector< idx > &dims)
Partial trace.
Definition: operations.h:1118
Matrix mismatch subsystems exception.
Definition: exception.h:270
Dimension(s) mismatch column vector size exception.
Definition: exception.h:340
dyn_mat< typename Derived::Scalar > transpose(const Eigen::MatrixBase< Derived > &A)
Transpose.
Definition: functions.h:41
dyn_mat< typename Derived::Scalar > powm(const Eigen::MatrixBase< Derived > &A, idx n)
Fast matrix power based on the SQUARE-AND-MULTIPLY algorithm.
Definition: functions.h:777
Type mismatch exception.
Definition: exception.h:585
idx get_dim_subsys(idx sz, idx N)
Definition: util.h:404
cmat hevects(const Eigen::MatrixBase< Derived > &A)
Hermitian eigenvectors.
Definition: functions.h:413
cmat kraus2choi(const std::vector< cmat > &Ks)
Choi matrix.
Definition: operations.h:818
dyn_mat< typename Derived::Scalar > ptrace(const Eigen::MatrixBase< Derived > &A, const std::vector< idx > &subsys, const std::vector< idx > &dims)
Partial trace.
Definition: operations.h:1241
bool check_square_mat(const Eigen::MatrixBase< Derived > &A)
Definition: util.h:101
Derived::Scalar trace(const Eigen::MatrixBase< Derived > &A)
Trace.
Definition: functions.h:124
cmat kraus2super(const std::vector< cmat > &Ks)
Superoperator matrix.
Definition: operations.h:742
dyn_mat< typename Derived1::Scalar > applyCTRL(const Eigen::MatrixBase< Derived1 > &state, const Eigen::MatrixBase< Derived2 > &A, const std::vector< idx > &ctrl, const std::vector< idx > &subsys, const std::vector< idx > &dims)
Applies the controlled-gate A to the part subsys of the multi-partite state vector or density matrix ...
Definition: operations.h:50
dyn_mat< typename Derived::Scalar > ptranspose(const Eigen::MatrixBase< Derived > &A, const std::vector< idx > &subsys, const std::vector< idx > &dims)
Partial transpose.
Definition: operations.h:1495
Eigen::MatrixXcd cmat
Complex (double precision) dynamic Eigen matrix.
Definition: types.h:60
bool check_dims(const std::vector< idx > &dims)
Definition: util.h:142
Permutation mismatch dimensions exception.
Definition: exception.h:430
std::size_t idx
Non-negative integer index.
Definition: types.h:35
Matrix is not square exception.
Definition: exception.h:151
Derived::Scalar sum(const Eigen::MatrixBase< Derived > &A)
Element-wise sum of A.
Definition: functions.h:205
dyn_mat< typename Derived::Scalar > reshape(const Eigen::MatrixBase< Derived > &A, idx rows, idx cols)
Reshape.
Definition: functions.h:1139
Object has zero size exception.
Definition: exception.h:134