diff --git a/source/algorithms.tex b/source/algorithms.tex
index ffe860726a..5e93435849 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -3409,10 +3409,10 @@
 \pnum
 \expects
 \tcode{Function} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
+the \oldconcept{MoveConstructible} requirements\iref{utility.req.cpp17.moveconstructible}.
 \begin{note}
 \tcode{Function} need not meet the requirements of
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}).
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}.
 \end{note}
 
 \pnum
@@ -4963,7 +4963,7 @@
 For the overload with an \tcode{ExecutionPolicy},
 there might be a performance cost
 if \tcode{iterator_traits<For\-ward\-It\-er\-ator1>::value_type}
-is not \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}).
+is not \oldconcept{\-Move\-Constructible}\iref{utility.req.cpp17.moveconstructible}.
 \end{note}
 
 \pnum
@@ -5758,7 +5758,7 @@
 \expects
 For the algorithms in namespace \tcode{std},
 the type of \tcode{*first}
-meets the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+meets the \oldconcept{MoveAssignable} requirements\iref{utility.req.cpp17.moveassignable}.
 
 \pnum
 \effects
@@ -5866,7 +5866,7 @@
 For the overloads with an \tcode{ExecutionPolicy},
 there might be a performance cost
 if \tcode{iterator_traits<ForwardIterator1>::value_type} does not meet
-the \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}) requirements.
+the \oldconcept{\-Move\-Constructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \end{note}
 
 \pnum
@@ -5939,7 +5939,7 @@
 For the overloads in namespace \tcode{std},
 \tcode{pred} is an equivalence relation and
 the type of \tcode{*first} meets
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconcept{MoveAssignable} requirements\iref{utility.req.cpp17.moveassignable}.
 
 \pnum
 \effects
@@ -6045,9 +6045,9 @@
     the \oldconcept{ForwardIterator} requirements and
     its value type is the same as \tcode{T},
     then \tcode{T} meets
-    the \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+    the \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable} requirements.
     Otherwise, \tcode{T} meets both
-    the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+    the \oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible} and
     \oldconcept{CopyAssignable} requirements.
     \begin{note}
     For the overloads with an \tcode{ExecutionPolicy},
@@ -6195,8 +6195,8 @@
 \tcode{ForwardIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -6693,8 +6693,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -6751,8 +6751,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -6821,8 +6821,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -6929,8 +6929,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements},
 the type of \tcode{*result_first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{\-Move\-Assignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{\-Move\-Assignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 For iterators \tcode{a1} and \tcode{b1} in \range{first}{last}, and
@@ -7134,8 +7134,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -7543,8 +7543,8 @@
 \tcode{BidirectionalIterator} meets
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -7834,8 +7834,8 @@
 \tcode{BidirectionalIterator} meets
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -8404,8 +8404,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconcept{MoveConstructible} requirements\iref{utility.req.cpp17.moveconstructible} and
+the \oldconcept{MoveAssignable} requirements\iref{utility.req.cpp17.moveassignable}.
 
 \pnum
 \effects
@@ -8457,8 +8457,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -8513,8 +8513,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwap\-pable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -8566,8 +8566,8 @@
 \tcode{RandomAccessIterator} meets
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConst\-ruct\-ible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Move\-Assign\-able} (\tref{cpp17.moveassignable}) requirements.
+the \oldconcept{MoveConst\-ruct\-ible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{Move\-Assign\-able}\iref{utility.req.cpp17.moveassignable} requirements.
 
 \pnum
 \effects
@@ -8726,7 +8726,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconcept{LessThanComparable} requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -8768,7 +8768,7 @@
 For the overloads in namespace \tcode{std},
 \tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
 For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
-requirements (\tref{cpp17.lessthancomparable}).
+requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -8804,7 +8804,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconcept{LessThanComparable} requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -8846,7 +8846,7 @@
 For the overloads in namespace \tcode{std},
 \tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
 For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
-requirements (\tref{cpp17.lessthancomparable}).
+requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -8884,7 +8884,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconcept{LessThanComparable} requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -8927,7 +8927,7 @@
 For the overloads in namespace \tcode{std},
 \tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
 For the first form, type \tcode{T} meets the \oldconcept{LessThanComparable}
-requirements (\tref{cpp17.lessthancomparable}).
+requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -9119,7 +9119,7 @@
 \tcode{bool(invoke(comp, invoke(proj, hi), invoke(proj, lo)))} is \tcode{false}.
 For the first form, type \tcode{T}
 meets the \oldconcept{LessThan\-Comparable}
-requirements (\tref{cpp17.lessthancomparable}).
+requirements\iref{utility.req.cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -9672,8 +9672,8 @@
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}
+and \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable} requirements.
 In the range \crange{first}{last},
 \tcode{binary_op} neither modifies elements
 nor invalidates iterators or subranges.
@@ -9795,7 +9795,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -9839,8 +9839,8 @@
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}
+and \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable} requirements.
 In the ranges \crange{first1}{last1} and
 \crange{first2}{first2 + (last1 - first1)}
 \tcode{binary_op1} and \tcode{binary_op2}
