pkuAI4M/lean_github · Datasets at Hugging Face

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/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs)	D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs)	Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	split_ifs	D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs)	case pos D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition h✝ : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q case neg D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition h✝ : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)	Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	apply Holds_coincide_PredVar	D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q	case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)	Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp	case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp only [predVarOccursIn_iff_mem_predVarSet]	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp only [hd.h2]	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	apply Holds_coincide_PredVar	D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)	case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)	Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp	case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp only [predVarOccursIn]	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux	[109, 1]	[238, 15]	simp	case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem	[241, 1]	[266, 8]	apply substitution_theorem_aux D I V V E τ ∅ F	D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F)	case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x	Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem	[241, 1]	[266, 8]	simp only [admits] at h1	case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F	case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F	Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem	[241, 1]	[266, 8]	exact h1	case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem	[241, 1]	[266, 8]	intro X _	case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x	case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_theorem	[241, 1]	[266, 8]	rfl	case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	simp only [IsValid] at h2	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : F.IsValid ⊢ (replace τ F).IsValid	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : F.IsValid ⊢ (replace τ F).IsValid TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	simp only [IsValid]	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F)	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	intro D I V E	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F)	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F)	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	obtain s1 := substitution_theorem D I V E τ F h1	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F)	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F)	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	simp only [← s1]	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F)	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Sub.lean	FOL.NV.Sub.Pred.All.Rec.substitution_is_valid	[269, 1]	[282, 11]	apply h2	F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F	no goals	Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	induction F	v : VarName F : Formula ⊢ occursIn v F ↔ v ∈ F.varSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ occursIn v F ↔ v ∈ F.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	all_goals simp only [occursIn] simp only [Formula.varSet]	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case eq_ v a✝¹ a✝ : VarName ⊢ v = a✝¹ ∨ v = a✝ ↔ v ∈ {a✝¹, a✝} case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝ ↔ v ∈ a✝.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ v = a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝.varSet ∪ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ v = a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝.varSet ∪ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset	Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case pred_const_ X xs \| pred_var_ X xs \| def_ X xs => simp	v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case eq_ x y => simp	v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case true_ \| false_ => tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case not_ phi phi_ih => tauto	v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case imp_ phi psi phi_ih psi_ih \| and_ phi psi phi_ih psi_ih \| or_ phi psi phi_ih psi_ih \| iff_ phi psi phi_ih psi_ih => simp tauto	v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	case forall_ x phi phi_ih \| exists_ x phi phi_ih => simp tauto	v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp only [occursIn]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp only [Formula.varSet]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp	v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp	v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	tauto	v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp	v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet	v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	tauto	v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	simp	v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x}	v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.occursIn_iff_mem_varSet	[295, 1]	[321, 10]	tauto	v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	induction F	v : VarName F : Formula ⊢ isBoundIn v F ↔ v ∈ F.boundVarSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ isBoundIn v F ↔ v ∈ F.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	all_goals simp only [isBoundIn] simp only [Formula.boundVarSet]	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ False ↔ v ∈ ∅ case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ False ↔ v ∈ ∅ case eq_ v a✝¹ a✝ : VarName ⊢ False ↔ v ∈ ∅ case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ v = a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ∪ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ v = a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ∪ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ ∅	Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case pred_const_ X xs \| pred_var_ X xs \| def_ X xs => simp	v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case eq_ x y => simp	v x y : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case true_ \| false_ => tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case not_ phi phi_ih => tauto	v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case imp_ phi psi phi_ih psi_ih \| and_ phi psi phi_ih psi_ih \| or_ phi psi phi_ih psi_ih \| iff_ phi psi phi_ih psi_ih => simp tauto	v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	case forall_ x phi phi_ih \| exists_ x phi phi_ih => simp tauto	v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp only [isBoundIn]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp only [Formula.boundVarSet]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ ∅	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp	v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp	v x y : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	tauto	v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp	v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet	v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	tauto	v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	simp	v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x}	v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isBoundIn_iff_mem_boundVarSet	[324, 1]	[350, 10]	tauto	v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	induction F	v : VarName F : Formula ⊢ isFreeIn v F ↔ v ∈ F.freeVarSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ isFreeIn v F ↔ v ∈ F.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	all_goals simp only [isFreeIn] simp only [Formula.freeVarSet]	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case eq_ v a✝¹ a✝ : VarName ⊢ v = a✝¹ ∨ v = a✝ ↔ v ∈ {a✝¹, a✝} case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ ¬v = a✝¹ ∧ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet \ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ ¬v = a✝¹ ∧ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet \ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset	Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case pred_const_ X xs \| pred_var_ X xs \| def_ X xs => simp	v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case eq_ x y => simp	v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case true_ \| false_ => tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case not_ phi phi_ih => tauto	v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case imp_ phi psi phi_ih psi_ih \| and_ phi psi phi_ih psi_ih \| or_ phi psi phi_ih psi_ih \| iff_ phi psi phi_ih psi_ih => simp tauto	v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	case forall_ x phi phi_ih \| exists_ x phi phi_ih => simp tauto	v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp only [isFreeIn]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp only [Formula.freeVarSet]	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet	case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp	v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp	v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	tauto	v : VarName ⊢ False ↔ v ∈ ∅	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	tauto	v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp	v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet	v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	tauto	v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	simp	v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x}	v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_iff_mem_freeVarSet	[353, 1]	[379, 10]	tauto	v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	induction F	v : VarName F : Formula h1 : isFreeIn v F ⊢ isFreeInInd v F	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)	Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula h1 : isFreeIn v F ⊢ isFreeInInd v F TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	any_goals simp only [isFreeIn] at h1	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)	case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : v = a✝¹ ∨ v = a✝ ⊢ isFreeInInd v (eq_ a✝¹ a✝) case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : ¬v = a✝¹ ∧ isFreeIn v a✝ ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : ¬v = a✝¹ ∧ isFreeIn v a✝ ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (def_ a✝¹ a✝)	Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	case pred_const_ X xs \| pred_var_ X xs \| eq_ x y \| def_ X xs => first \| exact isFreeInInd.pred_const_ X xs h1 \| exact isFreeInInd.pred_var_ X xs h1 \| exact isFreeInInd.eq_ x y h1 \| exact isFreeInInd.def_ X xs h1	v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	case not_ phi phi_ih => apply isFreeInInd.not_ exact phi_ih h1	v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	case imp_ phi psi phi_ih psi_ih \| and_ phi psi phi_ih psi_ih \| or_ phi psi phi_ih psi_ih \| iff_ phi psi phi_ih psi_ih => cases h1 case inl c1 => first \| apply isFreeInInd.imp_left_ \| apply isFreeInInd.and_left_ \| apply isFreeInInd.or_left_ \| apply isFreeInInd.iff_left_ exact phi_ih c1 case inr c1 => first \| apply isFreeInInd.imp_right_ \| apply isFreeInInd.and_right_ \| apply isFreeInInd.or_right_ \| apply isFreeInInd.iff_right_ exact psi_ih c1	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	simp only [isFreeIn] at h1	case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)	case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (def_ a✝¹ a✝)	Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	first \| exact isFreeInInd.pred_const_ X xs h1 \| exact isFreeInInd.pred_var_ X xs h1 \| exact isFreeInInd.eq_ x y h1 \| exact isFreeInInd.def_ X xs h1	v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact isFreeInInd.pred_const_ X xs h1	v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_const_ X xs)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_const_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact isFreeInInd.pred_var_ X xs h1	v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_var_ X xs)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact isFreeInInd.eq_ x y h1	v x y : VarName h1 : v = x ∨ v = y ⊢ isFreeInInd v (eq_ x y)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName h1 : v = x ∨ v = y ⊢ isFreeInInd v (eq_ x y) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact isFreeInInd.def_ X xs h1	v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	apply isFreeInInd.not_	v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_	case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_ TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact phi_ih h1	case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	cases h1	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)	case inl v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h✝ : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) case inr v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h✝ : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	case inl c1 => first \| apply isFreeInInd.imp_left_ \| apply isFreeInInd.and_left_ \| apply isFreeInInd.or_left_ \| apply isFreeInInd.iff_left_ exact phi_ih c1	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	case inr c1 => first \| apply isFreeInInd.imp_right_ \| apply isFreeInInd.and_right_ \| apply isFreeInInd.or_right_ \| apply isFreeInInd.iff_right_ exact psi_ih c1	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)	no goals	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	first \| apply isFreeInInd.imp_left_ \| apply isFreeInInd.and_left_ \| apply isFreeInInd.or_left_ \| apply isFreeInInd.iff_left_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact phi_ih c1	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	apply isFreeInInd.imp_left_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.imp_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.imp_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	apply isFreeInInd.and_left_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.and_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.and_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	apply isFreeInInd.or_left_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.or_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.or_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	apply isFreeInInd.iff_left_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	first \| apply isFreeInInd.imp_right_ \| apply isFreeInInd.and_right_ \| apply isFreeInInd.or_right_ \| apply isFreeInInd.iff_right_	v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi	Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Binders.lean	FOL.NV.isFreeIn_imp_isFreeInInd	[382, 1]	[413, 30]	exact psi_ih c1	case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs)

