diff --git a/source/algorithms.tex b/source/algorithms.tex
index 253d7ad18f..fa6b0876e7 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -262,8 +262,8 @@
 The number and order of deducible template parameters for algorithm declarations
 are unspecified, except where explicitly stated otherwise.
 \begin{note}
-Consequently, the algorithms may not
-be called with explicitly-specified template argument lists.
+Consequently, an implementation can reject calls
+that specify an explicit template argument list.
 \end{note}
 
 \rSec1[algorithms.parallel]{Parallel algorithms}
@@ -389,7 +389,7 @@
 where \tcode{is_trivially_copy_constructible_v<T>}
 and \tcode{is_trivially_destructible_v<T>} are \tcode{true}.
 \begin{note}
-This implies that user-supplied function objects should not rely on
+This implies that user-supplied function objects cannot rely on
 object identity of arguments for such input sequences.
 Users for whom the object identity of the arguments to these function objects
 is important should consider using a wrapping iterator
@@ -414,7 +414,7 @@
 unsequenced with respect to one another in the calling thread of execution.
 \begin{note}
 This means that multiple function object invocations
-may be interleaved on a single thread of execution,
+can be interleaved on a single thread of execution,
 which overrides the usual guarantee from \ref{intro.execution}
 that function executions do not overlap with one another.
 \end{note}
@@ -500,7 +500,7 @@
 or threads of execution implicitly created by the library;
 the latter will provide weakly parallel forward progress guarantees.
 \begin{note}
-This means that multiple function object invocations may be interleaved
+This means that multiple function object invocations can be interleaved
 on a single thread of execution,
 which overrides the usual guarantee from \ref{intro.execution}
 that function executions do not overlap with one another.
@@ -3153,7 +3153,7 @@
 starting from \tcode{first} and proceeding to \tcode{last - 1}.
 \begin{note}
 If the type of \tcode{first} meets the requirements of a mutable iterator,
-\tcode{f} may apply non-constant functions through the dereferenced iterator.
+\tcode{f} can apply non-constant functions through the dereferenced iterator.
 \end{note}
 
 \pnum
@@ -3188,7 +3188,7 @@
 every iterator in the range \range{first}{last}.
 \begin{note}
 If the type of \tcode{first} meets the requirements of a mutable iterator,
-\tcode{f} may apply non-constant functions through the dereferenced iterator.
+\tcode{f} can apply non-constant functions through the dereferenced iterator.
 \end{note}
 
 \pnum
@@ -3205,7 +3205,7 @@
 \pnum
 \begin{note}
 Does not return a copy of its \tcode{Function} parameter,
-since parallelization may not permit efficient state accumulation.
+since parallelization often does not permit efficient state accumulation.
 \end{note}
 \end{itemdescr}
 
@@ -3229,7 +3229,7 @@
 starting from \tcode{first} and proceeding to \tcode{last - 1}.
 \begin{note}
 If the result of \tcode{invoke(proj, *i)} is a mutable reference,
-\tcode{f} may apply non-constant functions.
+\tcode{f} can apply non-constant functions.
 \end{note}
 
 \pnum
@@ -3278,7 +3278,7 @@
 every iterator in the range \range{first}{first + n} in order.
 \begin{note}
 If the type of \tcode{first} meets the requirements of a mutable iterator,
-\tcode{f} may apply non-constant functions through the dereferenced iterator.
+\tcode{f} can apply non-constant functions through the dereferenced iterator.
 \end{note}
 
 \pnum
@@ -3314,7 +3314,7 @@
 every iterator in the range \range{first}{first + n}.
 \begin{note}
 If the type of \tcode{first} meets the requirements of a mutable iterator,
-\tcode{f} may apply non-constant functions through the dereferenced iterator.
+\tcode{f} can apply non-constant functions through the dereferenced iterator.
 \end{note}
 
 \pnum
@@ -3349,7 +3349,7 @@
 \range{first}{first + n} in order.
 \begin{note}
 If the result of \tcode{invoke(proj, *i)} is a mutable reference,
-\tcode{f} may apply non-constant functions.
+\tcode{f} can apply non-constant functions.
 \end{note}
 
 \pnum
@@ -4389,7 +4389,7 @@
 do not overlap.
 \begin{note}
 For the overload with an \tcode{ExecutionPolicy},
-there may be a performance cost
+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}).
 \end{note}
@@ -5287,7 +5287,7 @@
 do not overlap.
 \begin{note}
 For the overloads with an \tcode{ExecutionPolicy},
-there may be a performance cost
+there might be a performance cost
 if \tcode{iterator_traits<ForwardIterator1>::value_type} does not meet
 the \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}) requirements.
 \end{note}
@@ -5474,7 +5474,7 @@
     \oldconcept{CopyAssignable} requirements.
     \begin{note}
     For the overloads with an \tcode{ExecutionPolicy},
-    there may be a performance cost
+    there might be a performance cost
     if the value type of \tcode{ForwardIterator1} does not meet both the
     \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements.
     \end{note}
@@ -7009,7 +7009,7 @@
 
 \begin{note}
 For the overload with an \tcode{ExecutionPolicy},
-there may be a performance cost if \tcode{first}'s value type
+there might be a performance cost if \tcode{first}'s value type
 does not meet the \oldconcept{CopyConstructible} requirements.
 \end{note}
 
@@ -9527,7 +9527,7 @@
 that \tcode{exclusive_scan} excludes the $i^\text{th}$ input element
 from the $i^\text{th}$ sum.
 If \tcode{binary_op} is not mathematically associative,
-the behavior of \tcode{exclusive_scan} may be nondeterministic.
+the behavior of \tcode{exclusive_scan} might be nondeterministic.
 \end{note}
 \end{itemdescr}
 
@@ -9654,7 +9654,7 @@
 that \tcode{inclusive_scan} includes the $i^\text{th}$ input element
 in the $i^\text{th}$ sum.
 If \tcode{binary_op} is not mathematically associative,
-the behavior of \tcode{inclusive_scan} may be nondeterministic.
+the behavior of \tcode{inclusive_scan} might be nondeterministic.
 \end{note}
 \end{itemdescr}
 
@@ -9729,7 +9729,7 @@
 \tcode{transform_inclusive_scan} is that \tcode{trans\-form\-_\-exclusive_scan}
 excludes the $i^\text{th}$ input element from the $i^\text{th}$ sum.
 If \tcode{binary_op} is not mathematically associative,
-the behavior of \tcode{transform_exclusive_scan} may be nondeterministic.
+the behavior of \tcode{transform_exclusive_scan} might be nondeterministic.
 \tcode{transform_exclusive_scan}
 does not apply \tcode{unary_op} to \tcode{init}.
 \end{note}
@@ -9833,7 +9833,7 @@
 \tcode{transform_inclusive_scan} is that \tcode{trans\-form\-_\-inclusive_scan}
 includes the $i^\text{th}$ input element in the $i^\text{th}$ sum.
 If \tcode{binary_op} is not mathematically associative,
-the behavior of \tcode{transform_inclusive_scan} may be nondeterministic.
+the behavior of \tcode{transform_inclusive_scan} might be nondeterministic.
 \tcode{transform_inclusive_scan} does not
 apply \tcode{unary_op} to \tcode{init}.
 \end{note}
diff --git a/source/atomics.tex b/source/atomics.tex
index c7cc1ee16c..d15c918deb 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -528,7 +528,7 @@
 r2 = x.load(memory_order::relaxed);
 y.store(r2, memory_order::relaxed);
 \end{codeblock}
