The normal form of an expression E is
a constraint that is defined as follows:

- The normal form of a concept-id C<A, A, ..., A> is the normal form of the constraint-expression of C, after substituting A, A, ..., A for C's respective template parameters in the parameter mappings in each atomic constraint.If any such substitution results in an invalid type or expression, the program is ill-formed; no diagnostic is required.[Example 1: template<typename T> concept A = T::value || true; template<typename U> concept B = A<U*>; template<typename V> concept C = B<V&>;Normalization of B's constraint-expression is valid and results in T::value (with the mapping ) ∨ true (with an empty mapping), despite the expression T::value being ill-formed for a pointer type T.Normalization of C's constraint-expression results in the program being ill-formed, because it would form the invalid type V&* in the parameter mapping.—
*end example*] - The normal form of any other expression E is the atomic constraint whose expression is E and whose parameter mapping is the identity mapping.

[Note 1: *end note*]

Normalization of constraint-expressions
is performed
when determining the associated constraints ([temp.constr.constr])
of a declaration
and
when evaluating the value of an id-expression
that names a concept specialization ([expr.prim.id]).

— [Example 2: template<typename T> concept C1 = sizeof(T) == 1;
template<typename T> concept C2 = C1<T> && 1 == 2;
template<typename T> concept C3 = requires { typename T::type; };
template<typename T> concept C4 = requires (T x) { ++x; }
template<C2 U> void f1(U); // #1
template<C3 U> void f2(U); // #2
template<C4 U> void f3(U); // #3

—*end example*]

—