D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs)

Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

split_ifs

D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs)

case pos D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition h✝ : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q case neg D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition h✝ : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)

Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition ⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs)) ↔ if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q else Holds D I V tl (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

apply Holds_coincide_PredVar

D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q

case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp

case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp only [predVarOccursIn_iff_mem_predVarSet]

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp only [hd.h2]

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ hd.q.predVarSet → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : X = hd.name ∧ xs.length = hd.args.length ⊢ ∀ (P : PredName) (ds : List D), (P, ds.length) ∈ ∅ → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

apply Holds_coincide_PredVar

D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)

case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp

case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_const_ = I.pred_const_ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp only [predVarOccursIn]

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → ({ nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V' (τ X ds.length).1 ds) (hd :: tl) (τ X ds.length).2 else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux

[109, 1]

[238, 15]

simp

case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V' : VarAssignment D τ : PredName → ℕ → List VarName × Formula X : DefName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (def_ X xs) h2 : ∀ x ∉ binders, V x = V' x hd : Definition tl : List Definition c1 : ¬(X = hd.name ∧ xs.length = hd.args.length) ⊢ ∀ (P : PredName) (ds : List D), False → ((if ds.length = (τ P ds.length).1.length then Holds D I (Function.updateListITE V' (τ P ds.length).1 ds) (hd :: tl) (τ P ds.length).2 else I.pred_var_ P ds) ↔ I.pred_var_ P ds) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem

[241, 1]

[266, 8]

apply substitution_theorem_aux D I V V E τ ∅ F

D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F)

case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x

Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem

[241, 1]

[266, 8]

simp only [admits] at h1

case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F

case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F

Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ admitsAux τ ∅ F TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem

[241, 1]

[266, 8]

exact h1

case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h1 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admitsAux τ ∅ F ⊢ admitsAux τ ∅ F TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem

[241, 1]

[266, 8]

intro X _

case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x

case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F ⊢ ∀ x ∉ ∅, V x = V x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_theorem

[241, 1]

[266, 8]

rfl

case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h2 D : Type I : Interpretation D V : VarAssignment D E : Env τ : PredName → ℕ → List VarName × Formula F : Formula h1 : admits τ F X : VarName a✝ : X ∉ ∅ ⊢ V X = V X TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

simp only [IsValid] at h2

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : F.IsValid ⊢ (replace τ F).IsValid

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : F.IsValid ⊢ (replace τ F).IsValid TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

simp only [IsValid]

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F)

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ (replace τ F).IsValid TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

intro D I V E

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F)

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F)

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F ⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (replace τ F) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

obtain s1 := substitution_theorem D I V E τ F h1

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F)

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F)

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env ⊢ Holds D I V E (replace τ F) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

