Major Section: MISCELLANEOUS
When a hypothesis of a conditional rule has the form
(force hyp) it
is logically equivalent to
hyp but has a pragmatic effect. In
particular, when the rule is considered, the needed instance of the
hyp', is assumed and a special case is generated,
requiring the system to prove that
hyp' is true in the current
context. The proofs of all such ``forced assumptions'' are delayed
until the successful completion of the main goal.
Forcing should only be used on hypotheses that are always expected
to be true, such as the guards of functions. All the power of the
theorem prover is brought to bear on a forced hypothesis and no
backtracking is possible. If the
executable-counterpart of the
force is disabled, then no hypothesis is forced.
See enable-forcing and see disable-forcing. Forced goals can be
attacked immediately (see immediate-force-modep) or in a subsequent
forcing round (see forcing-round). See also see case-split.
It sometimes happens that a conditional rule is not applied because
hyp, could not be relieved, even though the
required instance of
hyp', can be shown true in the context.
This happens when insufficient resources are brought to bear on
at the time we try to relieve it. A sometimes desirable alternative
behavior is for the system to assume
hyp', apply the rule, and to
generate explicitly a special case to show that
hyp' is true in the
context. This is called ``forcing''
hyp. It can be arranged by
restating the rule so that the offending hypothesis,
embedded in a call of
force, as in
(force hyp). By using the
corollary field of the
rule-classes entry, a hypothesis
can be forced without changing the statement of the theorem from
which the rule is derived.
force is just a function of one argument that returns
that argument. It is generally enabled and hence evaporates during
simplification. But its presence among the hypotheses of a
conditional rule causes case splitting to occur if the hypothesis
cannot be conventionally relieved.
Since a forced hypothesis must be provable whenever the rule is otherwise applicable, forcing should be used only on hypotheses that are expected always to be true. A common situation is when the hypothesis is in fact a guard (or part of a guard) of some function involved in the pattern that triggers the rule. Intuitively, if that pattern term occurs in the current conjecture, then its guards had better be true, since otherwise nothing is known about the term.
A particularly common situation in which some hypotheses should be forced is in ``most general'' type-prescription lemmas. If a single lemma describes the ``expected'' type of a function, for all ``expected'' arguments, then it is probably a good idea to force the hypotheses of the lemma. Thus, every time a term involving the function arises, the term will be given the expected type and its arguments will be required to be of the expected type. In applying this advice it might be wise to avoid forcing those hypotheses that are in fact just type predicates on the arguments, since the routine that applies type-prescription lemmas has fairly thorough knowledge of the types of all terms.
Force can have the additional benefit of causing the ACL2 typing
mechanism to interact with the ACL2 rewriter to establish the
hypotheses of type-prescription rules. To understand this remark,
think of the ACL2 type reasoning system as a rather primitive
rule-based theorem prover for questions about Common Lisp types,
e.g., ``does this expression produce a
consp?'' ``does this
expression produce some kind of ACL2 number, e.g., an
rationalp, or a
complex-rationalp?'' etc. It is driven by
type-prescription rules. To relieve the hypotheses of such rules,
the type system recursively invokes itself. This can be done for
any hypothesis, whether it is ``type-like'' or not, since any
p, can be phrased as the type-like question ``does
produce an object of type
nil?'' However, as you might expect, the
type system is not very good at establishing hypotheses that are not
type-like, unless they happen to be assumed explicitly in the
context in which the question is posed, e.g., ``If
p produces a
consp then does
nil?'' If type reasoning alone is
insufficient to prove some instance of a hypothesis, then the
instance will not be proved by the type system and a
type-prescription rule with that hypothesis will be inapplicable in
that case. But by embedding such hypotheses in
you can effectively cause the type system to ``punt'' them to the
rest of the theorem prover. Of course, as already noted, this
should only be done on hypotheses that are ``always true.'' In
particular, if rewriting is required to establish some hypothesis of
a type-prescription rule, then the rule will be found inapplicable
because the hypothesis will not be established by type reasoning
The ACL2 rewriter uses the type reasoning system as a subsystem. It is therefore possible that the type system will force a hypothesis that the rewriter could establish. Before a forced hypothesis is reported out of the rewriter, we try to establish it by rewriting.
This makes the following surprising behavior possible: A type-prescription rule fails to apply because some true hypothesis is not being relieved. The user changes the rule so as to force the hypothesis. The system then applies the rule but reports no forcing. How can this happen? The type system ``punted'' the forced hypothesis to the rewriter, which established it.
Finally, we should mention that the rewriter is never willing to
force when there is an
if term present in the goal being simplified.
or terms are merely abbreviations for
if terms, they
also prevent forcing.