diff --git a/libcxx/include/__ranges/concepts.h b/libcxx/include/__ranges/concepts.h
--- a/libcxx/include/__ranges/concepts.h
+++ b/libcxx/include/__ranges/concepts.h
@@ -11,6 +11,7 @@
 
 #include <__config>
 #include <__ranges/access.h>
+#include <iterator>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -50,6 +51,11 @@
 
 template <range R>
 using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R> >;
+
+// [range.refinements]
+template <class _Tp>
+concept input_range = range<_Tp>&& input_iterator<iterator_t<_Tp> >;
+
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -84,6 +84,10 @@
 template<class S, class I>
   concept sentinel_for = see below;                        // since C++20
 
+// [iterator.concept.input], concept input_­iterator
+template<class I>
+  concept input_iterator = see below;                      // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
@@ -2599,6 +2603,14 @@
   input_or_output_iterator<_Ip> &&
   __weakly_equality_comparable_with<_Sp, _Ip>;
 
+// [iterator.concept.input]
+template<class _Ip>
+concept input_iterator =
+  input_or_output_iterator<_Ip> &&
+  indirectly_readable<_Ip> &&
+  requires { typename _ITER_CONCEPT<_Ip>; } &&
+  derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
+
 #undef _LIBCPP_NOEXCEPT_RETURN
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -38,6 +38,10 @@
 //     using range_reference_t = iter_reference_t<iterator_t<R>>;
 //   template<range R>
 //     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