simp only [← s1]

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F)

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D I V E (replace τ F) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Sub/Pred/All/Rec/Sub.lean

FOL.NV.Sub.Pred.All.Rec.substitution_is_valid

[269, 1]

[282, 11]

apply h2

F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F

no goals

Please generate a tactic in lean4 to solve the state. STATE: F : Formula τ : PredName → ℕ → List VarName × Formula h1 : admits τ F h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F D : Type I : Interpretation D V : VarAssignment D E : Env s1 : Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let zs := (τ X ds.length).1; let H := (τ X ds.length).2; if ds.length = zs.length then Holds D I (Function.updateListITE V zs ds) E H else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace τ F) ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if ds.length = (τ X ds.length).1.length then Holds D I (Function.updateListITE V (τ X ds.length).1 ds) E (τ X ds.length).2 else I.pred_var_ X ds } V E F TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

induction F

v : VarName F : Formula ⊢ occursIn v F ↔ v ∈ F.varSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ occursIn v F ↔ v ∈ F.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

all_goals simp only [occursIn] simp only [Formula.varSet]

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case eq_ v a✝¹ a✝ : VarName ⊢ v = a✝¹ ∨ v = a✝ ↔ v ∈ {a✝¹, a✝} case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝ ↔ v ∈ a✝.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝¹.varSet ∪ a✝.varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ v = a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝.varSet ∪ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ v = a✝¹ ∨ occursIn v a✝ ↔ v ∈ a✝.varSet ∪ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset

Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).varSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ occursIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).varSet case eq_ v a✝¹ a✝ : VarName ⊢ occursIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).varSet case true_ v : VarName ⊢ occursIn v true_ ↔ v ∈ true_.varSet case false_ v : VarName ⊢ occursIn v false_ ↔ v ∈ false_.varSet case not_ v : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v a✝.not_ ↔ v ∈ a✝.not_.varSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).varSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).varSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).varSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : occursIn v a✝¹ ↔ v ∈ a✝¹.varSet a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).varSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).varSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : occursIn v a✝ ↔ v ∈ a✝.varSet ⊢ occursIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).varSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case pred_const_ X xs | pred_var_ X xs | def_ X xs => simp