-should not produce \tcode{r1 == r2 == 42}, since the store of 42 to \tcode{y} is only
+this recommendation discourages producing \tcode{r1 == r2 == 42}, since the store of 42 to \tcode{y} is only
 possible if the store to \tcode{x} stores \tcode{42}, which circularly depends on the
 store to \tcode{y} storing \tcode{42}. Note that without this restriction, such an
 execution is possible.
@@ -636,8 +636,9 @@
 block\iref{intro.progress}.
 
 \pnum
+Operations that are lock-free should also be address-free.
 \begin{note}
-Operations that are lock-free should also be address-free. That is,
+That is,
 atomic operations on the same memory location via two different addresses will
 communicate atomically. The implementation should not depend on any
 per-process state. This restriction enables communication  by memory that is
@@ -1603,7 +1604,7 @@
 is \tcode{false}.
 \begin{note}
 Type arguments that are
-not also statically initializable may be difficult to use.
+not also statically initializable might be difficult to use.
 \end{note}
 
 \pnum
@@ -3443,10 +3444,7 @@
 
 \pnum
 Operations on an object of type \tcode{atomic_flag} shall be lock-free.
-\begin{note}
-Hence
-the operations should also be address-free.
-\end{note}
+The operations should also be address-free.
 
 \pnum
 The \tcode{atomic_flag} type is a standard-layout struct.
diff --git a/source/basic.tex b/source/basic.tex
index e8c15a4a91..dcbab7e5e2 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -692,10 +692,10 @@
 The entity is still declared in multiple translation units, and \ref{basic.link}
 still applies to these declarations. In particular,
 \grammarterm{lambda-expression}{s}\iref{expr.prim.lambda}
-appearing in the type of \tcode{D} may result
+appearing in the type of \tcode{D} might result
 in the different declarations having distinct types, and
 \grammarterm{lambda-expression}{s} appearing in a default argument of \tcode{D}
-may still denote different types in different translation units.
+might still denote different types in different translation units.
 \end{note}
 
 \pnum
@@ -822,9 +822,9 @@
 a name is introduced, which is not necessarily the same as the region in
 which the declaration occurs. In particular,
 \grammarterm{elaborated-type-specifier}{s}\iref{dcl.type.elab} and
-friend declarations\iref{class.friend} may introduce a (possibly not
+friend declarations\iref{class.friend} can introduce a (possibly not
 visible) name into an enclosing namespace; these restrictions apply to
-that region. Local extern declarations\iref{basic.link} may introduce
+that region. Local extern declarations\iref{basic.link} can introduce
 a name into the declarative region where the declaration appears and
 also introduce a (possibly not visible) name into an enclosing
 namespace; these restrictions apply to both regions.
@@ -2834,7 +2834,7 @@
 \grammarterm{using-directive}{s}
 do not declare entities.
 Enumerators do not have linkage,
-but may serve as the name of an enumeration with linkage\iref{dcl.enum}.
+but might serve as the name of an enumeration with linkage\iref{dcl.enum}.
 \end{note}
 
 \pnum
@@ -4538,7 +4538,7 @@
 
 \item A temporary bound to a reference in a \grammarterm{new-initializer}\iref{expr.new} persists until the completion of the full-expression containing the \grammarterm{new-initializer}.
 \begin{note}
-This may introduce a dangling reference.
+This might introduce a dangling reference.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -5809,7 +5809,7 @@
 initial value of the object, a value assigned to the object by $T$, or a
 value assigned to the object by another thread, according to the rules below.
 \begin{note}
-In some cases, there may instead be undefined behavior. Much of this
+In some cases, there might instead be undefined behavior. Much of this
 subclause is motivated by the desire to support atomic operations with explicit
 and detailed visibility constraints. However, it also implicitly supports a
 simpler view for more restricted programs.
@@ -5852,7 +5852,7 @@
 There is a separate order for each
 atomic object. There is no requirement that these can be combined into a single
 total order for all objects. In general this will be impossible since different
-threads may observe modifications to different objects in inconsistent orders.
+threads might observe modifications to different objects in inconsistent orders.
 \end{note}
 
 \pnum
@@ -6181,14 +6181,14 @@
 execution would not have encountered a data race. This includes implementations
 of data member assignment that overwrite adjacent members in separate memory
 locations. Reordering of atomic loads in cases in which the atomics in question
-may alias is also generally precluded, since this may violate the coherence
+might alias is also generally precluded, since this could violate the coherence
 rules.
 \end{note}
 
 \pnum
 \begin{note}
 Transformations that introduce a speculative read of a potentially
-shared memory location may not preserve the semantics of the \Cpp{} program as
+shared memory location might not preserve the semantics of the \Cpp{} program as
 defined in this document, since they potentially introduce a data race. However,
 they are typically valid in the context of an optimizing compiler that targets a
 specific machine with well-defined semantics for data races. They would be
@@ -6224,7 +6224,7 @@
   a lock-free execution in that thread shall complete.
   \begin{note}
     Concurrently executing threads
-    may prevent progress of a lock-free execution.
+    might prevent progress of a lock-free execution.
     For example,
     this situation can occur
     with load-locked store-conditional implementations.
@@ -6238,7 +6238,7 @@
     to provide absolute guarantees to this effect,
     since repeated and particularly inopportune interference
     from other threads
-    may prevent forward progress,
+    could prevent forward progress,
     e.g.,
     by repeatedly stealing a cache line
     for unrelated purposes
@@ -6306,9 +6306,7 @@
 \tcode{std::thread}\iref{thread.thread.class}
 or \tcode{std::jthread}\iref{thread.jthread.class}
 provide concurrent forward progress guarantees.
-\begin{note}
 General-purpose implementations should provide these guarantees.
-\end{note}
 
 \pnum
 \indextext{forward progress guarantees!parallel}%
@@ -6346,7 +6344,7 @@
 guarantees, which in turn are stronger than weakly parallel forward progress
 guarantees.
 \begin{note}
-For example, some kinds of synchronization between threads of execution may only
+For example, some kinds of synchronization between threads of execution might only
 make progress if the respective threads of execution provide parallel forward progress
 guarantees, but will fail to make progress under weakly parallel guarantees.
 \end{note}
@@ -6377,7 +6375,7 @@
 stronger forward progress guarantee for a certain amount of time, due to a
 second thread of execution $A$ being blocked on it with forward
 progress guarantee delegation. In turn, if $B$ then blocks with
-forward progress guarantee delegation on $C$, this may also temporarily
+forward progress guarantee delegation on $C$, this could also temporarily
 provide a stronger forward progress guarantee to $C$.
 \end{note}
 
@@ -6565,10 +6563,10 @@
 inline double fd() { return 1.0; }
 extern double d1;
 double d2 = d1;     // unspecified:
-                    // may be statically initialized to \tcode{0.0} or
+                    // either statically initialized to \tcode{0.0} or
                     // dynamically initialized to \tcode{0.0} if \tcode{d1} is
                     // dynamically initialized, or \tcode{1.0} otherwise
-double d1 = fd();   // may be initialized statically or dynamically to \tcode{1.0}
+double d1 = fd();   // either initialized statically or dynamically to \tcode{1.0}
 \end{codeblock}
 \end{note}
 
diff --git a/source/classes.tex b/source/classes.tex
index 3f59a2aa01..55db2d7040 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -196,7 +196,7 @@
 address\iref{expr.eq}.}
 \begin{note}
 $M(\mathtt{X})$ is the set of the types of all non-base-class subobjects