@@ -9935,7 +9935,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \item
   Neither \tcode{binary_op1} nor \tcode{binary_op2}
   invalidates subranges, nor modifies elements in the ranges
@@ -9985,7 +9985,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op} invalidates subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -10134,7 +10134,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in
@@ -10255,7 +10255,7 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided,
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements;
   otherwise, \tcode{U}
   meets the \oldconcept{MoveConstructible} requirements.
 \item
@@ -10334,7 +10334,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op}
   invalidates iterators or subranges, nor modifies elements in
@@ -10433,7 +10433,7 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided, \tcode{T} meets the
-  \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements;
   otherwise, \tcode{U} meets the
   \oldconcept{MoveConstructible} requirements.
 \item
@@ -10534,7 +10534,7 @@
 \begin{itemize}
 \item
   For the overloads with no \tcode{ExecutionPolicy},
-  \tcode{T} meets the \oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+  \tcode{T} meets the \oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable}
   requirements.
 \item
   For all overloads, in the ranges \crange{first}{last}
diff --git a/source/concepts.tex b/source/concepts.tex
index 0508cb542b..70df00a928 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -754,7 +754,7 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-Unlike the \oldconcept{Destructible} requirements~(\tref{cpp17.destructible}), this
+Unlike the \oldconcept{Destructible} requirements\iref{utility.req.cpp17.destructible}, this
 concept forbids destructors that are potentially throwing, even if a particular
 invocation of the destructor does not actually throw.
 \end{note}
diff --git a/source/future.tex b/source/future.tex
index 450109745c..4c0e1f23a1 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -292,7 +292,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{EqualityComparable} requirements (\tref{cpp17.equalitycomparable}).
+\tcode{T} meets the \oldconcept{EqualityComparable} requirements\iref{cpp17.equalitycomparable}.
 
 \pnum
 \returns
@@ -307,7 +307,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconcept{LessThanComparable} requirements \iref{cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -322,7 +322,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconcept{LessThanComparable} requirements \iref{cpp17.lessthancomparable}.
 
 \pnum
 \returns
@@ -337,7 +337,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconcept{LessThanComparable} requirements\iref{cpp17.lessthancomparable}.
 
 \pnum
 \returns
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 4de815cac6..49ceb318d0 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -1688,11 +1688,11 @@
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
-If \tcode{is_trivially_copy_constructible_v<stateT>} is \tcode{true},
+the \oldconcept{DefaultConstructible}\iref{utility.req.cpp17.defaultconstructible},
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible},
+\oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable}, and
+\oldconcept{Destructible}\iref{utility.req.cpp17.destructible} requirements.
+If \tcode{is_trivi\-ally_copy_constructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy constructor.
 If \tcode{is_trivially_copy_assignable_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy assignment operator.
@@ -1703,7 +1703,7 @@
 \oldconcept{CopyConstructible},
 \oldconcept{CopyAssignable},
 \oldconcept{Destructible},
-and \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+and \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} requirements.
 In addition, the expressions shown in \tref{fpos.operations}
 are valid and have the indicated semantics.
 In that table,
diff --git a/source/iterators.tex b/source/iterators.tex
index b765432c95..494df7a84c 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -2055,7 +2055,7 @@
 \tcode{T}
 if
 \tcode{X} meets the \oldconcept{Iterator}\iref{iterator.iterators} and
-\oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements and
+\oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} requirements and
 the expressions in \tref{inputiterator} are valid and have
 the indicated semantics.
 