v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case eq_ x y => simp

v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case true_ | false_ => tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case not_ phi phi_ih => tauto

v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case imp_ phi psi phi_ih psi_ih | and_ phi psi phi_ih psi_ih | or_ phi psi phi_ih psi_ih | iff_ phi psi phi_ih psi_ih => simp tauto

v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

case forall_ x phi phi_ih | exists_ x phi phi_ih => simp tauto

v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp only [occursIn]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ occursIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp only [Formula.varSet]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp

v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp

v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

tauto

v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ occursIn v phi ↔ v ∈ phi.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp

v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet

v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∪ psi.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

tauto

v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet psi_ih : occursIn v psi ↔ v ∈ psi.varSet ⊢ occursIn v phi ∨ occursIn v psi ↔ v ∈ phi.varSet ∨ v ∈ psi.varSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

simp

v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x}

v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∪ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.occursIn_iff_mem_varSet

[295, 1]

[321, 10]

tauto

v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : occursIn v phi ↔ v ∈ phi.varSet ⊢ v = x ∨ occursIn v phi ↔ v ∈ phi.varSet ∨ v = x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

induction F

v : VarName F : Formula ⊢ isBoundIn v F ↔ v ∈ F.boundVarSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ isBoundIn v F ↔ v ∈ F.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

all_goals simp only [isBoundIn] simp only [Formula.boundVarSet]

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ False ↔ v ∈ ∅ case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ False ↔ v ∈ ∅ case eq_ v a✝¹ a✝ : VarName ⊢ False ↔ v ∈ ∅ case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝¹.boundVarSet ∪ a✝.boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ v = a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ∪ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ v = a✝¹ ∨ isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ∪ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ ∅

Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).boundVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isBoundIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).boundVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isBoundIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).boundVarSet case true_ v : VarName ⊢ isBoundIn v true_ ↔ v ∈ true_.boundVarSet case false_ v : VarName ⊢ isBoundIn v false_ ↔ v ∈ false_.boundVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v a✝.not_ ↔ v ∈ a✝.not_.boundVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).boundVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).boundVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).boundVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isBoundIn v a✝¹ ↔ v ∈ a✝¹.boundVarSet a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).boundVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).boundVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isBoundIn v a✝ ↔ v ∈ a✝.boundVarSet ⊢ isBoundIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).boundVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case pred_const_ X xs | pred_var_ X xs | def_ X xs => simp