-that may be at a zero offset in \tcode{X}.
+that can be at a zero offset in \tcode{X}.
 \end{note}
 
 \begin{itemize}
@@ -869,7 +869,7 @@
 member function shall not be redeclared.
 \begin{note}
 There can be at most one definition of a non-inline member function in
-a program. There may be more than one
+a program. There can be more than one
 inline member function definition in a program.
 See~\ref{basic.def.odr} and~\ref{dcl.inline}.
 \end{note}
@@ -1528,7 +1528,7 @@
 
 \pnum
 \begin{note}
-All forms of copy/move constructor may be declared for a class.
+All forms of copy/move constructor can be declared for a class.
 \begin{example}
 \begin{codeblock}
 struct X {
@@ -1649,7 +1649,7 @@
 
 \begin{note}
 When the move constructor is not implicitly declared or explicitly supplied,
-expressions that otherwise would have invoked the move constructor may instead invoke
+expressions that otherwise would have invoked the move constructor might instead invoke
 a copy constructor.
 \end{note}
 
@@ -1814,7 +1814,7 @@
 see~\ref{over.ass}.
 \end{note}
 \begin{note}
-More than one form of copy assignment operator may be declared for a class.
+More than one form of copy assignment operator can be declared for a class.
 \end{note}
 \begin{note}
 If a class
@@ -1888,8 +1888,7 @@
 \end{note}
 {}
 \begin{note}
-More
-than one form of move assignment operator may be declared for a class.
+More than one form of move assignment operator can be declared for a class.
 \end{note}
 
 \pnum
@@ -2569,7 +2568,7 @@
 constructors, but does so only where the direct-initialization syntax\iref{dcl.init}
 or where casts~(\ref{expr.static.cast}, \ref{expr.cast}) are explicitly
 used; see also~\ref{over.match.copy}.
-A default constructor may be an explicit constructor; such a constructor
+A default constructor can be an explicit constructor; such a constructor
 will be used to perform default-initialization
 or value-initialization\iref{dcl.init}.
 \begin{example}
@@ -2599,7 +2598,7 @@
 a converting constructor.
 \begin{note}
 An implicitly-declared copy/move constructor is not an explicit constructor;
-it may be called for implicit type conversions.
+it can be called for implicit type conversions.
 \end{note}
 
 \rSec3[class.conv.fct]{Conversion functions}%
@@ -3602,7 +3601,7 @@
 from the layout of a most derived object of the same type. A base class
 subobject might have a polymorphic behavior\iref{class.cdtor}
 different from the polymorphic behavior of a most derived object of the
-same type. A base class subobject may be of zero size;
+same type. A base class subobject can be of zero size;
 however, two subobjects that have the same class type and that belong to
 the same most derived object must not be allocated at the same
 address\iref{intro.object}.
@@ -4217,7 +4216,7 @@
 \pnum
 \begin{note}
 An abstract class can be derived from a class that is not abstract, and
-a pure virtual function may override a virtual function which is not
+a pure virtual function can override a virtual function which is not
 pure.
 \end{note}
 
@@ -5157,7 +5156,7 @@
 \end{ncsimplebnf}
 
 \begin{note}
-A friend declaration may be the
+A friend declaration can be the
 \grammarterm{declaration} in a \grammarterm{template-declaration}
 (\ref{temp.pre}, \ref{temp.friend}).
 \end{note}
@@ -5665,7 +5664,7 @@
 refers to the class member.
 A
 \grammarterm{mem-initializer-id}
-for the hidden base class may be specified using a qualified name.
+for the hidden base class can be specified using a qualified name.
 \end{note}
 Unless the
 \grammarterm{mem-initializer-id}
@@ -5824,7 +5823,7 @@
 \begin{note}
 An abstract class\iref{class.abstract} is never a most derived
 class, thus its constructors never initialize virtual base classes, therefore the
-corresponding \grammarterm{mem-initializer}{s} may be omitted.
+corresponding \grammarterm{mem-initializer}{s} can be omitted.
 \end{note}
 An attempt to initialize more than one non-static data member of a union renders the
 program ill-formed.
@@ -6800,7 +6799,7 @@
 has no \grammarterm{noexcept-specifier},
 the implicitly-declared \tcode{==} operator function
 has an implicit exception specification\iref{except.spec} that
-may differ from the implicit exception specification of
+can differ from the implicit exception specification of
 the three-way comparison operator function.
 \end{note}
 \begin{example}
@@ -6927,7 +6926,7 @@
 \end{itemize}
 
 \begin{note}
-A synthesized three-way comparison may be ill-formed
+A synthesized three-way comparison is ill-formed
 if overload resolution finds usable candidates
 that do not otherwise meet the requirements implied by the defined expression.
 \end{note}
diff --git a/source/concepts.tex b/source/concepts.tex
index 5ed9b6f591..b7182b312b 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -395,7 +395,7 @@
 \term{common reference type}, \tcode{C}.
 \begin{note}
 \tcode{C} could be the same as \tcode{T}, or \tcode{U}, or it could be a
-different type. \tcode{C} may be a reference type.
+different type. \tcode{C} can be a reference type.
 \end{note}
 
 \begin{itemdecl}
diff --git a/source/containers.tex b/source/containers.tex
index 533202c6bc..44978c92b8 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -458,7 +458,7 @@
 pointers, or iterators referring to the elements
 of the containers being swapped.
 \begin{note}
-The \tcode{end()} iterator does not refer to any element, so it may be invalidated.
+The \tcode{end()} iterator does not refer to any element, so it can be invalidated.
 \end{note}
 \end{itemize}
 
@@ -604,7 +604,7 @@
 with \tcode{m == get_allocator()}.
 The default \tcode{construct} in \tcode{allocator} will
 call \tcode{::new((void*)p) T(args)},
-but specialized allocators may choose a different definition.
+but specialized allocators can choose a different definition.
 \end{note}
 
 \pnum
@@ -753,10 +753,10 @@
 \begin{note}
 For a \tcode{vector<int> x} with a size greater than one, \tcode{x[1] = 5}
 and \tcode{*x.begin() = 10} can be executed concurrently without a data race, but
-\tcode{x[0] = 5} and \tcode{*x.begin() = 10} executed concurrently may result in a data
+\tcode{x[0] = 5} and \tcode{*x.begin() = 10} executed concurrently can result in a data
 race.
 As an exception to the general rule, for a \tcode{vector<bool> y}, \tcode{y[0] = true}
-may race with \tcode{y[1] = true}.
+can race with \tcode{y[1] = true}.
 \end{note}
 
 \rSec2[sequence.reqmts]{Sequence containers}
@@ -878,7 +878,7 @@
  \effects Inserts an object of type \tcode{T} constructed with
  \tcode{std::forward<\brk{}Args\brk{}>(\brk{}args)...} before \tcode{p}.
  \begin{note}
-\tcode{args} may directly or indirectly refer to
+\tcode{args} can directly or indirectly refer to
  a value in \tcode{a}.
 \end{note}
  \\ \rowsep
@@ -3492,7 +3492,7 @@
 \pnum
 \begin{note}
 Unlike the \tcode{swap} function for other containers, \tcode{array::swap}
-takes linear time, may exit via an exception, and does not cause iterators to
+takes linear time, can exit via an exception, and does not cause iterators to
 become associated with the other container.
 \end{note}
 \end{itemdescr}
diff --git a/source/declarations.tex b/source/declarations.tex
index 5fabee5aa0..592fde29b1 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -110,7 +110,7 @@
 of the \grammarterm{init-declarator-list}.
 \begin{note}
 In the declaration for an entity, attributes appertaining to that
-entity may appear at the start of the declaration and after the
+entity can appear at the start of the declaration and after the
 \grammarterm{declarator-id} for that declaration.
 \end{note}
 \begin{example}
@@ -1089,7 +1089,7 @@
 from the end of every definition domain in which it is declared;
 no diagnostic is required.
 \begin{note}
-A call to an inline function or a use of an inline variable may be encountered
+A call to an inline function or a use of an inline variable can be encountered
 before its definition becomes reachable in a translation unit.
 \end{note}
 
@@ -3144,7 +3144,7 @@
 When several ``array of'' specifications are adjacent,
 a multidimensional array type is created;
 only the first of the constant expressions
-that specify the bounds of the arrays may be omitted.
+that specify the bounds of the arrays can be omitted.
 \begin{example}
 \begin{codeblock}
 int x3d[3][5][7];
@@ -3943,7 +3943,7 @@
 \begin{note}
 The keyword
 \tcode{this}
-may not appear in a default argument of a member function;
+cannot appear in a default argument of a member function;
 see~\ref{expr.prim.this}.
 \begin{example}
 \begin{codeblock}
@@ -4368,7 +4368,7 @@
 is called
 \defn{copy-initialization}.
 \begin{note}
-Copy-initialization may invoke a move\iref{class.copy.ctor}.
+Copy-initialization can invoke a move\iref{class.copy.ctor}.
 \end{note}
 
 \pnum
@@ -5123,7 +5123,7 @@
 \pnum
 \indextext{initialization!array of class objects}%
 \begin{note}
-An aggregate array or an aggregate class may contain elements of a
+An aggregate array or an aggregate class can contain elements of a
 class type with a user-declared constructor\iref{class.ctor}.
 Initialization of these aggregate objects is described in~\ref{class.expl.init}.
 \end{note}
@@ -7273,7 +7273,7 @@
 \begin{note}
 An explicit instantiation\iref{temp.explicit} or
 explicit specialization\iref{temp.expl.spec} of a template
-does not introduce a name and thus may be declared using an
+does not introduce a name and thus can be declared using an
 \grammarterm{unqualified-id} in a member of the enclosing namespace set,
 if the primary template is declared in an inline namespace.
 \end{note}
@@ -7948,7 +7948,7 @@
 as a function template introduced by a
 \grammarterm{using-declaration}, the program is ill-formed.
 \begin{note}
-Two \grammarterm{using-declaration}{s} may introduce functions with the same
+Two \grammarterm{using-declaration}{s} can introduce functions with the same
 name and the same parameter-type-list. If, for a call to an unqualified
 function name, function overload resolution selects the functions
 introduced by such \grammarterm{using-declaration}{s}, the function call is
@@ -8173,7 +8173,7 @@
 \begin{note}
 Some of the properties associated with an entity with language linkage
 are specific to each implementation and are not described here. For
-example, a particular language linkage may be associated with a
+example, a particular language linkage might be associated with a
 particular form of representing names of objects and functions with
 external linkage, or with a particular calling convention, etc.
 \end{note}
@@ -8344,7 +8344,7 @@
 \begin{note}
 Only
 one definition for an entity with a given name
-with C language linkage may appear in the
+with C language linkage can appear in the
 program (see~\ref{basic.def.odr});
 this implies that such an entity
 must not be defined in more
@@ -8566,10 +8566,8 @@
 its \grammarterm{attribute-namespace} is
 \tcode{std} followed by zero or more digits.
 \end{itemize}
-\begin{note}
 Each implementation should choose a distinctive name for the
 \grammarterm{attribute-namespace} in an \grammarterm{attribute-scoped-token}.
-\end{note}
 
 \pnum
 Two consecutive left square bracket tokens shall appear only
@@ -8724,7 +8722,7 @@
 \pnum
 \begin{note}
 The \tcode{carries_dependency} attribute does not change the meaning of the
-program, but may result in generation of more efficient code.
+program, but might result in generation of more efficient code.
 \end{note}
 
 \pnum
@@ -8792,7 +8790,7 @@
 \end{ncbnf}
 \begin{note}
 The \grammarterm{string-literal} in the \grammarterm{attribute-argument-clause}
-could be used to explain the rationale for deprecation and/or to suggest a replacing entity.
+can be used to explain the rationale for deprecation and/or to suggest a replacing entity.
 \end{note}
 
 \pnum
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index 87c4492a5d..91fdc0fd4e 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -1050,7 +1050,7 @@
 system is unspecified.
 \begin{note}
 The number of potential system error codes is large
-and unbounded, and some may not correspond to any POSIX \tcode{errno} value. Thus
+and unbounded, and some might not correspond to any POSIX \tcode{errno} value. Thus
 implementations are given latitude in determining correspondence.
 \end{note}
 \end{itemdescr}
diff --git a/source/expressions.tex b/source/expressions.tex
index a8202aaff7..c25b2038b7 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -73,7 +73,7 @@
 \indextext{operator!precedence of}%
 \indextext{expression!order of evaluation of}%
 \begin{note}
-The implementation may regroup operators according to
+The implementation can regroup operators according to
 the usual mathematical rules only
 where the operators really are associative or commutative.\footnote{Overloaded
 operators are never assumed to be associative or commutative.}
@@ -272,7 +272,7 @@
 that class shall not be an abstract class\iref{class.abstract}.
 A glvalue shall not have type \cv{}~\tcode{void}.
 \begin{note}
-A glvalue may have complete or incomplete non-\tcode{void} type.
+A glvalue can have complete or incomplete non-\tcode{void} type.
 Class and array prvalues can have cv-qualified types; other prvalues
 always have cv-unqualified types. See \ref{expr.type}.
 \end{note}
@@ -422,7 +422,7 @@
 \ref{temp.concept}).
 An unevaluated operand is not evaluated.
 \begin{note}
