Answer by Oleksandr R. for How to generally match, unify and merge patterns?

In my opinion, this is a very good and worthwhile question, but certainly not easy to answer. I don't have a full solution by any means, but as far as the comparison/matching part is concerned, the undocumented function Internal`ComparePatterns may be of substantial assistance. What follows is a short summary of what I know about this function, which exists in Mathematica 7 and 8, but not version 5.2. I would guess that it is new-in-6 and used in the implementation of OptionsPattern and related functions.

Internal`ComparePatterns[p, q] (where p and q are patterns) operates somewhat like MatchQ, except that rather than simply True or False to signify agreement or disagreement, multiple (namely, five) possibilities exist to describe the relationship p has to q:

1. Identity

   Two patterns are considered identical if they match verbatim up to, but not including, naming. This relation should obviously be transitive and commutative, and I haven't observed any counterexamples so far. An example could be:

   Internal`ComparePatterns[a_, b_](* -> "Identical" *)

   It is also aware of attributes that affect pattern matching. Here we attempt to mask the Orderless attribute of Plus (and thus possibly confuse Internal`ComparePatterns) by wrapping it in HoldComplete:

   Internal`ComparePatterns[ HoldComplete[x_Real + y_Integer], HoldComplete[y_Integer + x_Real]](* -> "Identical" *)

   Pattern names are not completely ignored, however, and seem to be taken into account where appropriate:

   Internal`ComparePatterns[x_Real + y_Integer, x_Integer + y_Real](* -> "Incomparable" *)

2. Equivalence

   If p has the same meaning as q but is not structurally identical, the patterns are considered equivalent:

   Internal`ComparePatterns[a | b, b | a] (* Alternatives is not Orderless *)(* -> "Equivalent" *)Internal`ComparePatterns[a : y_ + x_, b : (f : Plus)[x_, y_]](* -> "Equivalent" *)

   However, determination of this relationship is not completely robust. Patterns that are sufficiently structurally different sometimes will not be considered equivalent even if they manifestly are:

   Internal`ComparePatterns[a : y_ + x_, b : (f : Plus | Plus)[x_, y_]](* -> "Specific" *)

   Here are two more examples of patterns that are equivalent, but where the relationship is misstated. The second of these is particularly interesting:

   Internal`ComparePatterns[Repeated[_, Infinity], Repeated[_]](* -> "Specific" *)Internal`ComparePatterns[Repeated[_, {1, Infinity}], Repeated[_, Infinity]](* -> "Identical" *)

3. Specificity

   In some circumstances, Internal`ComparePatterns is able to determine when one pattern is a special case of another:

   Internal`ComparePatterns[_h, _](* -> "Specific" *)

   However, this situation is often misdiagnosed with equivalent patterns, which will instead be identified as special cases of each other:

   Internal`ComparePatterns[__, (_) ..](* -> "Specific" *)Internal`ComparePatterns[(_) .., __](* -> "Specific" *)

4. Disjointness

   What is more reliably stated is when one pattern is exclusive of another, i.e. there are no expressions that could be matched by both:

   Internal`ComparePatterns[_a, _b](* -> "Disjoint" *)

5. Incomparability

   Finally, we have the situation whereby the patterns are either unrelated, or Internal`ComparePatterns simply does not know how to interpret their relationship:

   Internal`ComparePatterns[a | b, b | c](* -> "Incomparable" *)

   Notably, it seems to be the case that Internal`ComparePatterns works entirely inside the pattern matcher, so that conditional patterns (which need to invoke the main evaluation loop), if not identical, are generally incomparable (by this mechanism):

   Internal`ComparePatterns[_ /; True, _ /; Sequence[True]](* -> "Incomparable" *)Internal`ComparePatterns[_?(True &), _ /; True](* -> "Incomparable" *)

Now let's try it on the examples:

Internal`ComparePatterns[a | b, b | a]           (* -> "Equivalent" -- correct *)Internal`ComparePatterns[a | b, c | b | a]       (* -> "Specific" -- correct *)Internal`ComparePatterns[a | b | c, b | a]       (* -> "Incomparable" -- correct *)Internal`ComparePatterns[a | b | (c : b), b | a] (* -> "Incomparable" -- incorrect, but: *)Internal`ComparePatterns[a | (c : b), b | a]     (* -> "Equivalent" -- correct *)Internal`ComparePatterns[{a ..}, {a ..}]         (* -> "Identical" -- correct *)Internal`ComparePatterns[{a ..}, {a ...}]        (* -> "Specific" -- correct *)Internal`ComparePatterns[{a ...}, {a ..}]        (* -> "Incomparable" -- correct *)

So, Internal`ComparePatterns fails only in one case, and its answer is still technically correct as it is the result of the inability of the function to see the relationship between these patterns (Internal`ComparePatterns[a | b | b, b | a] gives "Specific" rather than "Equivalent") and not a statement about the expressions they will match.

I should finish by saying that I wasn't able to find any concrete examples of where Internal`ComparePatterns is actually used in Mathematica, which should give one pause considering its occasional mistakes. However, it may be that I didn't find it because I wasn't trying hard enough, rather than because it isn't used anywhere. Here is code for a hook that can be installed (using $Pre = withHookedComparePatterns) during normal usage. If you're lucky enough to stumble on a function that uses Internal`ComparePatterns, the call stack and the call itself will be printed out at that point, which will help to identify what its use case is, if any. Anyone finding any examples is welcome to edit this answer to include them below (marking as Community Wiki at the same time, if desired).

ClearAll[withHookedComparePatterns];SetAttributes[withHookedComparePatterns, HoldAll];Begin["System`Private`"];withHookedComparePatterns[expr_] :=  Internal`InheritedBlock[{Internal`ComparePatterns},   Unprotect[Internal`ComparePatterns];   cp : Internal`ComparePatterns[___] /;     StackInhibit[Print[{Stack[], HoldForm[cp]}]; True] := cp;   Protect[Internal`ComparePatterns];   StackBegin[expr]  ];End[];