v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case eq_ x y => simp

v x y : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case true_ | false_ => tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case not_ phi phi_ih => tauto

v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case imp_ phi psi phi_ih psi_ih | and_ phi psi phi_ih psi_ih | or_ phi psi phi_ih psi_ih | iff_ phi psi phi_ih psi_ih => simp tauto

v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

case forall_ x phi phi_ih | exists_ x phi phi_ih => simp tauto

v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp only [isBoundIn]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isBoundIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp only [Formula.boundVarSet]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ ∅

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ False ↔ v ∈ (def_ a✝¹ a✝).boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp

v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp

v x y : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

tauto

v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ isBoundIn v phi ↔ v ∈ phi.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp

v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet

v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∪ psi.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

tauto

v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet psi_ih : isBoundIn v psi ↔ v ∈ psi.boundVarSet ⊢ isBoundIn v phi ∨ isBoundIn v psi ↔ v ∈ phi.boundVarSet ∨ v ∈ psi.boundVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

simp

v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x}

v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∪ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isBoundIn_iff_mem_boundVarSet

[324, 1]

[350, 10]

tauto

v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isBoundIn v phi ↔ v ∈ phi.boundVarSet ⊢ v = x ∨ isBoundIn v phi ↔ v ∈ phi.boundVarSet ∨ v = x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

induction F

v : VarName F : Formula ⊢ isFreeIn v F ↔ v ∈ F.freeVarSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula ⊢ isFreeIn v F ↔ v ∈ F.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

all_goals simp only [isFreeIn] simp only [Formula.freeVarSet]

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset case eq_ v a✝¹ a✝ : VarName ⊢ v = a✝¹ ∨ v = a✝ ↔ v ∈ {a✝¹, a✝} case true_ v : VarName ⊢ False ↔ v ∈ ∅ case false_ v : VarName ⊢ False ↔ v ∈ ∅ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝¹ ∨ isFreeIn v a✝ ↔ v ∈ a✝¹.freeVarSet ∪ a✝.freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ ¬v = a✝¹ ∧ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet \ {a✝¹} case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ ¬v = a✝¹ ∧ isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet \ {a✝¹} case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset

Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_const_ a✝¹ a✝) ↔ v ∈ (pred_const_ a✝¹ a✝).freeVarSet case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName ⊢ isFreeIn v (pred_var_ a✝¹ a✝) ↔ v ∈ (pred_var_ a✝¹ a✝).freeVarSet case eq_ v a✝¹ a✝ : VarName ⊢ isFreeIn v (eq_ a✝¹ a✝) ↔ v ∈ (eq_ a✝¹ a✝).freeVarSet case true_ v : VarName ⊢ isFreeIn v true_ ↔ v ∈ true_.freeVarSet case false_ v : VarName ⊢ isFreeIn v false_ ↔ v ∈ false_.freeVarSet case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v a✝.not_ ↔ v ∈ a✝.not_.freeVarSet case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.imp_ a✝) ↔ v ∈ (a✝¹.imp_ a✝).freeVarSet case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.and_ a✝) ↔ v ∈ (a✝¹.and_ a✝).freeVarSet case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.or_ a✝) ↔ v ∈ (a✝¹.or_ a✝).freeVarSet case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ ↔ v ∈ a✝¹.freeVarSet a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (a✝¹.iff_ a✝) ↔ v ∈ (a✝¹.iff_ a✝).freeVarSet case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (forall_ a✝¹ a✝) ↔ v ∈ (forall_ a✝¹ a✝).freeVarSet case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ ↔ v ∈ a✝.freeVarSet ⊢ isFreeIn v (exists_ a✝¹ a✝) ↔ v ∈ (exists_ a✝¹ a✝).freeVarSet case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case pred_const_ X xs | pred_var_ X xs | def_ X xs => simp

