internlm/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
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	obtain s1 := Sub.Var.All.Rec.Fresh.substitution_theorem D I V E (Function.updateListITE id zs xs) c H	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (V ∘ Function.updateListITE id zs xs) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Function.updateListITE_comp] at s1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (V ∘ Function.updateListITE id zs xs) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE (V ∘ id) zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp at s1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE (V ∘ id) zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [s1]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply Holds_coincide_Var	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H	case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ ∀ (v : VarName), isFreeIn v ((τ X xs.length).get ⋯).2 → Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	intro v a1	case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ ∀ (v : VarName), isFreeIn v ((τ X xs.length).get ⋯).2 → Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v	case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	by_cases c3 : v ∈ zs	case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply Function.updateListITE_mem_eq_len V' V v zs (List.map V xs) c3	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = (List.map V xs).length
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = (List.map V xs).length	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = xs.length
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [← c2]	case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = xs.length	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Function.updateListITE_not_mem V v zs (List.map V xs) c3]	case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v	case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Function.updateListITE_not_mem V' v zs (List.map V xs) c3]	case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = V v	case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ V' v = V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply h2	case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ V' v = V v	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ v ∉ binders
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	intro contra	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ v ∉ binders	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs contra : v ∈ binders ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [isFreeIn_iff_mem_freeVarSet] at a1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs contra : v ∈ binders ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Finset.eq_empty_iff_forall_not_mem] at h1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [c1] at h1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [← c2] at h1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then True → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp at h1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then True → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : ∀ x ∈ binders, x ∈ ((τ X xs.length).get ⋯).2.freeVarSet → x ∈ ((τ X xs.length).get ⋯).1 ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	specialize h1 v contra a1	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : ∀ x ∈ binders, x ∈ ((τ X xs.length).get ⋯).2.freeVarSet → x ∈ ((τ X xs.length).get ⋯).1 ⊢ False	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : v ∈ ((τ X xs.length).get ⋯).1 ⊢ False
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	contradiction	case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : v ∈ ((τ X xs.length).get ⋯).1 ⊢ False	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : ¬xs.length = ((τ X xs.length).get ⋯).1.length ⊢ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : ¬(τ X xs.length).isSome = true ⊢ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (replace c τ (eq_ x y))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (eq_ x y)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (eq_ x y)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E (replace c τ false_)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E false_
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E false_	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [admitsAux] at h1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi.not_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi).not_
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi).not_	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ¬Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ ¬Holds D I V E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	congr! 1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ¬Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ ¬Holds D I V E (replace c τ phi)	case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	exact phi_ih V binders h1 h2	case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [admitsAux] at h1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (phi.iff_ psi) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E ((replace c τ phi).iff_ (replace c τ psi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E ((replace c τ phi).iff_ (replace c τ psi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	cases h1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))	case intro D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x left✝ : admitsAux τ binders phi right✝ : admitsAux τ binders psi ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	congr! 1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))	case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi) case a.h.e'_2.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	exact phi_ih V binders h1_left h2	case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	exact psi_ih V binders h1_right h2	case a.h.e'_2.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [admitsAux] at h1	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (exists_ x phi) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (exists_ x (replace c τ phi))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (exists_ x (replace c τ phi))	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	first \| apply forall_congr' \| apply exists_congr	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	intro d	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V x d) E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply phi_ih (Function.updateITE V x d) (binders ∪ {x}) h1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V x d) E (replace c τ phi)	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ ∀ x_1 ∉ binders ∪ {x}, V' x_1 = Function.updateITE V x d x_1
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	intro v a1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ ∀ x_1 ∉ binders ∪ {x}, V' x_1 = Function.updateITE V x d x_1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = Function.updateITE V x d v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Function.updateITE]	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = Function.updateITE V x d v	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = if v = x then d else V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp at a1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = if v = x then d else V v	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ ¬v = x ⊢ V' v = if v = x then d else V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	push_neg at a1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ ¬v = x ⊢ V' v = if v = x then d else V v	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ v ≠ x ⊢ V' v = if v = x then d else V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	cases a1	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ v ≠ x ⊢ V' v = if v = x then d else V v	case h.intro D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName left✝ : v ∉ binders right✝ : v ≠ x ⊢ V' v = if v = x then d else V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	case h.intro a1_left a1_right => simp only [if_neg a1_right] exact h2 v a1_left	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = if v = x then d else V v	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply forall_congr'	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∀ (d : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∀ (d : D), Holds D I (Function.updateITE V x d) E (replace c τ phi)	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply exists_congr	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)	case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [if_neg a1_right]	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = if v = x then d else V v	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = V v
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	exact h2 v a1_left	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = V v	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	cases E	D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (def_ X xs) ↔ Holds D I V E (replace c τ (def_ X xs))	case nil D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs)) case cons D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 head✝ : Definition tail✝ : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (head✝ :: tail✝) H else I.pred_var_ X ds else I.pred_var_ X ds } V (head✝ :: tail✝) (def_ X xs) ↔ Holds D I V (head✝ :: tail✝) (replace c τ (def_ X xs))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	case nil => simp only [replace] simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs))	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs))	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) [] ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (def_ X xs)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) [] ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (def_ X xs)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [replace]	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (hd :: tl) H else I.pred_var_ X ds else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (replace c τ (def_ X xs))	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [Holds]	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	split_ifs	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply Holds_coincide_PredVar	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp	case h1 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [predVarOccursIn_iff_mem_predVarSet]	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [hd.h2]	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	apply Holds_coincide_PredVar	D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp	case h1 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp only [predVarOccursIn]	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean	FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux	[90, 1]	[226, 15]	simp	case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	ext cs	α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [RegExp.languageOf]	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x \| ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x \| ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}	case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	constructor	case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro a1	case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.elim a1	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro xs a2	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	clear a1	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a2	case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp.intro α : Type R : RegExp α cs : List α xs : List (List α) left✝ : ∀ r ∈ xs, r ∈ RegExp.languageOf α R right✝ : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a2_left a2_right => simp only [← a2_right] cases xs case nil => left simp case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [← a2_right]	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases xs	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join	case nil α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join case cons α : Type R : RegExp α cs head✝ : List α tail✝ : List (List α) a2_left : ∀ r ∈ head✝ :: tail✝, r ∈ RegExp.languageOf α R a2_right : (head✝ :: tail✝).join = cs ⊢ (head✝ :: tail✝).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (head✝ :: tail✝).join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case nil => left simp	α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	left	α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join	case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	right	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp at a2_left	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a2_left	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h.intro α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs left✝ : hd ∈ RegExp.languageOf α R right✝ : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.intro hd	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro a1	case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a1	case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case h.mpr.inl α : Type R : RegExp α cs : List α h✝ : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs case h.mpr.inr α : Type R : RegExp α cs : List α h✝ : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ left => apply Exists.intro [] simp simp only [left]	α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ right => apply Exists.elim right intro xs a2 clear right cases a2 case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.intro []	α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs	α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [left]	α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs	no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

