A second value is also returned indicating the `certainty' of
the first value. If this value is true, then the first
value is an accurate indication of the subtype relationship.
(The second value is always true when the first value
is true.)

The next figure summarizes the possible combinations of values
that might result.

The relationships between types reflected by subtypep
are those specific to the particular implementation. For example, if
an implementation supports only a single type of floating-point numbers,
in that implementation (subtypep 'float 'long-float)
returns the valuestrue and true
(since the two types are identical).

For all T1 and T2 other than *,
(array T1) and (array T2)
are two different type specifiers that always refer to the same sets of
things if and only if they refer to arrays
of exactly the same specialized representation, i.e.,
if (upgraded-array-element-type 'T1) and
(upgraded-array-element-type 'T2)
return two different type specifiers that always refer to the same sets of
objects.
This is another way of saying that
`(array type-specifier)
and
`(array ,(upgraded-array-element-type 'type-specifier))
refer to the same
set of specialized array representations.
For all T1 and T2 other than *,
(array T1)
and (array T2) is the empty set
if and only if they refer to arrays of different,
distinct specialized representations.

2. (upgraded-complex-part-type 'T1) and
(upgraded-complex-part-type 'T2)
return two different type specifiers that always refer to the
same sets of objects; in this case,
(complex T1) and
(complex T2) both refer to the
same specialized representation.

If (array <aet-x>)
and (array <aet-y>) are different names for
exactly the same set of objects,
these names should always refer to the same sets of
objects.
That implies that the following set of tests are also true:

The small differences between the subtypep specification for
the array and complex types are necessary because there
is no creation function for complexes which allows
the specification of the resultant part type independently of
the actual types of the parts. Thus in the case of the typecomplex,
the actual type of the parts is referred to, although a number
can be a member of more than one type.
For example, 17 is of type(mod 18)
as well as type(mod 256) and typeinteger;
and 2.3f5 is of typesingle-float
as well as typefloat.