@@ -2147,7 +2147,7 @@
 \begin{note}
 For input iterators, \tcode{a == b} does not imply \tcode{++a == ++b}.
 (Equality does not guarantee the substitution property or referential transparency.)
-Value type \tcode{T} is not required to be a \oldconcept{CopyAssignable} type (\tref{cpp17.copyassignable}).
+Value type \tcode{T} is not required to be a \oldconcept{CopyAssignable} type\iref{utility.req.cpp17.copyassignable}.
 Such an algorithm can be used with istreams as the source of the input data through the
 \tcode{istream_iterator}
 class template.
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 6fe8e8fa0e..55548f6e72 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -260,7 +260,7 @@
 requirements. Names in \textit{italic} type that begin with the prefix
 \oldconcept{} refer to sets of well-defined expression requirements typically
 presented in tabular form, possibly with additional prose semantic requirements.
-For example, \oldconcept{Destructible}~(\tref{cpp17.destructible}) is such a named
+For example, \oldconcept{Destructible}\iref{utility.req.cpp17.destructible} is such a named
 requirement. Names in \tcode{constant width} type refer to library concepts
 which are presented as a concept definition\iref{temp}, possibly with additional
 prose semantic requirements. For example,
@@ -1622,8 +1622,8 @@
 \rSec3[utility.requirements.general]{General}
 
 \pnum
-\ref{utility.arg.requirements}
-describes requirements on types and expressions used to instantiate templates
+Subclauses \ref{utility.arg.requirements}--\ref{utility.req.cpp17.destructible}
+describe requirements on types and expressions used to instantiate templates
 defined in the \Cpp{} standard library.
 \ref{swappable.requirements} describes the requirements on swappable types and
 swappable expressions.
@@ -1638,8 +1638,16 @@
 \pnum
 The template definitions in the \Cpp{} standard library
 refer to various named requirements whose details are set out in
-Tables~\ref{tab:cpp17.equalitycomparable}--\ref{tab:cpp17.destructible}.
-In these tables,
+subclauses
+\ref{utility.req.cpp17.equalitycomparable},
+\ref{utility.req.cpp17.lessthancomparable},
+\ref{utility.req.cpp17.defaultconstructible},
+\ref{utility.req.cpp17.moveconstructible},
+\ref{utility.req.cpp17.copyconstructible},
+\ref{utility.req.cpp17.moveassignable},
+\ref{utility.req.cpp17.copyassignable}, and
+\ref{utility.req.cpp17.destructible}.
+In those subclauses,
 \begin{itemize}
 \item
 \tcode{T} denotes an object or reference type to be
@@ -1665,12 +1673,20 @@
 \tcode{T()} shall be a well-defined expression\iref{dcl.init} if one of those
 signatures is called using the default argument\iref{dcl.fct.default}.
 