-In an unevaluated operand, a non-static class member may be
+In an unevaluated operand, a non-static class member can be
 named\iref{expr.prim.id} and naming of objects or functions does not, by
 itself, require that a definition be provided\iref{basic.def.odr}.
 An unevaluated operand is considered a full-expression\iref{intro.execution}.
@@ -1745,7 +1745,7 @@
 
 \pnum
 \begin{note}
-The function call operator or operator template may be constrained\iref{temp.constr.decl}
+The function call operator or operator template can be constrained\iref{temp.constr.decl}
 by a \grammarterm{type-constraint}\iref{temp.param},
 a \grammarterm{requires-clause}\iref{temp.pre},
 or a trailing \grammarterm{requires-clause}\iref{dcl.decl}.
@@ -2845,7 +2845,7 @@
 The \tcode{>} token following the
 \grammarterm{type-id} in a \tcode{dynamic_cast},
 \tcode{static_cast}, \tcode{reinterpret_cast}, or
-\tcode{const_cast} may be the product of replacing a
+\tcode{const_cast} might be the product of replacing a
 \tcode{>{>}} token by two consecutive \tcode{>}
 tokens\iref{temp.names}.
 \end{note}
@@ -4028,7 +4028,7 @@
 
 \pnum
 \begin{note}
-Subject to the restrictions in this subclause, an expression may be cast
+Subject to the restrictions in this subclause, an expression can be cast
 to its own type using a \tcode{const_cast} operator.
 \end{note}
 