v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case eq_ x y => simp

v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case true_ | false_ => tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case not_ phi phi_ih => tauto

v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case imp_ phi psi phi_ih psi_ih | and_ phi psi phi_ih psi_ih | or_ phi psi phi_ih psi_ih | iff_ phi psi phi_ih psi_ih => simp tauto

v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

case forall_ x phi phi_ih | exists_ x phi phi_ih => simp tauto

v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp only [isFreeIn]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ isFreeIn v (def_ a✝¹ a✝) ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp only [Formula.freeVarSet]

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet

case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ a✝.toFinset

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName ⊢ v ∈ a✝ ↔ v ∈ (def_ a✝¹ a✝).freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp

v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName ⊢ v ∈ xs ↔ v ∈ xs.toFinset TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp

v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y}

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName ⊢ v = x ∨ v = y ↔ v ∈ {x, y} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

tauto

v : VarName ⊢ False ↔ v ∈ ∅

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName ⊢ False ↔ v ∈ ∅ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

tauto

v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ isFreeIn v phi ↔ v ∈ phi.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp

v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet

v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∪ psi.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

tauto

v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet psi_ih : isFreeIn v psi ↔ v ∈ psi.freeVarSet ⊢ isFreeIn v phi ∨ isFreeIn v psi ↔ v ∈ phi.freeVarSet ∨ v ∈ psi.freeVarSet TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

simp

v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x}

v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet \ {x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_iff_mem_freeVarSet

[353, 1]

[379, 10]

tauto

v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x : VarName phi : Formula phi_ih : isFreeIn v phi ↔ v ∈ phi.freeVarSet ⊢ ¬v = x ∧ isFreeIn v phi ↔ v ∈ phi.freeVarSet ∧ ¬v = x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

induction F

v : VarName F : Formula h1 : isFreeIn v F ⊢ isFreeInInd v F

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)

Please generate a tactic in lean4 to solve the state. STATE: v : VarName F : Formula h1 : isFreeIn v F ⊢ isFreeInInd v F TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

any_goals simp only [isFreeIn] at h1

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)

case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : v = a✝¹ ∨ v = a✝ ⊢ isFreeInInd v (eq_ a✝¹ a✝) case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝¹ ∨ isFreeIn v a✝ ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : ¬v = a✝¹ ∧ isFreeIn v a✝ ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : ¬v = a✝¹ ∧ isFreeIn v a✝ ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (def_ a✝¹ a✝)

Please generate a tactic in lean4 to solve the state. STATE: case pred_const_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_const_ a✝¹ a✝) ⊢ isFreeInInd v (pred_const_ a✝¹ a✝) case pred_var_ v : VarName a✝¹ : PredName a✝ : List VarName h1 : isFreeIn v (pred_var_ a✝¹ a✝) ⊢ isFreeInInd v (pred_var_ a✝¹ a✝) case eq_ v a✝¹ a✝ : VarName h1 : isFreeIn v (eq_ a✝¹ a✝) ⊢ isFreeInInd v (eq_ a✝¹ a✝) case true_ v : VarName h1 : isFreeIn v true_ ⊢ isFreeInInd v true_ case false_ v : VarName h1 : isFreeIn v false_ ⊢ isFreeInInd v false_ case not_ v : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v a✝.not_ ⊢ isFreeInInd v a✝.not_ case imp_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.imp_ a✝) ⊢ isFreeInInd v (a✝¹.imp_ a✝) case and_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.and_ a✝) ⊢ isFreeInInd v (a✝¹.and_ a✝) case or_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.or_ a✝) ⊢ isFreeInInd v (a✝¹.or_ a✝) case iff_ v : VarName a✝¹ a✝ : Formula a_ih✝¹ : isFreeIn v a✝¹ → isFreeInInd v a✝¹ a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (a✝¹.iff_ a✝) ⊢ isFreeInInd v (a✝¹.iff_ a✝) case forall_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (forall_ a✝¹ a✝) ⊢ isFreeInInd v (forall_ a✝¹ a✝) case exists_ v a✝¹ : VarName a✝ : Formula a_ih✝ : isFreeIn v a✝ → isFreeInInd v a✝ h1 : isFreeIn v (exists_ a✝¹ a✝) ⊢ isFreeInInd v (exists_ a✝¹ a✝) case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