-\begin{oldconcepttable}{EqualityComparable}{}{cpp17.equalitycomparable}
-{x{1in}x{1in}p{3in}}
-\topline
-\hdstyle{Expression}  &   \hdstyle{Return type} &   \rhdr{Requirement} \\ \capsep
-\tcode{a == b}  &
-\tcode{decltype(a == b)} models \exposconceptx{boolean-testa\-ble}{boolean-testable} &
+\rSec3[utility.req.cpp17.equalitycomparable]{\oldconcept{EqualityComparable} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{EqualityComparable} requirements
+if the following expression is well-formed and has the specified semantics.
+
+\begin{itemdecl}
+a == b
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{decltype(a == b)} models \exposconcept{boolean-testable}.
 \tcode{==} is an equivalence relation,
 that is, it has the following properties:
 \begin{itemize}
@@ -1680,91 +1696,220 @@
 If \tcode{a == b}, then \tcode{b == a}.
 \item
 If \tcode{a == b} and \tcode{b == c}, then \tcode{a == c}.
-\end{itemize} \\
-\end{oldconcepttable}
+\end{itemize}
+\end{itemdescr}
 
-\begin{oldconcepttable}{LessThanComparable}{}{cpp17.lessthancomparable}
-{x{1in}x{1in}p{3in}}
-\topline
-\hdstyle{Expression}  &   \hdstyle{Return type} &   \hdstyle{Requirement} \\ \capsep
-\tcode{a < b}   &
-\tcode{decltype(a < b)} models \exposconceptx{boolean-testa\-ble}{boolean-testable} &
-\tcode{<} is a strict weak ordering relation\iref{alg.sorting}    \\
-\end{oldconcepttable}
+\rSec3[utility.req.cpp17.lessthancomparable]{\oldconcept{LessThanComparable} requirements}
 
-\enlargethispage{-3\baselineskip}
-\begin{oldconcepttable}{DefaultConstructible}{}{cpp17.defaultconstructible}
-{x{2.15in}p{3in}}
-\topline
-\hdstyle{Expression}        &     \hdstyle{Post-condition}  \\ \capsep
-\tcode{T t;}      &     object \tcode{t} is default-initialized   \\ \rowsep
-\tcode{T u\{\};}    &     object \tcode{u} is value-initialized or aggregate-initialized \\ \rowsep
-\tcode{T()}\br\tcode{T\{\}}  &  an object of type \tcode{T} is value-initialized
-                                or aggregate-initialized \\
-\end{oldconcepttable}
+\pnum
+A type \tcode{T} meets the \oldconcept{LessThanComparable} requirements
+if the following expression is well-formed and has the specified semantics.
 
-\begin{oldconcepttable}{MoveConstructible}{}{cpp17.moveconstructible}
-{p{1in}p{4.15in}}
-\topline
-\hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
-\tcode{T u = rv;}    &   \tcode{u} is equivalent to the value of \tcode{rv} before the construction\\ \rowsep
-\tcode{T(rv)}       &
-  \tcode{T(rv)} is equivalent to the value of \tcode{rv} before the construction \\ \rowsep
-\multicolumn{2}{|p{5.3in}|}{
-  \tcode{rv}'s state is unspecified
-  \begin{tailnote}
+\begin{itemdecl}
+a < b
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{decltype(a < b)} models \exposconcept{boolean-testable}.
+\tcode{<} is a strict weak ordering relation\iref{alg.sorting}.
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.defaultconstructible]{\oldconcept{DefaultConstructible} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{DefaultConstructible} requirements
+if the following statements and expressions are well-formed and have the specified semantics.
+
+\begin{itemdecl}
+T t;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+Object \tcode{t} is default-initialized.
+\end{itemdescr}
+
+\begin{itemdecl}
+T u{};
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+Object \tcode{u} is value-initialized or aggregate-initialized.
+\end{itemdescr}
+
+\begin{itemdecl}
+T()
+T{}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+A value-initialized or aggregate-initialized object of type \tcode{T}.
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.moveconstructible]{\oldconcept{MoveConstructible} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{MoveConstructible} requirements
+if the following statements and expressions are well-formed and have the specified semantics.
+
+\begin{itemdecl}
+T u = rv;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{u} is equivalent to the value of \tcode{rv} before the construction.
+
+\pnum
+\remarks
+The state of \tcode{rv} is unspecified.
+
+\pnum
+\begin{note}
 \tcode{rv} must still meet the requirements of the library
-  component that is using it. The operations listed in those requirements must
-  work as specified whether \tcode{rv} has been moved from or not.
-\end{tailnote}
-}\\
-\end{oldconcepttable}
+component that is using it. The operations listed in those requirements must
+work as specified whether \tcode{rv} has been moved from or not.
+\end{note}
+\end{itemdescr}
 
-\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconcept{MoveConstructible})}{cpp17.copyconstructible}
-{p{1in}p{4.15in}}
-\topline
-\hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
-\tcode{T u = v;}     &   the value of \tcode{v} is unchanged and is equivalent to \tcode{ u}\\ \rowsep
-\tcode{T(v)}        &
-  the value of \tcode{v} is unchanged and is equivalent to \tcode{T(v)} \\
-\end{oldconcepttable}
+\begin{itemdecl}
+T(rv)
+\end{itemdecl}
 