@@ -4084,7 +4084,7 @@
 \tcode{const_cast} that casts away a const-qualifier\footnote{\tcode{const_cast}
 is not limited to conversions that cast away a
 const-qualifier.}
-may produce undefined behavior\iref{dcl.type.cv}.
+might produce undefined behavior\iref{dcl.type.cv}.
 \end{note}
 
 \pnum
@@ -4459,7 +4459,7 @@
 \begin{note}
 This resumes the coroutine referred to
 by the result of \placeholder{await-suspend}.
-Any number of coroutines may be successively resumed in this fashion,
+Any number of coroutines can be successively resumed in this fashion,
 eventually returning control flow to the current coroutine caller or
 resumer\iref{dcl.fct.def.coroutine}.
 \end{note}
@@ -4689,7 +4689,7 @@
 \grammarterm{new-expression}{s}.
 \end{note}
 \begin{note}
-The \grammarterm{type-id} may be a cv-qualified type, in which case the
+The \grammarterm{type-id} can be a cv-qualified type, in which case the
 object created by the \grammarterm{new-expression} has a cv-qualified type.
 \end{note}
 
@@ -4920,9 +4920,9 @@
 A \Cpp{} program can provide alternative definitions of
 these functions\iref{replacement.functions} and/or class-specific
 versions\iref{class.free}.
-The set of allocation and deallocation functions that may be called
+The set of allocation and deallocation functions that can be called
 by a \grammarterm{new-expression}
-may include functions that do not perform allocation or deallocation;
+could include functions that do not perform allocation or deallocation;
 for example, see \ref{new.delete.placement}.
 \end{note}
 
@@ -6733,7 +6733,7 @@
 \begin{note}
 This restriction applies to the relationship
 between the left and right sides of the assignment operation; it is not a
-statement about how the target of the assignment may be aliased in general.
+statement about how the target of the assignment might be aliased in general.
 See~\ref{basic.lval}.
 \end{note}
 
@@ -6847,7 +6847,7 @@
   for \tcode{o} and its subobjects
   even if those objects are of non-literal class types.
   \begin{note}
-  Such a class may have a non-trivial destructor.
+  Such a class can have a non-trivial destructor.
   Within this evaluation,
   \tcode{std::is_constant_evaluated()}\iref{meta.const.eval}
   returns \tcode{true}.
@@ -7166,7 +7166,7 @@
 is an expression of integral or
 unscoped enumeration type, implicitly converted to a prvalue, where the converted expression is a core constant expression.
 \begin{note}
-Such expressions may be
+Such expressions can be
 used as bit-field lengths\iref{class.bit}, as enumerator
 initializers if the underlying type is not fixed\iref{dcl.enum},
 and as alignments\iref{dcl.align}.
@@ -7213,7 +7213,7 @@
 \end{itemize}
 and where the reference binding (if any) binds directly.
 \begin{note}
-Such expressions may be used in \tcode{new}
+Such expressions can be used in \tcode{new}
 expressions\iref{expr.new}, as case expressions\iref{stmt.switch},
 as enumerator initializers if the underlying type is
 fixed\iref{dcl.enum}, as array bounds\iref{dcl.array}, and
diff --git a/source/future.tex b/source/future.tex
index d29ad12f4f..48ec3c592a 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -2745,7 +2745,7 @@
 an atomic variable of static storage duration of a type that
 is initialization-compatible with \tcode{value}.
 \begin{note}
-This operation may need to initialize locks.
+This operation might need to initialize locks.
 \end{note}
 Concurrent access to the variable being initialized,
 even via an atomic operation,
diff --git a/source/intro.tex b/source/intro.tex
index 38a7908914..bbcac8c628 100644
--- a/source/intro.tex
+++ b/source/intro.tex
@@ -884,7 +884,7 @@
 \defnx{observable behavior}{behavior!observable} of the program.
 \begin{note}
 More stringent correspondences between abstract and actual
-semantics may be defined by each implementation.
+semantics can be defined by each implementation.
 \end{note}
 
 \rSec1[intro.structure]{Structure of this document}
diff --git a/source/iostreams.tex b/source/iostreams.tex
index ff251680af..43f5a11858 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -12085,7 +12085,7 @@
 
 \pnum
 \begin{note}
-Some operating systems may have no unambiguous way to distinguish between native format and generic format arguments.
+Some operating systems have no unambiguous way to distinguish between native format and generic format arguments.
 This is by design as it simplifies use for operating systems that do not require
 disambiguation. An implementation for an operating system where disambiguation
 is required is permitted to distinguish between the formats.
@@ -12114,7 +12114,7 @@
 A path stores a native format pathname\iref{fs.path.native.obs}
 and acts as if it also stores a generic format pathname,
 related as given below.
-The implementation may generate the generic format pathname
+The implementation can generate the generic format pathname
 based on the native format pathname (and possibly other information)
 when requested.
 \end{note}
@@ -12569,7 +12569,7 @@
 Appends \tcode{path(x).native()} to the pathname in the native format.
 \begin{note}
 This directly manipulates the value of \tcode{native()}
-and may not be portable between operating systems.
+and might not be portable between operating systems.
 \end{note}
 
 \pnum
@@ -13103,7 +13103,7 @@
 \pnum
 \begin{note}
 On non-POSIX operating systems, for a path \tcode{p},
-it may not be the case that \tcode{p.stem() + p.extension() == p.filename()},
+it is possible that \tcode{p.stem() + p.extension() == p.filename()} is \tcode{false},
 even though the generic format pathnames are the same.
 \end{note}
 \end{itemdescr}
@@ -14823,7 +14823,7 @@
 \pnum
 \begin{note}
 If the directory structure being iterated over contains cycles
-then the end iterator may be unreachable.
+then the end iterator might be unreachable.
 \end{note}
 
 \rSec3[fs.rec.dir.itr.members]{Members}
@@ -15744,7 +15744,7 @@
 \pnum
 \begin{note}
 The current path as returned by many operating systems is a dangerous
-  global variable. It may be changed unexpectedly by third-party or system
+  global variable. It might be changed unexpectedly by third-party or system
   library functions, or by another thread.
 \end{note}
 \end{itemdescr}
@@ -15771,7 +15771,7 @@
 \pnum
 \begin{note}
 The current path for many operating systems is a dangerous
-  global state. It may be changed unexpectedly by a third-party or system
+  global state. It might be changed unexpectedly by a third-party or system
   library functions, or by another thread.
 \end{note}
 \end{itemdescr}
@@ -16290,7 +16290,7 @@
 \pnum
 \begin{note}
 Conceptually permissions are viewed as bits, but the actual
-implementation may use some other mechanism.
+implementation can use some other mechanism.
 \end{note}
 
 \pnum
@@ -16496,13 +16496,13 @@
 \begin{itemize}
 \item If \tcode{old_p} and \tcode{new_p} resolve to the same existing file,
    no action is taken.
-\item Otherwise, the rename may include the following effects:
+\item Otherwise, the rename can include the following effects:
 \begin{itemize}
 \item if \tcode{new_p} resolves to an existing non-directory file,
     \tcode{new_p} is removed; otherwise,
 \item if \tcode{new_p} resolves to an existing directory,
     \tcode{new_p} is removed if empty on POSIX compliant operating systems