obtain s1 := Sub.Var.All.Rec.Fresh.substitution_theorem D I V E (Function.updateListITE id zs xs) c H

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (V ∘ Function.updateListITE id zs xs) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Function.updateListITE_comp] at s1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (V ∘ Function.updateListITE id zs xs) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE (V ∘ id) zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp at s1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE (V ∘ id) zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [s1]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((τ X xs.length).get ⋯).1 xs) c ((τ X xs.length).get ⋯).2)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply Holds_coincide_Var

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ Holds D I (Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs)) E ((τ X xs.length).get ⋯).2 ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H

case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ ∀ (v : VarName), isFreeIn v ((τ X xs.length).get ⋯).2 → Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

intro v a1

case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H ⊢ ∀ (v : VarName), isFreeIn v ((τ X xs.length).get ⋯).2 → Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

by_cases c3 : v ∈ zs

case h1 D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply Function.updateListITE_mem_eq_len V' V v zs (List.map V xs) c3

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = (List.map V xs).length

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = (List.map V xs).length

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = xs.length

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [← c2]

case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∈ zs ⊢ zs.length = xs.length

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Function.updateListITE_not_mem V v zs (List.map V xs) c3]

case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v

case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Function.updateListITE_not_mem V' v zs (List.map V xs) c3]

case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ Function.updateListITE V' ((τ X xs.length).get ⋯).1 (List.map V xs) v = V v

case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ V' v = V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply h2

case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ V' v = V v

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ v ∉ binders

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

intro contra

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs ⊢ v ∉ binders

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs contra : v ∈ binders ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [isFreeIn_iff_mem_freeVarSet] at a1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName a1 : isFreeIn v ((τ X xs.length).get ⋯).2 c3 : v ∉ zs contra : v ∈ binders ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Finset.eq_empty_iff_forall_not_mem] at h1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [c1] at h1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [← c2] at h1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then xs.length = ((τ X xs.length).get ⋯).1.length → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then True → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp at h1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : if h : True then True → ∀ (x : VarName), x ∉ binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) else True ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : ∀ x ∈ binders, x ∈ ((τ X xs.length).get ⋯).2.freeVarSet → x ∈ ((τ X xs.length).get ⋯).1 ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

