A contagem de incrementos de origem std::copy_n é mencionada no padrão?

Implementei um exemplo de iterador que conta cada incremento:

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>

template <class IteratorCategory = std::vector<int>::iterator::iterator_category>
class DereferenceCountingIterator : public std::vector<int>::iterator {
  public:
    using iterator_category = IteratorCategory;
  public:
    static std::size_t increaseCnt;

    DereferenceCountingIterator(
        typename std::vector<int>::iterator iter)
            : std::vector<int>::iterator(iter) {}

    auto& operator++() {
      ++increaseCnt;
      return std::vector<int>::iterator::operator++();
    }

    DereferenceCountingIterator<IteratorCategory> operator+(difference_type diff) {
        return static_cast<std::vector<int>::iterator&>(*this).operator+(diff);
    }
};

Esta classe de modelo pode funcionar tanto como RandomAccess quanto como iterador de entrada:

template<class IteratorCategory>
std::size_t DereferenceCountingIterator<IteratorCategory>::increaseCnt = 0;

using RandomAccessDereferenceContingIterator = DereferenceCountingIterator<>;
using NonRandomAccessDereferenceContingIterator
    = DereferenceCountingIterator<std::input_iterator_tag>;

O aplicativo com um exemplo:

int main() {
    auto vec = std::vector<int>{3, 4, 5};

    auto rAVecBegin = RandomAccessDereferenceContingIterator(vec.begin());
    auto nonRAVecBegin = NonRandomAccessDereferenceContingIterator(vec.begin());

    {
        const auto incBefore = RandomAccessDereferenceContingIterator::increaseCnt;
        auto out = std::vector<int>{};
        std::copy_n(rAVecBegin, 3, std::back_inserter(out));
        const auto incAfter = RandomAccessDereferenceContingIterator::increaseCnt;
        std::cout << incAfter - incBefore << std::endl;
    }

    {
        const auto incBefore = NonRandomAccessDereferenceContingIterator::increaseCnt;
        auto out = std::vector<int>{};
        std::copy_n(nonRAVecBegin, 3, std::back_inserter(out));
        const auto incAfter = NonRandomAccessDereferenceContingIterator::increaseCnt;
        std::cout << incAfter - incBefore << std::endl;
    }


    return 0;
}

A saída deste programa é a seguinte (in libstdc++e libc++):

3
2

Posso ter certeza de que isso aumenta copy_nexatamente n-1o iterador de origem se não for RandomAccessIterator e naumenta se for?