+//
+//   // [range.refinements], other range refinements
+//   template<class T>
+//     concept input_range = see below;
 // }
 
 #ifndef _LIBCPP_RANGES
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_iterator.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_iterator.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_iterator.compile.pass.cpp
@@ -0,0 +1,252 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 T>
+// concept input_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "test_iterators.h"
+
+static_assert(!std::copyable<noncopyable_input_iterator> &&
+              std::input_iterator<noncopyable_input_iterator>);
+static_assert(std::input_iterator<input_iterator<std::vector<int>::iterator> >);
+
+struct no_explicit_iter_concept {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+
+  no_explicit_iter_concept() = default;
+
+  no_explicit_iter_concept(no_explicit_iter_concept&&) = default;
+  no_explicit_iter_concept& operator=(no_explicit_iter_concept&&) = default;
+
+  no_explicit_iter_concept(no_explicit_iter_concept const&) = delete;
+  no_explicit_iter_concept& operator=(no_explicit_iter_concept const&) = delete;
+
+  value_type operator*() const;
+
+  no_explicit_iter_concept& operator++();
+  void operator++(int);
+};
+// ITER-CONCEPT is `random_access_iterator_tag` >:(
+static_assert(std::input_iterator<no_explicit_iter_concept>);
+
+namespace standard_types {
+static_assert(std::input_iterator<int*>);
+static_assert(std::input_iterator<int const*>);
+static_assert(std::input_iterator<int volatile*>);
+static_assert(std::input_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::input_iterator<std::array<int, 10>::iterator>);
+static_assert(std::input_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::input_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::input_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::input_iterator<std::deque<int>::iterator>);
+static_assert(std::input_iterator<std::deque<int>::const_iterator>);
+static_assert(std::input_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::input_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::input_iterator<std::filesystem::directory_iterator>);
+static_assert(
+    std::input_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::input_iterator<std::forward_list<int>::iterator>);
+static_assert(std::input_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(
+    !std::input_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(
+    !std::input_iterator<std::front_insert_iterator<std::deque<int> > >);
+static_assert(!std::input_iterator<std::insert_iterator<std::deque<int> > >);
+static_assert(
+    std::input_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(std::input_iterator<std::list<int>::iterator>);
+static_assert(std::input_iterator<std::list<int>::const_iterator>);
+static_assert(std::input_iterator<std::list<int>::reverse_iterator>);
+static_assert(std::input_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::input_iterator<std::map<int, int>::iterator>);
+static_assert(std::input_iterator<std::map<int, int>::const_iterator>);
+static_assert(std::input_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(std::input_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::input_iterator<std::multimap<int, int>::iterator>);
+static_assert(std::input_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(std::input_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(
+    std::input_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <memory>
+static_assert(!std::input_iterator<std::shared_ptr<int> >);
+static_assert(!std::input_iterator<std::shared_ptr<void> >);
+static_assert(!std::input_iterator<std::unique_ptr<int> >);
+static_assert(!std::input_iterator<std::unique_ptr<void> >);
+
+// <optional>
+static_assert(!std::input_iterator<std::optional<int> >);
+
+// <set>
+static_assert(std::input_iterator<std::set<int>::iterator>);
+static_assert(std::input_iterator<std::set<int>::const_iterator>);
+static_assert(std::input_iterator<std::set<int>::reverse_iterator>);
+static_assert(std::input_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::input_iterator<std::multiset<int>::iterator>);
+static_assert(std::input_iterator<std::multiset<int>::const_iterator>);
+static_assert(std::input_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(std::input_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::input_iterator<std::string::iterator>);
+static_assert(std::input_iterator<std::string::const_iterator>);
+static_assert(std::input_iterator<std::string::reverse_iterator>);
+static_assert(std::input_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::input_iterator<std::string_view::iterator>);
+static_assert(std::input_iterator<std::string_view::const_iterator>);
+static_assert(std::input_iterator<std::string_view::reverse_iterator>);
+static_assert(std::input_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(std::input_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(
+    std::input_iterator<std::unordered_map<int, int>::const_iterator>);
+
+static_assert(std::input_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(
+    std::input_iterator<std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(std::input_iterator<std::unordered_set<int>::iterator>);
+static_assert(std::input_iterator<std::unordered_set<int>::const_iterator>);
+
+static_assert(std::input_iterator<std::unordered_multiset<int, int>::iterator>);
+static_assert(
+    std::input_iterator<std::unordered_multiset<int, int>::const_iterator>);
+
+// <vector>
+static_assert(std::input_iterator<std::vector<int>::iterator>);
+static_assert(std::input_iterator<std::vector<int>::const_iterator>);
+static_assert(std::input_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::input_iterator<std::vector<int>::const_reverse_iterator>);
+static_assert(!std::input_iterator<std::vector<int> >);
+} // namespace standard_types
+
+struct not_weakly_incrementable {
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  not_weakly_incrementable() = default;
+
+  not_weakly_incrementable(not_weakly_incrementable&&) = default;
+  not_weakly_incrementable& operator=(not_weakly_incrementable&&) = default;
+
+  not_weakly_incrementable(not_weakly_incrementable const&) = delete;
+  not_weakly_incrementable& operator=(not_weakly_incrementable const&) = delete;
+
+  int operator*() const;
+
+  not_weakly_incrementable& operator++();
+};
+static_assert(!std::input_or_output_iterator<not_weakly_incrementable> &&
+              !std::input_iterator<not_weakly_incrementable>);
+
+struct not_indirectly_readable {
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  not_indirectly_readable() = default;
+
+  not_indirectly_readable(not_indirectly_readable&&) = default;
+  not_indirectly_readable& operator=(not_indirectly_readable&&) = default;
+
+  not_indirectly_readable(not_indirectly_readable const&) = delete;
+  not_indirectly_readable& operator=(not_indirectly_readable const&) = delete;
+
+  int operator*() const;
+
+  not_indirectly_readable& operator++();
+  void operator++(int);
+};
+static_assert(!std::indirectly_readable<not_indirectly_readable> &&
+              !std::input_iterator<not_indirectly_readable>);
+
+struct bad_iterator_category {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_category = void;
+
+  bad_iterator_category() = default;
+
+  bad_iterator_category(bad_iterator_category&&) = default;
+  bad_iterator_category& operator=(bad_iterator_category&&) = default;
+
+  bad_iterator_category(bad_iterator_category const&) = delete;
+  bad_iterator_category& operator=(bad_iterator_category const&) = delete;
+
+  value_type operator*() const;
+
+  bad_iterator_category& operator++();
+  void operator++(int);
+};
+static_assert(!std::input_iterator<bad_iterator_category>);
+
+struct bad_iterator_concept {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = void*;
+
+  bad_iterator_concept() = default;
+
+  bad_iterator_concept(bad_iterator_concept&&) = default;
+  bad_iterator_concept& operator=(bad_iterator_concept&&) = default;
+
+  bad_iterator_concept(bad_iterator_concept const&) = delete;
+  bad_iterator_concept& operator=(bad_iterator_concept const&) = delete;
+
+  value_type operator*() const;
+
+  bad_iterator_concept& operator++();
+  void operator++(int);
+};
+static_assert(!std::input_iterator<bad_iterator_concept>);
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/subsumption.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/subsumption.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/subsumption.compile.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 T>
+// concept input_iterator;
+
+#include <iterator>
+
+#include <concepts>
+
+// clang-format off
+template<std::input_or_output_iterator I>
+requires std::indirectly_readable<I> &&
+         std::derived_from<std::_ITER_CONCEPT<I>, std::input_iterator_tag>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::input_iterator>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_subsumption<int*>());
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/locale_dependent.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/locale_dependent.compile.pass.cpp
--- a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/locale_dependent.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/locale_dependent.compile.pass.cpp
@@ -28,17 +28,21 @@
 static_assert(std::input_or_output_iterator<std::istream_iterator<int, char> >);
 static_assert(std::sentinel_for<std::istream_iterator<int, char>,
                                 std::istream_iterator<int, char> >);
+static_assert(std::input_iterator<std::istream_iterator<int, char> >);
 
 static_assert(std::input_or_output_iterator<std::istreambuf_iterator<char> >);
 static_assert(std::sentinel_for<std::istreambuf_iterator<char>,
                                 std::istreambuf_iterator<char> >);
+static_assert(std::input_iterator<std::istreambuf_iterator<char> >);
 
 static_assert(
     !std::input_or_output_iterator<std::ostream_iterator<int, char> >);
 static_assert(!std::sentinel_for<std::ostream_iterator<int, char>,
                                  std::ostream_iterator<int, char> >);
+static_assert(!std::input_iterator<std::ostream_iterator<int, char> >);
 
 static_assert(
     !std::input_or_output_iterator<std::ostreambuf_iterator<int, char> >);
 static_assert(!std::sentinel_for<std::ostreambuf_iterator<int, char>,
                                  std::ostreambuf_iterator<int, char> >);
+static_assert(!std::input_iterator<std::ostreambuf_iterator<int, char> >);
diff --git a/libcxx/test/std/ranges/range.refinements/input_range.compile.pass.cpp b/libcxx/test/std/ranges/range.refinements/input_range.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.refinements/input_range.compile.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<range _Rp>
+// concept input_range;
+
+#include <ranges>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "test_range.h"
+
+namespace stdr = std::ranges;
+
+static_assert(stdr::input_range<std::array<int, 10> >);
+static_assert(stdr::input_range<std::deque<int> >);
+static_assert(stdr::input_range<std::forward_list<int> >);
+static_assert(stdr::input_range<std::list<int> >);
+static_assert(stdr::input_range<std::map<int, long> >);
+static_assert(stdr::input_range<std::multimap<int, long> >);
+static_assert(stdr::input_range<std::multiset<int> >);
+static_assert(stdr::input_range<std::set<int> >);
+static_assert(stdr::input_range<std::string>);
+static_assert(stdr::input_range<std::string_view>);
+static_assert(stdr::input_range<std::unordered_map<int, long> >);
+static_assert(stdr::input_range<std::unordered_multimap<int, long> >);
+static_assert(stdr::input_range<std::unordered_multiset<int> >);
+static_assert(stdr::input_range<std::unordered_set<int> >);
+static_assert(stdr::input_range<std::vector<int> >);
+
+static_assert(stdr::input_range<input_range<std::array<int, 10> > >);
+static_assert(stdr::input_range<input_range<std::deque<int> > >);
+static_assert(stdr::input_range<input_range<std::forward_list<int> > >);
+static_assert(stdr::input_range<input_range<std::list<int> > >);
+static_assert(stdr::input_range<input_range<std::map<int, long> > >);
+static_assert(stdr::input_range<input_range<std::multimap<int, long> > >);
+static_assert(stdr::input_range<input_range<std::multiset<int> > >);
+static_assert(stdr::input_range<input_range<std::set<int> > >);
+static_assert(stdr::input_range<input_range<std::string> >);
+static_assert(stdr::input_range<input_range<std::string_view> >);
+static_assert(stdr::input_range<input_range<std::unordered_map<int, long> > >);
+static_assert(
+    stdr::input_range<input_range<std::unordered_multimap<int, long> > >);
+static_assert(stdr::input_range<input_range<std::unordered_multiset<int> > >);
+static_assert(stdr::input_range<input_range<std::unordered_set<int> > >);
+static_assert(stdr::input_range<input_range<std::vector<int> > >);
diff --git a/libcxx/test/std/ranges/range.refinements/subsumption.compile.pass.cpp b/libcxx/test/std/ranges/range.refinements/subsumption.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.refinements/subsumption.compile.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 T>
+// concept input_iterator;
+
+#include <ranges>
+
+#include <iterator>
+#include <vector>
+
+// clang-format off
+template<std::ranges::range R>
+[[nodiscard]] constexpr bool check_input_range_subsumption() {
+  return false;
+}
+
+template<std::ranges::input_range>
+[[nodiscard]] constexpr bool check_input_range_subsumption() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_input_range_subsumption<std::vector<int> >());
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -632,6 +632,26 @@
 bool operator!= (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
 {   return !a.operator==(b); }
 
+struct noncopyable_input_iterator {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  noncopyable_input_iterator() = default;
+
+  noncopyable_input_iterator(noncopyable_input_iterator&&) = default;
+  noncopyable_input_iterator& operator=(noncopyable_input_iterator&&) = default;
+
+  noncopyable_input_iterator(noncopyable_input_iterator const&) = delete;
+  noncopyable_input_iterator&
+  operator=(noncopyable_input_iterator const&) = delete;
+
+  value_type operator*() const;
+
+  noncopyable_input_iterator& operator++();
+  void operator++(int);
+};
+
 #undef DELETE_FUNCTION
 
 #endif  // ITERATORS_H
diff --git a/libcxx/test/support/test_range.h b/libcxx/test/support/test_range.h
--- a/libcxx/test/support/test_range.h
+++ b/libcxx/test/support/test_range.h
@@ -10,6 +10,8 @@
 
 #include <ranges>
 
+#include "test_iterators.h"
+
 #ifdef _LIBCPP_HAS_NO_RANGES
 #error "test/suppoort/test_range.h" can only be included in builds supporting ranges
 #endif
@@ -26,4 +28,12 @@
   sentinel end() const;
 };
 
+template <class R>
+struct input_range {
+  input_iterator<std::ranges::iterator_t<R> > begin();
+  input_iterator<std::ranges::iterator_t<R const> > begin() const;
+  sentinel end();
+  sentinel end() const;
+};
+
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H