39 template<
class Matrix,
class SymmGroup>
40 std::vector<Boundary<Matrix, SymmGroup> >
43 assert(mpo.length() == mps.
length());
44 std::size_t L = mps.
length();
46 std::vector<Boundary<Matrix, SymmGroup> > left_(L+1);
49 for (
int i = 0; i < L; ++i) {
55 template<
class Matrix,
class SymmGroup>
56 std::vector<Boundary<Matrix, SymmGroup> >
59 assert(mpo.length() == mps.
length());
60 std::size_t L = mps.
length();
62 std::vector<Boundary<Matrix, SymmGroup> > right_(L+1);
65 for (
int i = L-1; i >= 0; --i) {
71 template<
class Matrix,
class SymmGroup>
85 template<
class Matrix,
class SymmGroup>
89 assert(mpo.length() == mps.
length());
90 std::size_t L = mps.
length();
96 maquis::cout <<
"expval site " << (size_t)i << std::endl;
103 template<
class Matrix,
class SymmGroup>
107 assert(mpo.length() == mps.
length());
108 std::size_t L = mps.
length();
112 for (
int i = 0; i < L; ++i) {
119 template<
class Matrix,
class SymmGroup>
122 std::size_t L = mps.
length();
125 left.
insert_block(Matrix(1, 1, 1), SymmGroup::IdentityCharge, SymmGroup::IdentityCharge);
135 template<
class Matrix,
class SymmGroup>
141 std::size_t L = mps1.
length();
144 left.
insert_block(Matrix(1, 1, 1), SymmGroup::IdentityCharge, SymmGroup::IdentityCharge);
153 template<
class Matrix,
class SymmGroup>
163 std::size_t L = mps1.
length();
166 left.
insert_block(Matrix(1, 1, 1), SymmGroup::IdentityCharge, SymmGroup::IdentityCharge);
168 for (
int i = 0; i < L; ++i) {
173 std::vector<typename MPS<Matrix, SymmGroup>::scalar_type> vals;
174 vals.reserve(left.
left_basis().sum_of_sizes());
175 for (
int n=0; n<left.
n_blocks(); ++n)
176 for (
int i=0; i<left.
left_basis()[n].second; ++i)
177 vals.push_back( left[n](i,0) );
184 template<
class Matrix,
class SymmGroup>
187 std::vector<int> * measure_es_where = NULL,
190 std::size_t L = mps.
length();
191 std::vector<double> ret;
201 for (std::size_t p = 1; p < L; ++p)
206 constmps[p-1].make_left_paired();
207 constmps[p].make_right_paired();
215 if (spectra != NULL && measure_es_where != NULL
216 && std::find(measure_es_where->begin(), measure_es_where->end(), p) != measure_es_where->end()) {
217 std::vector< std::string > labels;
218 std::vector< double > values;
219 for (std::size_t k = 0; k < s.
n_blocks(); ++k) {
220 std::ostringstream oss_c;
222 std::string c_str = oss_c.str();
223 for (std::size_t l = 0; l < s.
left_basis()[k].second; ++l) {
224 labels.push_back( c_str );
225 values.push_back( s[k](l,l) );
228 spectra->push_back(std::make_pair(labels, values));
233 for (std::vector<double>::const_iterator it = sv.begin();
234 it != sv.end(); ++it)
238 for (std::vector<double>::const_iterator it = sv.begin();
239 it != sv.end(); ++it)
241 ret.push_back(1/(1-n)*
log(S));
250 template<
class Matrix,
class SymmGroup>
257 template<
class Matrix,
class SymmGroup>
260 typedef typename SymmGroup::charge charge;
261 charge I = SymmGroup::IdentityCharge;
266 boost::lambda::_1, -boost::lambda::_2));
269 for (
int s=0; s<phys_psi.
size(); ++s)
270 for (
int ss=0; ss<phys_psi[s].second; ++ss) {
271 identblock(pb(phys_psi[s].first, phys_psi[s].first) + ss*phys_psi[s].second+ss, 0) = 1.;
277 trivial_i.
insert(std::make_pair(I, 1));
279 mident.
data() = ident;
282 for (
int p=0; p<L; ++p)
283 mps_ident[p] = mident;
285 return overlap(mps, mps_ident);
290 template<
class Matrix,
class SymmGroup>
293 assert( mps.
size() == dens[0].size() );
294 assert( dens_ops.size() == dens.size() );
295 size_t L = mps.
size();
299 for (
int p=0; p<L; ++p)
304 typename SymmGroup::charge empty, up, down, updown;
305 empty[0] = 0; empty[1] = 0;
306 up[0] = 1; up[1] = 0;
307 down[0] = 0; down[1] = 1;
308 updown[0] = 1; updown[1] = 1;
313 for (
size_t j=0; j<dens.size(); ++j) {
316 double cur_dens = mps[p].scalar_overlap(tmp);
317 maquis::cout <<
"Density[" << j <<
"] (before) = " << cur_dens << std::endl;
320 double a =
trace(rho(down, down)) *
trace(rho(updown, updown));
321 double b =
trace(rho(up, up)) *
trace(rho(down, down)) + dens[0][p] *
trace(rho(updown, updown)) - dens[1][p] *
trace(rho(updown, updown));
322 double c = - dens[1][p] *
trace(rho(up, up));
323 double k2 = ( -b +
sqrt(b*b - 4*a*c) ) / (2*a);
325 double k1 = dens[0][p] / (
trace(rho(up, up)) + k2*
trace(rho(updown,updown)) );
328 t0 += k1*
trace( rho(up, up) );
329 t0 += k2*
trace( rho(down, down) );
330 t0 += k1*k2*
trace( rho(updown, updown) );
331 double k0 = (1.-t0) /
trace(rho(empty, empty));
333 maquis::cout <<
"k0 = " << k0 << std::endl;
334 maquis::cout <<
"k1 = " << k1 << std::endl;
335 maquis::cout <<
"k2 = " << k2 << std::endl;
342 rescale(updown, updown) *=
std::sqrt(k1*k2);
347 for (
size_t j=0; j<dens.size(); ++j) {
349 double meas_dens = mps[p].scalar_overlap(tmp) / mps[p].scalar_norm();
350 maquis::cout <<
"Density[" << j <<
"] (after) = " << meas_dens <<
", should be " << dens[j][p] << std::endl;
356 mps[p+1].multiply_from_left(t_norm);
void move_normalization_l2r(size_t p1, size_t p2, DecompMethod method=DefaultSolver())
double expval(MPS< Matrix, SymmGroup > const &mps, MPO< Matrix, SymmGroup > const &mpo, int d)
std::vector< typename MPS< Matrix, SymmGroup >::scalar_type > multi_overlap(MPS< Matrix, SymmGroup > const &mps1, MPS< Matrix, SymmGroup > const &mps2)
size_type n_blocks() const
declaration of the MPS class (vector of MPSTensor)
static MPSTensor< Matrix, SymmGroup > local_op(MPSTensor< Matrix, SymmGroup > const &mps, block_matrix< Matrix, SymmGroup > const &op)
std::vector< double > calculate_bond_entropies(MPS< Matrix, SymmGroup > &mps)
std::vector< double > bond_renyi_entropies(const block_matrix< alps::numeric::diagonal_matrix< T >, SymmGroup > &set)
std::vector< Boundary< Matrix, SymmGroup > > left_mpo_overlaps(MPS< Matrix, SymmGroup > const &mps, MPO< Matrix, SymmGroup > const &mpo)
std::vector< typename MPS< Matrix, SymmGroup >::scalar_type > multi_expval(MPS< Matrix, SymmGroup > const &mps, MPO< Matrix, SymmGroup > const &mpo)
size_type insert_block(Matrix const &, charge, charge)
std::size_t size_of_block(charge c) const
Boundary< Matrix, SymmGroup > left_boundary() const
static Boundary< OtherMatrix, SymmGroup > overlap_mpo_right_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, Boundary< OtherMatrix, SymmGroup > const &right, MPOTensor< Matrix, SymmGroup > const &mpo)
static block_matrix< Matrix, SymmGroup > density_matrix(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor)
std::vector< std::pair< std::vector< std::string >, std::vector< double > > > entanglement_spectrum_type
Boundary< Matrix, SymmGroup > right_boundary() const
#define semi_parallel_for(constraint,...)
block_matrix< Matrix, SymmGroup > sqrt(block_matrix< Matrix, SymmGroup > m)
std::vector< Boundary< Matrix, SymmGroup > > right_mpo_overlaps(MPS< Matrix, SymmGroup > const &mps, MPO< Matrix, SymmGroup > const &mpo)
static block_matrix< OtherMatrix, SymmGroup > overlap_left_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, block_matrix< OtherMatrix, SymmGroup > const &left, block_matrix< OtherMatrix, SymmGroup > *localop=NULL)
block_matrix< Matrix, SymmGroup >::scalar_type trace(block_matrix< Matrix, SymmGroup > const &m)
block_matrix< Matrix, SymmGroup > adjoin(block_matrix< Matrix, SymmGroup > const &m)
MPS< Matrix, SymmGroup >::scalar_type overlap(MPS< Matrix, SymmGroup > const &mps1, MPS< Matrix, SymmGroup > const &mps2)
definition of MPO class (vector of MPOTensor)
void svd(block_matrix< Matrix, SymmGroup > const &M, block_matrix< Matrix, SymmGroup > &U, block_matrix< Matrix, SymmGroup > &V, block_matrix< DiagMatrix, SymmGroup > &S)
MPSTensor< Matrix, SymmGroup >::scalar_type scalar_type
MPS< Matrix, SymmGroup >::scalar_type norm(MPS< Matrix, SymmGroup > const &mps)
Index< SymmGroup > const & right_basis() const
static Boundary< OtherMatrix, SymmGroup > overlap_mpo_left_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, Boundary< OtherMatrix, SymmGroup > const &left, MPOTensor< Matrix, SymmGroup > const &mpo)
Logger< storage::archive > log
void fix_density(MPS< Matrix, SymmGroup > &mps, std::vector< block_matrix< Matrix, SymmGroup > > const &dens_ops, std::vector< std::vector< double > > const &dens)
std::vector< scalar_type > traces() const
std::size_t insert(std::pair< charge, std::size_t > const &x)
void gemm(block_matrix< Matrix1, SymmGroup > const &A, block_matrix< Matrix2, SymmGroup > const &B, block_matrix< Matrix3, SymmGroup > &C)
void canonize(size_t center, DecompMethod method=DefaultSolver())
Index< SymmGroup > const & site_dim(size_t i) const
std::vector< double > calculate_bond_renyi_entropies(MPS< Matrix, SymmGroup > &mps, double n, std::vector< int > *measure_es_where=NULL, entanglement_spectrum_type *spectra=NULL)
Index< SymmGroup > const & left_basis() const
block_matrix< Matrix, SymmGroup > & data()
functions to contract tensor network states
alps::numeric::real_type< T >::type real(T f)
MPS< Matrix, SymmGroup >::scalar_type dm_trace(MPS< Matrix, SymmGroup > const &mps, Index< SymmGroup > const &phys_psi)
T fuse(const A &ind, T d)
Fuse indices n[i] into one p = n[i] d^i.