diff --git a/libcxx/include/__iterator/concepts.h b/libcxx/include/__iterator/concepts.h
--- a/libcxx/include/__iterator/concepts.h
+++ b/libcxx/include/__iterator/concepts.h
@@ -57,6 +57,30 @@
     const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
   };
 
+// [iterator.concept.winc]
+template<class _Tp>
+inline constexpr bool __is_signed_integer_like = signed_integral<_Tp>;
+
+template<class _Ip>
+concept weakly_incrementable =
+  default_initializable<_Ip> &&
+  movable<_Ip> &&
+  requires(_Ip __i) {
+    typename iter_difference_t<_Ip>;
+    requires __is_signed_integer_like<iter_difference_t<_Ip> >;
+    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
+    __i++;                        // not required to be equality-preserving
+  };
+
+// [iterator.concept.inc]
+template<class _Ip>
+concept incrementable =
+  regular<_Ip> &&
+  weakly_incrementable<_Ip> &&
+  requires(_Ip __i) {
+    { __i++ } -> same_as<_Ip>;
+  };
+
 // clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -52,6 +52,14 @@
 template<class Out, class T>
   concept indirectly_writable = see below;                // since C++20
 
+// [iterator.concept.winc], concept weakly_­incrementable
+template<class I>
+  concept weakly_incrementable = see below;                // since C++20
+
+// [iterator.concept.inc], concept incrementable
+template<class I>
+  concept incrementable = see below;                       // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
@@ -438,6 +446,7 @@
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
+#include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
diff --git a/libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp
@@ -21,6 +21,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, int>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp
@@ -24,12 +24,16 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp
@@ -24,12 +24,16 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp
@@ -24,12 +24,16 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp
@@ -24,12 +24,16 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);
diff --git a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -21,3 +21,4 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp
@@ -18,7 +18,11 @@
 
 static_assert(std::indirectly_readable<fs::directory_iterator>);
 static_assert(!std::indirectly_writable<fs::directory_iterator, fs::directory_iterator::value_type>);
+static_assert(std::weakly_incrementable<fs::directory_iterator>);
+static_assert(!std::incrementable<fs::directory_iterator>);
 
 static_assert(std::indirectly_readable<fs::recursive_directory_iterator>);
 static_assert(
     !std::indirectly_writable<fs::recursive_directory_iterator, fs::recursive_directory_iterator::value_type>);