-    but may be an error on other operating systems.
+    but might be an error on other operating systems.
 \end{itemize}
 \end{itemize}
 A symbolic link is itself renamed, rather than the file it resolves to.
@@ -16565,7 +16565,7 @@
 The value of member \tcode{space_info::available}
       is operating system dependent.
 \begin{note}
-\tcode{available} may be
+\tcode{available} might be
       less than \tcode{free}.
 \end{note}
 \end{itemdescr}
diff --git a/source/lex.tex b/source/lex.tex
index 684fff1317..308630ca6a 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -143,7 +143,7 @@
 token\iref{lex.token}. The resulting tokens are syntactically and
 semantically analyzed and translated as a translation unit.
 \begin{note}
-The process of analyzing and translating the tokens may occasionally
+The process of analyzing and translating the tokens can occasionally
 result in one token being replaced by a sequence of other
 tokens\iref{temp.names}.
 \end{note}
@@ -168,13 +168,13 @@
 \item Translated translation units and instantiation units are combined
 as follows:
 \begin{note}
-Some or all of these may be supplied from a
+Some or all of these can be supplied from a
 library.
 \end{note}
 Each translated translation unit is examined to
 produce a list of required instantiations.
 \begin{note}
-This may include
+This can include
 instantiations which have been explicitly
 requested\iref{temp.explicit}.
 \end{note}
@@ -1394,7 +1394,7 @@
 actual extended
 character is encountered in the source text. Therefore, all extended
 characters are described in terms of \grammarterm{universal-character-name}{s}. However,
-the actual compiler implementation may use its own native character set,
+the actual compiler implementation can use its own native character set,
 so long as the same results are obtained.
 \end{note}
 
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index c605b4d81a..79487f81ca 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -1583,7 +1583,7 @@
 of type \tcode{P} may have an indeterminate value.
 \begin{note}
 Operations involving
-indeterminate values may cause undefined behavior.
+indeterminate values might cause undefined behavior.
 \end{note}
 
 \pnum
@@ -2050,7 +2050,7 @@
 fail. The allocator also may silently ignore the requested alignment.
 \begin{note}
 Additionally, the member function \tcode{allocate}
-for that type may fail by throwing an object of type
+for that type can fail by throwing an object of type
 \tcode{bad_alloc}.
 \end{note}
 
@@ -2819,7 +2819,7 @@
 an overload from the set of declarations described in this document
 behaves as if that overload were selected.
 \begin{note}
-For instance, an implementation may add parameters with default values,
+For instance, an implementation can add parameters with default values,
 or replace a member function with default arguments
 with two or more member functions with equivalent behavior,
 or add additional signatures for a member function name.
diff --git a/source/locales.tex b/source/locales.tex
index 4863cbdcae..1fe26c4196 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -231,7 +231,7 @@
 \begin{codeblock}
 operator()(const basic_string<C, T, A>&, const basic_string<C, T, A>&)
 \end{codeblock}
-is provided so that a locale may be used as a predicate argument to
+is provided so that a locale can be used as a predicate argument to
 the standard collections, to collate strings.
 \item
 Convenient global interfaces are provided for traditional
@@ -4029,7 +4029,7 @@
 
 \pnum
 \begin{note}
-The \tcode{fill} argument may be used in the implementation-defined
+The \tcode{fill} argument can be used in the implementation-defined
 formats or by derivations. A space character is a reasonable
 default for this argument.
 \end{note}
@@ -4070,7 +4070,7 @@
 \returns
 An iterator pointing immediately after the last character produced.
 \begin{note}
-The \tcode{fill} argument may be used in the implementation-defined
+The \tcode{fill} argument can be used in the implementation-defined
 formats or by derivations. A space character is a reasonable
 default for this argument.
 \end{note}
diff --git a/source/numerics.tex b/source/numerics.tex
index 52a7030210..fcfc4bd9c5 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -4030,7 +4030,7 @@
 is \impldef{type of \tcode{default_random_engine}}.
 \begin{note}
  The implementation
- may select this type
+ can select this type
  on the basis of performance,
  size,
  quality,
@@ -4038,7 +4038,7 @@
  so as to provide at least acceptable engine behavior
  for relatively casual, inexpert, and/or lightweight use.
  Because different implementations
- may select different underlying engine types,
+ can select different underlying engine types,
  code that uses this \tcode{typedef}
  need not generate identical sequences across implementations.
 \end{note}
@@ -7381,8 +7381,8 @@
 such that \tcode{i < a.size()}
 and \tcode{j < b.size()}.
 \begin{note}
-This property indicates an absence of aliasing and may be used to
-advantage by optimizing compilers. Compilers may take advantage
+This property indicates an absence of aliasing and can be used to
+advantage by optimizing compilers. Compilers can take advantage
 of inlining, constant propagation, loop fusion,
 tracking of pointers obtained from
 \tcode{operator new},
diff --git a/source/overloading.tex b/source/overloading.tex
index 7ba2afaa92..3f127ef6b9 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -4259,7 +4259,7 @@
 function templates. In particular, they are looked up like ordinary functions
 and function templates and they follow the same overload resolution rules. Also,
 they can be declared \tcode{inline} or \tcode{constexpr},
-they may have internal, module, or external linkage,
+they can have internal, module, or external linkage,
 they can be called explicitly, their addresses can be
 taken, etc.
 \end{note}
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 6d57b04bf6..f51c725e66 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -711,7 +711,7 @@
 
 \pnum
 \begin{note}
-Although an implementation may provide a mechanism for making arbitrary
+Although an implementation can provide a mechanism for making arbitrary
 source files available to the \tcode{< >} search, in general
 programmers should use the \tcode{< >} form for headers provided
 with the implementation, and the \tcode{" "} form for sources
diff --git a/source/regex.tex b/source/regex.tex
index 2dde693d7e..1d0793c838 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3283,7 +3283,7 @@
 
 \pnum
 \begin{note}
-This means that a compiler may call an
+This means that a compiler can call an
 implementation-specific search function, in which case a program-defined
 specialization of \tcode{regex_search} will not be
 called.
diff --git a/source/statements.tex b/source/statements.tex
index a405c13b2d..d7edfb1123 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -156,7 +156,7 @@
 Labels have their own name space and do not interfere with other
 identifiers.
 \begin{note}
-A label may have the same name as another declaration in the same scope or a
+A label can have the same name as another declaration in the same scope or a
 \grammarterm{template-parameter} from an enclosing scope. Unqualified name
 lookup\iref{basic.lookup.unqual} ignores labels.
 \end{note}
@@ -839,7 +839,7 @@
 A \tcode{return} statement can involve
 an invocation of a constructor to perform a copy or move of the operand
 if it is not a prvalue or if its type differs from the return type of the function.
-A copy operation associated with a \tcode{return} statement may be elided or
+A copy operation associated with a \tcode{return} statement can be elided or
 converted to a move operation if an automatic storage duration variable is returned\iref{class.copy.elision}.
 \end{note}
 \begin{example}
diff --git a/source/strings.tex b/source/strings.tex
index 6688dfdd14..0f64aa608d 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -3286,7 +3286,7 @@
 are left in valid but unspecified states.
 \begin{note}
 If \tcode{lhs} and \tcode{rhs} have equal allocators,
-the implementation may move from either.
+the implementation can move from either.
 \end{note}
 \end{itemdescr}
 
