namespace alps {
  template<typename I> class site_basis_match;
  template<typename I> class BasisDescriptor;
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, const alps::site_basis_match< I > & q);
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, const alps::BasisDescriptor< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::site_basis_match< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::BasisDescriptor< I > & q);
}

namespace alps {
  template<typename I, typename S = site_state<I> > 
    class basis_states_descriptor;
  template<typename I, typename S = std::vector<I>, 
           typename SS = site_state<I> > 
    class basis_states;
  template<typename I = unsigned int, typename J = short, 
           typename S = integer_state<I>, 
           typename SS = basis_states_descriptor<J> > 
    class lookup_basis_states;
  template<typename I, typename S, typename SS> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::basis_states< I, S, SS > & q);
  template<typename I, typename J, typename S, typename SS> 
    std::ostream & 
    operator<<(std::ostream & out, 
               const alps::lookup_basis_states< I, J, S, SS > & q);
}

namespace alps {
  template<typename I, typename S = std::vector<I>, 
           typename SS = site_state<I> > 
    class bloch_basis_states;
  template<typename I, typename S, typename SS> 
    std::ostream & 
    operator<<(std::ostream & out, 
               const alps::bloch_basis_states< I, S, SS > & q);
}

namespace alps {
  template<typename I, typename T = std::complex<double> > 
    class BondOperatorSplitter;
  class BondOperator;
  template<typename I, typename T> 
    boost::multi_array< std::pair< T, bool >, 4 > 
    get_fermionic_matrix(T, const BondOperator & m, 
                         const SiteBasisDescriptor< I > & basis1, 
                         const SiteBasisDescriptor< I > & basis2, 
                         const Parameters & p = Parameters());
  template<typename T, typename I> 
    boost::multi_array< T, 4 > 
    get_matrix(T, const BondOperator & m, 
               const SiteBasisDescriptor< I > & basis1, 
               const SiteBasisDescriptor< I > & basis2, 
               const Parameters & p = Parameters());
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::BondOperator & q);
  std::ostream & operator<<(std::ostream & out, const alps::BondOperator & q);
}

namespace alps {
  class BondTermDescriptor;
  template<typename I, typename T, typename STATE1, typename STATE2> 
    class BondOperatorEvaluator;
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::BondTermDescriptor & q);
  std::ostream & 
  operator<<(std::ostream & out, const alps::BondTermDescriptor & q);
}

namespace alps {
  template<typename TERM> class DefaultTermDescriptor;

  typedef DefaultTermDescriptor< SiteTermDescriptor > DefaultSiteTermDescriptor;
  typedef DefaultTermDescriptor< BondTermDescriptor > DefaultBondTermDescriptor;
  template<typename TERM> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, 
               const alps::DefaultTermDescriptor< TERM > & q);
  template<typename TERM> 
    std::ostream & 
    operator<<(std::ostream & out, 
               const alps::DefaultTermDescriptor< TERM > & q);
}

namespace alps {
  class GlobalOperator;
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::GlobalOperator & q);
  std::ostream & 
  operator<<(std::ostream & out, const alps::GlobalOperator & q);
}

namespace alps {
  template<typename I> class half_integer;
  template<typename I> double to_double(const half_integer< I > & x);
  template<typename I> I to_integer(const half_integer< I > & x);
  template<typename T> bool is_odd(T x);
  template<typename I> bool is_odd(const half_integer< I > & x);
  template<typename I> half_integer< I > abs(const half_integer< I > & x);
  template<typename I> 
    bool operator==(double x, const alps::half_integer< I > & y);
  template<typename I> 
    bool operator!=(double x, const alps::half_integer< I > & y);
  template<typename I> 
    bool operator<(double x, const alps::half_integer< I > & y);
  template<typename I> 
    bool operator>(double x, const alps::half_integer< I > & y);
  template<typename I> 
    bool operator<=(double x, const alps::half_integer< I > & y);
  template<typename I> 
    bool operator>=(double x, const alps::half_integer< I > & y);
  template<typename I> 
    alps::half_integer< I > 
    operator+(double x, const alps::half_integer< I > & y);
  template<typename I> 
    alps::half_integer< I > 
    operator-(double x, const alps::half_integer< I > & y);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & os, const alps::half_integer< I > & x);
  template<typename I> 
    std::istream & operator>>(std::istream & is, alps::half_integer< I > & x);
}

namespace alps {
  template<typename I> class HamiltonianDescriptor;
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, 
               const alps::HamiltonianDescriptor< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::HamiltonianDescriptor< I > & q);
}

namespace alps {
  template<typename M, typename G = typename graph_helper<>::graph_type> 
    class hamiltonian_matrix;
}

namespace alps {
  template<typename I, int N> class integer_state;

  template<typename I> class integer_state<I, 1>;
  template<typename I, int N> 
    bool operator==(integer_state< I, N > x, integer_state< I, N > y);
  template<typename I, int N> 
    bool operator<(integer_state< I, N > x, integer_state< I, N > y);
}

namespace alps {
  template<typename I = short> class model_helper;
}

