diff --git a/stl/inc/ranges b/stl/inc/ranges
index 1a435dccc7..b7e82235f2 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -5488,13 +5488,17 @@ namespace ranges {
 #endif // _HAS_CXX23
 
     template <class _Tuple, size_t _Index>
-    concept _Has_tuple_element = //
+    concept _Has_tuple_element =
+#if _HAS_CXX23
+        _Tuple_like<_Tuple> && _Index < tuple_size_v<_Tuple>;
+#else // ^^^ C++23 / C++20 vvv
         requires(_Tuple __t) {
             typename tuple_size<_Tuple>::type;
             requires _Index < tuple_size_v<_Tuple>;
             typename tuple_element_t<_Index, _Tuple>;
             { _STD get<_Index>(__t) } -> convertible_to<const tuple_element_t<_Index, _Tuple>&>;
         };
+#endif // C++20
 
     template <class _Tuple, size_t _Index>
     concept _Returnable_element = is_reference_v<_Tuple> || move_constructible<tuple_element_t<_Index, _Tuple>>;
diff --git a/stl/inc/tuple b/stl/inc/tuple
index 51bcd03fa9..de4ab09344 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -179,6 +179,43 @@ struct _Alloc_unpack_tuple_t {
     explicit _Alloc_unpack_tuple_t() = default;
 }; // tag type to disambiguate construction (from an allocator and unpacking a tuple/pair)
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+template <class _Tuple, class _Other, class _Indices = make_index_sequence<tuple_size_v<_Tuple>>>
+inline constexpr bool _Can_construct_values_from_tuple_like_v = false;
+
+template <class... _Types, class _Other, size_t... _Indices>
+inline constexpr bool _Can_construct_values_from_tuple_like_v<tuple<_Types...>, _Other, index_sequence<_Indices...>> =
+    conjunction_v<is_constructible<_Types, decltype(_STD get<_Indices>(_STD declval<_Other>()))>...>;
+
+#ifdef __clang__ // TRANSITION, LLVM-59827
+template <class _TupleLike, class _Tuple>
+concept _Can_construct_from_tuple_like = _Tuple_like<_TupleLike> && _Different_from<_TupleLike, _Tuple>
+                                      && (!_Is_subrange_v<remove_cvref_t<_TupleLike>>)
+                                      && (tuple_size_v<_Tuple> == tuple_size_v<remove_cvref_t<_TupleLike>>)
+                                      && _Can_construct_values_from_tuple_like_v<_Tuple, _TupleLike>
+                                      && (tuple_size_v<_Tuple> != 1
+                                          || (!is_convertible_v<_TupleLike, tuple_element_t<0, _Tuple>>
+                                              && !is_constructible_v<tuple_element_t<0, _Tuple>, _TupleLike>) );
+#endif // __clang__
+
+template <class _TTuple, class _UTuple, class _Indices = make_index_sequence<tuple_size_v<_UTuple>>>
+struct _Three_way_comparison_result_with_tuple_like {};
+
+template <class... _TTypes, class _UTuple, size_t... _Indices>
+    requires
+#ifndef __clang__ // TRANSITION, DevCom-10265237
+    (sizeof...(_TTypes) == sizeof...(_Indices)) &&
+#endif // __clang__
+    (requires { typename _Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>; } && ...)
+struct _Three_way_comparison_result_with_tuple_like<tuple<_TTypes...>, _UTuple, index_sequence<_Indices...>> {
+    using type = common_comparison_category_t<_Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <class _TTuple, _Tuple_like _UTuple>
+using _Three_way_comparison_result_with_tuple_like_t =
+    typename _Three_way_comparison_result_with_tuple_like<_TTuple, _UTuple>::type;
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
+
 template <>
 class tuple<> { // empty tuple
 public:
@@ -186,12 +223,24 @@ public:
 
     constexpr tuple(const tuple&) noexcept /* strengthened */ {} // TRANSITION, ABI: should be defaulted
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(_Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
+
     template <class _Alloc>
     _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&) noexcept /* strengthened */ {}
 
     template <class _Alloc>
     _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept /* strengthened */ {}
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+    template <class _Alloc, _Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(allocator_arg_t, const _Alloc&, _Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
+
     template <class _Tag, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>
     constexpr tuple(_Tag) noexcept /* strengthened */ {}
 
@@ -203,6 +252,20 @@ public:
     constexpr const tuple& operator=(const tuple&) const noexcept /* strengthened */ {
         return *this;
     }
+
+#ifdef __cpp_lib_concepts
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple& operator=(_Other&&) noexcept /* strengthened */ {
+        return *this;
+    }
+
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr const tuple& operator=(_Other&&) const noexcept /* strengthened */ {
+        return *this;
+    }
+#endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
     _CONSTEXPR20 void swap(tuple&) noexcept {}
@@ -223,6 +286,26 @@ public:
         return false;
     }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
+
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+    template <_Tuple_like _Other>
+#ifndef __clang__ // TRANSITION, DevCom-10265322
+        requires _Different_from<_Other, tuple>
+#endif // __clang__
+    _NODISCARD_FRIEND constexpr bool operator==(const tuple&, const _Other&) noexcept /* strengthened */ {
+        static_assert(tuple_size_v<_Other> == 0, "Cannot compare tuples of different sizes (N4928 [tuple.rel]/2).");
+        return true;
+    }
+
+    template <_Tuple_like _Other>
+        requires (tuple_size_v<remove_cvref_t<_Other>> == 0)
+#ifndef __clang__ // TRANSITION, DevCom-10265322
+                 && _Different_from<_Other, tuple>
+#endif // __clang__
+    _NODISCARD_FRIEND constexpr strong_ordering operator<=>(const tuple&, const _Other&) noexcept /* strengthened */ {
+        return strong_ordering::equal;
+    }
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 };
 
 template <class _This, class... _Rest>
@@ -343,6 +426,29 @@ public:
         tuple(const pair<_First, _Second>&& _Right) noexcept(
             _Tuple_nothrow_constructible_v<tuple, const _First, const _Second>) // strengthened
         : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+
+#ifdef __cpp_lib_concepts
+    template <class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v<_Other, index_sequence<_Indices...>> =
+        negation_v<conjunction<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _This>,
+            is_convertible<decltype(_STD get<_Indices + 1>(_STD declval<_Other>())), _Rest>...>>;
+
+#ifdef __clang__ // TRANSITION, LLVM-59827
+    template <class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // __clang__
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>) tuple(_Other&& _Right)
+        : tuple(_Unpack_tuple_t{}, _STD forward<_Other>(_Right)) {
+    }
+#endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
     template <class _Alloc, class _This2 = _This,
@@ -436,6 +542,22 @@ public:
     constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
         tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>&& _Right)
         : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#ifdef __cpp_lib_concepts
+#ifdef __clang__ // TRANSITION, LLVM-59827
+    template <class _Alloc, class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <class _Alloc, _Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // __clang__
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>)
+        tuple(allocator_arg_t, const _Alloc& _Al, _Other&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Other>(_Right)) {
+    }
+#endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
     tuple& operator=(const volatile tuple&) = delete;
@@ -570,6 +692,49 @@ public:
         _Get_rest()._Myfirst._Val = _STD forward<_Second>(_Right.second);
         return *this;
     }