+static_assert(std::weakly_incrementable<fs::recursive_directory_iterator>);
+static_assert(!std::incrementable<fs::recursive_directory_iterator>);
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h
@@ -0,0 +1,183 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+#define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+
+struct postfix_increment_returns_void {
+  using difference_type = int;
+  postfix_increment_returns_void& operator++();
+  void operator++(int);
+};
+
+struct postfix_increment_returns_copy {
+  using difference_type = int;
+  postfix_increment_returns_copy& operator++();
+  postfix_increment_returns_copy operator++(int);
+};
+
+struct has_integral_minus {
+  has_integral_minus& operator++();
+  has_integral_minus operator++(int);
+
+  long operator-(has_integral_minus) const;
+};
+
+struct has_distinct_difference_type_and_minus {
+  using difference_type = short;
+
+  has_distinct_difference_type_and_minus& operator++();
+  has_distinct_difference_type_and_minus operator++(int);
+
+  long operator-(has_distinct_difference_type_and_minus) const;
+};
+
+struct missing_difference_type {
+  missing_difference_type& operator++();
+  void operator++(int);
+};
+
+struct floating_difference_type {
+  using difference_type = float;
+
+  floating_difference_type& operator++();
+  void operator++(int);
+};
+
+struct non_const_minus {
+  non_const_minus& operator++();
+  non_const_minus operator++(int);
+
+  long operator-(non_const_minus);
+};
+
+struct non_integral_minus {
+  non_integral_minus& operator++();
+  non_integral_minus operator++(int);
+
+  void operator-(non_integral_minus);
+};
+
+struct bad_difference_type_good_minus {
+  using difference_type = float;
+
+  bad_difference_type_good_minus& operator++();
+  void operator++(int);
+
+  int operator-(bad_difference_type_good_minus) const;
+};
+
+struct not_default_initializable {
+  using difference_type = int;
+  not_default_initializable() = delete;
+
+  not_default_initializable& operator++();
+  void operator++(int);
+};
+
+struct not_movable {
+  using difference_type = int;
+
+  not_movable() = default;
+  not_movable(not_movable&&) = delete;
+
+  not_movable& operator++();
+  void operator++(int);
+};
+
+struct preinc_not_declared {
+  using difference_type = int;
+
+  void operator++(int);
+};
+
+struct postinc_not_declared {
+  using difference_type = int;
+
+  postinc_not_declared& operator++();
+};
+
+struct incrementable_with_difference_type {
+  using difference_type = int;
+
+  incrementable_with_difference_type& operator++();
+  incrementable_with_difference_type operator++(int);
+
+  bool operator==(incrementable_with_difference_type const&) const;
+};
+
+struct incrementable_without_difference_type {
+  incrementable_without_difference_type& operator++();
+  incrementable_without_difference_type operator++(int);
+
+  bool operator==(incrementable_without_difference_type const&) const;
+
+  int operator-(incrementable_without_difference_type) const;
+};
+
+struct difference_type_and_void_minus {
+  using difference_type = int;
+
+  difference_type_and_void_minus& operator++();
+  difference_type_and_void_minus operator++(int);
+
+  bool operator==(difference_type_and_void_minus const&) const;
+
+  void operator-(difference_type_and_void_minus) const;
+};
+
+struct noncopyable_with_difference_type {
+  using difference_type = int;
+
+  noncopyable_with_difference_type() = default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type&&) = default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type const&) = delete;
+
+  noncopyable_with_difference_type& operator=(noncopyable_with_difference_type&&) = default;
+  noncopyable_with_difference_type& operator=(noncopyable_with_difference_type const&) = delete;
+
+  noncopyable_with_difference_type& operator++();
+  noncopyable_with_difference_type operator++(int);
+
+  bool operator==(noncopyable_with_difference_type const&) const;
+};
+
+struct noncopyable_without_difference_type {
+  noncopyable_without_difference_type() = default;
+  noncopyable_without_difference_type(noncopyable_without_difference_type&&) = default;
+  noncopyable_without_difference_type(noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type& operator=(noncopyable_without_difference_type&&) = default;
+  noncopyable_without_difference_type& operator=(noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type& operator++();
+  noncopyable_without_difference_type operator++(int);
+
+  int operator-(noncopyable_without_difference_type const&) const;
+
+  bool operator==(noncopyable_without_difference_type const&) const;
+};
+
+struct noncopyable_with_difference_type_and_minus {
+  using difference_type = int;
+
+  noncopyable_with_difference_type_and_minus() = default;
+  noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus& operator++();
+  noncopyable_with_difference_type_and_minus operator++(int);
+
+  int operator-(noncopyable_with_difference_type_and_minus const&) const;
+
+  bool operator==(noncopyable_with_difference_type_and_minus const&) const;
+};
+
+#endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept indirectly_readable;
+
+#include <iterator>
+
+#include <concepts>
+#include <memory>
+#include <optional>
+
+#include "../incrementable.h"
+
+static_assert(std::incrementable<int>);
+static_assert(std::incrementable<int*>);
+static_assert(std::incrementable<int**>);
+
+static_assert(!std::incrementable<postfix_increment_returns_void>);
+static_assert(!std::incrementable<postfix_increment_returns_copy>);
+static_assert(!std::incrementable<has_integral_minus>);
+static_assert(!std::incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::incrementable<missing_difference_type>);
+static_assert(!std::incrementable<floating_difference_type>);
+static_assert(!std::incrementable<non_const_minus>);
+static_assert(!std::incrementable<non_integral_minus>);
+static_assert(!std::incrementable<bad_difference_type_good_minus>);
+static_assert(!std::incrementable<not_default_initializable>);
+static_assert(!std::incrementable<not_movable>);
+static_assert(!std::incrementable<preinc_not_declared>);
+static_assert(!std::incrementable<postinc_not_declared>);
+static_assert(std::incrementable<incrementable_with_difference_type>);
+static_assert(std::incrementable<incrementable_without_difference_type>);
+static_assert(std::incrementable<difference_type_and_void_minus>);
+static_assert(!std::incrementable<noncopyable_with_difference_type>);
+static_assert(!std::incrementable<noncopyable_without_difference_type>);
+static_assert(!std::incrementable<noncopyable_with_difference_type_and_minus>);
diff --git a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/subsumption.compile.pass.cpp
copy from libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
copy to libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/subsumption.compile.pass.cpp
--- a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/subsumption.compile.pass.cpp
@@ -10,14 +10,24 @@
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// iterator, reverse_iterator
-
-#include <span>
+// template<class T>
+// concept incrementable;
 
 #include <iterator>
 
-using iterator = std::span<int>::iterator;
-using value_type = iterator::value_type;
+#include <concepts>
+
+// clang-format off
+template<std::weakly_incrementable I>
+requires std::regular<I>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::incrementable>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
 
-static_assert(std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(check_subsumption<int*>());
diff --git a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/subsumption.compile.pass.cpp
copy from libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
copy to libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/subsumption.compile.pass.cpp
--- a/libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/subsumption.compile.pass.cpp
@@ -10,14 +10,24 @@
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// iterator, reverse_iterator
-
-#include <span>
+// template<class T>
+// concept weakly_incrementable;
 
 #include <iterator>
 
-using iterator = std::span<int>::iterator;
-using value_type = iterator::value_type;
+#include <concepts>
+
+// clang-format off
+template<std::default_initializable I>
+requires std::movable<I>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::weakly_incrementable>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
 
-static_assert(std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(check_subsumption<int*>());
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept std::weakly_incrementable;
+
+#include <iterator>
+
+#include <concepts>
+#include <memory>
+#include <optional>
+
+#include "../incrementable.h"
+
+static_assert(std::weakly_incrementable<int>);
+static_assert(std::weakly_incrementable<int*>);
+static_assert(std::weakly_incrementable<int**>);
+static_assert(!std::weakly_incrementable<int[]>);
+static_assert(!std::weakly_incrementable<int[10]>);
+static_assert(!std::weakly_incrementable<double>);
+static_assert(!std::weakly_incrementable<int&>);
+static_assert(!std::weakly_incrementable<int()>);
+static_assert(!std::weakly_incrementable<int (*)()>);
+static_assert(!std::weakly_incrementable<int (&)()>);
+
+struct S {};
+static_assert(!std::weakly_incrementable<int S::*>);
+
+#define CHECK_POINTER_TO_MEMBER_FUNCTIONS(qualifier)                                                                   \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier>);                                                   \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier noexcept>);                                          \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&>);                                                  \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier & noexcept>);                                        \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&&>);                                                 \
+  static_assert(!std::weakly_incrementable < int (S::*)() qualifier&& noexcept >);
+
+#define NO_QUALIFIER
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(NO_QUALIFIER);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(volatile);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const volatile);
+
+static_assert(std::weakly_incrementable<postfix_increment_returns_void>);
+static_assert(std::weakly_incrementable<postfix_increment_returns_copy>);
+static_assert(std::weakly_incrementable<has_integral_minus>);
+static_assert(std::weakly_incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::weakly_incrementable<missing_difference_type>);
+static_assert(!std::weakly_incrementable<floating_difference_type>);
+static_assert(!std::weakly_incrementable<non_const_minus>);
+static_assert(!std::weakly_incrementable<non_integral_minus>);
+static_assert(!std::weakly_incrementable<bad_difference_type_good_minus>);
+static_assert(!std::weakly_incrementable<not_default_initializable>);
+static_assert(!std::weakly_incrementable<not_movable>);
+static_assert(!std::weakly_incrementable<preinc_not_declared>);
+static_assert(!std::weakly_incrementable<postinc_not_declared>);
+static_assert(std::weakly_incrementable<incrementable_with_difference_type>);
+static_assert(std::weakly_incrementable<incrementable_without_difference_type>);
+static_assert(std::weakly_incrementable<difference_type_and_void_minus>);
+static_assert(std::weakly_incrementable<noncopyable_with_difference_type>);
+static_assert(std::weakly_incrementable<noncopyable_without_difference_type>);
+static_assert(std::weakly_incrementable<noncopyable_with_difference_type_and_minus>);
diff --git a/libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -19,3 +19,4 @@
 using iterator = std::back_insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -19,3 +19,4 @@
 using iterator = std::front_insert_iterator<std::list<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -19,3 +19,4 @@
 using iterator = std::insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -17,3 +17,4 @@
 using iterator = std::move_iterator<int*>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -17,3 +17,4 @@
 using iterator = std::reverse_iterator<int*>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -19,3 +19,4 @@
 using iterator = std::istream_iterator<int, std::istream>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -20,3 +20,5 @@
 using iterator = std::istreambuf_iterator<char>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(!std::incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -19,3 +19,4 @@
 using iterator = std::ostream_iterator<int, std::ostream>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);
diff --git a/libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -20,3 +20,4 @@
 using iterator = std::ostreambuf_iterator<char>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, char>);
+static_assert(!std::weakly_incrementable<iterator>);
diff --git a/libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp
@@ -18,3 +18,4 @@
 
 static_assert(std::indirectly_readable<std::cregex_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_iterator, char>);
+static_assert(std::incrementable<std::cregex_iterator>);
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp
@@ -18,3 +18,4 @@
 
 static_assert(std::indirectly_readable<std::cregex_token_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_token_iterator, char>);
+static_assert(std::incrementable<std::cregex_token_iterator>);
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -22,6 +22,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -21,6 +21,8 @@
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, char>);
+static_assert(std::incrementable<const_iterator>);
diff --git a/libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp
@@ -18,6 +18,8 @@
 
 static_assert(std::indirectly_readable<std::unique_ptr<int> >);
 static_assert(std::indirectly_writable<std::unique_ptr<int>, int>);
+static_assert(!std::weakly_incrementable<std::unique_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::unique_ptr<void> >);
 static_assert(!std::indirectly_writable<std::unique_ptr<void>, void>);
+static_assert(!std::weakly_incrementable<std::unique_ptr<void> >);
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp
@@ -18,6 +18,8 @@
 
 static_assert(std::indirectly_readable<std::shared_ptr<int> >);
 static_assert(std::indirectly_writable<std::shared_ptr<int>, int>);
+static_assert(!std::weakly_incrementable<std::shared_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::shared_ptr<void> >);
 static_assert(!std::indirectly_writable<std::shared_ptr<void>, void>);
+static_assert(!std::weakly_incrementable<std::shared_ptr<void> >);
diff --git a/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp
@@ -18,3 +18,4 @@
 
 static_assert(!std::indirectly_readable<std::optional<int> >);
 static_assert(!std::indirectly_writable<std::optional<int>, int>);
+static_assert(!std::weakly_incrementable<std::optional<int> >);