@@ -4452,7 +4452,7 @@
 \pnum
 \begin{note}
 Unlike \tcode{basic_string::data()} and \grammarterm{string-literal}s,
-\tcode{data()} may return a pointer to a buffer that is not null-terminated.
+\tcode{data()} can return a pointer to a buffer that is not null-terminated.
 Therefore it is typically a mistake to pass \tcode{data()} to a function that takes just a \tcode{const charT*} and expects a null-terminated string.
 \end{note}
 \end{itemdescr}
diff --git a/source/support.tex b/source/support.tex
index fc4abc510e..8cfe3d0f8f 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -1948,13 +1948,13 @@
 data race\iref{res.on.data.races}.
 \end{note}
 \begin{note}
-The order of registration may be indeterminate if \tcode{at_quick_exit} was called from more
+The order of registration could be indeterminate if \tcode{at_quick_exit} was called from more
 than one thread.
 \end{note}
 \begin{note}
 The
 \tcode{at_quick_exit} registrations are distinct from the \tcode{atexit} registrations,
-and applications may need to call both registration functions with the same argument.
+and applications might need to call both registration functions with the same argument.
 \end{note}
 
 \pnum
@@ -2261,7 +2261,7 @@
 the program shall also define
 the corresponding version without the \tcode{size} parameter.
 \begin{note}
-The default behavior below may change in the future, which will require
+The default behavior below might change in the future, which will require
 replacing both deallocation functions when replacing the allocation function.
 \end{note}
 
@@ -2510,7 +2510,7 @@
 the program shall also define
 the corresponding version without the \tcode{size} parameter.
 \begin{note}
-The default behavior below may change in the future, which will require
+The default behavior below might change in the future, which will require
 replacing both deallocation functions when replacing the allocation function.
 \end{note}
 
@@ -2833,7 +2833,7 @@
 \returns
 The current \tcode{new_handler}.
 \begin{note}
-This may be a null pointer value.
+This can be a null pointer value.
 \end{note}
 \end{itemdescr}
 
@@ -3584,7 +3584,7 @@
 \returns
 The current \tcode{terminate_handler}.
 \begin{note}
-This may be a null pointer value.
+This can be a null pointer value.
 \end{note}
 \end{itemdescr}
 
@@ -3676,7 +3676,7 @@
 \begin{note}
 If
 \tcode{rethrow_exception} rethrows the same exception object (rather than a copy),
-concurrent access to that rethrown exception object may introduce a data race.
+concurrent access to that rethrown exception object can introduce a data race.
 Changes in the number of \tcode{exception_ptr} objects that refer to a
 particular exception do not introduce a data race.
 \end{note}
@@ -3708,7 +3708,7 @@
 if this is not possible, to an instance of \tcode{bad_exception}.
 \begin{note}
 The
-copy constructor of the thrown exception may also fail, so the implementation is allowed
+copy constructor of the thrown exception can also fail, so the implementation is allowed
 to substitute a \tcode{bad_exception} object to avoid infinite
 recursion.
 \end{note}
@@ -5135,7 +5135,7 @@
 a mutex object across a suspend point.
 \end{note}
 \begin{note}
-A concurrent resumption of the coroutine may result in a data race.
+A concurrent resumption of the coroutine can result in a data race.
 \end{note}
 
 \indexlibrarymember{operator()}{coroutine_handle}%
diff --git a/source/templates.tex b/source/templates.tex
index 37217a440a..26c1916d9b 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -53,7 +53,7 @@
 The \tcode{>} token following the
 \grammarterm{template-parameter-list} of a
 \grammarterm{template-declaration}
-may be the product of replacing a
+can be the product of replacing a
 \tcode{>{>}} token by two consecutive \tcode{>}
 tokens\iref{temp.names}.
 \end{note}
@@ -117,7 +117,7 @@
 shall not be a
 \grammarterm{template-id}.
 \begin{note}
-That last component may be an \grammarterm{identifier}, an \grammarterm{operator-function-id},
+That last component can be an \grammarterm{identifier}, an \grammarterm{operator-function-id},
 a \grammarterm{conversion-function-id}, or a \grammarterm{literal-operator-id}. In
 a class template declaration, if the
 class name
@@ -258,7 +258,7 @@
 The \tcode{>} token following the
 \grammarterm{template-parameter-list} of a
 \grammarterm{type-parameter}
-may be the product of replacing a
+can be the product of replacing a
 \tcode{>{>}} token by two consecutive \tcode{>}
 tokens\iref{temp.names}.
 \end{note}
@@ -326,7 +326,7 @@
 \keyword{template})
 in the scope of the template declaration.
 \begin{note}
-A template argument may be a class template or alias template.
+A template argument can be a class template or alias template.
 For example,
 
 \begin{codeblock}
@@ -745,8 +745,8 @@
 the \grammarterm{template-id}.
 \begin{note}
 The second \tcode{>}
-token produced by this replacement rule may terminate an enclosing
-\grammarterm{template-id} construct or it may be part of a different
+token produced by this replacement rule could terminate an enclosing
+\grammarterm{template-id} construct or it could be part of a different
 construct (e.g., a cast).
 \end{note}
 \begin{example}
@@ -806,7 +806,7 @@
 \begin{note}
 The keyword
 \keyword{template}
-may not be applied to non-template members of class templates.
+cannot be applied to non-template members of class templates.
 \end{note}
 \begin{note}
 As is the case with the
@@ -1185,7 +1185,7 @@
 \end{codeblock}
 \end{example}
 \begin{note}
-A template type argument may be an incomplete type\iref{basic.types}.
+A template type argument can be an incomplete type\iref{basic.types}.
 \end{note}
 
 \rSec2[temp.arg.nontype]{Template non-type arguments}
@@ -2156,7 +2156,7 @@
 refer to the same type only if their \grammarterm{expression}{s} are
 equivalent\iref{temp.over.link}.
 \begin{note}
-However, such a type may be aliased,
+However, such a type might be aliased,
 e.g., by a \grammarterm{typedef-name}.
 \end{note}
 
@@ -3152,7 +3152,7 @@
 
 \pnum
 \begin{note}
-A friend declaration may first declare a member of an enclosing namespace scope\iref{temp.inject}.
+A friend declaration can first declare a member of an enclosing namespace scope\iref{temp.inject}.
 \end{note}
 
 \pnum
@@ -3370,7 +3370,7 @@
 used to specify template arguments of the \grammarterm{simple-template-id}
 of the partial specialization.
 \begin{note}
-The template arguments may be private types or
+The template arguments can be private types or
 objects that would normally not be accessible.
 Dependent names cannot be checked when declaring the partial specialization,
 but will be checked when substituting into the partial specialization.
@@ -3696,7 +3696,7 @@
 the relationship between the template parameters and the rest of the
 signature.
 \begin{note}
-Two distinct function templates may have identical function return types and
+Two distinct function templates can have identical function return types and
 function parameter lists, even if overload resolution alone cannot distinguish
 them.
 
@@ -6057,7 +6057,7 @@
 In particular, the template arguments and names
 used in the function declarator
 (including parameter types, return types and exception specifications)
-may be private types or objects that would normally not be accessible.
+can be private types or objects that would normally not be accessible.
 \end{note}
 
 \pnum
@@ -6611,7 +6611,7 @@
 or, where all template arguments can be deduced, a
 \grammarterm{template-name} or \grammarterm{operator-function-id}.
 \begin{note}