specialize h1 v contra a1

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : ∀ x ∈ binders, x ∈ ((τ X xs.length).get ⋯).2.freeVarSet → x ∈ ((τ X xs.length).get ⋯).1 ⊢ False

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : v ∈ ((τ X xs.length).get ⋯).1 ⊢ False

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

contradiction

case neg.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x c1 : (τ X xs.length).isSome = true c2 : xs.length = ((τ X xs.length).get ⋯).1.length opt : Option (List VarName × Formula) := τ X xs.length val : List VarName × Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 s1 : Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) ↔ Holds D I (Function.updateListITE V zs (List.map V xs)) E H v : VarName c3 : v ∉ zs contra : v ∈ binders a1 : v ∈ ((τ X xs.length).get ⋯).2.freeVarSet h1 : v ∈ ((τ X xs.length).get ⋯).1 ⊢ False

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : (τ X xs.length).isSome = true c2 : ¬xs.length = ((τ X xs.length).get ⋯).1.length ⊢ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1 : if h : (τ X xs.length).isSome = true then xs.length = ((τ X xs.length).get ⋯).1.length → binders ∩ (((τ X xs.length).get ⋯).2.freeVarSet \ ((τ X xs.length).get ⋯).1.toFinset) = ∅ else True c1 : ¬(τ X xs.length).isSome = true ⊢ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (replace c τ (eq_ x y))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (eq_ x y)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (eq_ x y) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (eq_ x y)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E (replace c τ false_)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E false_

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders false_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E false_

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [admitsAux] at h1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi.not_ h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi.not_)

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi).not_

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c τ phi).not_

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ¬Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ ¬Holds D I V E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

congr! 1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ¬Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ ¬Holds D I V E (replace c τ phi)

case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

exact phi_ih V binders h1 h2

case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [admitsAux] at h1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (phi.iff_ psi) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E (replace c τ (phi.iff_ psi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E ((replace c τ phi).iff_ (replace c τ psi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (phi.iff_ psi) ↔ Holds D I V E ((replace c τ phi).iff_ (replace c τ psi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

cases h1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders phi ∧ admitsAux τ binders psi h2 : ∀ x ∉ binders, V' x = V x ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))

case intro D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x left✝ : admitsAux τ binders phi right✝ : admitsAux τ binders psi ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

congr! 1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi) ↔ (Holds D I V E (replace c τ phi) ↔ Holds D I V E (replace c τ psi))

case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi) case a.h.e'_2.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

exact phi_ih V binders h1_left h2

case a.h.e'_1.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

exact psi_ih V binders h1_right h2

case a.h.e'_2.a D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) phi psi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) psi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders psi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)) V : VarAssignment D binders : Finset VarName h2 : ∀ x ∉ binders, V' x = V x h1_left : admitsAux τ binders phi h1_right : admitsAux τ binders psi ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E psi ↔ Holds D I V E (replace c τ psi)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [admitsAux] at h1

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ binders (exists_ x phi) h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c τ (exists_ x phi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (exists_ x (replace c τ phi))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (exists_ x (replace c τ phi))

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

first | apply forall_congr' | apply exists_congr

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

intro d

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V x d) E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply phi_ih (Function.updateITE V x d) (binders ∪ {x}) h1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V x d) E (replace c τ phi)

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ ∀ x_1 ∉ binders ∪ {x}, V' x_1 = Function.updateITE V x d x_1

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

intro v a1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D ⊢ ∀ x_1 ∉ binders ∪ {x}, V' x_1 = Function.updateITE V x d x_1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = Function.updateITE V x d v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Function.updateITE]

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = Function.updateITE V x d v

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = if v = x then d else V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp at a1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∪ {x} ⊢ V' v = if v = x then d else V v

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ ¬v = x ⊢ V' v = if v = x then d else V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

push_neg at a1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ ¬v = x ⊢ V' v = if v = x then d else V v

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ v ≠ x ⊢ V' v = if v = x then d else V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

cases a1

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1 : v ∉ binders ∧ v ≠ x ⊢ V' v = if v = x then d else V v

case h.intro D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName left✝ : v ∉ binders right✝ : v ≠ x ⊢ V' v = if v = x then d else V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

case h.intro a1_left a1_right => simp only [if_neg a1_right] exact h2 v a1_left

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = if v = x then d else V v

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply forall_congr'

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∀ (d : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∀ (d : D), Holds D I (Function.updateITE V x d) E (replace c τ phi)

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply exists_congr

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ (∃ d, Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E (replace c τ phi)

case h D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x ⊢ ∀ (a : D), Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) E ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V x a) E (replace c τ phi)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [if_neg a1_right]

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = if v = x then d else V v

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = V v

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

exact h2 v a1_left

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (List VarName × Formula) x : VarName phi : Formula phi_ih : ∀ (V : VarAssignment D) (binders : Finset VarName), admitsAux τ binders phi → (∀ x ∉ binders, V' x = V x) → (Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c τ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux τ (binders ∪ {x}) phi h2 : ∀ x ∉ binders, V' x = V x d : D v : VarName a1_left : v ∉ binders a1_right : v ≠ x ⊢ V' v = V v

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

cases E

D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (def_ X xs) ↔ Holds D I V E (replace c τ (def_ X xs))

case nil D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs)) case cons D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 head✝ : Definition tail✝ : List Definition ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (head✝ :: tail✝) H else I.pred_var_ X ds else I.pred_var_ X ds } V (head✝ :: tail✝) (def_ X xs) ↔ Holds D I V (head✝ :: tail✝) (replace c τ (def_ X xs))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

case nil => simp only [replace] simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs))

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (replace c τ (def_ X xs))

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) [] ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (def_ X xs)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 ⊢ Holds D { nonempty := ⋯, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) [] ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V [] (def_ X xs) ↔ Holds D I V [] (def_ X xs)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [replace]

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 => let opt := τ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (hd :: tl) H else I.pred_var_ X ds else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (replace c τ (def_ X xs))

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V (hd :: tl) (def_ X xs) ↔ Holds D I V (hd :: tl) (def_ X xs)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [Holds]

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

