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/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
simp only [occursIn] at h1
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) (forall_ x phi)
h2 : Formula.lc_at j (forall_ x phi)
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at j (forall_ x phi)
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) (forall_ x phi)
h2 : Formula.lc_at j (forall_ x phi)
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
simp only [Formula.lc_at] at h2
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at j (forall_ x phi)
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at j (forall_ x phi)
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
simp only [Formula.openList]
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔
Holds D I (V ∘ Var.close j (free_ z)) (forall_ x (Formula.openList (j + 1) [free_ z] phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] (forall_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
simp only [Holds]
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔
Holds D I (V ∘ Var.close j (free_ z)) (forall_ x (Formula.openList (j + 1) [free_ z] phi))
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ (∀ (d : D), Holds D I (shift D V d) phi) ↔
∀ (d : D), Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ Holds D I V (forall_ x phi) ↔
Holds D I (V ∘ Var.close j (free_ z)) (forall_ x (Formula.openList (j + 1) [free_ z] phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
apply forall_congr'
|
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ (∀ (d : D), Holds D I (shift D V d) phi) ↔
∀ (d : D), Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ ∀ (a : D),
Holds D I (shift D V a) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) a) (Formula.openList (j + 1) [free_ z] phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ (∀ (d : D), Holds D I (shift D V d) phi) ↔
∀ (d : D), Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
intro d
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ ∀ (a : D),
Holds D I (shift D V a) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) a) (Formula.openList (j + 1) [free_ z] phi)
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
⊢ ∀ (a : D),
Holds D I (shift D V a) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) a) (Formula.openList (j + 1) [free_ z] phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
specialize phi_ih (shift D V d) (j + 1) h1 h2
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (j : ℕ),
¬occursIn (free_ z) phi →
Formula.lc_at j phi → (Holds D I V phi ↔ Holds D I (V ∘ Var.close j (free_ z)) (Formula.openList j [free_ z] phi))
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
simp only [phi_ih]
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi) ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d) phi ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
congr! 1
|
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi) ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
|
case h.a.h.e'_3
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ shift D V d ∘ Var.close (j + 1) (free_ z) = shift D (V ∘ Var.close j (free_ z)) d
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi) ↔
Holds D I (shift D (V ∘ Var.close j (free_ z)) d) (Formula.openList (j + 1) [free_ z] phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsClose
|
[1129, 1]
|
[1204, 22]
|
apply extracted_1
|
case h.a.h.e'_3
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ shift D V d ∘ Var.close (j + 1) (free_ z) = shift D (V ∘ Var.close j (free_ z)) d
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.h.e'_3
D : Type
I : Interpretation D
z x : String
phi : Formula
V : VarAssignment D
j : ℕ
h1 : ¬occursIn (free_ z) phi
h2 : Formula.lc_at (j + 1) phi
d : D
phi_ih :
Holds D I (shift D V d) phi ↔
Holds D I (shift D V d ∘ Var.close (j + 1) (free_ z)) (Formula.openList (j + 1) [free_ z] phi)
⊢ shift D V d ∘ Var.close (j + 1) (free_ z) = shift D (V ∘ Var.close j (free_ z)) d
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
induction F generalizing j
|
F : Formula
j : ℕ
zs : List String
h1 : lc_at j F
⊢ openList j (List.map free_ zs) F = F
|
case pred_
zs : List String
a✝¹ : String
a✝ : List Var
j : ℕ
h1 : lc_at j (pred_ a✝¹ a✝)
⊢ openList j (List.map free_ zs) (pred_ a✝¹ a✝) = pred_ a✝¹ a✝
case not_
zs : List String
a✝ : Formula
a_ih✝ : ∀ (j : ℕ), lc_at j a✝ → openList j (List.map free_ zs) a✝ = a✝
j : ℕ
h1 : lc_at j a✝.not_
⊢ openList j (List.map free_ zs) a✝.not_ = a✝.not_
case imp_
zs : List String
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (j : ℕ), lc_at j a✝¹ → openList j (List.map free_ zs) a✝¹ = a✝¹
a_ih✝ : ∀ (j : ℕ), lc_at j a✝ → openList j (List.map free_ zs) a✝ = a✝
j : ℕ
h1 : lc_at j (a✝¹.imp_ a✝)
⊢ openList j (List.map free_ zs) (a✝¹.imp_ a✝) = a✝¹.imp_ a✝
case forall_
zs : List String
a✝¹ : String
a✝ : Formula
a_ih✝ : ∀ (j : ℕ), lc_at j a✝ → openList j (List.map free_ zs) a✝ = a✝
j : ℕ
h1 : lc_at j (forall_ a✝¹ a✝)
⊢ openList j (List.map free_ zs) (forall_ a✝¹ a✝) = forall_ a✝¹ a✝
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
j : ℕ
zs : List String
h1 : lc_at j F
⊢ openList j (List.map free_ zs) F = F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case pred_ X vs =>
simp only [Formula.lc_at] at h1
simp only [Formula.openList]
simp
apply List.map_mem_id
intro v a1
specialize h1 v a1
cases v
case _ x =>
simp only [Var.openList]
case _ i =>
cases i
case zero =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
case succ i =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : lc_at j (pred_ X vs)
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
h1 : lc_at j (pred_ X vs)
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case not_ phi phi_ih =>
simp only [Formula.lc_at] at h1
simp only [Formula.openList]
congr!
exact phi_ih j h1
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi.not_
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi.not_
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case forall_ x phi phi_ih =>
simp only [Formula.lc_at] at h1
simp only [Formula.openList]
simp
exact phi_ih (j + 1) h1
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j (forall_ x phi)
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j (forall_ x phi)
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.lc_at] at h1
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : lc_at j (pred_ X vs)
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
h1 : lc_at j (pred_ X vs)
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.openList]
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ pred_ X (List.map (Var.openList j (List.map free_ zs)) vs) = pred_ X vs
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ openList j (List.map free_ zs) (pred_ X vs) = pred_ X vs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ pred_ X (List.map (Var.openList j (List.map free_ zs)) vs) = pred_ X vs
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ List.map (Var.openList j (List.map free_ zs)) vs = vs
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ pred_ X (List.map (Var.openList j (List.map free_ zs)) vs) = pred_ X vs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
apply List.map_mem_id
|
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ List.map (Var.openList j (List.map free_ zs)) vs = vs
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ ∀ x ∈ vs, Var.openList j (List.map free_ zs) x = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ List.map (Var.openList j (List.map free_ zs)) vs = vs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
intro v a1
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ ∀ x ∈ vs, Var.openList j (List.map free_ zs) x = x
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
v : Var
a1 : v ∈ vs
⊢ Var.openList j (List.map free_ zs) v = v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
⊢ ∀ x ∈ vs, Var.openList j (List.map free_ zs) x = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
specialize h1 v a1
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
v : Var
a1 : v ∈ vs
⊢ Var.openList j (List.map free_ zs) v = v
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
v : Var
a1 : v ∈ vs
h1 : Var.lc_at j v
⊢ Var.openList j (List.map free_ zs) v = v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
zs : List String
X : String
vs : List Var
j : ℕ
h1 : ∀ v ∈ vs, Var.lc_at j v
v : Var
a1 : v ∈ vs
⊢ Var.openList j (List.map free_ zs) v = v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
cases v
|
case h1
zs : List String
X : String
vs : List Var
j : ℕ
v : Var
a1 : v ∈ vs
h1 : Var.lc_at j v
⊢ Var.openList j (List.map free_ zs) v = v
|
case h1.free_
zs : List String
X : String
vs : List Var
j : ℕ
a✝ : String
a1 : free_ a✝ ∈ vs
h1 : Var.lc_at j (free_ a✝)
⊢ Var.openList j (List.map free_ zs) (free_ a✝) = free_ a✝
case h1.bound_
zs : List String
X : String
vs : List Var
j a✝ : ℕ
a1 : bound_ a✝ ∈ vs
h1 : Var.lc_at j (bound_ a✝)
⊢ Var.openList j (List.map free_ zs) (bound_ a✝) = bound_ a✝
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
zs : List String
X : String
vs : List Var
j : ℕ
v : Var
a1 : v ∈ vs
h1 : Var.lc_at j v
⊢ Var.openList j (List.map free_ zs) v = v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case _ x =>
simp only [Var.openList]
|
zs : List String
X : String
vs : List Var
j : ℕ
x : String
a1 : free_ x ∈ vs
h1 : Var.lc_at j (free_ x)
⊢ Var.openList j (List.map free_ zs) (free_ x) = free_ x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
x : String
a1 : free_ x ∈ vs
h1 : Var.lc_at j (free_ x)
⊢ Var.openList j (List.map free_ zs) (free_ x) = free_ x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case _ i =>
cases i
case zero =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
case succ i =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ i ∈ vs
h1 : Var.lc_at j (bound_ i)
⊢ Var.openList j (List.map free_ zs) (bound_ i) = bound_ i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ i ∈ vs
h1 : Var.lc_at j (bound_ i)
⊢ Var.openList j (List.map free_ zs) (bound_ i) = bound_ i
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Var.openList]
|
zs : List String
X : String
vs : List Var
j : ℕ
x : String
a1 : free_ x ∈ vs
h1 : Var.lc_at j (free_ x)
⊢ Var.openList j (List.map free_ zs) (free_ x) = free_ x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
x : String
a1 : free_ x ∈ vs
h1 : Var.lc_at j (free_ x)
⊢ Var.openList j (List.map free_ zs) (free_ x) = free_ x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
cases i
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ i ∈ vs
h1 : Var.lc_at j (bound_ i)
⊢ Var.openList j (List.map free_ zs) (bound_ i) = bound_ i
|
case zero
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : Var.lc_at j (bound_ 0)
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
case succ
zs : List String
X : String
vs : List Var
j n✝ : ℕ
a1 : bound_ (n✝ + 1) ∈ vs
h1 : Var.lc_at j (bound_ (n✝ + 1))
⊢ Var.openList j (List.map free_ zs) (bound_ (n✝ + 1)) = bound_ (n✝ + 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ i ∈ vs
h1 : Var.lc_at j (bound_ i)
⊢ Var.openList j (List.map free_ zs) (bound_ i) = bound_ i
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case zero =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : Var.lc_at j (bound_ 0)
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : Var.lc_at j (bound_ 0)
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
case succ i =>
simp only [Var.lc_at] at h1
simp only [Var.openList]
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : Var.lc_at j (bound_ (i + 1))
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : Var.lc_at j (bound_ (i + 1))
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Var.lc_at] at h1
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : Var.lc_at j (bound_ 0)
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : Var.lc_at j (bound_ 0)
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Var.openList]
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ (if 0 < j then bound_ 0
else
if x : 0 - j < (List.map free_ zs).length then (List.map free_ zs)[0 - j]
else bound_ (0 - j - (List.map free_ zs).length + j)) =
bound_ 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ Var.openList j (List.map free_ zs) (bound_ 0) = bound_ 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ (if 0 < j then bound_ 0
else
if x : 0 - j < (List.map free_ zs).length then (List.map free_ zs)[0 - j]
else bound_ (0 - j - (List.map free_ zs).length + j)) =
bound_ 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j : ℕ
a1 : bound_ 0 ∈ vs
h1 : 0 < j
⊢ (if 0 < j then bound_ 0
else
if x : 0 - j < (List.map free_ zs).length then (List.map free_ zs)[0 - j]
else bound_ (0 - j - (List.map free_ zs).length + j)) =
bound_ 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Var.lc_at] at h1
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : Var.lc_at j (bound_ (i + 1))
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : Var.lc_at j (bound_ (i + 1))
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Var.openList]
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ (if i + 1 < j then bound_ (i + 1)
else
if x : i + 1 - j < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - j]
else bound_ (i + 1 - j - (List.map free_ zs).length + j)) =
bound_ (i + 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ Var.openList j (List.map free_ zs) (bound_ (i + 1)) = bound_ (i + 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [if_pos h1]
|
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ (if i + 1 < j then bound_ (i + 1)
else
if x : i + 1 - j < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - j]
else bound_ (i + 1 - j - (List.map free_ zs).length + j)) =
bound_ (i + 1)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
X : String
vs : List Var
j i : ℕ
a1 : bound_ (i + 1) ∈ vs
h1 : i + 1 < j
⊢ (if i + 1 < j then bound_ (i + 1)
else
if x : i + 1 - j < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - j]
else bound_ (i + 1 - j - (List.map free_ zs).length + j)) =
bound_ (i + 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.lc_at] at h1
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi.not_
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi.not_
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.openList]
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ (openList j (List.map free_ zs) phi).not_ = phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
congr!
|
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ (openList j (List.map free_ zs) phi).not_ = phi.not_
|
case h.e'_1
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi = phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ (openList j (List.map free_ zs) phi).not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
exact phi_ih j h1
|
case h.e'_1
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
zs : List String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j phi
⊢ openList j (List.map free_ zs) phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.lc_at] at h1
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j (phi.imp_ psi)
⊢ openList j (List.map free_ zs) (phi.imp_ psi) = phi.imp_ psi
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ openList j (List.map free_ zs) (phi.imp_ psi) = phi.imp_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j (phi.imp_ psi)
⊢ openList j (List.map free_ zs) (phi.imp_ psi) = phi.imp_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.openList]
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ openList j (List.map free_ zs) (phi.imp_ psi) = phi.imp_ psi
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ openList j (List.map free_ zs) (phi.imp_ psi) = phi.imp_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
cases h1
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
|
case intro
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
left✝ : lc_at j phi
right✝ : lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1 : lc_at j phi ∧ lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
congr!
|
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
|
case h.e'_1
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) phi = phi
case h.e'_2
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) psi = psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ (openList j (List.map free_ zs) phi).imp_ (openList j (List.map free_ zs) psi) = phi.imp_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
exact phi_ih j h1_left
|
case h.e'_1
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
exact psi_ih j h1_right
|
case h.e'_2
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) psi = psi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
zs : List String
phi psi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
psi_ih : ∀ (j : ℕ), lc_at j psi → openList j (List.map free_ zs) psi = psi
j : ℕ
h1_left : lc_at j phi
h1_right : lc_at j psi
⊢ openList j (List.map free_ zs) psi = psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.lc_at] at h1
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j (forall_ x phi)
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at j (forall_ x phi)
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp only [Formula.openList]
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ forall_ x (openList (j + 1) (List.map free_ zs) phi) = forall_ x phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList j (List.map free_ zs) (forall_ x phi) = forall_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
simp
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ forall_ x (openList (j + 1) (List.map free_ zs) phi) = forall_ x phi
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList (j + 1) (List.map free_ zs) phi = phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ forall_ x (openList (j + 1) (List.map free_ zs) phi) = forall_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.Formula.OpenListLC
|
[1207, 1]
|
[1256, 28]
|
exact phi_ih (j + 1) h1
|
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList (j + 1) (List.map free_ zs) phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
zs : List String
x : String
phi : Formula
phi_ih : ∀ (j : ℕ), lc_at j phi → openList j (List.map free_ zs) phi = phi
j : ℕ
h1 : lc_at (j + 1) phi
⊢ openList (j + 1) (List.map free_ zs) phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
induction F generalizing j zs
|
F : Formula
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) F) ↔ Formula.lc_at (j + zs.length) F
|
case pred_
a✝¹ : String
a✝ : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (pred_ a✝¹ a✝)) ↔ Formula.lc_at (j + zs.length) (pred_ a✝¹ a✝)
case not_
a✝ : Formula
a_ih✝ :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) a✝) ↔ Formula.lc_at (j + zs.length) a✝
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) a✝.not_) ↔ Formula.lc_at (j + zs.length) a✝.not_
case imp_
a✝¹ a✝ : Formula
a_ih✝¹ :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) a✝¹) ↔ Formula.lc_at (j + zs.length) a✝¹
a_ih✝ :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) a✝) ↔ Formula.lc_at (j + zs.length) a✝
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (a✝¹.imp_ a✝)) ↔ Formula.lc_at (j + zs.length) (a✝¹.imp_ a✝)
case forall_
a✝¹ : String
a✝ : Formula
a_ih✝ :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) a✝) ↔ Formula.lc_at (j + zs.length) a✝
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (forall_ a✝¹ a✝)) ↔
Formula.lc_at (j + zs.length) (forall_ a✝¹ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) F) ↔ Formula.lc_at (j + zs.length) F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case not_ phi phi_ih =>
simp only [Formula.openList]
simp only [Formula.lc_at]
apply phi_ih
|
phi : Formula
phi_ih :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) phi) ↔ Formula.lc_at (j + zs.length) phi
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) phi.not_) ↔ Formula.lc_at (j + zs.length) phi.not_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
phi : Formula
phi_ih :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) phi) ↔ Formula.lc_at (j + zs.length) phi
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) phi.not_) ↔ Formula.lc_at (j + zs.length) phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case forall_ _ phi phi_ih =>
simp only [Formula.openList]
simp only [Formula.lc_at]
simp only [phi_ih]
have s1 : j + 1 + List.length zs = j + List.length zs + 1
linarith;
simp only [s1]
|
a✝ : String
phi : Formula
phi_ih :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) phi) ↔ Formula.lc_at (j + zs.length) phi
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (forall_ a✝ phi)) ↔
Formula.lc_at (j + zs.length) (forall_ a✝ phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
a✝ : String
phi : Formula
phi_ih :
∀ (j : ℕ) (zs : List String),
Formula.lc_at j (Formula.openList j (List.map free_ zs) phi) ↔ Formula.lc_at (j + zs.length) phi
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (forall_ a✝ phi)) ↔
Formula.lc_at (j + zs.length) (forall_ a✝ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Formula.openList]
|
X : String
vs : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (pred_ X vs)) ↔ Formula.lc_at (j + zs.length) (pred_ X vs)
|
X : String
vs : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (pred_ X (List.map (Var.openList j (List.map free_ zs)) vs)) ↔
Formula.lc_at (j + zs.length) (pred_ X vs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (Formula.openList j (List.map free_ zs) (pred_ X vs)) ↔ Formula.lc_at (j + zs.length) (pred_ X vs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Formula.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (pred_ X (List.map (Var.openList j (List.map free_ zs)) vs)) ↔
Formula.lc_at (j + zs.length) (pred_ X vs)
|
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) ↔ ∀ v ∈ vs, Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
⊢ Formula.lc_at j (pred_ X (List.map (Var.openList j (List.map free_ zs)) vs)) ↔
Formula.lc_at (j + zs.length) (pred_ X vs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
constructor
|
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) ↔ ∀ v ∈ vs, Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) → ∀ v ∈ vs, Var.lc_at (j + zs.length) v
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ vs, Var.lc_at (j + zs.length) v) → ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) ↔ ∀ v ∈ vs, Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
intro a1 v a2
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) → ∀ v ∈ vs, Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
v : Var
a2 : v ∈ vs
⊢ Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v) → ∀ v ∈ vs, Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
specialize a1 (Var.openList j (List.map free_ zs) v)
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
v : Var
a2 : v ∈ vs
⊢ Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v ∈ List.map (Var.openList j (List.map free_ zs)) vs →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
v : Var
a2 : v ∈ vs
⊢ Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at a1
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v ∈ List.map (Var.openList j (List.map free_ zs)) vs →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
∀ x ∈ vs,
Var.openList j (List.map free_ zs) x = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v ∈ List.map (Var.openList j (List.map free_ zs)) vs →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
specialize a1 v a2
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
∀ x ∈ vs,
Var.openList j (List.map free_ zs) x = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
∀ x ∈ vs,
Var.openList j (List.map free_ zs) x = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at a1
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 :
Var.openList j (List.map free_ zs) v = Var.openList j (List.map free_ zs) v →
Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
cases v
|
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
|
case mp.free_
X : String
vs : List Var
j : ℕ
zs : List String
a✝ : String
a2 : free_ a✝ ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (free_ a✝))
⊢ Var.lc_at (j + zs.length) (free_ a✝)
case mp.bound_
X : String
vs : List Var
j : ℕ
zs : List String
a✝ : ℕ
a2 : bound_ a✝ ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ a✝))
⊢ Var.lc_at (j + zs.length) (bound_ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
X : String
vs : List Var
j : ℕ
zs : List String
v : Var
a2 : v ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) v)
⊢ Var.lc_at (j + zs.length) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ x =>
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
x : String
a2 : free_ x ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (free_ x))
⊢ Var.lc_at (j + zs.length) (free_ x)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
x : String
a2 : free_ x ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (free_ x))
⊢ Var.lc_at (j + zs.length) (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ i =>
simp only [Var.lc_at]
simp only [Var.openList] at a1
split at a1
case _ c1 =>
linarith
case _ c1 =>
split at a1
case _ c2 =>
simp at c2
exact lt_add_of_tsub_lt_left c2
case _ c2 =>
simp only [Var.lc_at] at a1
simp at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ Var.lc_at (j + zs.length) (bound_ i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ Var.lc_at (j + zs.length) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
x : String
a2 : free_ x ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (free_ x))
⊢ Var.lc_at (j + zs.length) (free_ x)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
x : String
a2 : free_ x ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (free_ x))
⊢ Var.lc_at (j + zs.length) (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ Var.lc_at (j + zs.length) (bound_ i)
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ Var.lc_at (j + zs.length) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.openList] at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ i < j + zs.length
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 :
Var.lc_at j
(if i < j then bound_ i
else
if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 : Var.lc_at j (Var.openList j (List.map free_ zs) (bound_ i))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
split at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 :
Var.lc_at j
(if i < j then bound_ i
else
if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
case inl
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
h✝ : i < j
a1 : Var.lc_at j (bound_ i)
⊢ i < j + zs.length
case inr
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
h✝ : ¬i < j
a1 :
Var.lc_at j
(if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
a1 :
Var.lc_at j
(if i < j then bound_ i
else
if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c1 =>
linarith
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : i < j
a1 : Var.lc_at j (bound_ i)
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : i < j
a1 : Var.lc_at j (bound_ i)
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c1 =>
split at a1
case _ c2 =>
simp at c2
exact lt_add_of_tsub_lt_left c2
case _ c2 =>
simp only [Var.lc_at] at a1
simp at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
a1 :
Var.lc_at j
(if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
a1 :
Var.lc_at j
(if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
linarith
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : i < j
a1 : Var.lc_at j (bound_ i)
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : i < j
a1 : Var.lc_at j (bound_ i)
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
split at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
a1 :
Var.lc_at j
(if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
case inl
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
h✝ : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
⊢ i < j + zs.length
case inr
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
h✝ : ¬i - j < (List.map free_ zs).length
a1 : Var.lc_at j (bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
a1 :
Var.lc_at j
(if x : i - j < (List.map free_ zs).length then (List.map free_ zs)[i - j]
else bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c2 =>
simp at c2
exact lt_add_of_tsub_lt_left c2
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c2 =>
simp only [Var.lc_at] at a1
simp at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : Var.lc_at j (bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : Var.lc_at j (bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at c2
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
⊢ i < j + zs.length
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2✝ : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
c2 : i - j < zs.length
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
exact lt_add_of_tsub_lt_left c2
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2✝ : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
c2 : i - j < zs.length
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2✝ : i - j < (List.map free_ zs).length
a1 : Var.lc_at j (List.map free_ zs)[i - j]
c2 : i - j < zs.length
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at] at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : Var.lc_at j (bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : i - j - (List.map free_ zs).length + j < j
⊢ i < j + zs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : Var.lc_at j (bound_ (i - j - (List.map free_ zs).length + j))
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : i - j - (List.map free_ zs).length + j < j
⊢ i < j + zs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a2 : bound_ i ∈ vs
c1 : ¬i < j
c2 : ¬i - j < (List.map free_ zs).length
a1 : i - j - (List.map free_ zs).length + j < j
⊢ i < j + zs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
intro a1 v a2
|
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ vs, Var.lc_at (j + zs.length) v) → ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
|
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
v : Var
a2 : v ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
⊢ (∀ v ∈ vs, Var.lc_at (j + zs.length) v) → ∀ v ∈ List.map (Var.openList j (List.map free_ zs)) vs, Var.lc_at j v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
cases v
|
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
v : Var
a2 : v ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j v
|
case mpr.free_
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
a✝ : String
a2 : free_ a✝ ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (free_ a✝)
case mpr.bound_
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
a✝ : ℕ
a2 : bound_ a✝ ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (bound_ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
v : Var
a2 : v ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ x =>
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
x : String
a2 : free_ x ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (free_ x)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
x : String
a2 : free_ x ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ i =>
simp only [Var.lc_at]
simp at a2
apply Exists.elim a2
intro z a3
clear a2
cases a3
case _ a3_left a3_right =>
specialize a1 z a3_left
cases z
case _ x =>
simp only [Var.openList] at a3_right
case _ i' =>
simp only [Var.lc_at] at a1
simp only [Var.openList] at a3_right
split at a3_right
case _ c1 =>
simp at a3_right
subst a3_right
exact c1
case _ c1 =>
simp at c1
simp at a3_right
split at a3_right
case _ c2 =>
contradiction
case _ c2 =>
exfalso
apply c2
exact Nat.sub_lt_left_of_lt_add c1 a1
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (bound_ i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
x : String
a2 : free_ x ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (free_ x)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
x : String
a2 : free_ x ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at]
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (bound_ i)
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ Var.lc_at j (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at a2
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : bound_ i ∈ List.map (Var.openList j (List.map free_ zs)) vs
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
apply Exists.elim a2
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ ∀ (a : Var), a ∈ vs ∧ Var.openList j (List.map free_ zs) a = bound_ i → i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
intro z a3
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ ∀ (a : Var), a ∈ vs ∧ Var.openList j (List.map free_ zs) a = bound_ i → i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
⊢ ∀ (a : Var), a ∈ vs ∧ Var.openList j (List.map free_ zs) a = bound_ i → i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
clear a2
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
a2 : ∃ a ∈ vs, Var.openList j (List.map free_ zs) a = bound_ i
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
cases a3
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
case intro
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
left✝ : z ∈ vs
right✝ : Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3 : z ∈ vs ∧ Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ a3_left a3_right =>
specialize a1 z a3_left
cases z
case _ x =>
simp only [Var.openList] at a3_right
case _ i' =>
simp only [Var.lc_at] at a1
simp only [Var.openList] at a3_right
split at a3_right
case _ c1 =>
simp at a3_right
subst a3_right
exact c1
case _ c1 =>
simp at c1
simp at a3_right
split at a3_right
case _ c2 =>
contradiction
case _ c2 =>
exfalso
apply c2
exact Nat.sub_lt_left_of_lt_add c1 a1
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
specialize a1 z a3_left
|
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
a1 : Var.lc_at (j + zs.length) z
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
a1 : ∀ v ∈ vs, Var.lc_at (j + zs.length) v
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
cases z
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
a1 : Var.lc_at (j + zs.length) z
⊢ i < j
|
case free_
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
a✝ : String
a3_left : free_ a✝ ∈ vs
a3_right : Var.openList j (List.map free_ zs) (free_ a✝) = bound_ i
a1 : Var.lc_at (j + zs.length) (free_ a✝)
⊢ i < j
case bound_
X : String
vs : List Var
j : ℕ
zs : List String
i a✝ : ℕ
a3_left : bound_ a✝ ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ a✝) = bound_ i
a1 : Var.lc_at (j + zs.length) (bound_ a✝)
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
z : Var
a3_left : z ∈ vs
a3_right : Var.openList j (List.map free_ zs) z = bound_ i
a1 : Var.lc_at (j + zs.length) z
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ x =>
simp only [Var.openList] at a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
x : String
a3_left : free_ x ∈ vs
a3_right : Var.openList j (List.map free_ zs) (free_ x) = bound_ i
a1 : Var.lc_at (j + zs.length) (free_ x)
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
x : String
a3_left : free_ x ∈ vs
a3_right : Var.openList j (List.map free_ zs) (free_ x) = bound_ i
a1 : Var.lc_at (j + zs.length) (free_ x)
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ i' =>
simp only [Var.lc_at] at a1
simp only [Var.openList] at a3_right
split at a3_right
case _ c1 =>
simp at a3_right
subst a3_right
exact c1
case _ c1 =>
simp at c1
simp at a3_right
split at a3_right
case _ c2 =>
contradiction
case _ c2 =>
exfalso
apply c2
exact Nat.sub_lt_left_of_lt_add c1 a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : Var.lc_at (j + zs.length) (bound_ i')
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : Var.lc_at (j + zs.length) (bound_ i')
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.openList] at a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
x : String
a3_left : free_ x ∈ vs
a3_right : Var.openList j (List.map free_ zs) (free_ x) = bound_ i
a1 : Var.lc_at (j + zs.length) (free_ x)
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i : ℕ
x : String
a3_left : free_ x ∈ vs
a3_right : Var.openList j (List.map free_ zs) (free_ x) = bound_ i
a1 : Var.lc_at (j + zs.length) (free_ x)
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.lc_at] at a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : Var.lc_at (j + zs.length) (bound_ i')
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : i' < j + zs.length
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : Var.lc_at (j + zs.length) (bound_ i')
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp only [Var.openList] at a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : i' < j + zs.length
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
a3_right :
(if i' < j then bound_ i'
else
if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a3_right : Var.openList j (List.map free_ zs) (bound_ i') = bound_ i
a1 : i' < j + zs.length
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
split at a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
a3_right :
(if i' < j then bound_ i'
else
if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
|
case inl
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
h✝ : i' < j
a3_right : bound_ i' = bound_ i
⊢ i < j
case inr
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
h✝ : ¬i' < j
a3_right :
(if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
a3_right :
(if i' < j then bound_ i'
else
if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c1 =>
simp at a3_right
subst a3_right
exact c1
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : bound_ i' = bound_ i
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : bound_ i' = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
case _ c1 =>
simp at c1
simp at a3_right
split at a3_right
case _ c2 =>
contradiction
case _ c2 =>
exfalso
apply c2
exact Nat.sub_lt_left_of_lt_add c1 a1
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : ¬i' < j
a3_right :
(if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : ¬i' < j
a3_right :
(if x : i' - j < (List.map free_ zs).length then (List.map free_ zs)[i' - j]
else bound_ (i' - j - (List.map free_ zs).length + j)) =
bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
simp at a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : bound_ i' = bound_ i
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : i' = i
⊢ i < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : bound_ i' = bound_ i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
subst a3_right
|
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : i' = i
⊢ i < j
|
X : String
vs : List Var
j : ℕ
zs : List String
i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
⊢ i' < j
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
a3_right : i' = i
⊢ i < j
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_instantiate
|
[1259, 1]
|
[1342, 19]
|
exact c1
|
X : String
vs : List Var
j : ℕ
zs : List String
i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
⊢ i' < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
X : String
vs : List Var
j : ℕ
zs : List String
i' : ℕ
a3_left : bound_ i' ∈ vs
a1 : i' < j + zs.length
c1 : i' < j
⊢ i' < j
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.