-\begin{oldconcepttable}{MoveAssignable}{}{cpp17.moveassignable}
-{p{1in}p{1in}p{1in}p{1.9in}}
-\topline
-\hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
-\tcode{t = rv}  &   \tcode{T\&} &   \tcode{t}       &
-  If \tcode{t} and \tcode{rv} do not refer to the same object,
-  \tcode{t} is equivalent to the value of \tcode{rv} before the assignment\\ \rowsep
-\multicolumn{4}{|p{5.3in}|}{
-  \tcode{rv}'s state is unspecified.
-  \begin{tailnote}
-  \tcode{rv} must still meet the requirements of the library
-  component that is using it, whether or not \tcode{t} and \tcode{rv} refer to the same object.
-  The operations listed in those requirements must
-  work as specified whether \tcode{rv} has been moved from or not.
-\end{tailnote}
-}\\
-\end{oldconcepttable}
+\begin{itemdescr}
+\pnum
+\result
+A value equivalent to the value of \tcode{rv} before the construction.
 
-\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconcept{MoveAssignable})}{cpp17.copyassignable}
-{p{1in}p{1in}p{1in}p{1.9in}}
-\topline
-\hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
-\tcode{t = v}   &   \tcode{T\&} &   \tcode{t}   &   \tcode{t} is equivalent to \tcode{v}, the value of \tcode{v} is unchanged\\
-\end{oldconcepttable}
+\pnum
+\remarks
+The state of \tcode{rv} is unspecified.
 
-\begin{oldconcepttable}{Destructible}{}{cpp17.destructible}
-{p{1in}p{4.15in}}
-\topline
-\hdstyle{Expression}      &   \hdstyle{Post-condition}  \\ \capsep
-\tcode{u.\~T()} &   All resources owned by \tcode{u} are reclaimed, no exception is propagated. \\ \rowsep
-\multicolumn{2}{|l|}{
-  \begin{tailnote}
-  Array types and non-object types are not \oldconcept{Destructible}.
-  \end{tailnote}
-} \\
-\end{oldconcepttable}
+\pnum
+\begin{note}
+\tcode{rv} must still meet the requirements of the library
+component that is using it. The operations listed in those requirements must
+work as specified whether \tcode{rv} has been moved from or not.
+\end{note}
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.copyconstructible]{\oldconcept{CopyConstructible} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{CopyConstructible} requirements
+if \tcode{T} meets the \oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} requirements, and
+if the following statements and expressions are well-formed and have the specified semantics.
+
+\begin{itemdecl}
+T u = v;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+The value of \tcode{v} is unchanged and is equivalent to \tcode{u}.
+\end{itemdescr}
+
+\begin{itemdecl}
+T(v)
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+The value of \tcode{v} is unchanged and is equivalent to \tcode{T(v)}.
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.moveassignable]{\oldconcept{MoveAssignable} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{MoveAssignable} requirements
+if the following expression is well-formed and has the specified semantics.
+
+\begin{itemdecl}
+t = rv
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\ensures
+If \tcode{t} and \tcode{rv} do not refer to the same object,
+\tcode{t} is equivalent to the value of \tcode{rv} before the assignment.
+
+\pnum
+\result
+\tcode{T\&}.
+
+\pnum
+\returns
+\tcode{t}.
+
+\pnum
+\remarks
+The state of \tcode{rv} is unspecified.
+
+\pnum
+\begin{note}
+\tcode{rv} must still meet the requirements of the library
+component that is using it, whether or not \tcode{t} and \tcode{rv} refer to the same object.
+The operations listed in those requirements must
+work as specified whether \tcode{rv} has been moved from or not.
+\end{note}
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.copyassignable]{\oldconcept{CopyAssignable} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{CopyAssignable} requirements
+if \tcode{T} meets the \oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable} requirements, and if
+if the following expression is well-formed and has the specified semantics.
+
+\begin{itemdecl}
+t = v
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\ensures
+\tcode{t} is equivalent to \tcode{v}, the value of \tcode{v} is unchanged.
+
+\pnum
+\result
+\tcode{T\&}.
+
+\pnum
+\returns
+\tcode{t}.
+\end{itemdescr}
+
+\rSec3[utility.req.cpp17.destructible]{\oldconcept{Destructible} requirements}
+
+\pnum
+A type \tcode{T} meets the \oldconcept{Destructible} requirements
+if the following expression is well-formed and has the specified semantics.
+
+\begin{itemdecl}
+u.~T()
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\ensures
+All resources owned by \tcode{u} are reclaimed, no exception is propagated.
+\end{itemdescr}
+
+\pnum
+\begin{note}
+Array types and non-object types are not \oldconcept{Destructible}.
+\end{note}
 
 \rSec3[swappable.requirements]{Swappable requirements}
 