split_ifs

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds } V tl (def_ X xs) ↔ Holds D I V tl (def_ X xs)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply Holds_coincide_PredVar

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp

case h1 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [predVarOccursIn_iff_mem_predVarSet]

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [hd.h2]

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

apply Holds_coincide_PredVar

D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_ case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_var_ P ds ↔ I.pred_var_ P ds)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp

case h1 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds else I.pred_var_ X ds }.pred_const_ = I.pred_const_

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp only [predVarOccursIn]

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ X ds.length).isSome = true then if ds.length = ((τ X ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ X ds.length).get ⋯).1 ds) (hd :: tl) ((τ X ds.length).get ⋯).2 else I.pred_var_ X ds 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 c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

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

097a4abea51b641d144539b9a0f7516f3b9d818c

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

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

[90, 1]

[226, 15]

simp

case h2 D : Type I : Interpretation D V' : VarAssignment D c : Char τ : PredName → ℕ → Option (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 h : (τ P ds.length).isSome = true then if ds.length = ((τ P ds.length).get ⋯).1.length then Holds D I (Function.updateListITE V' ((τ P ds.length).get ⋯).1 ds) (hd :: tl) ((τ P ds.length).get ⋯).2 else I.pred_var_ P ds else I.pred_var_ P ds) ↔ I.pred_var_ P ds)

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

ext cs

α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [RegExp.languageOf]

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x | ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x | ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}

case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

constructor

case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro a1

case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.elim a1

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro xs a2

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

clear a1

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a2

case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp.intro α : Type R : RegExp α cs : List α xs : List (List α) left✝ : ∀ r ∈ xs, r ∈ RegExp.languageOf α R right✝ : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a2_left a2_right => simp only [← a2_right] cases xs case nil => left simp case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [← a2_right]

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases xs

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join

case nil α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join case cons α : Type R : RegExp α cs head✝ : List α tail✝ : List (List α) a2_left : ∀ r ∈ head✝ :: tail✝, r ∈ RegExp.languageOf α R a2_right : (head✝ :: tail✝).join = cs ⊢ (head✝ :: tail✝).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (head✝ :: tail✝).join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case nil => left simp

α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

left

α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join

case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

right

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp at a2_left

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a2_left

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h.intro α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs left✝ : hd ∈ RegExp.languageOf α R right✝ : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.intro hd

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro a1

case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a1

case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case h.mpr.inl α : Type R : RegExp α cs : List α h✝ : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs case h.mpr.inr α : Type R : RegExp α cs : List α h✝ : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ left => apply Exists.intro [] simp simp only [left]

α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ right => apply Exists.elim right intro xs a2 clear right cases a2 case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.intro []

α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs

α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs

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

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [left]

α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs

no goals