+
+#ifdef __cpp_lib_concepts
+    template <bool _Const_assignment, class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Can_assign_values_from_tuple_like_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<false, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<_This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<_Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<true, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<const _This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<const _Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) const {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<false, _Other>
+    constexpr tuple& operator=(_Other&& _Right) {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+
+    template <_Tuple_like _Other>
+        requires _Different_from<_Other, tuple> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<true, _Other>
+    constexpr const tuple& operator=(_Other&& _Right) const {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+#endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
     _CONSTEXPR20 void swap(tuple& _Right) noexcept(
@@ -610,6 +775,56 @@ public:
         }
         return _Mybase::_Three_way_compare(_Right._Get_rest());
     }
+
+#if _HAS_CXX23
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1753916
+    template <class _Other, class _Indices = make_index_sequence<1 + sizeof...(_Rest)>>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v = false;
+
+    template <class _Other, size_t... _Indices>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v<_Other, index_sequence<_Indices...>> =
+        (requires(const tuple& _Left, const _Other& _Right) {
+             { _STD get<_Indices>(_Left) == _STD get<_Indices>(_Right) } -> _Boolean_testable;
+         } && ...);
+#endif // ^^^ no workaround ^^^
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr bool _Equals_to_tuple_like(const _Other& _Right, index_sequence<_Indices...>) const {
+        return ((_STD get<_Indices>(*this) == _STD get<_Indices>(_Right)) && ...);
+    }
+
+    template <_Tuple_like _Other>
+#ifndef __clang__ // TRANSITION, DevCom-10265322
+        requires _Different_from<_Other, tuple>
+#endif // __clang__
+    _NODISCARD_FRIEND constexpr bool operator==(const tuple& _Left, const _Other& _Right) {
+        static_assert(1 + sizeof...(_Rest) == tuple_size_v<_Other>,
+            "Cannot compare tuples of different sizes (N4928 [tuple.rel]/2).");
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1753916
+        static_assert(_Can_equal_compare_with_tuple_like_v<_Other>,
+            "For all i, where 0 <= i < sizeof...(TTypes), get<i>(t) == get<i>(u) must be a valid expression (N4928 "
+            "[tuple.rel]/2).");
+#endif // ^^^ no workaround ^^^
+        return _Left._Equals_to_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr auto _Three_way_compare_with_tuple_like(
+        const _Other& _Right, index_sequence<_Indices...>) const {
+        _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> _Result = strong_ordering::equal;
+        (void) (((_Result = _Synth_three_way{}(_STD get<_Indices>(*this), _STD get<_Indices>(_Right))) == 0) && ...);
+        return _Result;
+    }
+
+    template <_Tuple_like _Other>
+#ifndef __clang__ // TRANSITION, DevCom-10265322
+        requires _Different_from<_Other, tuple>
+#endif // __clang__
+    _NODISCARD_FRIEND constexpr auto operator<=>(const tuple& _Left, const _Other& _Right)
+        -> _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> {
+        return _Left._Three_way_compare_with_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+#endif // _HAS_CXX23
 #else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
     template <class... _Other>
     _NODISCARD constexpr bool _Less(const tuple<_Other...>& _Right) const {
@@ -667,7 +882,8 @@ tuple(allocator_arg_t, _Alloc, tuple<_Types...>) -> tuple<_Types...>;
 
 _EXPORT_STD template <class... _Types1, class... _Types2>
 _NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
-    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
+    static_assert(
+        sizeof...(_Types1) == sizeof...(_Types2), "Cannot compare tuples of different sizes (N4928 [tuple.rel]/2).");
     return _Left._Equals(_Right);
 }
 
@@ -675,7 +891,6 @@ _NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple
 _EXPORT_STD template <class... _Types1, class... _Types2>
 _NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
     const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
-    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
     return _Left._Three_way_compare(_Right);
 }
 #else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
@@ -837,7 +1052,11 @@ struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next
           index_sequence<_Ix..., (_Ix_next + 0 * _Kx_next)...>, // repeat _Ix_next, ignoring the elements of _Kx_next
           _Ix_next + 1, _Rest...> {};
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+template <_Tuple_like... _Tuples>
+#else // ^^^ C++23 / C++20 vvv
 template <class... _Tuples>
+#endif // C++20
 using _Tuple_cat1 = _Tuple_cat2<tuple<_Tuples&&...>, index_sequence<>, index_sequence<>, 0,
     make_index_sequence<tuple_size_v<_Remove_cvref_t<_Tuples>>>...>;
 
@@ -846,7 +1065,11 @@ constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty _A
     return _Ret{_STD get<_Kx>(_STD get<_Ix>(_STD move(_Arg)))...};
 }
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+_EXPORT_STD template <_Tuple_like... _Tuples>
+#else // ^^^ C++23 / C++20 vvv
 _EXPORT_STD template <class... _Tuples>
+#endif // C++20
 _NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples
     using _Cat1   = _Tuple_cat1<_Tuples...>;
     using _Ret    = typename _Cat1::_Ret;
@@ -856,13 +1079,21 @@ _NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&.
 }
 
 #if _HAS_CXX17
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+template <class _Callable, _Tuple_like _Tuple, size_t... _Indices>
+#else // ^^^ C++23 / C++20 vvv
 template <class _Callable, class _Tuple, size_t... _Indices>
+#endif // C++20
 constexpr decltype(auto) _Apply_impl(_Callable&& _Obj, _Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
     noexcept(_STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...))) {
     return _STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+_EXPORT_STD template <class _Callable, _Tuple_like _Tuple>
+#else // ^^^ C++23 / C++20 vvv
 _EXPORT_STD template <class _Callable, class _Tuple>
+#endif // C++20
 constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
     noexcept(_Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
@@ -870,7 +1101,11 @@ constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
 }
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+template <class _Ty, _Tuple_like _Tuple, size_t... _Indices>
+#else // ^^^ C++23 / C++20 vvv
 template <class _Ty, class _Tuple, size_t... _Indices>
+#endif // C++20
 constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
     is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
     // construct _Ty from the elements of _Tpl
@@ -879,7 +1114,11 @@ constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>)
     return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+_EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
+#else // ^^^ C++23 / C++20 vvv
 _EXPORT_STD template <class _Ty, class _Tuple>
