url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | rw [liftN_instN_lo k e2 e3 j _ (Nat.zero_le _), Nat.add_comm] | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k < k
⊢ inst (liftN k e2) e3 (j + k) = liftN k (inst e2 e3 j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k < k
⊢ inst (liftN k e2) e3 (j + k) = liftN k (inst e2 e3 j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | have hk := Nat.lt_of_le_of_ne (Nat.not_lt.1 h) (Ne.symm h') | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k
h' : ¬i = k
⊢ inst (bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k
h' : ¬i = k
hk : k < i
⊢ inst (bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k
h' : ¬i = k
⊢ inst (bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | let i+1 := i | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k
h' : ¬i = k
hk : k < i
⊢ inst (bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 (j + k) =
inst
(if i + 1 < j + k + 1 then bvar (i + 1) else if i + 1 = j + k + 1 then liftN (j + k + 1) e3 else bvar (i + 1 - 1))
(inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k
h' : ¬i = k
hk : k < i
⊢ inst (bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | simp [inst, instVar] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 (j + k) =
inst
(if i + 1 < j + k + 1 then bvar (i + 1) else if i + 1 = j + k + 1 then liftN (j + k + 1) e3 else bvar (i + 1 - 1))
(inst e2 e3 j) k | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ (if i < j + k then bvar i else if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 (j + k) =
inst
(if i + 1 < j + k + 1 then bvar (i + 1) else if i + 1 = j + k + 1 then liftN (j + k + 1) e3 else bvar (i + 1 - 1))
(inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | split <;> rename_i hi | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ (if i < j + k then bvar i else if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k | case inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : i < j + k
⊢ bvar i =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k
case inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
⊢ (if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
⊢ (if i < j + k then bvar i else if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | split <;> rename_i hi' | case inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
⊢ (if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k | case inr.inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : i = j + k
⊢ liftN (j + k) e3 = inst (if i + 1 < j + k + 1 then bvar (i + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k
case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
⊢ (if i = j + k then liftN (j + k) e3 else bvar (i - 1)) =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | simp [Nat.succ_lt_succ hi, inst, instVar, h, h'] | case inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : i < j + k
⊢ bvar i =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : i < j + k
⊢ bvar i =
inst (if i + 1 < j + k + 1 then bvar (i + 1) else if i = j + k then liftN (j + k + 1) e3 else bvar i) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | subst i | case inr.inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : i = j + k
⊢ liftN (j + k) e3 = inst (if i + 1 < j + k + 1 then bvar (i + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (if j + k + 1 < j + k + 1 then bvar (j + k + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inl
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : i = j + k
⊢ liftN (j + k) e3 = inst (if i + 1 < j + k + 1 then bvar (i + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | simp | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (if j + k + 1 < j + k + 1 then bvar (j + k + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (liftN (j + k + 1) e3) (inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (if j + k + 1 < j + k + 1 then bvar (j + k + 1) else liftN (j + k + 1) e3) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | suffices liftN (j+k+1) .. = _ by rw [this]; exact (inst_liftN ..).symm | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (liftN (j + k + 1) e3) (inst e2 e3 j) k | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k + 1) e3 = liftN 1 (liftN (j + k) e3) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k) e3 = inst (liftN (j + k + 1) e3) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | exact (liftN'_liftN' (Nat.zero_le _) (Nat.le_add_left k j)).symm | case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k + 1) e3 = liftN 1 (liftN (j + k) e3) k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ liftN (j + k + 1) e3 = liftN 1 (liftN (j + k) e3) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | rw [this] | i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
this : liftN (j + k + 1) ?m.110132 = ?m.110135
⊢ liftN (j + k) e3 = inst (liftN (j + k + 1) e3) (inst e2 e3 j) k | i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
this : liftN (j + k + 1) e3 = ?m.110135
⊢ liftN (j + k) e3 = inst ?m.110135 (inst e2 e3 j) k
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ VExpr | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
this : liftN (j + k + 1) ?m.110132 = ?m.110135
⊢ liftN (j + k) e3 = inst (liftN (j + k + 1) e3) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | exact (inst_liftN ..).symm | i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
this : liftN (j + k + 1) e3 = ?m.110135
⊢ liftN (j + k) e3 = inst ?m.110135 (inst e2 e3 j) k
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ VExpr | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
this : liftN (j + k + 1) e3 = ?m.110135
⊢ liftN (j + k) e3 = inst ?m.110135 (inst e2 e3 j) k
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬j + k + 1 < k
h' : ¬j + k + 1 = k
hk : k < j + k + 1
hi : ¬j + k < j + k
⊢ VExpr
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | have hk := Nat.lt_of_le_of_ne (Nat.not_lt.1 hi) (Ne.symm hi') | case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k | case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk✝ : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
hk : j + k < i
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | let i+1 := i | case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk✝ : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
hk : j + k < i
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar (i + 1 - 1) = inst (if i + 1 + 1 < j + k + 1 then bvar (i + 1 + 1) else bvar (i + 1)) (inst e2 e3 j) k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k
h' : ¬i + 1 = k
hk✝ : k < i + 1
hi : ¬i < j + k
hi' : ¬i = j + k
hk : j + k < i
⊢ bvar (i - 1) = inst (if i + 1 < j + k + 1 then bvar (i + 1) else bvar i) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | simp [Nat.add_lt_add_iff_right, hi, inst, instVar] | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar (i + 1 - 1) = inst (if i + 1 + 1 < j + k + 1 then bvar (i + 1 + 1) else bvar (i + 1)) (inst e2 e3 j) k | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar (i + 1 - 1) = inst (if i + 1 + 1 < j + k + 1 then bvar (i + 1 + 1) else bvar (i + 1)) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | have := Nat.lt_of_le_of_lt (Nat.le_add_left ..) hk | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
this : k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_hi | [432, 1] | [453, 66] | rw [if_neg (Nat.lt_asymm this), if_neg (Nat.ne_of_gt this)] | case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
this : k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr.inr
i✝¹ : Nat
e2 e3 : VExpr
k j i✝ i : Nat
h : ¬i + 1 + 1 < k
h' : ¬i + 1 + 1 = k
hk✝ : k < i + 1 + 1
hi : ¬i + 1 < j + k
hi' : ¬i + 1 = j + k
hk : j + k < i + 1
this : k < i + 1
⊢ bvar i = if i + 1 < k then bvar (i + 1) else if i + 1 = k then liftN k (inst e2 e3 j) else bvar i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_hi | [455, 1] | [459, 31] | induction e1 generalizing k with simp [liftN, inst, instVar, *]
| bvar i => apply inst_instVar_hi
| _ => rename_i IH; apply IH | e1 e2 e3 : VExpr
k j : Nat
⊢ inst (inst e1 e2 k) e3 (j + k) = inst (inst e1 e3 (j + k + 1)) (inst e2 e3 j) k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e1 e2 e3 : VExpr
k j : Nat
⊢ inst (inst e1 e2 k) e3 (j + k) = inst (inst e1 e3 (j + k + 1)) (inst e2 e3 j) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_hi | [455, 1] | [459, 31] | apply inst_instVar_hi | case bvar
e2 e3 : VExpr
j i k : Nat
⊢ inst (if i < k then bvar i else if i = k then liftN k e2 else bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
e2 e3 : VExpr
j i k : Nat
⊢ inst (if i < k then bvar i else if i = k then liftN k e2 else bvar (i - 1)) e3 (j + k) =
inst (if i < j + k + 1 then bvar i else if i = j + k + 1 then liftN (j + k + 1) e3 else bvar (i - 1)) (inst e2 e3 j)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_hi | [455, 1] | [459, 31] | rename_i IH | case forallE
e2 e3 : VExpr
j : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (k : Nat), inst (inst binderType✝ e2 k) e3 (j + k) = inst (inst binderType✝ e3 (j + k + 1)) (inst e2 e3 j) k
body_ih✝ : ∀ (k : Nat), inst (inst body✝ e2 k) e3 (j + k) = inst (inst body✝ e3 (j + k + 1)) (inst e2 e3 j) k
k : Nat
⊢ inst (inst body✝ e2 (k + 1)) e3 (j + k + 1) = inst (inst body✝ e3 (j + k + 1 + 1)) (inst e2 e3 j) (k + 1) | case forallE
e2 e3 : VExpr
j : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (k : Nat), inst (inst binderType✝ e2 k) e3 (j + k) = inst (inst binderType✝ e3 (j + k + 1)) (inst e2 e3 j) k
IH : ∀ (k : Nat), inst (inst body✝ e2 k) e3 (j + k) = inst (inst body✝ e3 (j + k + 1)) (inst e2 e3 j) k
k : Nat
⊢ inst (inst body✝ e2 (k + 1)) e3 (j + k + 1) = inst (inst body✝ e3 (j + k + 1 + 1)) (inst e2 e3 j) (k + 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
e2 e3 : VExpr
j : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (k : Nat), inst (inst binderType✝ e2 k) e3 (j + k) = inst (inst binderType✝ e3 (j + k + 1)) (inst e2 e3 j) k
body_ih✝ : ∀ (k : Nat), inst (inst body✝ e2 k) e3 (j + k) = inst (inst body✝ e3 (j + k + 1)) (inst e2 e3 j) k
k : Nat
⊢ inst (inst body✝ e2 (k + 1)) e3 (j + k + 1) = inst (inst body✝ e3 (j + k + 1 + 1)) (inst e2 e3 j) (k + 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_hi | [455, 1] | [459, 31] | apply IH | case forallE
e2 e3 : VExpr
j : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (k : Nat), inst (inst binderType✝ e2 k) e3 (j + k) = inst (inst binderType✝ e3 (j + k + 1)) (inst e2 e3 j) k
IH : ∀ (k : Nat), inst (inst body✝ e2 k) e3 (j + k) = inst (inst body✝ e3 (j + k + 1)) (inst e2 e3 j) k
k : Nat
⊢ inst (inst body✝ e2 (k + 1)) e3 (j + k + 1) = inst (inst body✝ e3 (j + k + 1 + 1)) (inst e2 e3 j) (k + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
e2 e3 : VExpr
j : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (k : Nat), inst (inst binderType✝ e2 k) e3 (j + k) = inst (inst binderType✝ e3 (j + k + 1)) (inst e2 e3 j) k
IH : ∀ (k : Nat), inst (inst body✝ e2 k) e3 (j + k) = inst (inst body✝ e3 (j + k + 1)) (inst e2 e3 j) k
k : Nat
⊢ inst (inst body✝ e2 (k + 1)) e3 (j + k + 1) = inst (inst body✝ e3 (j + k + 1 + 1)) (inst e2 e3 j) (k + 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [instVar] | i : Nat
e2 e3 : VExpr
k j : Nat
⊢ inst (instVar i e2 (k + j + 1)) e3 j = inst (instVar i (liftN 1 e3 k) j) e2 (k + j) | i : Nat
e2 e3 : VExpr
k j : Nat
⊢ inst (if i < k + j + 1 then bvar i else if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
e2 e3 : VExpr
k j : Nat
⊢ inst (instVar i e2 (k + j + 1)) e3 j = inst (instVar i (liftN 1 e3 k) j) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | split <;> rename_i h | i : Nat
e2 e3 : VExpr
k j : Nat
⊢ inst (if i < k + j + 1 then bvar i else if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
⊢ inst (bvar i) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
case inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
⊢ inst (if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
e2 e3 : VExpr
k j : Nat
⊢ inst (if i < k + j + 1 then bvar i else if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | split <;> rename_i h' | case inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
⊢ inst (if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : i = k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
⊢ inst (if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | split <;> rename_i h1 | case inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
⊢ inst (bvar i) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ inst (bvar i) e3 j = inst (bvar i) e2 (k + j)
case inl.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
⊢ inst (bvar i) e3 j = inst (if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
⊢ inst (bvar i) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | split <;> rename_i h1' | case inl.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
⊢ inst (bvar i) e3 j = inst (if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inl.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : i = j
⊢ inst (bvar i) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j)
case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
⊢ inst (bvar i) e3 j = inst (if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar, h1] | case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ inst (bvar i) e3 j = inst (bvar i) e2 (k + j) | case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ bvar i = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ inst (bvar i) e3 j = inst (bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [if_pos (Nat.lt_of_lt_of_le h1 (Nat.le_add_left ..))] | case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ bvar i = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : i < j
⊢ bvar i = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | subst i | case inl.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : i = j
⊢ inst (bvar i) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j) | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ inst (bvar j) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : i = j
⊢ inst (bvar i) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar] | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ inst (bvar j) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j) | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN j (liftN 1 e3 k)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ inst (bvar j) e3 j = inst (liftN j (liftN 1 e3 k)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [liftN'_comm (h := Nat.zero_le _), Nat.add_comm] | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN j (liftN 1 e3 k)) e2 (k + j) | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN 1 (liftN j e3) (k + j)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN j (liftN 1 e3 k)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | exact (inst_liftN ..).symm | case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN 1 (liftN j e3) (k + j)) e2 (k + j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
e2 e3 : VExpr
k j : Nat
h : j < k + j + 1
h1 : ¬j < j
⊢ liftN j e3 = inst (liftN 1 (liftN j e3) (k + j)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have hj := Nat.lt_of_le_of_ne (Nat.not_lt.1 h1) (Ne.symm h1') | case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j) | case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
hj : j < i
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | let i+1 := i | case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
hj : j < i
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j) | case inl.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : i + 1 < k + j + 1
h1 : ¬i + 1 < j
h1' : ¬i + 1 = j
hj : j < i + 1
⊢ inst (bvar (i + 1)) e3 j = inst (bvar (i + 1 - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : i < k + j + 1
h1 : ¬i < j
h1' : ¬i = j
hj : j < i
⊢ inst (bvar i) e3 j = inst (bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar, h1, h1', Nat.lt_of_succ_lt_succ h] | case inl.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : i + 1 < k + j + 1
h1 : ¬i + 1 < j
h1' : ¬i + 1 = j
hj : j < i + 1
⊢ inst (bvar (i + 1)) e3 j = inst (bvar (i + 1 - 1)) e2 (k + j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : i + 1 < k + j + 1
h1 : ¬i + 1 < j
h1' : ¬i + 1 = j
hj : j < i + 1
⊢ inst (bvar (i + 1)) e3 j = inst (bvar (i + 1 - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | subst i | case inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : i = k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : i = k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have := Nat.lt_succ_of_le (Nat.le_add_left j k) | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j) | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [if_neg (Nat.lt_asymm this), if_neg (Nat.ne_of_gt this)] | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j) | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = inst (bvar (k + j + 1 - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j =
inst
(if k + j + 1 < j then bvar (k + j + 1)
else if k + j + 1 = j then liftN j (liftN 1 e3 k) else bvar (k + j + 1 - 1))
e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar] | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = inst (bvar (k + j + 1 - 1)) e2 (k + j) | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = liftN (k + j) e2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = inst (bvar (k + j + 1 - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | suffices liftN (k+j+1) .. = _ by rw [this]; exact inst_liftN .. | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = liftN (k + j) e2 | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ liftN (k + j + 1) e2 = liftN 1 (liftN (k + j) e2) j | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ inst (liftN (k + j + 1) e2) e3 j = liftN (k + j) e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | exact (liftN'_liftN' (Nat.zero_le _) (Nat.le_add_left j k)).symm | case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ liftN (k + j + 1) e2 = liftN 1 (liftN (k + j) e2) j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ liftN (k + j + 1) e2 = liftN 1 (liftN (k + j) e2) j
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [this] | e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this✝ : j < Nat.succ (k + j)
this : liftN (k + j + 1) ?m.117762 = ?m.117771
⊢ inst (liftN (k + j + 1) e2) e3 j = liftN (k + j) e2 | e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this✝ : j < Nat.succ (k + j)
this : liftN (k + j + 1) e2 = ?m.117771
⊢ inst ?m.117771 e3 j = liftN (k + j) e2
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ VExpr | Please generate a tactic in lean4 to solve the state.
STATE:
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this✝ : j < Nat.succ (k + j)
this : liftN (k + j + 1) ?m.117762 = ?m.117771
⊢ inst (liftN (k + j + 1) e2) e3 j = liftN (k + j) e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | exact inst_liftN .. | e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this✝ : j < Nat.succ (k + j)
this : liftN (k + j + 1) e2 = ?m.117771
⊢ inst ?m.117771 e3 j = liftN (k + j) e2
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ VExpr | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this✝ : j < Nat.succ (k + j)
this : liftN (k + j + 1) e2 = ?m.117771
⊢ inst ?m.117771 e3 j = liftN (k + j) e2
e2 e3 : VExpr
k j : Nat
h : ¬k + j + 1 < k + j + 1
this : j < Nat.succ (k + j)
⊢ VExpr
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have hk := Nat.lt_of_le_of_ne (Nat.not_lt.1 h) (Ne.symm h') | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
hk : k + j + 1 < i
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | let i+1 := i | case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
hk : k + j + 1 < i
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk : k + j + 1 < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i : Nat
e2 e3 : VExpr
k j : Nat
h : ¬i < k + j + 1
h' : ¬i = k + j + 1
hk : k + j + 1 < i
⊢ inst (bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have hk := Nat.lt_of_add_lt_add_right hk | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk : k + j + 1 < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk : k + j + 1 < i + 1
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar, hk] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ inst (bvar (i + 1 - 1)) e3 j =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar (i + 1 - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have := Nat.lt_of_le_of_lt (Nat.le_add_left ..) hk | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [if_neg (Nat.lt_asymm this), if_neg (Nat.ne_of_gt this)] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ (if i < j then bvar i else if i = j then liftN j e3 else bvar (i - 1)) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | have := Nat.lt_succ_of_lt this | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this : j < i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [if_neg (Nat.lt_asymm this), if_neg (Nat.ne_of_gt this)] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = inst (bvar i) e2 (k + j) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) =
inst (if i + 1 < j then bvar (i + 1) else if i + 1 = j then liftN j (liftN 1 e3 k) else bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | simp [inst, instVar] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = inst (bvar i) e2 (k + j) | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = inst (bvar i) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_instVar_lo | [464, 1] | [493, 60] | rw [if_neg (Nat.lt_asymm hk), if_neg (Nat.ne_of_gt hk)] | case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
i✝ : Nat
e2 e3 : VExpr
k j i : Nat
h : ¬i + 1 < k + j + 1
h' : ¬i + 1 = k + j + 1
hk✝ : k + j + 1 < i + 1
hk : k + j < i
this✝ : j < i
this : j < Nat.succ i
⊢ bvar (i - 1) = if i < k + j then bvar i else if i = k + j then liftN (k + j) e2 else bvar (i - 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_lo | [495, 1] | [500, 37] | induction e1 generalizing j with simp [liftN, inst, instVar, *]
| bvar i => apply inst_instVar_lo
| _ => rename_i IH; exact IH (j+1) | e1 e2 e3 : VExpr
k j : Nat
⊢ inst (inst e1 e2 (k + j + 1)) e3 j = inst (inst e1 (liftN 1 e3 k) j) e2 (k + j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e1 e2 e3 : VExpr
k j : Nat
⊢ inst (inst e1 e2 (k + j + 1)) e3 j = inst (inst e1 (liftN 1 e3 k) j) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_lo | [495, 1] | [500, 37] | apply inst_instVar_lo | case bvar
e2 e3 : VExpr
k i j : Nat
⊢ inst (if i < k + j + 1 then bvar i else if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
e2 e3 : VExpr
k i j : Nat
⊢ inst (if i < k + j + 1 then bvar i else if i = k + j + 1 then liftN (k + j + 1) e2 else bvar (i - 1)) e3 j =
inst (if i < j then bvar i else if i = j then liftN j (liftN 1 e3 k) else bvar (i - 1)) e2 (k + j)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_lo | [495, 1] | [500, 37] | rename_i IH | case forallE
e2 e3 : VExpr
k : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (j : Nat), inst (inst binderType✝ e2 (k + j + 1)) e3 j = inst (inst binderType✝ (liftN 1 e3 k) j) e2 (k + j)
body_ih✝ : ∀ (j : Nat), inst (inst body✝ e2 (k + j + 1)) e3 j = inst (inst body✝ (liftN 1 e3 k) j) e2 (k + j)
j : Nat
⊢ inst (inst body✝ e2 (k + j + 1 + 1)) e3 (j + 1) = inst (inst body✝ (liftN 1 e3 k) (j + 1)) e2 (k + j + 1) | case forallE
e2 e3 : VExpr
k : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (j : Nat), inst (inst binderType✝ e2 (k + j + 1)) e3 j = inst (inst binderType✝ (liftN 1 e3 k) j) e2 (k + j)
IH : ∀ (j : Nat), inst (inst body✝ e2 (k + j + 1)) e3 j = inst (inst body✝ (liftN 1 e3 k) j) e2 (k + j)
j : Nat
⊢ inst (inst body✝ e2 (k + j + 1 + 1)) e3 (j + 1) = inst (inst body✝ (liftN 1 e3 k) (j + 1)) e2 (k + j + 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
e2 e3 : VExpr
k : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (j : Nat), inst (inst binderType✝ e2 (k + j + 1)) e3 j = inst (inst binderType✝ (liftN 1 e3 k) j) e2 (k + j)
body_ih✝ : ∀ (j : Nat), inst (inst body✝ e2 (k + j + 1)) e3 j = inst (inst body✝ (liftN 1 e3 k) j) e2 (k + j)
j : Nat
⊢ inst (inst body✝ e2 (k + j + 1 + 1)) e3 (j + 1) = inst (inst body✝ (liftN 1 e3 k) (j + 1)) e2 (k + j + 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.inst_inst_lo | [495, 1] | [500, 37] | exact IH (j+1) | case forallE
e2 e3 : VExpr
k : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (j : Nat), inst (inst binderType✝ e2 (k + j + 1)) e3 j = inst (inst binderType✝ (liftN 1 e3 k) j) e2 (k + j)
IH : ∀ (j : Nat), inst (inst body✝ e2 (k + j + 1)) e3 j = inst (inst body✝ (liftN 1 e3 k) j) e2 (k + j)
j : Nat
⊢ inst (inst body✝ e2 (k + j + 1 + 1)) e3 (j + 1) = inst (inst body✝ (liftN 1 e3 k) (j + 1)) e2 (k + j + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
e2 e3 : VExpr
k : Nat
binderType✝ body✝ : VExpr
binderType_ih✝ :
∀ (j : Nat), inst (inst binderType✝ e2 (k + j + 1)) e3 j = inst (inst binderType✝ (liftN 1 e3 k) j) e2 (k + j)
IH : ∀ (j : Nat), inst (inst body✝ e2 (k + j + 1)) e3 j = inst (inst body✝ (liftN 1 e3 k) j) e2 (k + j)
j : Nat
⊢ inst (inst body✝ e2 (k + j + 1 + 1)) e3 (j + 1) = inst (inst body✝ (liftN 1 e3 k) (j + 1)) e2 (k + j + 1)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.instN_bvar0 | [502, 1] | [505, 79] | induction e generalizing k with simp [liftN, inst, *]
| bvar i => induction i generalizing k <;> cases k <;> simp [*, lift, liftN] | e : VExpr
k : Nat
⊢ inst (liftN 1 e (k + 1)) (bvar 0) k = e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e : VExpr
k : Nat
⊢ inst (liftN 1 e (k + 1)) (bvar 0) k = e
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.instN_bvar0 | [502, 1] | [505, 79] | induction i generalizing k <;> cases k <;> simp [*, lift, liftN] | case bvar
i k : Nat
⊢ instVar (liftVar 1 i (k + 1)) (bvar 0) k = bvar i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
i k : Nat
⊢ instVar (liftVar 1 i (k + 1)) (bvar 0) k = bvar i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_consN | [548, 9] | [548, 100] | induction n <;> simp [*] | l : Lift
n : Nat
⊢ depth (consN l n) = depth l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
n : Nat
⊢ depth (consN l n) = depth l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.consN_consN | [550, 1] | [551, 27] | induction b <;> simp [*] | l : Lift
a b : Nat
⊢ consN (consN l a) b = consN l (a + b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
a b : Nat
⊢ consN (consN l a) b = consN l (a + b)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.consN_comp | [553, 1] | [554, 27] | induction n <;> simp [*] | l₁ l₂ : Lift
n : Nat
⊢ consN (comp l₁ l₂) n = comp (consN l₁ n) (consN l₂ n) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l₁ l₂ : Lift
n : Nat
⊢ consN (comp l₁ l₂) n = comp (consN l₁ n) (consN l₂ n)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_skipN | [556, 9] | [556, 92] | induction n <;> simp [*] | n : Nat
⊢ depth (skipN n) = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ depth (skipN n) = n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.consN_skip_eq | [558, 1] | [559, 25] | rw [← consN_comp] | l : Lift
k : Nat
⊢ consN (skip l) k = comp (consN l k) (consN (skipN 1) k) | l : Lift
k : Nat
⊢ consN (skip l) k = consN (comp l (skipN 1)) k | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
k : Nat
⊢ consN (skip l) k = comp (consN l k) (consN (skipN 1) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.consN_skip_eq | [558, 1] | [559, 25] | rfl | l : Lift
k : Nat
⊢ consN (skip l) k = consN (comp l (skipN 1)) k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
k : Nat
⊢ consN (skip l) k = consN (comp l (skipN 1)) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ | [561, 1] | [567, 29] | match l with
| .skip l => cases H; exact ⟨l, 0, rfl, rfl⟩
| .cons l =>
obtain ⟨l, k, rfl, ⟨⟩⟩ := depth_succ (l := l) H
exact ⟨l, k+1, rfl, rfl⟩ | n : Nat
l : Lift
H : depth l = n + 1
⊢ ∃ l' k, depth l' = n ∧ l = consN (skip l') k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l : Lift
H : depth l = n + 1
⊢ ∃ l' k, depth l' = n ∧ l = consN (skip l') k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ | [561, 1] | [567, 29] | cases H | n : Nat
l✝ l : Lift
H : depth (skip l) = n + 1
⊢ ∃ l' k, depth l' = n ∧ skip l = consN (skip l') k | case refl
l✝ l : Lift
⊢ ∃ l' k, depth l' = depth l ∧ skip l = consN (skip l') k | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l✝ l : Lift
H : depth (skip l) = n + 1
⊢ ∃ l' k, depth l' = n ∧ skip l = consN (skip l') k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ | [561, 1] | [567, 29] | exact ⟨l, 0, rfl, rfl⟩ | case refl
l✝ l : Lift
⊢ ∃ l' k, depth l' = depth l ∧ skip l = consN (skip l') k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
l✝ l : Lift
⊢ ∃ l' k, depth l' = depth l ∧ skip l = consN (skip l') k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ | [561, 1] | [567, 29] | obtain ⟨l, k, rfl, ⟨⟩⟩ := depth_succ (l := l) H | n : Nat
l✝ l : Lift
H : depth (cons l) = n + 1
⊢ ∃ l' k, depth l' = n ∧ cons l = consN (skip l') k | case intro.intro.intro.refl
l✝ l : Lift
k : Nat
H : depth (cons (consN (skip l) k)) = depth l + 1
⊢ ∃ l' k_1, depth l' = depth l ∧ cons (consN (skip l) k) = consN (skip l') k_1 | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l✝ l : Lift
H : depth (cons l) = n + 1
⊢ ∃ l' k, depth l' = n ∧ cons l = consN (skip l') k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ | [561, 1] | [567, 29] | exact ⟨l, k+1, rfl, rfl⟩ | case intro.intro.intro.refl
l✝ l : Lift
k : Nat
H : depth (cons (consN (skip l) k)) = depth l + 1
⊢ ∃ l' k_1, depth l' = depth l ∧ cons (consN (skip l) k) = consN (skip l') k_1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.refl
l✝ l : Lift
k : Nat
H : depth (cons (consN (skip l) k)) = depth l + 1
⊢ ∃ l' k_1, depth l' = depth l ∧ cons (consN (skip l) k) = consN (skip l') k_1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ' | [569, 1] | [572, 65] | let ⟨l', k, h1, h2⟩ := depth_succ H | n : Nat
l : Lift
H : depth l = n + 1
⊢ ∃ l' k, depth l' = n ∧ l = comp l' (consN (skipN 1) k) | n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ ∃ l' k, depth l' = n ∧ l = comp l' (consN (skipN 1) k) | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l : Lift
H : depth l = n + 1
⊢ ∃ l' k, depth l' = n ∧ l = comp l' (consN (skipN 1) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ' | [569, 1] | [572, 65] | exact ⟨.consN l' k, k, by simp [h1], by rwa [← consN_skip_eq]⟩ | n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ ∃ l' k, depth l' = n ∧ l = comp l' (consN (skipN 1) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ ∃ l' k, depth l' = n ∧ l = comp l' (consN (skipN 1) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ' | [569, 1] | [572, 65] | simp [h1] | n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ depth (consN l' k) = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ depth (consN l' k) = n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.Lift.depth_succ' | [569, 1] | [572, 65] | rwa [← consN_skip_eq] | n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ l = comp (consN l' k) (consN (skipN 1) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
l : Lift
H : depth l = n + 1
l' : Lift
k : Nat
h1 : depth l' = n
h2 : l = consN (skip l') k
⊢ l = comp (consN l' k) (consN (skipN 1) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_comp | [580, 1] | [581, 99] | induction l₂ generalizing l₁ n <;> [skip; skip; cases l₁ <;> [skip; skip; cases n]] <;> simp [*] | l₁ l₂ : Lift
n : Nat
⊢ Lift.liftVar (Lift.comp l₁ l₂) n = Lift.liftVar l₂ (Lift.liftVar l₁ n) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l₁ l₂ : Lift
n : Nat
⊢ Lift.liftVar (Lift.comp l₁ l₂) n = Lift.liftVar l₂ (Lift.liftVar l₁ n)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_skipN | [583, 1] | [586, 52] | induction n generalizing i with
| zero => rfl
| succ _ ih => simp [ih, Nat.add_right_comm]; rfl | n i : Nat
⊢ Lift.liftVar (Lift.skipN n) i = i + n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n i : Nat
⊢ Lift.liftVar (Lift.skipN n) i = i + n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_skipN | [583, 1] | [586, 52] | rfl | case zero
i : Nat
⊢ Lift.liftVar (Lift.skipN Nat.zero) i = i + Nat.zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
i : Nat
⊢ Lift.liftVar (Lift.skipN Nat.zero) i = i + Nat.zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_skipN | [583, 1] | [586, 52] | simp [ih, Nat.add_right_comm] | case succ
n✝ : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.skipN n✝) i = i + n✝
i : Nat
⊢ Lift.liftVar (Lift.skipN (Nat.succ n✝)) i = i + Nat.succ n✝ | case succ
n✝ : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.skipN n✝) i = i + n✝
i : Nat
⊢ i + n✝ + 1 = i + Nat.succ n✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n✝ : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.skipN n✝) i = i + n✝
i : Nat
⊢ Lift.liftVar (Lift.skipN (Nat.succ n✝)) i = i + Nat.succ n✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_skipN | [583, 1] | [586, 52] | rfl | case succ
n✝ : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.skipN n✝) i = i + n✝
i : Nat
⊢ i + n✝ + 1 = i + Nat.succ n✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n✝ : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.skipN n✝) i = i + n✝
i : Nat
⊢ i + n✝ + 1 = i + Nat.succ n✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_consN_skipN | [588, 1] | [593, 30] | induction k generalizing i with
| zero => simp [liftVar_skipN]
| succ k ih =>
cases i with simp [liftVar, Nat.succ_lt_succ_iff, ih]
| succ i => split <;> rfl | n k i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_consN_skipN | [588, 1] | [593, 30] | simp [liftVar_skipN] | case zero
n i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) Nat.zero) i = liftVar n i Nat.zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) Nat.zero) i = liftVar n i Nat.zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_consN_skipN | [588, 1] | [593, 30] | cases i with simp [liftVar, Nat.succ_lt_succ_iff, ih]
| succ i => split <;> rfl | case succ
n k : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k
i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) (Nat.succ k)) i = liftVar n i (Nat.succ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n k : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k
i : Nat
⊢ Lift.liftVar (Lift.consN (Lift.skipN n) (Nat.succ k)) i = liftVar n i (Nat.succ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_consN_skipN | [588, 1] | [593, 30] | split <;> rfl | case succ.succ
n k : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k
i : Nat
⊢ (if i < k then i else n + i) + 1 = if i < k then Nat.succ i else n + Nat.succ i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ
n k : Nat
ih : ∀ {i : Nat}, Lift.liftVar (Lift.consN (Lift.skipN n) k) i = liftVar n i k
i : Nat
⊢ (if i < k then i else n + i) + 1 = if i < k then Nat.succ i else n + Nat.succ i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.liftVar_depth_zero | [595, 1] | [596, 81] | induction l generalizing n <;> [skip; skip; cases n] <;> simp_all [Lift.depth] | l : Lift
n : Nat
H : Lift.depth l = 0
⊢ Lift.liftVar l n = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
n : Nat
H : Lift.depth l = 0
⊢ Lift.liftVar l n = n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.lift'_consN_skipN | [608, 1] | [609, 70] | induction e generalizing k <;> simp [liftN, liftVar_consN_skipN, *] | n : Nat
e : VExpr
k : Nat
⊢ liftN n e k = lift' e (Lift.consN (Lift.skipN n) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
e : VExpr
k : Nat
⊢ liftN n e k = lift' e (Lift.consN (Lift.skipN n) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.lift'_comp | [611, 1] | [612, 60] | induction e generalizing l₁ l₂ <;> simp [liftVar_comp, *] | l₁ l₂ : Lift
e : VExpr
⊢ lift' (lift' e l₁) l₂ = lift' e (Lift.comp l₁ l₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l₁ l₂ : Lift
e : VExpr
⊢ lift' (lift' e l₁) l₂ = lift' e (Lift.comp l₁ l₂)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VExpr.lean | Lean4Lean.VExpr.lift'_depth_zero | [614, 1] | [615, 63] | induction e generalizing l <;> simp_all [liftVar_depth_zero] | l : Lift
e : VExpr
H : Lift.depth l = 0
⊢ lift' e l = e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
e : VExpr
H : Lift.depth l = 0
⊢ lift' e l = e
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | have H' := H.strong henv hΓ | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H : IsDefEq env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2 | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H : IsDefEq env U Γ e1 e2 A
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2 | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H : IsDefEq env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | clear hΓ H | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H : IsDefEq env U Γ e1 e2 A
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2 | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2 | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H : IsDefEq env U Γ e1 e2 A
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | induction H' with
| bvar h => exact ⟨.bvar h, .bvar h, .refl⟩
| symm _ ih => exact ⟨ih.2.1, ih.1, .symm ih.2.2⟩
| trans _ _ ih1 ih2 => exact ⟨ih1.1, ih2.2.1, .trans ih1.2.2 ih2.2.2⟩
| @constDF _ _ ls₁ ls₂ _ _ h1 h2 h3 h4 h5 =>
exact ⟨.const h1 h2 h4, .defeq sorry <| .const h1 h3 (h5.length_eq.symm.trans h4), .constDF h5⟩
| @sortDF l l' _ h1 h2 h3 =>
refine ⟨.sort h1, ?_, .sortDF h3⟩
exact .defeq (hdf (.sort (l := l'.succ) h2) (.sort (l := l.succ) h1)
(.sortDF <| VLevel.succ_congr h3.symm)) (.sort h2)
| appDF _ _ _ _ _ _ _ _ _ ihf iha ihBa =>
let ⟨hf, hf', ff⟩ := ihf; let ⟨ha, ha', aa⟩ := iha
exact ⟨.app hf ha, .defeq (hdf ihBa.2.1 ihBa.1 (.symm ihBa.2.2)) (.app hf' ha'), .appDF ff aa⟩
| lamDF _ _ _ _ _ _ _ ihA ihB ihB' ihb ihb' =>
refine ⟨.lam ihA.1 ihb.1, .defeq ?_ <| .lam ihA.2.1 ihb'.2.1, .lamDF ihA.2.2 ihb.2.2⟩
exact hdf (.forallE ihA.2.1 ihB'.1) (.forallE ihA.1 ihB.1) <|
.symm <| .forallEDF ihA.2.2 ihB.2.2
| forallEDF _ _ _ _ _ ih1 ih2 ih3 =>
exact ⟨.forallE ih1.1 ih2.1, .forallE ih1.2.1 ih3.2.1, .forallEDF ih1.2.2 ih2.2.2⟩
| defeqDF _ _ _ ih1 ih2 =>
have h := hdf ih1.1 ih1.2.1 ih1.2.2; exact ⟨.defeq h ih2.1, .defeq h ih2.2.1, ih2.2.2⟩
| beta _ _ _ _ _ _ _ _ ihA _ ihe ihe' _ ihee =>
exact ⟨.app (.lam ihA.1 ihe.1) ihe'.1, ihee.1, .beta (hty ihe.1) (hty ihe'.1)⟩
| eta _ _ _ _ _ _ _ ihA _ _ ihe ihe' =>
have := HasTypeU1.app ihe'.1 (.bvar .zero)
rw [instN_bvar0] at this
exact ⟨.lam ihA.1 this, ihe.1, .eta⟩
| proofIrrel _ _ _ ih1 ih2 ih3 =>
exact ⟨ih2.1, ih3.1, .proofIrrel (hty ih1.1) (hty ih2.1) (hty ih3.1)⟩
| extra h1 h2 h3 _ _ _ _ _ _ _ _ _ ihl' ihr' =>
exact ⟨ihl'.1, ihr'.1, .extra h1 h2 h3⟩ | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
H' : IsDefEqStrong env U Γ e1 e2 A
⊢ HasTypeU1 env U defEq Γ e1 A ∧ HasTypeU1 env U defEq Γ e2 A ∧ IsDefEqU1 env U hasType Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.bvar h, .bvar h, .refl⟩ | case bvar
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
u✝ : VLevel
h : Lookup Γ✝ i✝ A✝
a✝¹ : VLevel.WF U u✝
a✝ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.bvar i✝) A✝ ∧
HasTypeU1 env U defEq Γ✝ (VExpr.bvar i✝) A✝ ∧ IsDefEqU1 env U hasType Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
u✝ : VLevel
h : Lookup Γ✝ i✝ A✝
a✝¹ : VLevel.WF U u✝
a✝ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.bvar i✝) A✝ ∧
HasTypeU1 env U defEq Γ✝ (VExpr.bvar i✝) A✝ ∧ IsDefEqU1 env U hasType Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨ih.2.1, ih.1, .symm ih.2.2⟩ | case symm
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEqStrong env U Γ✝ e✝ e'✝ A✝
ih : HasTypeU1 env U defEq Γ✝ e✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e✝ e'✝
⊢ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e'✝ e✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEqStrong env U Γ✝ e✝ e'✝ A✝
ih : HasTypeU1 env U defEq Γ✝ e✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e✝ e'✝
⊢ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e'✝ e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨ih1.1, ih2.2.1, .trans ih1.2.2 ih2.2.2⟩ | case trans
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEqStrong env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEqStrong env U Γ✝ e₂✝ e₃✝ A✝
ih1 : HasTypeU1 env U defEq Γ✝ e₁✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₂✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₁✝ e₂✝
ih2 : HasTypeU1 env U defEq Γ✝ e₂✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₃✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₂✝ e₃✝
⊢ HasTypeU1 env U defEq Γ✝ e₁✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₃✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₁✝ e₃✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEqStrong env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEqStrong env U Γ✝ e₂✝ e₃✝ A✝
ih1 : HasTypeU1 env U defEq Γ✝ e₁✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₂✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₁✝ e₂✝
ih2 : HasTypeU1 env U defEq Γ✝ e₂✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₃✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₂✝ e₃✝
⊢ HasTypeU1 env U defEq Γ✝ e₁✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e₃✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e₁✝ e₃✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.const h1 h2 h4, .defeq sorry <| .const h1 h3 (h5.length_eq.symm.trans h4), .constDF h5⟩ | case constDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
c✝ : Name
ci✝ : VConstant
ls₁ ls₂ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls₁ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls₂ → VLevel.WF U l
h4 : List.length ls₁ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls₁ ls₂
a✝⁴ : VLevel.WF U u✝
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝)
a_ih✝³ :
HasTypeU1 env U defEq [] (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type)
a_ih✝² :
HasTypeU1 env U defEq [] (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type)
a_ih✝ :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type)
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.const c✝ ls₁) (VExpr.instL ls₁ ci✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.const c✝ ls₂) (VExpr.instL ls₁ ci✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.const c✝ ls₁) (VExpr.const c✝ ls₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
c✝ : Name
ci✝ : VConstant
ls₁ ls₂ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls₁ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls₂ → VLevel.WF U l
h4 : List.length ls₁ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls₁ ls₂
a✝⁴ : VLevel.WF U u✝
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝)
a_ih✝³ :
HasTypeU1 env U defEq [] (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type)
a_ih✝² :
HasTypeU1 env U defEq [] (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls₁ ci✝.type) (VExpr.instL ls₁ ci✝.type)
a_ih✝ :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls₂ ci✝.type) (VExpr.instL ls₂ ci✝.type)
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.const c✝ ls₁) (VExpr.instL ls₁ ci✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.const c✝ ls₂) (VExpr.instL ls₁ ci✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.const c✝ ls₁) (VExpr.const c✝ ls₂)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | refine ⟨.sort h1, ?_, .sortDF h3⟩ | case sortDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
l l' : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l ≈ l'
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.sort l) (VExpr.sort (VLevel.succ l)) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.sort l) (VExpr.sort l') | case sortDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
l l' : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l ≈ l'
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
l l' : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l ≈ l'
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.sort l) (VExpr.sort (VLevel.succ l)) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.sort l) (VExpr.sort l')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact .defeq (hdf (.sort (l := l'.succ) h2) (.sort (l := l.succ) h1)
(.sortDF <| VLevel.succ_congr h3.symm)) (.sort h2) | case sortDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
l l' : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l ≈ l'
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
l l' : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l ≈ l'
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.sort l') (VExpr.sort (VLevel.succ l))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | let ⟨hf, hf', ff⟩ := ihf | case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) | case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | let ⟨ha, ha', aa⟩ := iha | case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) | case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
ha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝
ha' : HasTypeU1 env U defEq Γ✝ a'✝ A✝
aa : IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.app hf ha, .defeq (hdf ihBa.2.1 ihBa.1 (.symm ihBa.2.2)) (.app hf' ha'), .appDF ff aa⟩ | case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
ha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝
ha' : HasTypeU1 env U defEq Γ✝ a'✝ A✝
aa : IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (VExpr.sort v✝)
a_ih✝¹ :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihf :
HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ f✝ f'✝
iha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝ ∧ HasTypeU1 env U defEq Γ✝ a'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
ihBa :
HasTypeU1 env U defEq Γ✝ (inst B✝ a✝⁷) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ a'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝)
hf : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
hf' : HasTypeU1 env U defEq Γ✝ f'✝ (VExpr.forallE A✝ B✝)
ff : IsDefEqU1 env U hasType Γ✝ f✝ f'✝
ha : HasTypeU1 env U defEq Γ✝ a✝⁷ A✝
ha' : HasTypeU1 env U defEq Γ✝ a'✝ A✝
aa : IsDefEqU1 env U hasType Γ✝ a✝⁷ a'✝
⊢ HasTypeU1 env U defEq Γ✝ (app f✝ a✝⁷) (inst B✝ a✝⁷) ∧
HasTypeU1 env U defEq Γ✝ (app f'✝ a'✝) (inst B✝ a✝⁷) ∧ IsDefEqU1 env U hasType Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.