@@ -1955,8 +2100,8 @@
 A type \tcode{H} meets the \defnoldconcept{Hash} requirements if:
 \begin{itemize}
 \item it is a function object type\iref{function.objects},
-\item it meets the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
-  \oldconcept{Destructible} (\tref{cpp17.destructible}) requirements, and
+\item it meets the \oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible} and
+  \oldconcept{Destructible}\iref{utility.req.cpp17.destructible} requirements, and
 \item the expressions shown in \tref{cpp17.hash}
 are valid and have the indicated semantics.
 \end{itemize}
@@ -2640,7 +2785,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be copied
 when the client container is copy-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
+the \oldconcept{CopyAssignable} requirements\iref{utility.req.cpp17.copyassignable} and
 the copy operation shall not throw exceptions.
 
 \pnum
@@ -2662,7 +2807,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be moved
 when the client container is move-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
+the \oldconcept{MoveAssignable} requirements\iref{utility.req.cpp17.moveassignable} and
 the move operation shall not throw exceptions.
 
 \pnum
@@ -2714,7 +2859,7 @@
 
 \pnum
 An allocator type \tcode{X} shall meet the
-\oldconcept{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
+\oldconcept{CopyConstructible} requirements\iref{utility.req.cpp17.copyconstructible}.
 The \tcode{XX::pointer}, \tcode{XX::const_pointer}, \tcode{XX::void_pointer}, and
 \tcode{XX::const_void_pointer} types shall meet the
 \oldconcept{Nullable\-Pointer} requirements (\tref{cpp17.nullablepointer}).
diff --git a/source/memory.tex b/source/memory.tex
index d3bc9c6071..2c182b0914 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -2100,7 +2100,7 @@
 
 \pnum
 If the deleter's type \tcode{D} is not a reference type, \tcode{D} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconcept{Destructible} requirements\iref{utility.req.cpp17.destructible}.
 
 \pnum
 If the \grammarterm{qualified-id} \tcode{remove_reference_t<D>::pointer} is valid and denotes a
@@ -2134,7 +2134,7 @@
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconcept{DefaultConstructible} requirements\iref{utility.req.cpp17.defaultconstructible},
 and that construction does not throw an exception.
 
 \pnum
@@ -2161,7 +2161,7 @@
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconcept{DefaultConstructible} requirements\iref{utility.req.cpp17.defaultconstructible},
 and that construction does not throw an exception.
 
 \pnum
@@ -2241,7 +2241,7 @@
 \expects
 If \tcode{D} is not a reference type,
 \tcode{D} meets the \oldconcept{MoveConstructible}
-requirements (\tref{cpp17.moveconstructible}).
+requirements\iref{utility.req.cpp17.moveconstructible}.
 Construction
 of the deleter from an rvalue of type \tcode{D} does not
 throw an exception.
@@ -2349,7 +2349,7 @@
 \pnum
 \expects
 If \tcode{D} is not a reference type, \tcode{D} meets the
-\oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
+\oldconcept{MoveAssignable} requirements\iref{utility.req.cpp17.moveassignable} and assignment
 of the deleter from an rvalue of type \tcode{D} does not throw an exception.
 Otherwise, \tcode{D} is a reference type;
 \tcode{remove_reference_t<D>} meets the \oldconcept{CopyAssignable}
diff --git a/source/numerics.tex b/source/numerics.tex
index 14308f349e..cf1311ca6c 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1991,8 +1991,8 @@
 
 \pnum
 \tcode{E} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}
+and \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable} requirements.
 These operations shall each be of complexity
 no worse than \bigoh{\text{size of state}}.
 
@@ -2361,8 +2361,8 @@
 
 \pnum
 \tcode{D} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}
+and \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable} requirements.
 
 \pnum
 The sequence of numbers
@@ -2393,10 +2393,10 @@
 
 \pnum
 \tcode{P} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible},
+\oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable},
 and