+#endif // C++20
 _NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_Make_from_tuple_impl<_Ty>(
     _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
     // construct _Ty from the elements of _Tpl
@@ -891,19 +1130,52 @@ _NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_Make_
 template <class... _Types, class _Alloc>
 struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {}; // true_type if container allocator enabled
 
-#ifdef __cpp_lib_concepts
-template <class... _TTypes, class... _UTypes, template <class> class _TQual, template <class> class _UQual>
-    requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
-struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
-    using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual,
+    class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_reference;
+
+template <class _TTuple, class _UTuple, template <class> class _TQual, template <class> class _UQual,
+    size_t... _Indices>
+    requires requires {
+                 typename tuple<common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>,
+                     _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
+             }
+struct _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Indices...>> {
+    using type = tuple<
+        common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>, _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
 };
 
-template <class... _TTypes, class... _UTypes>
-    requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
-struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
-    using type = tuple<common_type_t<_TTypes, _UTypes>...>;
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
+          && requires { typename _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; }
+struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual> {
+    using type = typename _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
 };
-#endif // __cpp_lib_concepts
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_type;
+
+template <class _TTuple, class _UTuple, size_t... _Indices>
+    requires requires {
+                 typename tuple<
+                     common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+             }
+struct _Tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Indices...>> {
+    using type = tuple<common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
+          && requires { typename _Tuple_like_common_type<_TTuple, _UTuple>::type; }
+struct common_type<_TTuple, _UTuple> {
+    using type = typename _Tuple_like_common_type<_TTuple, _UTuple>::type;
+};
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
 #if _HAS_TR1_NAMESPACE
 namespace _DEPRECATE_TR1_NAMESPACE tr1 {
diff --git a/stl/inc/utility b/stl/inc/utility
index 35834b5711..1ad3d703bc 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -524,7 +524,7 @@ _NODISCARD constexpr bool operator>=(const pair<_Ty1, _Ty2>& _Left, const pair<_
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-#ifdef __cpp_lib_concepts
+#if _HAS_CXX23 && defined(__cpp_lib_concepts)
 template <class _Ty1, class _Ty2, class _Uty1, class _Uty2, template <class> class _TQual,
     template <class> class _UQual>
     requires requires {
@@ -540,7 +540,7 @@ template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
 struct common_type<pair<_Ty1, _Ty2>, pair<_Uty1, _Uty2>> {
     using type = pair<common_type_t<_Ty1, _Uty1>, common_type_t<_Ty2, _Uty2>>;
 };
-#endif // __cpp_lib_concepts
+#endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
 template <class _Ty>
 struct _Unrefwrap_helper { // leave unchanged if not a reference_wrapper
diff --git a/stl/inc/xutility b/stl/inc/xutility
index d4df0ef461..7478201040 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -1096,14 +1096,30 @@ struct _Is_allocator<_Ty, void_t<typename _Ty::value_type, decltype(_STD declval
 
 // deduction guide utilities (N4892 [associative.general]/2)
 template <class _Iter>
-using _Guide_key_t = remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
+using _Guide_key_t =
+#if _HAS_CXX23
+    remove_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ C++23 / C++20 vvv
+    remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
+#endif // C++20
 
 template <class _Iter>
-using _Guide_val_t = typename iterator_traits<_Iter>::value_type::second_type;
+using _Guide_val_t =
+#if _HAS_CXX23
+    tuple_element_t<1, typename iterator_traits<_Iter>::value_type>;
+#else // ^^^ C++23 / C++20 vvv
+    typename iterator_traits<_Iter>::value_type::second_type;
+#endif // C++20
 
 template <class _Iter>
-using _Guide_pair_t = pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
-    typename iterator_traits<_Iter>::value_type::second_type>;
+using _Guide_pair_t =
+#if _HAS_CXX23
+    pair<add_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>,
+        tuple_element_t<1, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ C++23 / C++20 vvv
+    pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
+        typename iterator_traits<_Iter>::value_type::second_type>;
+#endif // C++20
 
 _EXPORT_STD template <class _Ty>
 struct is_execution_policy : false_type {};
@@ -3603,17 +3619,6 @@ namespace ranges {
     };
 } // namespace ranges
 
-// These declarations must be visible to qualified name lookup for _STD get in _Pair_like below, even if <tuple> hasn't
-// yet been included.
-_EXPORT_STD template <size_t _Index, class... _Types>
-_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
-_EXPORT_STD template <size_t _Index, class... _Types>
-_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
-_EXPORT_STD template <size_t _Index, class... _Types>
-_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
-_EXPORT_STD template <size_t _Index, class... _Types>
-_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
-
 namespace ranges {
     template <class _From, class _To>
     concept _Uses_nonqualification_pointer_conversion =
@@ -3624,6 +3629,7 @@ namespace ranges {
     concept _Convertible_to_non_slicing = convertible_to<_From, _To>
                                        && (!_Uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>);
 
+#if !_HAS_CXX23
     template <class _Ty>
     concept _Pair_like =
         (!is_reference_v<_Ty>) && requires(_Ty __t) {
@@ -3634,9 +3640,14 @@ namespace ranges {
                                       { _STD get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Ty>&>;
                                       { _STD get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Ty>&>;
                                   };
+#endif // !_HAS_CXX23
 
     template <class _Ty, class _First, class _Second>
-    concept _Pair_like_convertible_from = (!range<_Ty>) && _Pair_like<_Ty> && constructible_from<_Ty, _First, _Second>
+    concept _Pair_like_convertible_from = (!range<_Ty>)
+#if _HAS_CXX23
+                                       && (!is_reference_v<_Ty>)
+#endif // _HAS_CXX23
+                                       && _Pair_like<_Ty> && constructible_from<_Ty, _First, _Second>
                                        && _Convertible_to_non_slicing<_First, tuple_element_t<0, _Ty>>
                                        && convertible_to<_Second, tuple_element_t<1, _Ty>>;
 
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 85bebe3ffb..15a3c3bdec 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -325,7 +325,6 @@
 // P2077R3 Heterogeneous Erasure Overloads For Associative Containers
 // P2136R3 invoke_r()
 // P2165R4 Compatibility Between tuple, pair, And tuple-like Objects
-//     (changes to views::zip and pair only)
 // P2166R1 Prohibiting basic_string And basic_string_view Construction From nullptr
 // P2186R2 Removing Garbage Collection Support
 // P2273R3 constexpr unique_ptr
@@ -1738,7 +1737,12 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define __cpp_lib_string_contains             202011L
 #define __cpp_lib_string_resize_and_overwrite 202110L
 #define __cpp_lib_to_underlying               202102L
-#define __cpp_lib_unreachable                 202202L
+
+#ifdef __cpp_lib_concepts
+#define __cpp_lib_tuple_like 202207L
+#endif // __cpp_lib_concepts
+
+#define __cpp_lib_unreachable 202202L
 #endif // _HAS_CXX23
 
 // macros with language mode sensitivity
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 261c92e5d5..cb9206752b 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -82,6 +82,9 @@ std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_deallocate_ma
 # Too many constexpr operations
 std/utilities/charconv/charconv.to.chars/integral.pass.cpp FAIL
 
+# libc++ tests strengthened assignment operators (not compatible with P2165R4: "Compatibility Between tuple, pair, And tuple-like Objects")
+std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp FAIL
+
 # libc++ has not implemented P2505R5: "Monadic Functions for std::expected"
 std/language.support/support.limits/support.limits.general/expected.version.compile.pass.cpp FAIL
 
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 22e1b45d8f..9b1904a4cc 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -551,7 +551,12 @@ tests\P1899R3_views_stride_death
 tests\P1951R1_default_arguments_pair_forward_ctor
 tests\P2136R3_invoke_r
 tests\P2162R2_std_visit_for_derived_classes_from_variant
+tests\P2165R4_tuple_like_common_reference
+tests\P2165R4_tuple_like_common_type
+tests\P2165R4_tuple_like_operations
 tests\P2165R4_tuple_like_pair
+tests\P2165R4_tuple_like_relational_operators
+tests\P2165R4_tuple_like_tuple_members
 tests\P2231R1_complete_constexpr_optional_variant
 tests\P2273R3_constexpr_unique_ptr
 tests\P2278R4_basic_const_iterator
diff --git a/tests/std/tests/P0433R2_deduction_guides/test.cpp b/tests/std/tests/P0433R2_deduction_guides/test.cpp
index 8b99de5f0b..e943019850 100644
--- a/tests/std/tests/P0433R2_deduction_guides/test.cpp
+++ b/tests/std/tests/P0433R2_deduction_guides/test.cpp
@@ -651,6 +651,20 @@ void test_map_or_multimap() {
     static_assert(is_same_v<decltype(m15), M<long, char, MyGreater>>);
     static_assert(is_same_v<decltype(m16), M<long, char, MyGreater, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(m17), M<long, char, less<long>, MyAlloc<CPurr>>>);
+
+    { // Verify changes from P2165R4
+        using TupleIter = tuple<int, double>*;
+        static_assert(is_same_v<decltype(M{TupleIter{}, TupleIter{}}), M<int, double>>);
+
+        using PairIter = pair<int, float>*;
+        static_assert(is_same_v<decltype(M{PairIter{}, PairIter{}}), M<int, float>>);
+
+        using ArrayIter = array<int, 2>*;
+        static_assert(is_same_v<decltype(M{ArrayIter{}, ArrayIter{}}), M<int, int>>);
+
+        using SubrangeIter = ranges::subrange<int*, int*>*;
+        static_assert(is_same_v<decltype(M{SubrangeIter{}, SubrangeIter{}}), M<int*, int*>>);
+    }
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 }
 
diff --git a/tests/std/tests/P2165R4_tuple_like_common_reference/env.lst b/tests/std/tests/P2165R4_tuple_like_common_reference/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_common_reference/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2165R4_tuple_like_common_reference/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_common_reference/test.compile.pass.cpp
new file mode 100644
index 0000000000..b644d1d355
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_common_reference/test.compile.pass.cpp
@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+using namespace std;
+using ranges::subrange;
+
+template <class T, class U>
+concept CanCommonReference = requires { typename common_reference<T, U>::type; };
+
+template <class T, class U, class Expected>
+    requires CanCommonReference<T, U>
+constexpr bool test_common_reference =
+    same_as<common_reference_t<T, U>, Expected> && same_as<common_reference_t<U, T>, Expected>;
+
+struct Sentinel {
+    bool operator==(const auto&) const; // not defined
+    operator unreachable_sentinel_t() const; // not defined
+};
+
+template <>
+struct std::common_type<Sentinel, unreachable_sentinel_t> {
+    using type = unreachable_sentinel_t;
+};
+
+template <>
+struct std::common_type<unreachable_sentinel_t, Sentinel> {
+    using type = unreachable_sentinel_t;
+};
+
+static_assert(test_common_reference<Sentinel, unreachable_sentinel_t, unreachable_sentinel_t>);
+
+// Test common_reference<tuple, tuple>
+static_assert(test_common_reference<tuple<>, tuple<>, tuple<>>);
+static_assert(test_common_reference<tuple<char&&>, tuple<const int&>, tuple<int>>);
+static_assert(test_common_reference<tuple<int&>, tuple<const int&>, tuple<const int&>>);
+static_assert(test_common_reference<tuple<int&>, tuple<int&&>, tuple<const int&>>);
+static_assert(test_common_reference<tuple<short, int, long>, tuple<long, int, short>, tuple<long, int, long>>);
+
+// Test common_reference<cvref tuple, cvref tuple>
+static_assert(test_common_reference<tuple<>&, tuple<>&&, const tuple<>&>);
+static_assert(
+    test_common_reference<const tuple<int, long>&, volatile tuple<int, long>&, const volatile tuple<int, long>&>);
+static_assert(test_common_reference<tuple<int&, const int&&, volatile int&>&,
+    const tuple<const int&, const int, const int&>, tuple<const int&, int, const volatile int&>>);
+
+// Test common_reference<tuple, tuple-like>, tuple-like is pair
+static_assert(test_common_reference<tuple<int, int>, pair<int, int>, tuple<int, int>>);
+static_assert(test_common_reference<tuple<int, long>, pair<short, long long>, tuple<int, long long>>);
+static_assert(
+    test_common_reference<tuple<int&, long&&>, pair<const int&, const long&&>, tuple<const int&, const long&&>>);
+static_assert(test_common_reference<tuple<short&, const volatile long&&>, pair<volatile int, long>, tuple<int, long>>);
+
+// Test common_reference<cvref tuple, cvref tuple-like>, tuple-like is pair
+static_assert(test_common_reference<tuple<int, int>&, pair<int, int>&, tuple<int&, int&>>);
+static_assert(test_common_reference<const tuple<int, int>&, const pair<int, int>&, tuple<const int&, const int&>>);
+static_assert(
+    test_common_reference<tuple<int&, long&&>&, const pair<const int&, const long&&>&, tuple<const int&, const long&>>);
+static_assert(test_common_reference<const tuple<short&, const volatile long&&>, const pair<volatile int, long>&,
+    tuple<int, long>>);
+
+// Test common_reference<tuple, tuple-like>, tuple-like is array
+static_assert(test_common_reference<tuple<>, array<int, 0>, tuple<>>);
+static_assert(test_common_reference<tuple<int>, array<int, 1>, tuple<int>>);
+static_assert(test_common_reference<tuple<int, long>, array<int, 2>, tuple<int, long>>);
+static_assert(test_common_reference<tuple<short, int&&, const long>, array<int, 3>, tuple<int, int, long>>);
+static_assert(test_common_reference<tuple<short&, int&&, const volatile long>, array<int, 3>, tuple<int, int, long>>);
+
+// Test common_reference<cvref tuple, cvref tuple-like>, tuple-like is array
+static_assert(test_common_reference<const tuple<>&, array<int, 0>, tuple<>>);
+static_assert(test_common_reference<tuple<int>&, array<int, 1>&, tuple<int&>>);
+static_assert(test_common_reference<const tuple<int, long>&&, array<int, 2>&, tuple<const int&, long>>);
+
+// Test common_reference<tuple, tuple-like>, tuple-like is ranges::subrange
+static_assert(test_common_reference<tuple<int*, int*>, subrange<int*, int*>, tuple<int*, int*>>);
+static_assert(
+    test_common_reference<tuple<int*, const int*>, subrange<const int*, int*>, tuple<const int*, const int*>>);
+static_assert(test_common_reference<tuple<int*, Sentinel>, subrange<int*, unreachable_sentinel_t>,
+    tuple<int*, unreachable_sentinel_t>>);
+static_assert(test_common_reference<tuple<const volatile int*, Sentinel>, subrange<int*, unreachable_sentinel_t>,
+    tuple<const volatile int*, unreachable_sentinel_t>>);
+
+// Test common_reference<cvref tuple, cvref tuple-like>, tuple-like is ranges::subrange
+static_assert(test_common_reference<const tuple<int*, int*>&&, const subrange<int*, int*>, tuple<int*, int*>>);
+static_assert(
+    test_common_reference<const tuple<int*, const int*>&, subrange<const int*, int*>, tuple<const int*, const int*>>);
+
+// Test invalid common_references
+static_assert(!CanCommonReference<tuple<int>, array<int, 2>>);
+static_assert(!CanCommonReference<tuple<int>, subrange<int*, int*>>);
+static_assert(!CanCommonReference<tuple<int>, pair<int, int>>);
diff --git a/tests/std/tests/P2165R4_tuple_like_common_type/env.lst b/tests/std/tests/P2165R4_tuple_like_common_type/env.lst
new file mode 100644
index 0000000000..18e2d7c71e
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_common_type/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp
new file mode 100644
index 0000000000..79eca27f32
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+using namespace std;
+using ranges::subrange;
+
+template <class T, class U>
+concept CanCommonType = requires { typename common_type<T, U>::type; };
+
+template <class T, class U, class Expected>
+    requires CanCommonType<T, U>
+inline constexpr bool test_common_type =
+    same_as<common_type_t<T, U>, Expected> && same_as<common_type_t<U, T>, Expected>;
+
+struct Sentinel {
+    bool operator==(const auto&) const; // not defined
+    operator unreachable_sentinel_t() const; // not defined
+};
+
+template <>
+struct std::common_type<Sentinel, unreachable_sentinel_t> {
+    using type = unreachable_sentinel_t;
+};
+
+template <>
+struct std::common_type<unreachable_sentinel_t, Sentinel> {
+    using type = unreachable_sentinel_t;
+};
+
+static_assert(test_common_type<Sentinel, unreachable_sentinel_t, unreachable_sentinel_t>);
+
+// Test common_type<tuple, tuple>
+static_assert(test_common_type<tuple<>, tuple<>, tuple<>>);
+static_assert(test_common_type<tuple<char>, tuple<int>, tuple<int>>);
+static_assert(test_common_type<tuple<int&>, tuple<const int&>, tuple<int>>);
+static_assert(test_common_type<tuple<int&>, tuple<int&&>, tuple<int>>);
+static_assert(test_common_type<tuple<short, long, long>, tuple<long, int, short>, tuple<long, long, long>>);
+
+// Test common_reference<cvref tuple, cvref tuple>
+static_assert(test_common_type<const tuple<>&, tuple<>&&, tuple<>>);
+static_assert(test_common_type<tuple<char>&, const tuple<int>&&, tuple<int>>);
+static_assert(test_common_type<tuple<int&>&, tuple<const int&>, tuple<int>>);
+static_assert(test_common_type<volatile tuple<int&>&, tuple<int&&>, tuple<int>>);
+
+// Test common_type<tuple, tuple-like>, tuple-like is pair
+static_assert(test_common_type<tuple<int, int>, pair<int, int>, tuple<int, int>>);
+static_assert(test_common_type<tuple<int, long>, pair<short, long long>, tuple<int, long long>>);
+static_assert(test_common_type<tuple<int&, long&&>, pair<const int&, const long&&>, tuple<int, long>>);
+static_assert(test_common_type<tuple<short&, const volatile long&&>, pair<volatile int, long>, tuple<int, long>>);
+
+// Test common_type<cvref tuple, cvref tuple-like>, tuple-like is pair
+static_assert(test_common_type<const tuple<int, int>&&, volatile pair<int, int>&, tuple<int, int>>);
+static_assert(test_common_type<volatile tuple<int, long>&&, const pair<short, long long>&&, tuple<int, long long>>);
+
+// Test common_type<tuple, tuple-like>, tuple-like is array
+static_assert(test_common_type<tuple<>, array<int, 0>, tuple<>>);
+static_assert(test_common_type<tuple<int>, array<int, 1>, tuple<int>>);
+static_assert(test_common_type<tuple<int, long>, array<int, 2>, tuple<int, long>>);
+static_assert(test_common_type<tuple<short, int, long>, array<int, 3>, tuple<int, int, long>>);
+static_assert(test_common_type<tuple<short&, int&&, const volatile long>, array<int, 3>, tuple<int, int, long>>);
+
+// Test common_type<cvref tuple, cvref tuple-like>, tuple-like is array
+static_assert(test_common_type<const tuple<>&&, volatile array<int, 0>&, tuple<>>);
+static_assert(test_common_type<const tuple<int>&, volatile array<int, 1>&&, tuple<int>>);
+
+// Test common_type<tuple, tuple-like>, tuple-like is ranges::subrange
+static_assert(test_common_type<tuple<int*, int*>, subrange<int*, int*>, tuple<int*, int*>>);
+static_assert(test_common_type<tuple<int*, const int*>, subrange<const int*, int*>, tuple<const int*, const int*>>);
+static_assert(test_common_type<tuple<int*, Sentinel>, subrange<int*, unreachable_sentinel_t>,
+    tuple<int*, unreachable_sentinel_t>>);
+static_assert(test_common_type<tuple<const volatile int*, Sentinel>, subrange<int*, unreachable_sentinel_t>,
+    tuple<const volatile int*, unreachable_sentinel_t>>);
+
+// Test common_type<cvref tuple, cvref tuple-like>, tuple-like is ranges::subrange
+static_assert(test_common_type<const tuple<int*, int*>&, volatile subrange<int*, int*>&&, tuple<int*, int*>>);
+static_assert(test_common_type<volatile tuple<int*, Sentinel>&, const subrange<int*, unreachable_sentinel_t>&&,
+    tuple<int*, unreachable_sentinel_t>>);
+
+// Test invalid common_types
+static_assert(!CanCommonType<tuple<int>, array<int, 2>>);
+static_assert(!CanCommonType<tuple<int>, subrange<int*, int*>>);
+static_assert(!CanCommonType<tuple<int>, pair<int, int>>);
diff --git a/tests/std/tests/P2165R4_tuple_like_operations/env.lst b/tests/std/tests/P2165R4_tuple_like_operations/env.lst
new file mode 100644
index 0000000000..18e2d7c71e
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_operations/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp
new file mode 100644
index 0000000000..3f13d449cb
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp
@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+#include <cassert>
+#include <functional>
+#include <memory>
+#include <ranges>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+using namespace std;
+using ranges::subrange;
+
+namespace test_apply {
+    struct TakeAnythingFn {
+        void operator()(auto&&...) const noexcept; // not defined
+    };
+
+    struct StrSentinel {
+        constexpr bool operator==(const char*) const; // not defined
+    };
+
+    template <class T>
+    concept CanApply = requires(T tuple_like) { apply(TakeAnythingFn{}, tuple_like); };
+
+    static_assert(CanApply<tuple<>>);
+    static_assert(CanApply<tuple<char, wchar_t>>);
+    static_assert(CanApply<tuple<char, signed char, unsigned char>>);
+    static_assert(CanApply<pair<int, unsigned int>>);
+    static_assert(CanApply<array<int, 0>>);
+    static_assert(CanApply<array<short, 1>>);
+    static_assert(CanApply<array<long, 2>>);
+    static_assert(CanApply<array<long long, 3>>);
+    static_assert(CanApply<subrange<wchar_t*, wchar_t*>>);
+    static_assert(CanApply<subrange<char*, StrSentinel>>);
+    static_assert(!CanApply<void>);
+    static_assert(!CanApply<int>);
+    static_assert(!CanApply<StrSentinel>);
+    static_assert(!CanApply<ranges::copy_result<int*, int*>>);
+
+    static constexpr int some_ints[] = {1, 2, 3};
+
+    constexpr bool test() {
+        { // Test apply with empty tuple-like types
+            true_type func;
+            assert(apply(func, tuple{}));
+            assert(apply(func, array<int, 0>{}));
+        }
+
+        { // Test apply with one-sized tuple-like types
+            identity func;
+            assert(apply(func, tuple{7}) == 7);
+            assert(apply(func, array{7}) == 7);
+        }
+
+        { // Test apply with pair-like types
+            minus func;
+            assert(apply(func, tuple{1, 1}) == 0);
+            assert(apply(func, pair{3, 3}) == 0);
+            assert(apply(func, array{5, 5}) == 0);
+
+            constexpr subrange rng = some_ints;
+            assert(apply(func, rng) == -3);
+        }
+
+        { // Test apply with big tuple-like types
+            auto func = [](auto&&... vals) { return (vals + ...); };
+            assert(apply(func, tuple{1, 2, 3}) == 6);
+            assert(apply(func, array{4, 5, 6}) == 15);
+        }
+
+        return true;
+    }
+} // namespace test_apply
+
+namespace test_make_from_tuple {
+    template <class T, class Tuple>
+    concept CanMakeFromTuple = requires(Tuple tuple_like) {
+                                   { make_from_tuple<T>(tuple_like) } -> same_as<T>;
+                               };
+
+    static_assert(CanMakeFromTuple<string, tuple<>>);
+    static_assert(CanMakeFromTuple<string, tuple<size_t, char>>);
+    static_assert(CanMakeFromTuple<wstring, tuple<size_t, wchar_t, allocator<wchar_t>>>);
+    static_assert(CanMakeFromTuple<tuple<int, unsigned int>, pair<int, unsigned int>>);
+    static_assert(CanMakeFromTuple<string, array<int, 0>>);
+    static_assert(CanMakeFromTuple<vector<int>, array<long, 2>>);
+    static_assert(CanMakeFromTuple<vector<wchar_t>, subrange<wchar_t*, wchar_t*>>);
+    static_assert(CanMakeFromTuple<vector<int>, subrange<int*, int*>>);
+    static_assert(!CanMakeFromTuple<int, void>);
+    static_assert(!CanMakeFromTuple<long, int>);
+    static_assert(!CanMakeFromTuple<void*, int*>);
+    static_assert(!CanMakeFromTuple<ranges::copy_result<int*, int*>, int*>);
+
+    constexpr bool test() {
+        { // Test make_from_tuple with empty tuple-like types
+            struct S {
+                constexpr bool operator==(const S&) const = default;
+            };
+
+            assert(make_from_tuple<S>(tuple{}) == S{});
+            assert(make_from_tuple<S>(array<int, 0>{}) == S{});
+        }
+
+        { // Test make_from_tuple with one-sized tuple-like types
+            assert(make_from_tuple<int>(tuple{7}) == 7);
+            assert(make_from_tuple<int>(array{7}) == 7);
+        }
+
+        { // Test make_from_tuple with pair-like types
+            struct S {
+                constexpr S(int* x_, int* y_) : x{x_}, y{y_} {}
+                constexpr bool operator==(const S&) const = default;
+
+                int* x;
+                int* y;
+            };
+
+            int a = 0;
+            int b = 1;
+            S expected_val{&a, &b};
+
+            assert(make_from_tuple<S>(tuple{&a, &b}) == expected_val);
+            assert(make_from_tuple<S>(pair{&a, &b}) == expected_val);
+            assert(make_from_tuple<S>(array{&a, &b}) == expected_val);
+            assert(make_from_tuple<S>(subrange{&a, &b}) == expected_val);
+        }
+
+        { // Test make_from_tuple with big tuple-like types
+            struct NoIncrement {};
+            struct S {
+                constexpr S(NoIncrement, int x_, int y_, int z_) : x{x_}, y{y_}, z{z_} {}
+                constexpr S(int x_, int y_, int z_) : x{x_ + 1}, y{y_ + 1}, z{z_ + 1} {}
+                constexpr bool operator==(const S&) const = default;
+
+                int x;
+                int y;
+                int z;
+            };
+
+            S expected_val{NoIncrement{}, 2, 3, 4};
+            assert(make_from_tuple<S>(tuple{1, 2, 3}) == expected_val);
+            assert(make_from_tuple<S>(array{1, 2, 3}) == expected_val);
+        }
+
+        return true;
+    }
+} // namespace test_make_from_tuple
+
+namespace test_tuple_cat {
+    template <class... Tuples>
+    concept CanTupleCat = requires(Tuples... tpls) { tuple_cat(tpls...); };
+
+    template <class Expected, class... Tuples>
+    concept CheckTupleCat = CanTupleCat<Tuples...> && same_as<decltype(tuple_cat(declval<Tuples>()...)), Expected>;
+
+    static_assert(CheckTupleCat<tuple<>, tuple<>, array<int, 0>>);
+    static_assert(CheckTupleCat<tuple<size_t, char, size_t, wchar_t>, tuple<size_t, char>, pair<size_t, wchar_t>>);
+    static_assert(CheckTupleCat<tuple<int*, int*>, array<int, 0>, subrange<int*, int*>>);
+    static_assert(CheckTupleCat<tuple<long, long, long, long>, array<long, 2>, pair<long, long>>);
+    static_assert(CheckTupleCat<tuple<int, wchar_t*, wchar_t*>, array<int, 1>, subrange<wchar_t*, wchar_t*>>);
+    static_assert(!CanTupleCat<void>);
+    static_assert(!CanTupleCat<int>);
+    static_assert(!CanTupleCat<int, tuple<int>>);
+    static_assert(!CanTupleCat<int, array<int, 1>>);
+    static_assert(!CanTupleCat<tuple<>, tuple<int>, int>);
+
+    constexpr bool test() {
+        // Test tuple_cat with empty tuple-like types
+        assert(tuple_cat(tuple{}, array<int, 0>{}) == tuple{});
+
+        // Test tuple_cat with one-sized tuple-like types
+        assert((tuple_cat(tuple{7}, array{8}) == tuple{7, 8}));
+
+        { // Test tuple_cat with pair-like types
+            int a = 0;
+            int b = 1;
+            assert(
+                (tuple_cat(tuple{1, 2}, array{3, 4}, pair{5, 6}, subrange{&a, &b}) == tuple{1, 2, 3, 4, 5, 6, &a, &b}));
+        }
+
+        // Test tuple_cat with big tuple-like types
+        assert((tuple_cat(tuple{1, 2, 3}, array{4, 5, 6}) == tuple{1, 2, 3, 4, 5, 6}));
+
+        return true;
+    }
+} // namespace test_tuple_cat
+
+static_assert(test_apply::test());
+static_assert(test_make_from_tuple::test());
+static_assert(test_tuple_cat::test());
diff --git a/tests/std/tests/P2165R4_tuple_like_relational_operators/env.lst b/tests/std/tests/P2165R4_tuple_like_relational_operators/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_relational_operators/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2165R4_tuple_like_relational_operators/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_relational_operators/test.compile.pass.cpp
new file mode 100644
index 0000000000..52d7a2c337
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_relational_operators/test.compile.pass.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+#include <cassert>
+#include <compare>
+#include <concepts>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+using namespace std;
+using ranges::subrange;
+
+struct Incomparable {};
+
+struct NeverCompare {
+    template <int = 0>
+    constexpr bool operator==(const NeverCompare&) const {
+        assert(false);
+        return true;
+    }
+
+    template <int = 0>
+    constexpr auto operator<=>(const NeverCompare&) const {
+        assert(false);
+        return strong_ordering::equal;
+    }
+};
+
+template <class T, class U>
+concept verify_comparisons = equality_comparable_with<T, U> && three_way_comparable_with<T, U>;
+
+constexpr bool test() {
+    { // Check comparisons of empty tuple-like types
+        static_assert(verify_comparisons<tuple<>, array<int, 0>>);
+        static_assert(!verify_comparisons<tuple<>, array<Incomparable, 0>>);
+
+        static_assert(tuple{} == array<int, 0>{});
+
+        constexpr same_as<strong_ordering> auto cmp = (tuple{} <=> array<int, 0>{});
+        static_assert(is_eq(cmp));
+    }
+
+    { // Check comparisons of (tuple_size_v == 1) tuple-like types
+        static_assert(verify_comparisons<tuple<int>, array<int, 1>>);
+        static_assert(!verify_comparisons<tuple<int>, array<Incomparable, 1>>);
+        static_assert(tuple{5} == array{5});
+        static_assert(tuple{6} != array{7});
+        static_assert(is_eq(tuple{1} <=> array{1}));
+        static_assert(is_lt(tuple{1} <=> array{2}));
+        static_assert(is_gt(tuple{3} <=> array{2}));
+    }
+
+    { // Check comparisons of (tuple_size_v == 2) tuple-like types
+        static_assert(verify_comparisons<tuple<int, int>, array<int, 2>>);
+        static_assert(!verify_comparisons<tuple<int, int>, array<Incomparable, 2>>);
+        static_assert(!verify_comparisons<tuple<Incomparable, Incomparable>, array<Incomparable, 2>>);
+        static_assert(verify_comparisons<tuple<int, int>, pair<int, int>>);
+        static_assert(!verify_comparisons<tuple<int, int>, pair<int, Incomparable>>);
+        static_assert(!verify_comparisons<tuple<int*, int*>,
+                      subrange<int*, int*>>); // subrange does not model equality_comparable
+
+        static_assert(tuple{1, 2} == array<int, 2>{1, 2});
+        static_assert(tuple<int, int>{2, 1} != array<int, 2>{1, 2});
+        static_assert(is_eq(tuple{1, 2} <=> array{1, 2}));
+        static_assert(is_lt(tuple{1, 1} <=> array{1, 2}));
+        static_assert(is_gt(tuple{2, 1} <=> array{1, 1}));
+
+        static_assert(tuple{1, 2} == pair{1, 2});
+        static_assert(tuple{2, 1} != pair{1, 2});
+        static_assert(is_eq(tuple{1, 2} <=> pair{1, 2}));
+        static_assert(is_lt(tuple{1, 1} <=> pair{1, 2}));
+        static_assert(is_gt(tuple{2, 1} <=> pair{1, 1}));
+
+        int a    = 0;
+        int b    = 1;
+        int c[2] = {2, 3};
+        static_assert(tuple{&a, &b} == subrange{&a, &b});
+        static_assert(tuple{&b, &a} != subrange{&a, &b});
+        static_assert(is_eq(tuple{&a, &b} <=> pair{&a, &b}));
+        static_assert(is_lt(tuple{&c[0], &c[0]} <=> pair{&c[0], &c[1]}));
+        static_assert(is_gt(tuple{&c[1], &c[0]} <=> pair{&c[0], &c[1]}));
+    }
+
+    { // Check comparisons of (tuple_size_v == 3) tuple-like types
+        static_assert(verify_comparisons<tuple<int, int, int>, array<int, 3>>);
+        static_assert(!verify_comparisons<tuple<int, Incomparable, int>, array<Incomparable, 3>>);
+        static_assert(tuple{1, 2, 3} == array{1, 2, 3});
+        static_assert(tuple{6, 7, 8} != array{7, 8, 9});
+        static_assert(is_eq(tuple{1, 2, 3} <=> array{1, 2, 3}));
+        static_assert(is_lt(tuple{1, 2, 3} <=> array{1, 2, 4}));
+        static_assert(is_gt(tuple{4, 3, 2} <=> array{3, 2, 1}));
+    }
+
+    { // Check short circuit evaluation
+        static_assert(tuple{0, NeverCompare{}} != pair{1, NeverCompare{}});
+        static_assert(is_lt(tuple{0, NeverCompare{}} <=> pair{1, NeverCompare{}}));
+        static_assert(is_gt(tuple{1, NeverCompare{}} <=> pair{0, NeverCompare{}}));
+    }
+
+    { // Check result type of three-way comparison
+        struct NeedsToSynth3Way {
+            bool operator<(const NeedsToSynth3Way&) const; // not defined
+        };
+
+        static_assert(same_as<strong_ordering, decltype(tuple{0, 1} <=> array{0, 2})>);
+        static_assert(same_as<weak_ordering, decltype(tuple{NeedsToSynth3Way{}} <=> array{NeedsToSynth3Way{}})>);
+        static_assert(same_as<partial_ordering, decltype(tuple{0, 1.f} <=> array{0, 2})>);
+    }
+
+    { // Check incorrect three-way comparisons
+        static_assert(!three_way_comparable_with<tuple<int>, array<int, 2>>);
+        static_assert(!three_way_comparable_with<tuple<int>, subrange<int*, int*>>);
+        static_assert(!three_way_comparable_with<tuple<int>, pair<int, int>>);
+    }
+
+    return true;
+}
+
+static_assert(test());
diff --git a/tests/std/tests/P2165R4_tuple_like_tuple_members/env.lst b/tests/std/tests/P2165R4_tuple_like_tuple_members/env.lst
new file mode 100644
index 0000000000..18e2d7c71e
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_tuple_members/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2165R4_tuple_like_tuple_members/test.cpp b/tests/std/tests/P2165R4_tuple_like_tuple_members/test.cpp
new file mode 100644
index 0000000000..b9ba3f2c4f
--- /dev/null
+++ b/tests/std/tests/P2165R4_tuple_like_tuple_members/test.cpp
@@ -0,0 +1,303 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <memory_resource>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+using namespace std;
+
+template <template <class...> class Template, class T, size_t N, class Indices = make_index_sequence<N>>
+struct repeat_type_injection_impl;
+
+template <template <class...> class Template, class T, size_t N, size_t... Indices>
+struct repeat_type_injection_impl<Template, T, N, index_sequence<Indices...>> {
+    template <size_t>
+    using repeat_type = T;
+
+    using type = Template<repeat_type<Indices>...>;
+};
+
+template <template <class...> class Template, class T, size_t N>
+using repeat_type_injection = typename repeat_type_injection_impl<Template, T, N>::type;
+
+static_assert(same_as<repeat_type_injection<tuple, int, 0>, tuple<>>);
+static_assert(same_as<repeat_type_injection<pair, int, 2>, pair<int, int>>);
+static_assert(same_as<repeat_type_injection<tuple, int, 4>, tuple<int, int, int, int>>);
+
+struct TmpChar {
+    constexpr TmpChar() : TmpChar('\0') {}
+    constexpr TmpChar(char c) : val{c} {}
+
+    constexpr TmpChar(const TmpChar&) = default;
+    constexpr TmpChar(TmpChar&& other) : val{exchange(other.val, '\x7F')} {}
+
+    constexpr TmpChar& operator=(const TmpChar&) = default;
+    constexpr TmpChar& operator=(TmpChar&& other) {
+        if (this != &other) {
+            val = exchange(other.val, '\x7F');
+        }
+        return *this;
+    }
+
+    char val;
+    constexpr bool operator==(const TmpChar&) const = default;
+};
+
+struct EvilComma {
+    constexpr EvilComma& operator=(size_t) {
+        return *this;
+    }
+
+    constexpr const EvilComma& operator=(size_t) const {
+        return *this;
+    }
+
+    constexpr void operator,(auto&&) const {
+        assert(false);
+    }
+};
+
+template <size_t N, template <class...> class TplLike>
+struct tester {
+public:
+    template <class T>
+    using Tuple = repeat_type_injection<tuple, T, N>;
+
+    template <class T>
+    using TupleLike = repeat_type_injection<TplLike, T, N>;
+
+    static constexpr bool run() {
+        using Seq = make_index_sequence<N>;
+        static_assert(test_tuple_like_constructor(Seq{}));
+        static_assert(test_tuple_like_allocator_constructor(Seq{}));
+        static_assert(test_tuple_like_assignment(Seq{}));
+        static_assert(test_pair_like_const_assignment(Seq{}));
+        return true;
+    }
+
+private:
+    template <size_t... Indices>
+    static constexpr bool test_tuple_like_constructor(index_sequence<Indices...>) {
+        // Test tuple(tuple-like) constructor with TupleLike<int>&
+        static_assert(constructible_from<Tuple<int>, TupleLike<int>&>);
+        static_assert(constructible_from<Tuple<int&>, TupleLike<int>&>);
+        static_assert(constructible_from<Tuple<const int&>, TupleLike<int>&>);
+        static_assert(!constructible_from<Tuple<int&&>, TupleLike<int>&> || N == 0);
+        static_assert(!constructible_from<Tuple<const int&&>, TupleLike<int>&> || N == 0);
+
+        // Test tuple(tuple-like) constructor with const TupleLike<int>&
+        static_assert(constructible_from<Tuple<int>, const TupleLike<int>&>);
+        static_assert(!constructible_from<Tuple<int&>, const TupleLike<int>&> || N == 0);
+        static_assert(constructible_from<Tuple<const int&>, const TupleLike<int>&>);
+        static_assert(!constructible_from<Tuple<int&&>, const TupleLike<int>&> || N == 0);
+        static_assert(!constructible_from<Tuple<const int&&>, const TupleLike<int>&> || N == 0);
+
+        // Test tuple(tuple-like) constructor with TupleLike<int>
+        static_assert(constructible_from<Tuple<int>, TupleLike<int>>);
+        static_assert(!constructible_from<Tuple<int&>, TupleLike<int>> || N == 0);
+        static_assert(constructible_from<Tuple<const int&>, TupleLike<int>>);
+        static_assert(constructible_from<Tuple<int&&>, TupleLike<int>>);
+        static_assert(constructible_from<Tuple<const int&&>, TupleLike<int>>);
+
+        // Test tuple(tuple-like) constructor with const TupleLike<int>
+        static_assert(constructible_from<Tuple<int>, const TupleLike<int>>);
+        static_assert(!constructible_from<Tuple<int&>, const TupleLike<int>> || N == 0);
+        static_assert(constructible_from<Tuple<const int&>, const TupleLike<int>>);
+        static_assert(!constructible_from<Tuple<int&&>, const TupleLike<int>> || N == 0);
+        static_assert(constructible_from<Tuple<const int&&>, const TupleLike<int>>);
+
+        auto get_letter      = [](size_t Idx) { return static_cast<char>('A' + Idx); };
+        TupleLike<TmpChar> a = {get_letter(Indices)...}; // 'A', 'B', 'C', ...
+
+        Tuple<TmpChar> t1(a);
+        assert((get<Indices>(t1) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<TmpChar&> t2(a);
+        assert((&get<Indices>(t2) == &get<Indices>(a)) && ...);
+
+        Tuple<const TmpChar&> t3(a);
+        assert((&get<Indices>(t3) == &get<Indices>(a)) && ...);
+
+        Tuple<TmpChar> t4(as_const(a));
+        assert((get<Indices>(t4) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<const TmpChar&> t5(as_const(a));
+        assert((&get<Indices>(t5) == &get<Indices>(a)) && ...);
+
+        Tuple<TmpChar> t6(std::move(a));
+        assert((get<Indices>(t6) == get_letter(Indices) && get<Indices>(a) == '\x7F') && ...);
+        ((get<Indices>(a) = std::move(get<Indices>(t6))), ...);
+
+        Tuple<const TmpChar&> t7(std::move(a));
+        assert((&get<Indices>(t7) == &get<Indices>(a)) && ...);
+
+        Tuple<TmpChar&&> t8(std::move(a));
+        assert((&get<Indices>(t8) == &get<Indices>(a)) && ...);
+
+        Tuple<const TmpChar&&> t9(std::move(a));
+        assert((&get<Indices>(t9) == &get<Indices>(a)) && ...);
+
+        Tuple<TmpChar> t10(std::move(as_const(a)));
+        assert((get<Indices>(t10) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<const TmpChar&> t11(std::move(as_const(a)));
+        assert((get<Indices>(t11) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<const TmpChar&&> t12(std::move(as_const(a)));
+        assert((get<Indices>(t12) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        // Check explicit specifier
+        static_assert(!convertible_to<string_view, string>);
+        static_assert(convertible_to<TupleLike<int>, Tuple<long>>);
+        static_assert(!convertible_to<TupleLike<string_view>, Tuple<string>> || N == 0);
+        static_assert(constructible_from<Tuple<string>, TupleLike<string_view>>);
+
+        return true;
+    }
+
+    template <size_t... Indices>
+    static constexpr bool test_tuple_like_allocator_constructor(index_sequence<Indices...>) {
+        // Test tuple(allocator_arg_t, Alloc, tuple-like)
+        static_assert(constructible_from<Tuple<string>, allocator_arg_t, allocator<char>, TupleLike<string>&>);
+        static_assert(constructible_from<Tuple<string>, allocator_arg_t, allocator<char>, const TupleLike<string>&>);
+        static_assert(constructible_from<Tuple<string>, allocator_arg_t, allocator<char>, TupleLike<string>>);
+        static_assert(constructible_from<Tuple<string>, allocator_arg_t, allocator<char>, const TupleLike<string>>);
+
+        if (!is_constant_evaluated()) {
+            using Alloc = pmr::polymorphic_allocator<char>;
+
+            array<byte, 128> buffer;
+            pmr::monotonic_buffer_resource resource{buffer.data(), buffer.size()};
+            auto get_str = [&](size_t Idx) { return pmr::string({static_cast<char>('A' + Idx)}, Alloc{&resource}); };
+
+            TupleLike<pmr::string> a = {get_str(Indices)...}; // "A"s, "B"s, "C"s, ...
+
+            Tuple<pmr::string> t1(allocator_arg, Alloc{&resource}, a);
+            assert((get<Indices>(t1).get_allocator() == get<Indices>(a).get_allocator()) && ...);
+            assert((ranges::equal(get<Indices>(t1), get_str(Indices)) //
+                       && ranges::equal(get<Indices>(a), get_str(Indices)))
+                   && ...);
+
+            array<byte, 128> extra_buffer;
+            pmr::monotonic_buffer_resource extra_resource{extra_buffer.data(), extra_buffer.size()};
+
+            Tuple<const pmr::string> t2(allocator_arg, Alloc{&extra_resource}, a);
+            assert((get<Indices>(t2).get_allocator() != get<Indices>(a).get_allocator()) && ...);
+            assert((ranges::equal(get<Indices>(t2), get_str(Indices)) //
+                       && ranges::equal(get<Indices>(a), get_str(Indices)))
+                   && ...);
+        }
+
+        return true;
+    }
+
+    template <size_t... Indices>
+    static constexpr bool test_tuple_like_assignment(index_sequence<Indices...>) {
+        // Test operator=(tuple-like)
+        static_assert(is_assignable_v<Tuple<int>&, TupleLike<int>&>);
+        static_assert(is_assignable_v<Tuple<int>&, const TupleLike<int>&>);
+        static_assert(is_assignable_v<Tuple<int>&, TupleLike<int>>);
+        static_assert(is_assignable_v<Tuple<int>&, const TupleLike<int>>);
+
+        auto get_letter      = [](size_t Idx) { return static_cast<char>('A' + Idx); };
+        TupleLike<TmpChar> a = {get_letter(Indices)...};
+
+        Tuple<TmpChar> t1;
+        t1 = a;
+        assert((get<Indices>(t1) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<TmpChar> t2;
+        t2 = as_const(a);
+        assert((get<Indices>(t2) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        Tuple<TmpChar> t3;
+        t3 = std::move(a);
+        assert((get<Indices>(t3) == get_letter(Indices) && get<Indices>(a) == '\x7F') && ...);
+        ((get<Indices>(a) = std::move(get<Indices>(t3))), ...);
+
+        Tuple<TmpChar> t4;
+        t4 = std::move(as_const(a));
+        assert((get<Indices>(t4) == get_letter(Indices) && get<Indices>(a) == get_letter(Indices)) && ...);
+
+        // Check comma hijacking
+        Tuple<EvilComma> t5;
+        t5 = TupleLike<size_t>{Indices...};
+
+        return true;
+    }
+
+    template <size_t... Indices>
+    static constexpr bool test_pair_like_const_assignment(index_sequence<Indices...>) {
+        using Ref = vector<bool>::reference;
+
+        // Test operator=(tuple-like) const
+        static_assert(is_assignable_v<const Tuple<Ref>&, TupleLike<bool>&>);
+        static_assert(is_assignable_v<const Tuple<Ref>&, const TupleLike<bool>&>);
+        static_assert(is_assignable_v<const Tuple<Ref>&, TupleLike<bool>>);
+        static_assert(is_assignable_v<const Tuple<Ref>&, const TupleLike<bool>>);
+
+        auto get_false_true = [](size_t Idx) { return static_cast<bool>(Idx % 2); };
+        auto get_true_false = [](size_t Idx) { return static_cast<bool>((Idx + 1) % 2); };
+
+        vector<bool> booleans = {get_false_true(Indices)...}; // false, true, false, true, ...
+        TupleLike<bool> a     = {get_true_false(Indices)...}; // true, false, true, false, ...
+
+        const Tuple<Ref> t1{booleans[Indices]...};
+        t1 = a;
+        assert((get<Indices>(t1) == get_true_false(Indices)) && ...);
+        booleans = {get_false_true(Indices)...};
+
+        const Tuple<Ref> t2{booleans[Indices]...};
+        t2 = as_const(a);
+        assert((get<Indices>(t2) == get_true_false(Indices)) && ...);
+        booleans = {get_false_true(Indices)...};
+
+        const Tuple<Ref> t3{booleans[Indices]...};
+        t3 = std::move(a);
+        assert((get<Indices>(t3) == get_true_false(Indices)) && ...);
+        booleans = {get_false_true(Indices)...};
+
+        const Tuple<Ref> t4{booleans[Indices]...};
+        t4 = std::move(as_const(a));
+        assert((get<Indices>(t4) == get_true_false(Indices)) && ...);
+
+        // Check comma hijacking
+        const Tuple<EvilComma> t5;
+        t5 = TupleLike<size_t>{Indices...};
+
+        return true;
+    }
+};
+
+template <class...>
+struct TupleLikeArrayImpl;
+
+template <>
+struct TupleLikeArrayImpl<> {
+    using type = array<int, 0>;
+};
+
+template <class Head, class... Rest>
+struct TupleLikeArrayImpl<Head, Rest...> {
+    using type = array<Head, 1 + sizeof...(Rest)>;
+};
+
+template <class... Ts>
+using TupleLikeArray = typename TupleLikeArrayImpl<Ts...>::type;
+
+int main() {
+    static_assert(tester<0, TupleLikeArray>::run());
+    static_assert(tester<1, TupleLikeArray>::run());
+    static_assert(tester<2, TupleLikeArray>::run());
+    static_assert(tester<2, pair>::run());
+    static_assert(tester<3, TupleLikeArray>::run());
+}
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 7dedee3a9d..4ab785b5d7 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -2154,6 +2154,20 @@ STATIC_ASSERT(__cpp_lib_transparent_operators == 201510L);
 STATIC_ASSERT(__cpp_lib_tuple_element_t == 201402L);
 #endif
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#ifndef __cpp_lib_tuple_like
+#error __cpp_lib_tuple_like is not defined
+#elif __cpp_lib_tuple_like != 202207L
+#error __cpp_lib_tuple_like is not 202207L
+#else
+STATIC_ASSERT(__cpp_lib_tuple_like == 202207L);
+#endif
+#else
+#ifdef __cpp_lib_tuple_like
+#error __cpp_lib_tuple_like is defined
+#endif
+#endif
+
 #ifndef __cpp_lib_tuples_by_type
 #error __cpp_lib_tuples_by_type is not defined
 #elif __cpp_lib_tuples_by_type != 201304L