A constraint P *subsumes* a constraint Q
if and only if,
for every disjunctive clause
in the disjunctive normal form136
of P, subsumes every conjunctive clause
in the conjunctive normal form137
of Q, where

- a disjunctive clause subsumes a conjunctive clause if and only if there exists an atomic constraint in for which there exists an atomic constraint in such that subsumes , and
- an atomic constraint A subsumes another atomic constraint B if and only if the A and B are identical using the rules described in [temp.constr.atomic].

[ Note

: — *end note*

]The subsumption relation defines a partial ordering on constraints.

This partial ordering is used to determine

- the best viable candidate of non-template functions ([over.match.best]),
- the address of a non-template function ([over.over]),
- the matching of template template arguments,

A declaration D1 is *more constrained*
than another declaration D2 when D1 is at least as
constrained as D2, and D2 is not at least as
constrained as D1.

[ Example

: *end example*

]template<typename T> concept C1 = requires(T t) { --t; }; template<typename T> concept C2 = C1<T> && requires(T t) { *t; }; template<C1 T> void f(T); // #1 template<C2 T> void f(T); // #2 template<typename T> void g(T); // #3 template<C1 T> void g(T); // #4 f(0); // selects #1 f((int*)0); // selects #2 g(true); // selects #3 because C1<bool> is not satisfied g(0); // selects #4—

A constraint is in disjunctive normal form when it is a disjunction of
clauses where each clause is a conjunction of atomic constraints.