-\oldconcept{Equality\-Comp\-arable} (\tref{cpp17.equalitycomparable}) requirements.
+\oldconcept{Equality\-Comp\-arable}\iref{utility.req.cpp17.equalitycomparable} requirements.
 
 \pnum
 For each of the constructors of \tcode{D}
diff --git a/source/strings.tex b/source/strings.tex
index c0213a348a..7ecb6ac49e 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -239,10 +239,10 @@
 \pnum
 \expects
 \tcode{state_type} meets the
-\oldconcept{Destructible} (\tref{cpp17.destructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}), and
-\oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
+\oldconcept{Destructible}\iref{utility.req.cpp17.destructible},
+\oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable},
+\oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible}, and
+\oldconcept{DefaultConstructible}\iref{utility.req.cpp17.defaultconstructible} requirements.
 \end{itemdescr}
 
 \rSec2[char.traits.specializations]{\tcode{char_traits} specializations}
diff --git a/source/threads.tex b/source/threads.tex
index ab471217c1..54914a511c 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -9749,8 +9749,8 @@
 
 \pnum
 \tcode{CompletionFunction} shall meet the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible} and
+\oldconcept{Destructible}\iref{utility.req.cpp17.destructible} requirements.
 \tcode{is_nothrow_invocable_v<CompletionFunction\&>} shall be \tcode{true}.
 
 \pnum
@@ -9758,15 +9758,15 @@
 an unspecified type, such that,
 in addition to satisfying the requirements of \tcode{CompletionFunction},
 it meets the \oldconcept{DefaultConstructible}
-requirements (\tref{cpp17.defaultconstructible}) and
+requirements\iref{utility.req.cpp17.defaultconstructible} and
 \tcode{completion()} has no effects.
 
 \pnum
 \tcode{barrier::arrival_token} is an unspecified type,
 such that it meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}),
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible},
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable}, and
+\oldconcept{Destructible}\iref{utility.req.cpp17.destructible} requirements.
 
 \indexlibrarymember{max}{barrier}%
 \begin{itemdecl}
diff --git a/source/time.tex b/source/time.tex
index edf6306a6c..7ad2883689 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1043,8 +1043,8 @@
 
 \item
 the types \tcode{TC::rep}, \tcode{TC::duration}, and \tcode{TC::time_point}
-meet the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
-\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable})
+meet the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} and
+\oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable}
 and \oldconcept{Swappable}\iref{swappable.requirements}
 requirements and the requirements of
 numeric types\iref{numeric.requirements},
@@ -3979,8 +3979,8 @@
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{day}'s unspecified internal storage.
-\tcode{day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{day} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements,
 and participates in basic arithmetic with \tcode{days} objects,
 which represent a difference between two \tcode{day} objects.
 
@@ -4272,8 +4272,8 @@
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{month}'s unspecified internal storage.
-\tcode{month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{month} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements,
 and participates in basic arithmetic with \tcode{months} objects,
 which represent a difference between two \tcode{month} objects.
 
@@ -4582,8 +4582,8 @@
 It can represent values in the range \crange{min()}{max()}.
 It can be constructed with any \tcode{int} value,
 which will be subsequently truncated to fit into \tcode{year}'s unspecified internal storage.
-\tcode{year} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{year} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements,
 and participates in basic arithmetic with \tcode{years} objects,
 which represent a difference between two \tcode{year} objects.
 
@@ -4937,7 +4937,7 @@
 it may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{weekday}'s unspecified internal storage.
-\tcode{weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{weekday} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} requirements.
 \begin{note}
 \tcode{weekday} is not
 \oldconcept{LessThanComparable}
@@ -5520,8 +5520,8 @@
 \pnum
 \tcode{month_day} represents a specific day of a specific month,
 but with an unspecified year.
-\tcode{month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{month_day} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements.
 
 \pnum
 \tcode{month_day} is a trivially copyable and standard-layout class type.
@@ -6021,8 +6021,8 @@
 \tcode{year_month} represents a specific month of a specific year,
 but with an unspecified day.
 \tcode{year_month} is a field-based time point with a resolution of \tcode{months}.
-\tcode{year_month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements.
 
 \pnum
 \tcode{year_month} is a trivially copyable and standard-layout class type.
@@ -6377,8 +6377,8 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements.
 
 \pnum
 \tcode{year_month_day} is a trivially copyable and standard-layout class type.
@@ -6838,8 +6838,8 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day_last} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable}
+and \oldconcept{LessThanComparable}\iref{utility.req.cpp17.lessthancomparable} requirements.
 
 \pnum
 \tcode{year_month_day_last} is a trivially copyable and standard-layout class type.
@@ -7209,7 +7209,7 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} requirements.
 
 \pnum
 \tcode{year_month_weekday} is a trivially copyable and standard-layout class type.
@@ -7602,7 +7602,7 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday_last} meets the \oldconcept{EqualityComparable}\iref{utility.req.cpp17.equalitycomparable} requirements.
 
 \pnum
 \tcode{year_month_weekday_last} is a trivially copyable and standard-layout class type.