-The declaration may declare a
+The declaration can declare a
 \grammarterm{qualified-id},
 in which case the
 \grammarterm{unqualified-id}
@@ -7260,7 +7260,7 @@
 the class template specialization to which the member function specialization
 belongs is implicitly instantiated.
 \begin{note}
-Default function arguments may be specified in the declaration or
+Default function arguments can be specified in the declaration or
 definition of a member function of a class template specialization that is
 explicitly specialized.
 \end{note}
@@ -7717,7 +7717,7 @@
 
 \pnum
 \begin{note}
-Type deduction may fail for the following reasons:
+Type deduction can fail for the following reasons:
 \begin{itemize}
 \item Attempting to instantiate a pack expansion containing multiple packs of differing lengths.
 \item
diff --git a/source/threads.tex b/source/threads.tex
index 3d681b0c81..a7632e1533 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -7234,7 +7234,7 @@
 
 \begin{note}
 Line \#1 might not result in concurrency because
-the \tcode{async} call uses the default policy, which may use
+the \tcode{async} call uses the default policy, which might use
 \tcode{launch::deferred}, in which case the lambda might not be invoked until the
 \tcode{get()} call; in that case, \tcode{work1} and \tcode{work2} are called on the
 same thread and there is no concurrency.
diff --git a/source/time.tex b/source/time.tex
index ccaee251d7..071ae92e2d 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1074,7 +1074,7 @@
 \tcode{Rep(0)}.
 \begin{note}
 \tcode{Rep(0)} is specified instead of
-\tcode{Rep()} because \tcode{Rep()} may have some other meaning, such as an
+\tcode{Rep()} because \tcode{Rep()} can have some other meaning, such as an
 uninitialized value.
 \end{note}
 
@@ -1140,7 +1140,7 @@
 \tcode{duration} arguments will convert to it without requiring a division
 operation. The representation of this type is intended to be able to hold any
 value resulting from this conversion with no truncation error, although
-floating-point durations may have round-off errors.
+floating-point durations can have round-off errors.
 \end{note}
 
 \indexlibraryglobal{common_type}%
@@ -3347,7 +3347,7 @@
 Its epoch is unspecified, and
 \tcode{noexcept(file_clock::now())} is \tcode{true}.
 \begin{note}
-The type that \tcode{file_clock} denotes may be
+The type that \tcode{file_clock} denotes can be
 in a different namespace than \tcode{std::chrono},
 such as \tcode{std::file\-sys\-tem}.
 \end{note}
@@ -6382,7 +6382,7 @@
 \tcode{d_} with \tcode{ymdl.day()}.
 \begin{note}
 This conversion from \tcode{year_month_day_last} to \tcode{year_month_day}
-may be more efficient than converting a \tcode{year_month_day_last} to a \tcode{sys_days},
+might be more efficient than converting a \tcode{year_month_day_last} to a \tcode{sys_days},
 and then converting that \tcode{sys_days} to a \tcode{year_month_day}.
 \end{note}
 \end{itemdescr}
@@ -6690,7 +6690,7 @@
 \begin{note}
 If \tcode{ymd.month()} is February
 and \tcode{ymd.day()} is not in the range \crange{1d}{28d},
-\tcode{ok()} may return \tcode{false} for
+\tcode{ok()} can return \tcode{false} for
 the resultant \tcode{year_month_day}.
 \end{note}
 \end{itemdescr}
@@ -6951,7 +6951,7 @@
 
 \pnum
 \begin{note}
-This value may be computed on demand.
+This value might be computed on demand.
 \end{note}
 \end{itemdescr}
 
diff --git a/source/utilities.tex b/source/utilities.tex
index 8162497741..c64509461f 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -1980,7 +1980,7 @@
 
 \pnum
 \begin{note}
-An implementation may support additional types in the template parameter
+An implementation can support additional types in the template parameter
 pack \tcode{Tuples} that support the \tcode{tuple}-like protocol, such as
 \tcode{pair} and \tcode{array}.
 \end{note}
@@ -2290,7 +2290,7 @@
 \pnum
 \begin{note}
 The above definition does not require \tcode{t$_{\mathrm{tail}}$}
-(or \tcode{u$_{\mathrm{tail}}$}) to be constructed. It may not
+(or \tcode{u$_{\mathrm{tail}}$}) to be constructed. It might not
 even be possible, as \tcode{t} and \tcode{u} are not required to be copy
 constructible. Also, all comparison operator functions are short circuited;
 they do not perform element accesses beyond what is required to determine the
@@ -5278,7 +5278,7 @@
 
 \pnum
 \begin{note}
-The discriminated type may contain values of different types but does not attempt conversion between them,
+The discriminated type can contain values of different types but does not attempt conversion between them,
 i.e., \tcode{5} is held strictly as an \tcode{int} and is not implicitly convertible either to \tcode{"5"} or to \tcode{5.0}.
 This indifference to interpretation but awareness of type effectively allows safe, generic containers of single values, with no scope for surprises from ambiguous conversions.
 \end{note}
@@ -7479,7 +7479,7 @@
 it points to was created by global \tcode{operator new} and not
 previously declared reachable.
 \begin{note}
-This may be used to inform a
+This can be used to inform a
 garbage collector or leak detector that this region of memory need not
 be traced.
 \end{note}
@@ -7490,8 +7490,8 @@
 
 \pnum
 \begin{note}
-Under some conditions implementations may need to allocate memory.
-However, the request can be ignored if memory allocation fails.
+The request can be ignored
+if a memory allocation needed by the implementation fails.
 \end{note}
 \end{itemdescr}
 
@@ -7609,7 +7609,7 @@
 \begin{note}
 The alignment assumption on an object \tcode{X}
 expressed by a call to \tcode{assume_aligned}
-may result in generation of more efficient code.
+might result in generation of more efficient code.
 It is up to the program to ensure that the assumption actually holds.
 The call does not cause the compiler to verify or enforce this.
 An implementation might only make the assumption
@@ -9063,7 +9063,7 @@
 \tcode{get_deleter()(old_p)}.
 \begin{note}
 The order of these operations is significant
-because the call to \tcode{get_deleter()} may destroy \tcode{*this}.
+because the call to \tcode{get_deleter()} might destroy \tcode{*this}.
 \end{note}
 
 \pnum
@@ -9774,7 +9774,7 @@
 The template parameter \tcode{T} of \tcode{shared_ptr}
 may be an incomplete type.
 \begin{note}
-\tcode{T} may be a function type.
+\tcode{T} can be a function type.
 \end{note}
 
 \pnum
@@ -10111,7 +10111,7 @@
 \begin{note}
 The use count updates caused by the temporary object
 construction and destruction are not observable side
-effects, so the implementation may meet the effects (and the
+effects, so the implementation can meet the effects (and the
 implied guarantees) via different means, without creating a
 temporary. In particular, in the example:
 \begin{codeblock}
@@ -10120,7 +10120,7 @@
 p = p;
 q = p;
 \end{codeblock}
-both assignments may be no-ops.
+both assignments can be no-ops.
 \end{note}
 \end{itemdescr}
 
@@ -18563,9 +18563,9 @@
 \end{codeblock}
 \end{example}
 \begin{note}
-Because different parallel architectures may require idiosyncratic
+Because different parallel architectures might require idiosyncratic
 parameters for efficient execution, implementations
-may provide additional execution policies to those described in this
+can provide additional execution policies to those described in this
 standard as extensions.
 \end{note}