finite_chain.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/symmetry/block_tensor_storage.hpp>
#include <uni20/symmetry/space.hpp>
#include <uni20/tensor_network/site_types.hpp>
 
#include <cstddef>
#include <span>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace uni20::tensor_network
{
 
template <typename Scalar, Space Bond, Space Physical, BlockTensorStorage Storage = SeparateSparseBlockStorage<>>
class FiniteMps {
  public:
    using value_type = std::remove_cv_t<Scalar>;
    using bond_space_type = Bond;
    using physical_space_type = Physical;
    using storage_policy = Storage;
    using site_type = MpsSite<Scalar, Bond, Physical, Bond, Storage>;
 
    explicit FiniteMps(std::vector<site_type> sites) : sites_(std::move(sites)), revisions_(sites_.size())
    {
      this->validate();
    }
 
    auto size() const noexcept -> std::size_t { return sites_.size(); }
 
    auto symmetry() const -> Symmetry { return sites_.front().symmetry(); }
 
    auto site(std::size_t index) const -> site_type const& { return sites_.at(index); }
 
    auto sites() const noexcept -> std::span<site_type const> { return sites_; }
 
    auto revision(std::size_t index) const -> std::size_t { return revisions_.at(index); }
 
    void replace_site(std::size_t index, site_type replacement)
    {
      site_type const& current = sites_.at(index);
      if (replacement.symmetry() != this->symmetry() || replacement.domain() != current.domain() ||
          replacement.codomain() != current.codomain())
      {
        throw std::invalid_argument("FiniteMps replacement site must preserve every space");
      }
      sites_[index] = std::move(replacement);
      ++revisions_[index];
    }
 
    void replace_pair(std::size_t first_index, site_type first, site_type second)
    {
      if (first_index >= this->size() || first_index + 1 >= this->size())
        throw std::out_of_range("FiniteMps pair index is out of range");
 
      site_type const& current_first = sites_[first_index];
      site_type const& current_second = sites_[first_index + 1];
      if (first.symmetry() != this->symmetry() || second.symmetry() != this->symmetry() ||
          first.domain() != current_first.domain() || second.codomain() != current_second.codomain() ||
          second.domain().template space<1>() != current_second.domain().template space<1>() ||
          first.codomain().template space<0>() != second.domain().template space<0>())
      {
        throw std::invalid_argument("FiniteMps replacement pair has incompatible spaces");
      }
 
      sites_[first_index] = std::move(first);
      sites_[first_index + 1] = std::move(second);
      ++revisions_[first_index];
      ++revisions_[first_index + 1];
    }
 
  private:
    void validate() const
    {
      if (sites_.empty()) throw std::invalid_argument("FiniteMps requires at least one site");
      Symmetry const chain_symmetry = sites_.front().symmetry();
      for (std::size_t index = 0; index < sites_.size(); ++index)
      {
        if (sites_[index].symmetry() != chain_symmetry)
          throw std::invalid_argument("FiniteMps sites must share one symmetry");
        if (index + 1 < sites_.size() &&
            sites_[index].codomain().template space<0>() != sites_[index + 1].domain().template space<0>())
        {
          throw std::invalid_argument("FiniteMps adjacent bond spaces must compare exactly equal");
        }
      }
    }
 
    std::vector<site_type> sites_;
    std::vector<std::size_t> revisions_;
};
 
template <typename Scalar, Space Auxiliary, Space Physical, BlockTensorStorage Storage = SeparateSparseBlockStorage<>>
class FiniteMpo {
  public:
    using value_type = std::remove_cv_t<Scalar>;
    using auxiliary_space_type = Auxiliary;
    using physical_space_type = Physical;
    using storage_policy = Storage;
    using site_type = MpoSite<Scalar, Auxiliary, Physical, Auxiliary, Physical, Storage>;
 
    explicit FiniteMpo(std::vector<site_type> sites) : sites_(std::move(sites)), revisions_(sites_.size())
    {
      this->validate();
    }
 
    auto size() const noexcept -> std::size_t { return sites_.size(); }
 
    auto symmetry() const -> Symmetry { return sites_.front().symmetry(); }
 
    auto site(std::size_t index) const -> site_type const& { return sites_.at(index); }
 
    auto sites() const noexcept -> std::span<site_type const> { return sites_; }
 
    auto revision(std::size_t index) const -> std::size_t { return revisions_.at(index); }
 
    void replace_site(std::size_t index, site_type replacement)
    {
      site_type const& current = sites_.at(index);
      if (replacement.symmetry() != this->symmetry() || replacement.domain() != current.domain() ||
          replacement.codomain() != current.codomain())
      {
        throw std::invalid_argument("FiniteMpo replacement site must preserve every space");
      }
      sites_[index] = std::move(replacement);
      ++revisions_[index];
    }
 
  private:
    void validate() const
    {
      if (sites_.empty()) throw std::invalid_argument("FiniteMpo requires at least one site");
      Symmetry const chain_symmetry = sites_.front().symmetry();
      for (std::size_t index = 0; index < sites_.size(); ++index)
      {
        if (sites_[index].symmetry() != chain_symmetry)
          throw std::invalid_argument("FiniteMpo sites must share one symmetry");
        if (index + 1 < sites_.size() &&
            sites_[index].codomain().template space<0>() != sites_[index + 1].domain().template space<0>())
        {
          throw std::invalid_argument("FiniteMpo adjacent auxiliary spaces must compare exactly equal");
        }
      }
    }
 
    std::vector<site_type> sites_;
    std::vector<std::size_t> revisions_;
};
 
} // namespace uni20::tensor_network