namespace alps {
  class ModelLibrary;
  alps::oxstream & 
  operator<<(alps::oxstream & os, const alps::ModelLibrary & l);
  std::ostream & operator<<(std::ostream & os, const alps::ModelLibrary & l);
  std::istream & operator>>(std::istream & is, alps::ModelLibrary & l);
}

namespace alps {
  template<typename T = std::complex<double> > class OperatorEvaluator;
}

namespace alps {
  template<typename I> class OperatorDescriptor;
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, const alps::OperatorDescriptor< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::OperatorDescriptor< I > & q);
}

namespace alps {
  template<typename T = std::complex<double> > class OperatorSubstitution;
}

namespace alps {
  template<typename I> class QuantumNumberDescriptor;
  template<typename I> 
    bool operator<(const QuantumNumberDescriptor< I > & q1, 
                   const QuantumNumberDescriptor< I > & q2);
  template<typename I> 
    QuantumNumberDescriptor< I > 
    operator+(const QuantumNumberDescriptor< I > & x, 
              const QuantumNumberDescriptor< I > & y);
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, 
               const alps::QuantumNumberDescriptor< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, 
               const alps::QuantumNumberDescriptor< I > & q);
}

namespace alps {
  template<typename EdgeWeightMap> struct nonzero_edge_weight;
  template<typename G, typename B> 
    bool is_frustrated(const G & graph, B bond_map);
  template<typename G, typename B, typename S> 
    bool is_frustrated(const G & graph, B bond_map, S site_map);
  template<typename I, typename G> 
    bool has_sign_problem(const HamiltonianDescriptor< I > & ham, 
                          const graph_helper< G > & lattice, 
                          const Parameters & p);
}

namespace alps {
  template<typename I> class SiteBasisDescriptor;
  template<typename I> 
    alps::oxstream & 
    operator<<(alps::oxstream & out, const alps::SiteBasisDescriptor< I > & q);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::SiteBasisDescriptor< I > & q);
}

namespace alps {
  template<typename I, typename STATE = site_state<I> > class site_basis;
  template<typename I, typename STATE> 
    bool is_fermionic(const site_basis< I, STATE > & b, int s);
  template<typename I, typename STATE> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::site_basis< I, STATE > & s);
}

namespace alps {
  template<typename I, typename T = std::complex<double> > 
    class SiteOperatorSplitter;
  class SiteOperator;
  template<typename T, typename I> 
    boost::multi_array< std::pair< T, bool >, 2 > 
    get_fermionic_matrix(T, const SiteOperator & m, 
                         const SiteBasisDescriptor< I > & basis1, 
                         const Parameters & p = Parameters());
  template<typename T, typename I> 
    boost::multi_array< T, 2 > 
    get_matrix(T, const SiteOperator & m, 
               const SiteBasisDescriptor< I > & basis1, 
               const Parameters & p = Parameters(), 
               bool ignore_fermion = false);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::SiteOperator & q);
  std::ostream & operator<<(std::ostream & out, const alps::SiteOperator & q);
}

namespace alps {
  template<typename I> class site_state;
  template<typename I> class single_qn_site_state;
  template<typename I> 
    bool operator<(const single_qn_site_state< I > & x, 
                   const single_qn_site_state< I > & y);
  template<typename I> 
    bool operator>(const single_qn_site_state< I > & x, 
                   const single_qn_site_state< I > & y);
  template<typename I> 
    bool operator==(const single_qn_site_state< I > & x, 
                    const single_qn_site_state< I > & y);
  template<typename I> 
    bool operator<=(const single_qn_site_state< I > & x, 
                    const single_qn_site_state< I > & y);
  template<typename I> 
    bool operator>=(const single_qn_site_state< I > & x, 
                    const single_qn_site_state< I > & y);
  template<typename I> 
    half_integer< I > 
    get_quantumnumber(const site_state< I > & s, 
                      typename site_state< I >::size_type i);
  template<typename I> 
    half_integer< I > 
    get_quantumnumber(const single_qn_site_state< I > & s, std::size_t i);
  template<typename I> 
    half_integer< I > & 
    get_quantumnumber(site_state< I > & s, 
                      typename site_state< I >::size_type i);
  template<typename I> 
    half_integer< I > & 
    get_quantumnumber(single_qn_site_state< I > & s, std::size_t i);
  template<typename I> 
    std::size_t get_quantumnumber_index(const std::string & n, 
                                        const SiteBasisDescriptor< I > & b);
  template<typename S, typename I> 
    S::quantumnumber_type 
    get_quantumnumber(const S & s, const std::string & n, 
                      const SiteBasisDescriptor< I > & b);
  template<typename I, typename S> 
    bool is_fermionic(const SiteBasisDescriptor< I > & b, const S & s);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::site_state< I > & s);
  template<typename I> 
    std::ostream & 
    operator<<(std::ostream & out, const alps::single_qn_site_state< I > & s);
}

namespace alps {
  class SiteTermDescriptor;
  template<typename I, typename T, typename STATE> 
    class SiteOperatorEvaluator;
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::SiteTermDescriptor & q);
  std::ostream & 
  operator<<(std::ostream & out, const alps::SiteTermDescriptor & q);
}

namespace alps {
  std::string substitute(std::string const & text, unsigned int type);
  Parameters substitute(Parameters const & parms, unsigned int type);
}