case not_ phi phi_ih => apply isFreeInInd.not_ exact phi_ih h1

v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

simp only [isFreeIn] at h1

case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝)

case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : v ∈ a✝ ⊢ isFreeInInd v (def_ a✝¹ a✝)

Please generate a tactic in lean4 to solve the state. STATE: case def_ v : VarName a✝¹ : DefName a✝ : List VarName h1 : isFreeIn v (def_ a✝¹ a✝) ⊢ isFreeInInd v (def_ a✝¹ a✝) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

first | exact isFreeInInd.pred_const_ X xs h1 | exact isFreeInInd.pred_var_ X xs h1 | exact isFreeInInd.eq_ x y h1 | exact isFreeInInd.def_ X xs h1

v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact isFreeInInd.pred_const_ X xs h1

v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_const_ X xs)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_const_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact isFreeInInd.pred_var_ X xs h1

v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_var_ X xs)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : PredName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (pred_var_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact isFreeInInd.eq_ x y h1

v x y : VarName h1 : v = x ∨ v = y ⊢ isFreeInInd v (eq_ x y)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v x y : VarName h1 : v = x ∨ v = y ⊢ isFreeInInd v (eq_ x y) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact isFreeInInd.def_ X xs h1

v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName X : DefName xs : List VarName h1 : v ∈ xs ⊢ isFreeInInd v (def_ X xs) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

apply isFreeInInd.not_

v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_

case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi.not_ TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact phi_ih h1

case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi h1 : isFreeIn v phi ⊢ isFreeInInd v phi TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

cases h1

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)

case inl v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h✝ : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) case inr v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h✝ : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi h1 : isFreeIn v phi ∨ isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

case inl c1 => first | apply isFreeInInd.imp_left_ | apply isFreeInInd.and_left_ | apply isFreeInInd.or_left_ | apply isFreeInInd.iff_left_ exact phi_ih c1

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

case inr c1 => first | apply isFreeInInd.imp_right_ | apply isFreeInInd.and_right_ | apply isFreeInInd.or_right_ | apply isFreeInInd.iff_right_ exact psi_ih c1

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)

no goals

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

first | apply isFreeInInd.imp_left_ | apply isFreeInInd.and_left_ | apply isFreeInInd.or_left_ | apply isFreeInInd.iff_left_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact phi_ih c1

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

apply isFreeInInd.imp_left_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.imp_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.imp_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

apply isFreeInInd.and_left_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.and_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.and_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

apply isFreeInInd.or_left_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.or_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.or_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

apply isFreeInInd.iff_left_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v phi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v phi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

first | apply isFreeInInd.imp_right_ | apply isFreeInInd.and_right_ | apply isFreeInInd.or_right_ | apply isFreeInInd.iff_right_

v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi)

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi

Please generate a tactic in lean4 to solve the state. STATE: v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v (phi.iff_ psi) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Binders.lean

FOL.NV.isFreeIn_imp_isFreeInInd

[382, 1]

[413, 30]

exact psi_ih c1

case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName phi psi : Formula phi_ih : isFreeIn v phi → isFreeInInd v phi psi_ih : isFreeIn v psi → isFreeInInd v psi c1 : isFreeIn v psi ⊢ isFreeInInd v psi TACTIC: