How can I tell simp to instantiate schematic variables? - isabelle

Question

In the example below, I want to use simp to prove that some terms from
simply typed lambda calculus typecheck.
I add each typechecking rule as a rewriting rule for simp, so simp performs
conditional rewrites and creates schematic variables along the way.
However, while rewriting the side conditions for some rewrites, simp gets
stuck on rewriting terms involving schematic variables, because it does not
instantiate them:
theory Stlc imports Main
begin
type_synonym var = string
datatype exp =
Var var
| Const nat
| Plus exp exp
| Abs var exp
| App exp exp
datatype type =
Nat |
Fun type type
type_synonym ('k, 'v) fmap = "'k ⇒ 'v option"
definition lookup :: "('k, 'v) fmap ⇒ 'k ⇒ 'v option" where
"lookup m x = m x"
definition add :: "('k, 'v) fmap ⇒ 'k ⇒ 'v ⇒ ('k, 'v) fmap" where
"add m x a = (λy. if y = x then Some a else m y)"
definition empty :: "('k, 'v) fmap" where
"empty = (λy. None)"
notation
lookup (infix "$?" 60) and
add ("_ $+ '( _ ', _ ')") and
empty ("$0")
inductive hasty :: "(var, type) fmap ⇒ exp ⇒ type ⇒ bool" where
HtVar:
"G $? x = Some t
⟹ hasty G (Var x) t" |
HtConst:
"hasty G (Const n) Nat" |
HtPlus:
"⟦ hasty G e1 Nat;
hasty G e2 Nat ⟧
⟹ hasty G (Plus e1 e2) Nat" |
HtAbs:
"hasty (G $+ (x, t1)) e1 t2
⟹ hasty G (Abs x e1) (Fun t1 t2)" |
HtApp:
"⟦ hasty G e1 (Fun t1 t2);
hasty G e2 t1 ⟧
⟹ hasty G (App e1 e2) t2"
named_theorems my_simps "simplification rules for typechecking"
declare HtVar [my_simps]
declare HtConst [my_simps]
declare HtPlus [my_simps]
declare HtAbs [my_simps]
declare HtApp [my_simps]
declare lookup_def [my_simps]
declare add_def [my_simps]
lemma "hasty $0 (Plus (Const 1) (Const 1)) Nat"
using [[simp_trace_new mode=full]]
apply(simp add: my_simps)
done
lemma "hasty $0 (Abs ''n'' (Abs ''m'' (Plus (Var ''n'') (Var ''m''))))
(Fun Nat (Fun Nat Nat))"
apply (simp add: my_simps)
done
lemma "⟦P ∧ Q ⟧ ⟹ Q"
apply (rule conjE)
apply(simp) (* note: this simp step does instantiate schematic variables *)
apply assumption
done
(* but here, it seems that simp does not instantiate schematic variables: *)
lemma eleven: "hasty $0 (App (App
(Abs ''n'' (Abs ''m'' (Plus (Var ''n'') (Var ''m''))))
(Const 7)) (Const 4)) Nat"
using [[simp_trace_new mode=full]]
apply (simp add: my_simps) (* seems to fail on unifying "?t1.3 = type.Nat" *)
The relevant part of the simplifier trace (I guess) is the following:
Apply rewrite rule?
Instance of Option.option.inject: Some ?t1.3 = Some type.Nat ≡ ?t1.3 = type.Nat
Trying to rewrite: Some ?t1.3 = Some type.Nat
Successfully rewrote
Some ?t1.3 = Some type.Nat ≡ ?t1.3 = type.Nat
Step failed
In an instance of Stlc.hasty.HtVar:
(λy. if y = ''m'' then Some ?t1.1 else if y = ''n'' then Some ?t1.3 else $0 y) $? ''n'' = Some type.Nat ⟹
hasty (λy. if y = ''m'' then Some ?t1.1 else if y = ''n'' then Some ?t1.3 else $0 y) (Var ''n'') type.Nat ≡ True
Was trying to rewrite:
hasty (λy. if y = ''m'' then Some ?t1.1 else if y = ''n'' then Some ?t1.3 else $0 y) (Var ''n'') type.Nat
Just before the failing step, rewriting stops at ?t1.3 = type.Nat.
However, I would like ?t1.3 = type.Nat to be rewritten to True, and
?t1.3 be instantiated to type.Nat along the way.
How can I achieve this?

Answer 1

Isabelle's simplifier on its own never instantiates any schematic variables in the goal. This is only done by the so-called solvers. for example, the solver HOL unsafe tries among others the tactics rule refl and assumption. This is why the example with ⟦P ∧ Q ⟧ ⟹ Q works with simp.
For solving the assumptions of conditional rewrite rules like HtVar, the subgoaler also plays a role. The subgoaler determines how the conditions should be solved. By default in HOL, this is asm_simp_tac, i.e., the equivalent to the method simp (no_asm_simp). This subgoaler cannot handle the instantiation of schematics in the assumption. You can see this by enabling the other simplifier trace:
using [[simp_trace]] supply [[simp_trace_depth_limit=10]]
apply (simp add: my_simps)
gives the following trace message:
[6]Proved wrong theorem (bad subgoaler?)
hasty (λy. if y = ''m'' then Some ?t1.1 else if y = ''n'' then Some type.Nat else $0 y) (Var ''n'') type.Nat ≡ True
Should have proved:
hasty (λy. if y = ''m'' then Some ?t1.1 else if y = ''n'' then Some ?t1.3 else $0 y) (Var ''n'') type.Nat
So if you want to use the simplifier for this kind of type checking, you need a different subgoaler. I'm not enough of an expert to help you with that. You can find more documentation in the Isabelle/Isar reference manual, section 9.3.6.
Instead, I recomment that you write your own type inference method (e.g., using Eisbach) that applies the type inference rules and calls the simplifier as needed. This avoids the problems with the subgoaler.

Answer 2

It seems that for this kind of proof goals, which can be solved by repeatedly applying an inference rule, one should use the classical reasoner (auto) rather than the rewriter (simpl).
If I declare all typing rules as safe intro rules:
declare HtVar [intro!]
declare HtConst [intro!]
declare HtPlus [intro!]
declare HtAbs [intro!]
declare HtApp [intro!]
Then most of my lemma is proved by auto, which leaves open two lookup goals that can be solved by simp:
lemma eleven: "hasty $0 (App (App
(Abs ''n'' (Abs ''m'' (Plus (Var ''n'') (Var ''m''))))
(Const 7)) (Const 4)) Nat"
apply(auto)
apply(simp_all add: my_simps)
done
Also, given a classical reasoner such as auto, one can easily specify what rewriter to use on the remaining subgoals as follows, so the above proof can be condensed into one line:
apply(auto simp add: my_simps)
Whereas, given a rewriter such as simp, it seems to be a bit more involved to specify what method to use on the remaining subgoals.