diff --git a/source/utilities.tex b/source/utilities.tex
index fd9453e2e3..abfb44d4e2 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -246,9 +246,9 @@
 Type
 \tcode{T}
 meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible})
+\oldconcept{MoveConstructible}\iref{utility.req.cpp17.moveconstructible}
 and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+\oldconcept{MoveAssignable}\iref{utility.req.cpp17.moveassignable}
 requirements.
 
 \pnum
@@ -3326,7 +3326,7 @@
 \pnum
 \tcode{T} shall be a type
 other than \cv{} \tcode{in_place_t} or \cv{} \tcode{nullopt_t}
-that meets the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+that meets the \oldconcept{Destructible} requirements\iref{utility.req.cpp17.destructible}.
 
 \rSec3[optional.ctor]{Constructors}
 
@@ -5045,7 +5045,7 @@
 
 \pnum
 All types in \tcode{Types} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconcept{Destructible} requirements\iref{utility.req.cpp17.destructible}.
 
 \pnum
 A program that instantiates the definition of \tcode{variant} with
@@ -7418,7 +7418,7 @@
 
 \pnum
 When \tcode{T} is not \cv{} \tcode{void}, it shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconcept{Destructible} requirements\iref{utility.req.cpp17.destructible}.
 \tcode{E} shall meet
 the \oldconcept{Destructible} requirements.
 
@@ -8795,7 +8795,7 @@
 
 \pnum
 \tcode{E} shall meet the requirements of
-\oldconcept{Destructible} (\tref{cpp17.destructible}).
+\oldconcept{Destructible}\iref{utility.req.cpp17.destructible}.
 
 \rSec3[expected.void.cons]{Constructors}
 
@@ -14776,8 +14776,8 @@
 \begin{itemize}
 \item meet the \oldconcept{Hash} requirements (\tref{cpp17.hash}),
 with \tcode{Key} as the function
-call argument type, the \oldconcept{Default\-Constructible} requirements (\tref{cpp17.defaultconstructible}),
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
+call argument type, the \oldconcept{Default\-Constructible} requirements\iref{utility.req.cpp17.defaultconstructible},
+the \oldconcept{CopyAssignable} requirements\iref{utility.req.cpp17.copyassignable},
 the \oldconcept{Swappable} requirements\iref{swappable.requirements},
 \item meet the requirement that if \tcode{k1 == k2} is \tcode{true}, \tcode{h(k1) == h(k2)} is
 also \tcode{true}, where \tcode{h} is an object of type \tcode{hash<Key>} and \tcode{k1} and \tcode{k2}
@@ -16746,11 +16746,11 @@
 A type \tcode{F} meets the \defnnewoldconcept{BasicFormatter} requirements if
 it meets the
 \begin{itemize}
-\item \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\item \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\item \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
+\item \oldconcept{DefaultConstructible}\iref{utility.req.cpp17.defaultconstructible},
+\item \oldconcept{CopyConstructible}\iref{utility.req.cpp17.copyconstructible},
+\item \oldconcept{CopyAssignable}\iref{utility.req.cpp17.copyassignable},
 \item \oldconcept{Swappable}\iref{swappable.requirements}, and
-\item \oldconcept{Destructible} (\tref{cpp17.destructible})
+\item \oldconcept{Destructible}\iref{utility.req.cpp17.destructible}
 \end{itemize}
 requirements, and
 the expressions shown in \tref{formatter.basic} are valid and