[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
t : Term L α
g : α → β
v : β → M
⊢ realize v (relabel g t) = realize (v ∘ g) t
[PROOFSTEP]
induction' t with _ n f ts ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : α → β
v : β → M
_a✝ : α
⊢ realize v (relabel g (var _a✝)) = realize (v ∘ g) (var _a✝)
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : α → β
v : β → M
n : ℕ
f : Functions L n
ts : Fin n → Term L α
ih : ∀ (a : Fin n), realize v (relabel g (ts a)) = realize (v ∘ g) (ts a)
⊢ realize v (relabel g (func f ts)) = realize (v ∘ g) (func f ts)
[PROOFSTEP]
simp [ih]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
⊢ realize v (Functions.apply₁ f t) = funMap f ![realize v t]
[PROOFSTEP]
rw [Functions.apply₁, Term.realize]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
⊢ (funMap f fun i => realize v (Matrix.vecCons t ![] i)) = funMap f ![realize v t]
[PROOFSTEP]
refine' congr rfl (funext fun i => _)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
i : Fin 1
⊢ realize v (Matrix.vecCons t ![] i) = Matrix.vecCons (realize v t) ![] i
[PROOFSTEP]
simp only [Matrix.cons_val_fin_one]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 2
t₁ t₂ : Term L α
v : α → M
⊢ realize v (Functions.apply₂ f t₁ t₂) = funMap f ![realize v t₁, realize v t₂]
[PROOFSTEP]
rw [Functions.apply₂, Term.realize]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 2
t₁ t₂ : Term L α
v : α → M
⊢ (funMap f fun i => realize v (Matrix.vecCons t₁ ![t₂] i)) = funMap f ![realize v t₁, realize v t₂]
[PROOFSTEP]
refine' congr rfl (funext (Fin.cases _ _))
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 2
t₁ t₂ : Term L α
v : α → M
⊢ realize v (Matrix.vecCons t₁ ![t₂] 0) = Matrix.vecCons (realize v t₁) ![realize v t₂] 0
[PROOFSTEP]
simp only [Matrix.cons_val_zero]
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 2
t₁ t₂ : Term L α
v : α → M
⊢ ∀ (i : Fin 1), realize v (Matrix.vecCons t₁ ![t₂] (succ i)) = Matrix.vecCons (realize v t₁) ![realize v t₂] (succ i)
[PROOFSTEP]
simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
t : Term L α
tf : α → Term L β
v : β → M
⊢ realize v (subst t tf) = realize (fun a => realize v (tf a)) t
[PROOFSTEP]
induction' t with _ _ _ _ ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
tf : α → Term L β
v : β → M
_a✝ : α
⊢ realize v (subst (var _a✝) tf) = realize (fun a => realize v (tf a)) (var _a✝)
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
tf : α → Term L β
v : β → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), realize v (subst (_ts✝ a) tf) = realize (fun a => realize v (tf a)) (_ts✝ a)
⊢ realize v (subst (func _f✝ _ts✝) tf) = realize (fun a => realize v (tf a)) (func _f✝ _ts✝)
[PROOFSTEP]
simp [ih]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h : ↑(varFinset t) ⊆ s
v : α → M
⊢ realize (v ∘ Subtype.val) (restrictVar t (Set.inclusion h)) = realize v t
[PROOFSTEP]
induction' t with _ _ _ _ ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝ : ↑(varFinset t) ⊆ s
v : α → M
_a✝ : α
h : ↑(varFinset (var _a✝)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (var _a✝) (Set.inclusion h)) = realize v (var _a✝)
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝ : ↑(varFinset t) ⊆ s
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinset (_ts✝ a)) ⊆ s),
    realize (v ∘ Subtype.val) (restrictVar (_ts✝ a) (Set.inclusion h)) = realize v (_ts✝ a)
h : ↑(varFinset (func _f✝ _ts✝)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (func _f✝ _ts✝) (Set.inclusion h)) = realize v (func _f✝ _ts✝)
[PROOFSTEP]
simp_rw [varFinset, Finset.coe_biUnion, Set.iUnion_subset_iff] at h 
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝¹ : ↑(varFinset t) ⊆ s
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinset (_ts✝ a)) ⊆ s),
    realize (v ∘ Subtype.val) (restrictVar (_ts✝ a) (Set.inclusion h)) = realize v (_ts✝ a)
h✝ : ↑(Finset.biUnion Finset.univ fun i => varFinset (_ts✝ i)) ⊆ s
h : ∀ (i : Fin l✝), i ∈ ↑Finset.univ → ↑(varFinset (_ts✝ i)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (func _f✝ _ts✝) (Set.inclusion h✝)) = realize v (func _f✝ _ts✝)
[PROOFSTEP]
exact congr rfl (funext fun i => ih i (h i (Finset.mem_univ i)))
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft t (Set.inclusion h)) = realize (Sum.elim v xs) t
[PROOFSTEP]
induction' t with a _ _ _ ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
a : α ⊕ γ
h : ↑(varFinsetLeft (var a)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (var a) (Set.inclusion h)) = realize (Sum.elim v xs) (var a)
[PROOFSTEP]
cases a
[GOAL]
case var.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
val✝ : α
h : ↑(varFinsetLeft (var (Sum.inl val✝))) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (var (Sum.inl val✝)) (Set.inclusion h)) =
    realize (Sum.elim v xs) (var (Sum.inl val✝))
[PROOFSTEP]
rfl
[GOAL]
case var.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
val✝ : γ
h : ↑(varFinsetLeft (var (Sum.inr val✝))) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (var (Sum.inr val✝)) (Set.inclusion h)) =
    realize (Sum.elim v xs) (var (Sum.inr val✝))
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L (α ⊕ γ)
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinsetLeft (_ts✝ a)) ⊆ s),
    realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (_ts✝ a) (Set.inclusion h)) =
      realize (Sum.elim v xs) (_ts✝ a)
h : ↑(varFinsetLeft (func _f✝ _ts✝)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (func _f✝ _ts✝) (Set.inclusion h)) =
    realize (Sum.elim v xs) (func _f✝ _ts✝)
[PROOFSTEP]
simp_rw [varFinsetLeft, Finset.coe_biUnion, Set.iUnion_subset_iff] at h 
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_3
t : Term L (α ⊕ γ)
s : Set α
h✝¹ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L (α ⊕ γ)
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinsetLeft (_ts✝ a)) ⊆ s),
    realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (_ts✝ a) (Set.inclusion h)) =
      realize (Sum.elim v xs) (_ts✝ a)
h✝ : ↑(Finset.biUnion Finset.univ fun i => varFinsetLeft (_ts✝ i)) ⊆ s
h : ∀ (i : Fin l✝), i ∈ ↑Finset.univ → ↑(varFinsetLeft (_ts✝ i)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (func _f✝ _ts✝) (Set.inclusion h✝)) =
    realize (Sum.elim v xs) (func _f✝ _ts✝)
[PROOFSTEP]
exact congr rfl (funext fun i => ih i (h i (Finset.mem_univ i)))
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
t : Term (L[[α]]) β
v : β → M
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars t) = realize v t
[PROOFSTEP]
induction' t with _ n f ts ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
_a✝ : β
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (var _a✝)) = realize v (var _a✝)
[PROOFSTEP]
simp
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n : ℕ
f : Functions (L[[α]]) n
ts : Fin n → Term (L[[α]]) β
ih : ∀ (a : Fin n), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func f ts)) = realize v (func f ts)
[PROOFSTEP]
cases n
[GOAL]
case func.zero
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
f : Functions (L[[α]]) Nat.zero
ts : Fin Nat.zero → Term (L[[α]]) β
ih :
  ∀ (a : Fin Nat.zero), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func f ts)) = realize v (func f ts)
[PROOFSTEP]
cases f
[GOAL]
case func.zero.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
ts : Fin Nat.zero → Term (L[[α]]) β
ih :
  ∀ (a : Fin Nat.zero), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions L Nat.zero
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func (Sum.inl val✝) ts)) =
    realize v (func (Sum.inl val✝) ts)
[PROOFSTEP]
simp only [realize, ih, Nat.zero_eq, constantsOn, mk₂_Functions]
  --Porting note: below lemma does not work with simp for some reason
[GOAL]
case func.zero.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
ts : Fin Nat.zero → Term (L[[α]]) β
ih :
  ∀ (a : Fin Nat.zero), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions L Nat.zero
⊢ (funMap val✝ fun i => realize v (ts i)) = funMap (Sum.inl val✝) fun i => realize v (ts i)
[PROOFSTEP]
rw [withConstants_funMap_sum_inl]
[GOAL]
case func.zero.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
ts : Fin Nat.zero → Term (L[[α]]) β
ih :
  ∀ (a : Fin Nat.zero), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions (constantsOn α) Nat.zero
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func (Sum.inr val✝) ts)) =
    realize v (func (Sum.inr val✝) ts)
[PROOFSTEP]
simp only [realize, constantsToVars, Sum.elim_inl, funMap_eq_coe_constants]
[GOAL]
case func.zero.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
ts : Fin Nat.zero → Term (L[[α]]) β
ih :
  ∀ (a : Fin Nat.zero), realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions (constantsOn α) Nat.zero
⊢ ↑(Language.con L val✝) = ↑(Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
case func.succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n✝ : ℕ
f : Functions (L[[α]]) (Nat.succ n✝)
ts : Fin (Nat.succ n✝) → Term (L[[α]]) β
ih :
  ∀ (a : Fin (Nat.succ n✝)),
    realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func f ts)) = realize v (func f ts)
[PROOFSTEP]
cases' f with _ f
[GOAL]
case func.succ.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n✝ : ℕ
ts : Fin (Nat.succ n✝) → Term (L[[α]]) β
ih :
  ∀ (a : Fin (Nat.succ n✝)),
    realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions L (Nat.succ n✝)
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func (Sum.inl val✝) ts)) =
    realize v (func (Sum.inl val✝) ts)
[PROOFSTEP]
simp only [realize, ih, constantsOn, mk₂_Functions]
  --Porting note: below lemma does not work with simp for some reason
[GOAL]
case func.succ.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n✝ : ℕ
ts : Fin (Nat.succ n✝) → Term (L[[α]]) β
ih :
  ∀ (a : Fin (Nat.succ n✝)),
    realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
val✝ : Functions L (Nat.succ n✝)
⊢ (funMap val✝ fun i => realize v (ts i)) = funMap (Sum.inl val✝) fun i => realize v (ts i)
[PROOFSTEP]
rw [withConstants_funMap_sum_inl]
[GOAL]
case func.succ.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n✝ : ℕ
ts : Fin (Nat.succ n✝) → Term (L[[α]]) β
ih :
  ∀ (a : Fin (Nat.succ n✝)),
    realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (ts a)) = realize v (ts a)
f : Functions (constantsOn α) (Nat.succ n✝)
⊢ realize (Sum.elim (fun a => ↑(Language.con L a)) v) (constantsToVars (func (Sum.inr f) ts)) =
    realize v (func (Sum.inr f) ts)
[PROOFSTEP]
exact isEmptyElim f
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
t : Term L (α ⊕ β)
v : β → M
⊢ realize v (varsToConstants t) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) t
[PROOFSTEP]
induction' t with ab n f ts ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
ab : α ⊕ β
⊢ realize v (varsToConstants (var ab)) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (var ab)
[PROOFSTEP]
cases' ab with a b
[GOAL]
case var.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
a : α
⊢ realize v (varsToConstants (var (Sum.inl a))) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (var (Sum.inl a))
[PROOFSTEP]
simp [Language.con, realize, constantMap, funMap_eq_coe_constants]
[GOAL]
case var.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
b : β
⊢ realize v (varsToConstants (var (Sum.inr b))) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (var (Sum.inr b))
[PROOFSTEP]
simp [realize, constantMap]
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n : ℕ
f : Functions L n
ts : Fin n → Term L (α ⊕ β)
ih : ∀ (a : Fin n), realize v (varsToConstants (ts a)) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (ts a)
⊢ realize v (varsToConstants (func f ts)) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (func f ts)
[PROOFSTEP]
simp only [realize, constantsOn, mk₂_Functions, ih]
  --Porting note: below lemma does not work with simp for some reason
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
v : β → M
n : ℕ
f : Functions L n
ts : Fin n → Term L (α ⊕ β)
ih : ∀ (a : Fin n), realize v (varsToConstants (ts a)) = realize (Sum.elim (fun a => ↑(Language.con L a)) v) (ts a)
⊢ (funMap (Sum.inl f) fun i => realize (Sum.elim (fun a => ↑(Language.con L a)) v) (ts i)) =
    funMap f fun i => realize (Sum.elim (fun a => ↑(Language.con L a)) v) (ts i)
[PROOFSTEP]
rw [withConstants_funMap_sum_inl]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs) (↑constantsVarsEquivLeft t) =
    realize (Sum.elim v xs) t
[PROOFSTEP]
simp only [constantsVarsEquivLeft, realize_relabel, Equiv.coe_trans, Function.comp_apply, constantsVarsEquiv_apply,
  relabelEquiv_symm_apply]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm)
      (constantsToVars t) =
    realize (Sum.elim v xs) t
[PROOFSTEP]
refine' _root_.trans _ realize_constantsToVars
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm)
      (constantsToVars t) =
    realize (Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs)) (constantsToVars t)
[PROOFSTEP]
rcongr x
[GOAL]
case e_v.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
x : α ⊕ β ⊕ Fin n
⊢ (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm) x =
    Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs) x
[PROOFSTEP]
rcases x with (a | (b | i))
[GOAL]
case e_v.h.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
a : α
⊢ (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm) (Sum.inl a) =
    Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs) (Sum.inl a)
[PROOFSTEP]
simp
[GOAL]
case e_v.h.inr.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
b : β
⊢ (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm) (Sum.inr (Sum.inl b)) =
    Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs) (Sum.inr (Sum.inl b))
[PROOFSTEP]
simp
[GOAL]
case e_v.h.inr.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
i : Fin n
⊢ (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm) (Sum.inr (Sum.inr i)) =
    Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs) (Sum.inr (Sum.inr i))
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
t : Term L α
v : α → M
⊢ Term.realize v (onTerm φ t) = Term.realize v t
[PROOFSTEP]
induction' t with _ n f ts ih
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
v : α → M
_a✝ : α
⊢ Term.realize v (onTerm φ (var _a✝)) = Term.realize v (var _a✝)
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
v : α → M
n : ℕ
f : Functions L n
ts : Fin n → Term L α
ih : ∀ (a : Fin n), Term.realize v (onTerm φ (ts a)) = Term.realize v (ts a)
⊢ Term.realize v (onTerm φ (func f ts)) = Term.realize v (func f ts)
[PROOFSTEP]
simp only [Term.realize, LHom.onTerm, LHom.map_onFunction, ih]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
t : Term L α
v : α → M
⊢ Term.realize (↑g ∘ v) t = ↑g (Term.realize v t)
[PROOFSTEP]
induction t
[GOAL]
case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
_a✝ : α
⊢ Term.realize (↑g ∘ v) (var _a✝) = ↑g (Term.realize v (var _a✝))
[PROOFSTEP]
rfl
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ Term.realize (↑g ∘ v) (func _f✝ _ts✝) = ↑g (Term.realize v (func _f✝ _ts✝))
[PROOFSTEP]
rw [Term.realize, Term.realize, g.map_fun]
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ (funMap _f✝ fun i => Term.realize (↑g ∘ v) (_ts✝ i)) = funMap _f✝ (↑g ∘ fun i => Term.realize v (_ts✝ i))
[PROOFSTEP]
refine' congr rfl _
[GOAL]
case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ (fun i => Term.realize (↑g ∘ v) (_ts✝ i)) = ↑g ∘ fun i => Term.realize v (_ts✝ i)
[PROOFSTEP]
ext x
[GOAL]
case func.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
x : Fin l✝
⊢ Term.realize (↑g ∘ v) (_ts✝ x) = (↑g ∘ fun i => Term.realize v (_ts✝ i)) x
[PROOFSTEP]
simp [*]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize ⊤ v xs ↔ True
[PROOFSTEP]
simp [Top.top]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⊓ ψ) v xs ↔ Realize φ v xs ∧ Realize ψ v xs
[PROOFSTEP]
simp [Inf.inf, Realize]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ (Realize φ v xs → Realize ψ v xs → False) → False ↔ Realize φ v xs ∧ Realize ψ v xs
[PROOFSTEP]
tauto
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
l : List (BoundedFormula L α n)
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊓ x_1) ⊤ l) v xs ↔ ∀ (φ : BoundedFormula L α n), φ ∈ l → Realize φ v xs
[PROOFSTEP]
induction' l with φ l ih
[GOAL]
case nil
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊓ x_1) ⊤ []) v xs ↔ ∀ (φ : BoundedFormula L α n), φ ∈ [] → Realize φ v xs
[PROOFSTEP]
simp
[GOAL]
case cons
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ✝ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
v : α → M
xs : Fin n → M
φ : BoundedFormula L α n
l : List (BoundedFormula L α n)
ih : Realize (List.foldr (fun x x_1 => x ⊓ x_1) ⊤ l) v xs ↔ ∀ (φ : BoundedFormula L α n), φ ∈ l → Realize φ v xs
⊢ Realize (List.foldr (fun x x_1 => x ⊓ x_1) ⊤ (φ :: l)) v xs ↔
    ∀ (φ_1 : BoundedFormula L α n), φ_1 ∈ φ :: l → Realize φ_1 v xs
[PROOFSTEP]
simp [ih]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⟹ ψ) v xs ↔ Realize φ v xs → Realize ψ v xs
[PROOFSTEP]
simp only [Realize]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 1
t : Term L (α ⊕ Fin l)
⊢ Realize (Relations.boundedFormula₁ R t) v xs ↔ RelMap R ![realize (Sum.elim v xs) t]
[PROOFSTEP]
rw [Relations.boundedFormula₁, realize_rel, iff_eq_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 1
t : Term L (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (Matrix.vecCons t ![] i)) = RelMap R ![realize (Sum.elim v xs) t]
[PROOFSTEP]
refine' congr rfl (funext fun _ => _)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 1
t : Term L (α ⊕ Fin l)
x✝ : Fin 1
⊢ realize (Sum.elim v xs) (Matrix.vecCons t ![] x✝) = Matrix.vecCons (realize (Sum.elim v xs) t) ![] x✝
[PROOFSTEP]
simp only [Matrix.cons_val_fin_one]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ Realize (Relations.boundedFormula₂ R t₁ t₂) v xs ↔ RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]
[PROOFSTEP]
rw [Relations.boundedFormula₂, realize_rel, iff_eq_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] i)) =
    RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]
[PROOFSTEP]
refine' congr rfl (funext (Fin.cases _ _))
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] 0) =
    Matrix.vecCons (realize (Sum.elim v xs) t₁) ![realize (Sum.elim v xs) t₂] 0
[PROOFSTEP]
simp only [Matrix.cons_val_zero]
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ ∀ (i : Fin 1),
    realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] (succ i)) =
      Matrix.vecCons (realize (Sum.elim v xs) t₁) ![realize (Sum.elim v xs) t₂] (succ i)
[PROOFSTEP]
simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⊔ ψ) v xs ↔ Realize φ v xs ∨ Realize ψ v xs
[PROOFSTEP]
simp only [realize, Sup.sup, realize_not, eq_iff_iff]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (∼φ ⟹ ψ) v xs ↔ Realize φ v xs ∨ Realize ψ v xs
[PROOFSTEP]
tauto
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
l : List (BoundedFormula L α n)
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l) v xs ↔ ∃ φ, φ ∈ l ∧ Realize φ v xs
[PROOFSTEP]
induction' l with φ l ih
[GOAL]
case nil
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ []) v xs ↔ ∃ φ, φ ∈ [] ∧ Realize φ v xs
[PROOFSTEP]
simp
[GOAL]
case cons
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ✝ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
v : α → M
xs : Fin n → M
φ : BoundedFormula L α n
l : List (BoundedFormula L α n)
ih : Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l) v xs ↔ ∃ φ, φ ∈ l ∧ Realize φ v xs
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (φ :: l)) v xs ↔ ∃ φ_1, φ_1 ∈ φ :: l ∧ Realize φ_1 v xs
[PROOFSTEP]
simp_rw [List.foldr_cons, realize_sup, ih, List.mem_cons, or_and_right, exists_or, exists_eq_left]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (∃'θ) v xs ↔ ∃ a, Realize θ v (snoc xs a)
[PROOFSTEP]
rw [BoundedFormula.ex, realize_not, realize_all, not_forall]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ (∃ x, ¬Realize (∼θ) v (snoc xs x)) ↔ ∃ a, Realize θ v (snoc xs a)
[PROOFSTEP]
simp_rw [realize_not, Classical.not_not]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⇔ ψ) v xs ↔ (Realize φ v xs ↔ Realize ψ v xs)
[PROOFSTEP]
simp only [BoundedFormula.iff, realize_inf, realize_imp, and_imp, ← iff_def]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
h : m = n
h' : m ≤ n
φ : BoundedFormula L α m
v : α → M
xs : Fin n → M
⊢ Realize (castLE h' φ) v xs ↔ Realize φ v (xs ∘ ↑(castIso h))
[PROOFSTEP]
subst h
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m : ℕ
φ : BoundedFormula L α m
v : α → M
h' : m ≤ m
xs : Fin m → M
⊢ Realize (castLE h' φ) v xs ↔ Realize φ v (xs ∘ ↑(castIso (_ : m = m)))
[PROOFSTEP]
simp only [castLE_rfl, castIso_refl, OrderIso.coe_refl, Function.comp.right_id]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
φ : BoundedFormula L α n
v : α → M
v' : β → M
xs : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
⊢ Realize (mapTermRel ft fr (fun x => id) φ) v' xs ↔ Realize φ v xs
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : α → M
v' : β → M
xs✝ : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
n✝ : ℕ
xs : Fin n✝ → M
⊢ Realize (mapTermRel ft fr (fun x => id) falsum) v' xs ↔ Realize falsum v xs
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : α → M
v' : β → M
xs✝ : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ Realize (mapTermRel ft fr (fun x => id) (equal t₁✝ t₂✝)) v' xs ↔ Realize (equal t₁✝ t₂✝) v xs
[PROOFSTEP]
simp [mapTermRel, Realize, h1]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : α → M
v' : β → M
xs✝ : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ Realize (mapTermRel ft fr (fun x => id) (rel R✝ ts✝)) v' xs ↔ Realize (rel R✝ ts✝) v xs
[PROOFSTEP]
simp [mapTermRel, Realize, h1, h2]
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : α → M
v' : β → M
xs✝ : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 : ∀ {xs : Fin n✝ → M}, Realize (mapTermRel ft fr (fun x => id) f₁✝) v' xs ↔ Realize f₁✝ v xs
ih2 : ∀ {xs : Fin n✝ → M}, Realize (mapTermRel ft fr (fun x => id) f₂✝) v' xs ↔ Realize f₂✝ v xs
xs : Fin n✝ → M
⊢ Realize (mapTermRel ft fr (fun x => id) (f₁✝ ⟹ f₂✝)) v' xs ↔ Realize (f₁✝ ⟹ f₂✝) v xs
[PROOFSTEP]
simp [mapTermRel, Realize, ih1, ih2]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin n)
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : α → M
v' : β → M
xs✝ : Fin n → M
h1 : ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs : Fin n → M), realize (Sum.elim v' xs) (ft n t) = realize (Sum.elim v xs) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih : ∀ {xs : Fin (n✝ + 1) → M}, Realize (mapTermRel ft fr (fun x => id) f✝) v' xs ↔ Realize f✝ v xs
xs : Fin n✝ → M
⊢ Realize (mapTermRel ft fr (fun x => id) (∀'f✝)) v' xs ↔ Realize (∀'f✝) v xs
[PROOFSTEP]
simp only [mapTermRel, Realize, ih, id.def]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
φ : BoundedFormula L α n
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) φ) v' xs ↔ Realize φ (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) falsum) v' xs ↔
    Realize falsum (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (equal t₁✝ t₂✝)) v' xs ↔
    Realize (equal t₁✝ t₂✝) (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
simp [mapTermRel, Realize, h1]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (rel R✝ ts✝)) v' xs ↔
    Realize (rel R✝ ts✝) (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
simp [mapTermRel, Realize, h1, h2]
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 :
  ∀ (xs : Fin (k + n✝) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f₁✝) v' xs ↔
      Realize f₁✝ (v xs) (xs ∘ natAdd k)
ih2 :
  ∀ (xs : Fin (k + n✝) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f₂✝) v' xs ↔
      Realize f₂✝ (v xs) (xs ∘ natAdd k)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (f₁✝ ⟹ f₂✝)) v' xs ↔
    Realize (f₁✝ ⟹ f₂✝) (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
simp [mapTermRel, Realize, ih1, ih2]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ natAdd k)) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih :
  ∀ (xs : Fin (k + (n✝ + 1)) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f✝) v' xs ↔
      Realize f✝ (v xs) (xs ∘ natAdd k)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (∀'f✝)) v' xs ↔
    Realize (∀'f✝) (v xs) (xs ∘ natAdd k)
[PROOFSTEP]
simp [mapTermRel, Realize, ih, hv]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
⊢ Realize (relabel g φ) v xs ↔ Realize φ (Sum.elim v (xs ∘ castAdd n) ∘ g) (xs ∘ natAdd m)
[PROOFSTEP]
rw [relabel, realize_mapTermRel_add_castLe]
[GOAL]
case h1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
⊢ ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (m + n) → M),
    realize (Sum.elim v xs') (Term.relabel (relabelAux g n) t) =
      realize (Sum.elim (Sum.elim v (xs' ∘ castAdd n) ∘ g) (xs' ∘ natAdd m)) t
[PROOFSTEP]
intros
[GOAL]
case h2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
⊢ ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (id R) x = RelMap R x
[PROOFSTEP]
intros
[GOAL]
case hv
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
⊢ ∀ (n : ℕ) (xs : Fin (m + n) → M) (x : M),
    Sum.elim v (snoc xs x ∘ castAdd (n + 1)) ∘ g = Sum.elim v (xs ∘ castAdd n) ∘ g
[PROOFSTEP]
intros
[GOAL]
case h1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
n✝ : ℕ
t✝ : Term L (α ⊕ Fin n✝)
xs'✝ : Fin (m + n✝) → M
⊢ realize (Sum.elim v xs'✝) (Term.relabel (relabelAux g n✝) t✝) =
    realize (Sum.elim (Sum.elim v (xs'✝ ∘ castAdd n✝) ∘ g) (xs'✝ ∘ natAdd m)) t✝
[PROOFSTEP]
simp
[GOAL]
case h2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
n✝ : ℕ
R✝ : Relations L n✝
x✝ : Fin n✝ → M
⊢ RelMap (id R✝) x✝ = RelMap R✝ x✝
[PROOFSTEP]
simp
[GOAL]
case hv
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
n✝ : ℕ
xs✝ : Fin (m + n✝) → M
x✝ : M
⊢ Sum.elim v (snoc xs✝ x✝ ∘ castAdd (n✝ + 1)) ∘ g = Sum.elim v (xs✝ ∘ castAdd n✝) ∘ g
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ Realize (liftAt n' m φ) v xs ↔ Realize φ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
rw [liftAt]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ Realize (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) φ) v
      xs ↔
    Realize φ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ : ℕ
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) falsum)
      v xs ↔
    Realize falsum v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
simp [mapTermRel, Realize]
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1))
        (equal t₁✝ t₂✝))
      v xs ↔
    Realize (equal t₁✝ t₂✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1))
        (rel R✝ ts✝))
      v xs ↔
    Realize (rel R✝ ts✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f₁✝)
          v xs ↔
        Realize f₁✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
ih2 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f₂✝)
          v xs ↔
        Realize f₂✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1))
        (f₁✝ ⟹ f₂✝))
      v xs ↔
    Realize (f₁✝ ⟹ f₂✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) (∀'f✝))
      v xs ↔
    Realize (∀'f✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ k + 1 + n' = k + n' + 1
[PROOFSTEP]
rw [add_assoc, add_comm 1 n', ← add_assoc]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) (∀'f✝))
      v xs ↔
    Realize (∀'f✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (∀ (x : M), Realize f✝ v ((snoc xs x ∘ ↑(castIso h)) ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')) ↔
    ∀ (x : M), Realize f✝ v (snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') x)
[PROOFSTEP]
refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
[GOAL]
case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ ((snoc xs x ∘ ↑(castIso h)) ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') (last k) =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') x (last k)
[PROOFSTEP]
simp only [Function.comp_apply, val_last, snoc_last]
[GOAL]
case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ snoc xs x (↑(castIso h) (if k < m then castAdd n' (last k) else addNat (last k) n')) = x
[PROOFSTEP]
by_cases h : k < m
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (↑(castIso h✝) (if k < m then castAdd n' (last k) else addNat (last k) n')) = x
[PROOFSTEP]
rw [if_pos h]
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (↑(castIso h✝) (castAdd n' (last k))) = x
[PROOFSTEP]
refine' (congr rfl (ext _)).trans (snoc_last _ _)
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ ↑(↑(castIso h✝) (castAdd n' (last k))) = ↑(last (k + n'))
[PROOFSTEP]
simp only [coe_orderIso_apply, coe_castAdd, val_last, self_eq_add_right]
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ n' = 0
[PROOFSTEP]
refine' le_antisymm (le_of_add_le_add_left ((hmn.trans (Nat.succ_le_of_lt h)).trans _)) n'.zero_le
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ m ≤ m + 0
[PROOFSTEP]
rw [add_zero]
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (↑(castIso h✝) (if k < m then castAdd n' (last k) else addNat (last k) n')) = x
[PROOFSTEP]
rw [if_neg h]
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (↑(castIso h✝) (addNat (last k) n')) = x
[PROOFSTEP]
refine' (congr rfl (ext _)).trans (snoc_last _ _)
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ ↑(↑(castIso h✝) (addNat (last k) n')) = ↑(last (k + n'))
[PROOFSTEP]
simp
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ((snoc xs x ∘ ↑(castIso h)) ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') (castSucc i) =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') x (castSucc i)
[PROOFSTEP]
simp only [Function.comp_apply, Fin.snoc_castSucc]
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ snoc xs x (↑(castIso h) (if ↑(castSucc i) < m then castAdd n' (castSucc i) else addNat (castSucc i) n')) =
    xs (if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
refine' (congr rfl (ext _)).trans (snoc_castSucc _ _ _)
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(↑(castIso h) (if ↑(castSucc i) < m then castAdd n' (castSucc i) else addNat (castSucc i) n')) =
    ↑(castSucc (if ↑i < m then castAdd n' i else addNat i n'))
[PROOFSTEP]
simp only [coe_castSucc, coe_orderIso_apply]
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(if ↑i < m then castAdd n' (castSucc i) else addNat (castSucc i) n') =
    ↑(if ↑i < m then castAdd n' i else addNat i n')
[PROOFSTEP]
split_ifs
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
h✝ : ↑i < m
⊢ ↑(castAdd n' (castSucc i)) = ↑(castAdd n' i)
[PROOFSTEP]
simp
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
h✝ : ¬↑i < m
⊢ ↑(addNat (castSucc i) n') = ↑(addNat i n')
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n m : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
hmn : m ≤ n
⊢ Realize (liftAt 1 m φ) v xs ↔ Realize φ v (xs ∘ fun i => if ↑i < m then castSucc i else succ i)
[PROOFSTEP]
simp [realize_liftAt (add_le_add_right hmn 1), castSucc]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
⊢ Realize (liftAt 1 n φ) v xs ↔ Realize φ v (xs ∘ castSucc)
[PROOFSTEP]
rw [realize_liftAt_one (refl n), iff_eq_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
⊢ Realize φ v (xs ∘ fun i => if ↑i < n then castSucc i else succ i) = Realize φ v (xs ∘ castSucc)
[PROOFSTEP]
refine' congr rfl (congr rfl (funext fun i => _))
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
i : Fin n
⊢ (if ↑i < n then castSucc i else succ i) = castSucc i
[PROOFSTEP]
rw [if_pos i.is_lt]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n✝
tf : α → Term L β
v : β → M
xs : Fin n✝ → M
n : ℕ
t : Term L (α ⊕ Fin n)
x : Fin n → M
⊢ realize (Sum.elim v x) (Term.subst t (Sum.elim (Term.relabel Sum.inl ∘ tf) (var ∘ Sum.inr))) =
    realize (Sum.elim (fun a => realize v (tf a)) x) t
[PROOFSTEP]
rw [Term.realize_subst]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n✝
tf : α → Term L β
v : β → M
xs : Fin n✝ → M
n : ℕ
t : Term L (α ⊕ Fin n)
x : Fin n → M
⊢ realize (fun a => realize (Sum.elim v x) (Sum.elim (Term.relabel Sum.inl ∘ tf) (var ∘ Sum.inr) a)) t =
    realize (Sum.elim (fun a => realize v (tf a)) x) t
[PROOFSTEP]
rcongr a
[GOAL]
case e_v.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n✝
tf : α → Term L β
v : β → M
xs : Fin n✝ → M
n : ℕ
t : Term L (α ⊕ Fin n)
x : Fin n → M
a : α ⊕ Fin n
⊢ realize (Sum.elim v x) (Sum.elim (Term.relabel Sum.inl ∘ tf) (var ∘ Sum.inr) a) =
    Sum.elim (fun a => realize v (tf a)) x a
[PROOFSTEP]
cases a
[GOAL]
case e_v.h.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n✝
tf : α → Term L β
v : β → M
xs : Fin n✝ → M
n : ℕ
t : Term L (α ⊕ Fin n)
x : Fin n → M
val✝ : α
⊢ realize (Sum.elim v x) (Sum.elim (Term.relabel Sum.inl ∘ tf) (var ∘ Sum.inr) (Sum.inl val✝)) =
    Sum.elim (fun a => realize v (tf a)) x (Sum.inl val✝)
[PROOFSTEP]
simp only [Sum.elim_inl, Function.comp_apply, Term.realize_relabel, Sum.elim_comp_inl]
[GOAL]
case e_v.h.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n✝
tf : α → Term L β
v : β → M
xs : Fin n✝ → M
n : ℕ
t : Term L (α ⊕ Fin n)
x : Fin n → M
val✝ : Fin n
⊢ realize (Sum.elim v x) (Sum.elim (Term.relabel Sum.inl ∘ tf) (var ∘ Sum.inr) (Sum.inr val✝)) =
    Sum.elim (fun a => realize v (tf a)) x (Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
φ : BoundedFormula L α n
tf : α → Term L β
v : β → M
xs : Fin n → M
⊢ ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (id R) x = RelMap R x
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs : Fin n → M
⊢ Realize (restrictFreeVar φ (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize φ v xs
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h✝ : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
h : ↑(freeVarFinset falsum) ⊆ s
xs : Fin n✝ → M
⊢ Realize (restrictFreeVar falsum (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize falsum v xs
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h✝ : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
h : ↑(freeVarFinset (equal t₁✝ t₂✝)) ⊆ s
xs : Fin n✝ → M
⊢ Realize (restrictFreeVar (equal t₁✝ t₂✝) (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize (equal t₁✝ t₂✝) v xs
[PROOFSTEP]
simp [restrictFreeVar, Realize]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h✝ : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs✝ : Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
h : ↑(freeVarFinset (rel R✝ ts✝)) ⊆ s
xs : Fin n✝ → M
⊢ Realize (restrictFreeVar (rel R✝ ts✝) (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize (rel R✝ ts✝) v xs
[PROOFSTEP]
simp [restrictFreeVar, Realize]
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h✝ : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 :
  ∀ (h : ↑(freeVarFinset f₁✝) ⊆ s) {xs : Fin n✝ → M},
    Realize (restrictFreeVar f₁✝ (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize f₁✝ v xs
ih2 :
  ∀ (h : ↑(freeVarFinset f₂✝) ⊆ s) {xs : Fin n✝ → M},
    Realize (restrictFreeVar f₂✝ (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize f₂✝ v xs
h : ↑(freeVarFinset (f₁✝ ⟹ f₂✝)) ⊆ s
xs : Fin n✝ → M
⊢ Realize (restrictFreeVar (f₁✝ ⟹ f₂✝) (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize (f₁✝ ⟹ f₂✝) v xs
[PROOFSTEP]
simp [restrictFreeVar, Realize, ih1, ih2]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : DecidableEq α
n : ℕ
φ : BoundedFormula L α n
s : Set α
h✝ : ↑(freeVarFinset φ) ⊆ s
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 :
  ∀ (h : ↑(freeVarFinset f✝) ⊆ s) {xs : Fin (n✝ + 1) → M},
    Realize (restrictFreeVar f✝ (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize f✝ v xs
h : ↑(freeVarFinset (∀'f✝)) ⊆ s
xs : Fin n✝ → M
⊢ Realize (restrictFreeVar (∀'f✝) (Set.inclusion h)) (v ∘ Subtype.val) xs ↔ Realize (∀'f✝) v xs
[PROOFSTEP]
simp [restrictFreeVar, Realize, ih3]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
φ : BoundedFormula (L[[α]]) β n
v : β → M
xs : Fin n → M
⊢ Realize (↑constantsVarsEquiv φ) (Sum.elim (fun a => ↑(Language.con L a)) v) xs ↔ Realize φ v xs
[PROOFSTEP]
refine' realize_mapTermRel_id (fun n t xs => realize_constantsVarsEquivLeft) fun n R xs => _
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n✝ : ℕ
φ : BoundedFormula (L[[α]]) β n✝
v : β → M
xs✝ : Fin n✝ → M
n : ℕ
R : Relations (L[[α]]) n
xs : Fin n → M
⊢ RelMap (↑((fun x => Equiv.sumEmpty (Relations L x) (Relations (constantsOn α) x)) n) R) xs = RelMap R xs
[PROOFSTEP]
rw [← (lhomWithConstants L α).map_onRelation (Equiv.sumEmpty (L.Relations n) ((constantsOn α).Relations n) R) xs]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n✝ : ℕ
φ : BoundedFormula (L[[α]]) β n✝
v : β → M
xs✝ : Fin n✝ → M
n : ℕ
R : Relations (L[[α]]) n
xs : Fin n → M
⊢ RelMap (LHom.onRelation (lhomWithConstants L α) (↑(Equiv.sumEmpty (Relations L n) (Relations (constantsOn α) n)) R))
      xs =
    RelMap R xs
[PROOFSTEP]
rcongr
[GOAL]
case a
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n✝ : ℕ
φ : BoundedFormula (L[[α]]) β n✝
v : β → M
xs✝ : Fin n✝ → M
n : ℕ
R : Relations (L[[α]]) n
xs : Fin n → M
⊢ RelMap (LHom.onRelation (lhomWithConstants L α) (↑(Equiv.sumEmpty (Relations L n) (Relations (constantsOn α) n)) R))
      xs ↔
    RelMap R xs
[PROOFSTEP]
cases' R with R R
[GOAL]
case a.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n✝ : ℕ
φ : BoundedFormula (L[[α]]) β n✝
v : β → M
xs✝ : Fin n✝ → M
n : ℕ
xs : Fin n → M
R : Relations L n
⊢ RelMap
      (LHom.onRelation (lhomWithConstants L α)
        (↑(Equiv.sumEmpty (Relations L n) (Relations (constantsOn α) n)) (Sum.inl R)))
      xs ↔
    RelMap (Sum.inl R) xs
[PROOFSTEP]
simp
[GOAL]
case a.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n✝ : ℕ
φ : BoundedFormula (L[[α]]) β n✝
v : β → M
xs✝ : Fin n✝ → M
n : ℕ
xs : Fin n → M
R : Relations (constantsOn α) n
⊢ RelMap
      (LHom.onRelation (lhomWithConstants L α)
        (↑(Equiv.sumEmpty (Relations L n) (Relations (constantsOn α) n)) (Sum.inr R)))
      xs ↔
    RelMap (Sum.inr R) xs
[PROOFSTEP]
exact isEmptyElim R
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs : Fin k → M
⊢ Realize (↑(relabelEquiv g) φ) v xs ↔ Realize φ (v ∘ ↑g) xs
[PROOFSTEP]
simp only [relabelEquiv, mapTermRelEquiv_apply, Equiv.coe_refl]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs : Fin k → M
⊢ Realize
      (mapTermRel (fun n => ↑(Term.relabelEquiv (Equiv.sumCongr g (_root_.Equiv.refl (Fin n))))) (fun n => id)
        (fun x => id) φ)
      v xs ↔
    Realize φ (v ∘ ↑g) xs
[PROOFSTEP]
refine' realize_mapTermRel_id (fun n t xs => _) fun _ _ _ => rfl
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ realize (Sum.elim v xs) (↑(Term.relabelEquiv (Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) t) =
    realize (Sum.elim (v ∘ ↑g) xs) t
[PROOFSTEP]
simp only [relabelEquiv_apply, Term.realize_relabel]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ realize (Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) t = realize (Sum.elim (v ∘ ↑g) xs) t
[PROOFSTEP]
refine' congr (congr rfl _) rfl
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n))) = Sum.elim (v ∘ ↑g) xs
[PROOFSTEP]
ext (i | i)
[GOAL]
case h.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
i : α
⊢ (Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) (Sum.inl i) = Sum.elim (v ∘ ↑g) xs (Sum.inl i)
[PROOFSTEP]
rfl
[GOAL]
case h.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
i : Fin n
⊢ (Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) (Sum.inr i) = Sum.elim (v ∘ ↑g) xs (Sum.inr i)
[PROOFSTEP]
rfl
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
⊢ Realize (∀'liftAt 1 n φ) v xs ↔ Realize φ v xs
[PROOFSTEP]
inhabit M
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
⊢ Realize (∀'liftAt 1 n φ) v xs ↔ Realize φ v xs
[PROOFSTEP]
simp only [realize_all, realize_liftAt_one_self]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
⊢ (∀ (a : M), Realize φ v (snoc xs a ∘ castSucc)) ↔ Realize φ v xs
[PROOFSTEP]
refine' ⟨fun h => _, fun h a => _⟩
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
h : ∀ (a : M), Realize φ v (snoc xs a ∘ castSucc)
⊢ Realize φ v xs
[PROOFSTEP]
refine' (congr rfl (funext fun i => _)).mp (h default)
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
h : ∀ (a : M), Realize φ v (snoc xs a ∘ castSucc)
i : Fin n
⊢ (snoc xs default ∘ castSucc) i = xs i
[PROOFSTEP]
simp
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
h : Realize φ v xs
a : M
⊢ Realize φ v (snoc xs a ∘ castSucc)
[PROOFSTEP]
refine' (congr rfl (funext fun i => _)).mp h
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
inhabited_h : Inhabited M
h : Realize φ v xs
a : M
i : Fin n
⊢ xs i = (snoc xs a ∘ castSucc) i
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
φ ψ : BoundedFormula L α n
hφ : IsQF φ
hψ : IsPrenex ψ
v : α → M
xs : Fin n → M
⊢ Realize (toPrenexImpRight φ ψ) v xs ↔ Realize (φ ⟹ ψ) v xs
[PROOFSTEP]
induction' hψ with _ _ hψ _ _ _hψ ih _ _ _hψ ih
[GOAL]
case of_isQF
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hψ : IsQF φ✝
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
[PROOFSTEP]
rw [hψ.toPrenexImpRight]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ Realize (toPrenexImpRight φ (∀'φ✝)) v xs ↔ Realize (φ ⟹ ∀'φ✝) v xs
[PROOFSTEP]
refine' _root_.trans (forall_congr' fun _ => ih hφ.liftAt) _
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∀ (a : M), Realize (liftAt 1 n✝ φ ⟹ φ✝) v (snoc xs a)) ↔ Realize (φ ⟹ ∀'φ✝) v xs
[PROOFSTEP]
simp only [realize_imp, realize_liftAt_one_self, snoc_comp_castSucc, realize_all]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∀ (a : M), Realize φ v xs → Realize φ✝ v (snoc xs a)) ↔ Realize φ v xs → ∀ (a : M), Realize φ✝ v (snoc xs a)
[PROOFSTEP]
exact ⟨fun h1 a h2 => h1 h2 a, fun h1 h2 a => h1 a h2⟩
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ Realize (toPrenexImpRight φ (∃'φ✝)) v xs ↔ Realize (φ ⟹ ∃'φ✝) v xs
[PROOFSTEP]
unfold toPrenexImpRight
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ Realize (∃'toPrenexImpRight (liftAt 1 n✝ φ) φ✝) v xs ↔ Realize (φ ⟹ ∃'φ✝) v xs
[PROOFSTEP]
rw [realize_ex]
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∃ a, Realize (toPrenexImpRight (liftAt 1 n✝ φ) φ✝) v (snoc xs a)) ↔ Realize (φ ⟹ ∃'φ✝) v xs
[PROOFSTEP]
refine' _root_.trans (exists_congr fun _ => ih hφ.liftAt) _
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∃ a, Realize (liftAt 1 n✝ φ ⟹ φ✝) v (snoc xs a)) ↔ Realize (φ ⟹ ∃'φ✝) v xs
[PROOFSTEP]
simp only [realize_imp, realize_liftAt_one_self, snoc_comp_castSucc, realize_ex]
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)) ↔ Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
[PROOFSTEP]
refine' ⟨_, fun h' => _⟩
[GOAL]
case ex.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
⊢ (∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)) → Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
[PROOFSTEP]
rintro ⟨a, ha⟩ h
[GOAL]
case ex.refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
a : M
ha : Realize φ v xs → Realize φ✝ v (snoc xs a)
h : Realize φ v xs
⊢ ∃ a, Realize φ✝ v (snoc xs a)
[PROOFSTEP]
exact ⟨a, ha h⟩
[GOAL]
case ex.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
by_cases φ.Realize v xs
[GOAL]
case ex.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
by_cases φ.Realize v xs
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
h : Realize φ v xs
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
obtain ⟨a, ha⟩ := h' h
[GOAL]
case pos.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
h : Realize φ v xs
a : M
ha : Realize φ✝ v (snoc xs a)
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
exact ⟨a, fun _ => ha⟩
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
h : ¬Realize φ v xs
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
inhabit M
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hψ : IsPrenex φ✝
ih :
  ∀ {φ : BoundedFormula L α (n✝ + 1)},
    IsQF φ → ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenexImpRight φ φ✝) v xs ↔ Realize (φ ⟹ φ✝) v xs
φ : BoundedFormula L α n✝
hφ : IsQF φ
xs : Fin n✝ → M
h' : Realize φ v xs → ∃ a, Realize φ✝ v (snoc xs a)
h : ¬Realize φ v xs
inhabited_h : Inhabited M
⊢ ∃ a, Realize φ v xs → Realize φ✝ v (snoc xs a)
[PROOFSTEP]
exact ⟨default, fun h'' => (h h'').elim⟩
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
φ ψ : BoundedFormula L α n
hφ : IsPrenex φ
hψ : IsPrenex ψ
v : α → M
xs : Fin n → M
⊢ Realize (toPrenexImp φ ψ) v xs ↔ Realize (φ ⟹ ψ) v xs
[PROOFSTEP]
revert ψ
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
hφ : IsPrenex φ
v : α → M
xs : Fin n → M
⊢ ∀ {ψ : BoundedFormula L α n}, IsPrenex ψ → (Realize (toPrenexImp φ ψ) v xs ↔ Realize (φ ⟹ ψ) v xs)
[PROOFSTEP]
induction' hφ with _ _ hφ _ _ _hφ ih _ _ _hφ ih
[GOAL]
case of_isQF
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hφ : IsQF φ✝
xs : Fin n✝ → M
⊢ ∀ {ψ : BoundedFormula L α n✝}, IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
[PROOFSTEP]
intro ψ hψ
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
⊢ ∀ {ψ : BoundedFormula L α n✝}, IsPrenex ψ → (Realize (toPrenexImp (∀'φ✝) ψ) v xs ↔ Realize (∀'φ✝ ⟹ ψ) v xs)
[PROOFSTEP]
intro ψ hψ
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
⊢ ∀ {ψ : BoundedFormula L α n✝}, IsPrenex ψ → (Realize (toPrenexImp (∃'φ✝) ψ) v xs ↔ Realize (∃'φ✝ ⟹ ψ) v xs)
[PROOFSTEP]
intro ψ hψ
[GOAL]
case of_isQF
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hφ : IsQF φ✝
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs
[PROOFSTEP]
rw [hφ.toPrenexImp]
[GOAL]
case of_isQF
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hφ : IsQF φ✝
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ Realize (toPrenexImpRight φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs
[PROOFSTEP]
exact realize_toPrenexImpRight hφ hψ
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ Realize (toPrenexImp (∀'φ✝) ψ) v xs ↔ Realize (∀'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
unfold toPrenexImp
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ Realize (∃'toPrenexImp φ✝ (liftAt 1 n✝ ψ)) v xs ↔ Realize (∀'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
rw [realize_ex]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ (∃ a, Realize (toPrenexImp φ✝ (liftAt 1 n✝ ψ)) v (snoc xs a)) ↔ Realize (∀'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
refine' _root_.trans (exists_congr fun _ => ih hψ.liftAt) _
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ (∃ a, Realize (φ✝ ⟹ liftAt 1 n✝ ψ) v (snoc xs a)) ↔ Realize (∀'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
simp only [realize_imp, realize_liftAt_one_self, snoc_comp_castSucc, realize_all]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ (∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs) ↔ (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
[PROOFSTEP]
refine' ⟨_, fun h' => _⟩
[GOAL]
case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ (∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs) → (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
[PROOFSTEP]
rintro ⟨a, ha⟩ h
[GOAL]
case all.refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
a : M
ha : Realize φ✝ v (snoc xs a) → Realize ψ v xs
h : ∀ (a : M), Realize φ✝ v (snoc xs a)
⊢ Realize ψ v xs
[PROOFSTEP]
exact ha (h a)
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
by_cases ψ.Realize v xs
[GOAL]
case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
by_cases ψ.Realize v xs
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
h : Realize ψ v xs
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
inhabit M
[GOAL]
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
h : Realize ψ v xs
inhabited_h : Inhabited M
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
exact ⟨default, fun _h'' => h⟩
[GOAL]
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
h : ¬Realize ψ v xs
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
obtain ⟨a, ha⟩ := not_forall.1 (h ∘ h')
[GOAL]
case neg.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
h' : (∀ (a : M), Realize φ✝ v (snoc xs a)) → Realize ψ v xs
h : ¬Realize ψ v xs
a : M
ha : ¬Realize φ✝ v (snoc xs a)
⊢ ∃ a, Realize φ✝ v (snoc xs a) → Realize ψ v xs
[PROOFSTEP]
exact ⟨a, fun h => (ha h).elim⟩
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ Realize (toPrenexImp (∃'φ✝) ψ) v xs ↔ Realize (∃'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
refine' _root_.trans (forall_congr' fun _ => ih hψ.liftAt) _
[GOAL]
case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝¹ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
_hφ : IsPrenex φ✝
ih :
  ∀ {xs : Fin (n✝ + 1) → M} {ψ : BoundedFormula L α (n✝ + 1)},
    IsPrenex ψ → (Realize (toPrenexImp φ✝ ψ) v xs ↔ Realize (φ✝ ⟹ ψ) v xs)
xs : Fin n✝ → M
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ (∀ (a : M), Realize (φ✝ ⟹ liftAt 1 n✝ ψ) v (snoc xs a)) ↔ Realize (∃'φ✝ ⟹ ψ) v xs
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
φ : BoundedFormula L α n
v : α → M
⊢ ∀ {xs : Fin n → M}, Realize (toPrenex φ) v xs ↔ Realize φ v xs
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ f1 f2 h1 h2 _ _ h
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
⊢ ∀ {xs : Fin n✝ → M}, Realize (toPrenex falsum) v xs ↔ Realize falsum v xs
[PROOFSTEP]
exact Iff.rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
⊢ ∀ {xs : Fin n✝ → M}, Realize (toPrenex (equal t₁✝ t₂✝)) v xs ↔ Realize (equal t₁✝ t₂✝) v xs
[PROOFSTEP]
exact Iff.rfl
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
⊢ ∀ {xs : Fin n✝ → M}, Realize (toPrenex (rel R✝ ts✝)) v xs ↔ Realize (rel R✝ ts✝) v xs
[PROOFSTEP]
exact Iff.rfl
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
f1 f2 : BoundedFormula L α n✝
h1 : ∀ {xs : Fin n✝ → M}, Realize (toPrenex f1) v xs ↔ Realize f1 v xs
h2 : ∀ {xs : Fin n✝ → M}, Realize (toPrenex f2) v xs ↔ Realize f2 v xs
⊢ ∀ {xs : Fin n✝ → M}, Realize (toPrenex (f1 ⟹ f2)) v xs ↔ Realize (f1 ⟹ f2) v xs
[PROOFSTEP]
intros
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
f1 f2 : BoundedFormula L α n✝
h1 : ∀ {xs : Fin n✝ → M}, Realize (toPrenex f1) v xs ↔ Realize f1 v xs
h2 : ∀ {xs : Fin n✝ → M}, Realize (toPrenex f2) v xs ↔ Realize f2 v xs
xs✝ : Fin n✝ → M
⊢ Realize (toPrenex (f1 ⟹ f2)) v xs✝ ↔ Realize (f1 ⟹ f2) v xs✝
[PROOFSTEP]
rw [toPrenex, realize_toPrenexImp f1.toPrenex_isPrenex f2.toPrenex_isPrenex, realize_imp, realize_imp, h1, h2]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
h : ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenex f✝) v xs ↔ Realize f✝ v xs
⊢ ∀ {xs : Fin n✝ → M}, Realize (toPrenex (∀'f✝)) v xs ↔ Realize (∀'f✝) v xs
[PROOFSTEP]
intros
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
h : ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenex f✝) v xs ↔ Realize f✝ v xs
xs✝ : Fin n✝ → M
⊢ Realize (toPrenex (∀'f✝)) v xs✝ ↔ Realize (∀'f✝) v xs✝
[PROOFSTEP]
rw [realize_all, toPrenex, realize_all]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs : Fin l → M
inst✝ : Nonempty M
v : α → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
h : ∀ {xs : Fin (n✝ + 1) → M}, Realize (toPrenex f✝) v xs ↔ Realize f✝ v xs
xs✝ : Fin n✝ → M
⊢ (∀ (a : M), Realize (toPrenex f✝) v (snoc xs✝ a)) ↔ ∀ (a : M), Realize f✝ v (snoc xs✝ a)
[PROOFSTEP]
exact forall_congr' fun a => h
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
ψ : BoundedFormula L α n
v : α → M
xs : Fin n → M
⊢ Realize (onBoundedFormula φ ψ) v xs ↔ Realize ψ v xs
[PROOFSTEP]
induction' ψ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
xs : Fin n✝ → M
⊢ Realize (onBoundedFormula φ falsum) v xs ↔ Realize falsum v xs
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ Realize (onBoundedFormula φ (equal t₁✝ t₂✝)) v xs ↔ Realize (equal t₁✝ t₂✝) v xs
[PROOFSTEP]
simp only [onBoundedFormula, realize_bdEqual, realize_onTerm]
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ Term.realize (Sum.elim v xs) t₁✝ = Term.realize (Sum.elim v xs) t₂✝ ↔ Realize (equal t₁✝ t₂✝) v xs
[PROOFSTEP]
rfl
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ Realize (onBoundedFormula φ (rel R✝ ts✝)) v xs ↔ Realize (rel R✝ ts✝) v xs
[PROOFSTEP]
simp only [onBoundedFormula, realize_rel, LHom.map_onRelation, Function.comp_apply, realize_onTerm]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ (RelMap R✝ fun i => Term.realize (Sum.elim v xs) (ts✝ i)) ↔ Realize (rel R✝ ts✝) v xs
[PROOFSTEP]
rfl
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 : ∀ {xs : Fin n✝ → M}, Realize (onBoundedFormula φ f₁✝) v xs ↔ Realize f₁✝ v xs
ih2 : ∀ {xs : Fin n✝ → M}, Realize (onBoundedFormula φ f₂✝) v xs ↔ Realize f₂✝ v xs
xs : Fin n✝ → M
⊢ Realize (onBoundedFormula φ (f₁✝ ⟹ f₂✝)) v xs ↔ Realize (f₁✝ ⟹ f₂✝) v xs
[PROOFSTEP]
simp only [onBoundedFormula, ih1, ih2, realize_imp]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n✝¹ : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
n : ℕ
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, Realize (onBoundedFormula φ f✝) v xs ↔ Realize f✝ v xs
xs : Fin n✝ → M
⊢ Realize (onBoundedFormula φ (∀'f✝)) v xs ↔ Realize (∀'f✝) v xs
[PROOFSTEP]
simp only [onBoundedFormula, ih3, realize_all]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
k : ℕ
R : Relations L k
ts : Fin k → Term L α
⊢ (RelMap R fun i => Term.realize (Sum.elim v default) (Term.relabel Sum.inl (ts i))) ↔
    RelMap R fun i => Term.realize v (ts i)
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
⊢ Realize (Relations.formula₁ R t) v ↔ RelMap R ![Term.realize v t]
[PROOFSTEP]
rw [Relations.formula₁, realize_rel, iff_eq_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
⊢ (RelMap R fun i => Term.realize v (Matrix.vecCons t ![] i)) = RelMap R ![Term.realize v t]
[PROOFSTEP]
refine' congr rfl (funext fun _ => _)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
x✝ : Fin 1
⊢ Term.realize v (Matrix.vecCons t ![] x✝) = Matrix.vecCons (Term.realize v t) ![] x✝
[PROOFSTEP]
simp only [Matrix.cons_val_fin_one]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ Realize (Relations.formula₂ R t₁ t₂) v ↔ RelMap R ![Term.realize v t₁, Term.realize v t₂]
[PROOFSTEP]
rw [Relations.formula₂, realize_rel, iff_eq_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ (RelMap R fun i => Term.realize v (Matrix.vecCons t₁ ![t₂] i)) = RelMap R ![Term.realize v t₁, Term.realize v t₂]
[PROOFSTEP]
refine' congr rfl (funext (Fin.cases _ _))
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ Term.realize v (Matrix.vecCons t₁ ![t₂] 0) = Matrix.vecCons (Term.realize v t₁) ![Term.realize v t₂] 0
[PROOFSTEP]
simp only [Matrix.cons_val_zero]
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ ∀ (i : Fin 1),
    Term.realize v (Matrix.vecCons t₁ ![t₂] (succ i)) = Matrix.vecCons (Term.realize v t₁) ![Term.realize v t₂] (succ i)
[PROOFSTEP]
simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ✝ ψ : Formula L α
v✝ : α → M
φ : Formula L α
g : α → β
v : β → M
⊢ Realize (relabel g φ) v ↔ Realize φ (v ∘ g)
[PROOFSTEP]
rw [Realize, Realize, relabel, BoundedFormula.realize_relabel, iff_eq_eq, Fin.castAdd_zero]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ✝ ψ : Formula L α
v✝ : α → M
φ : Formula L α
g : α → β
v : β → M
⊢ BoundedFormula.Realize φ (Sum.elim v (default ∘ Fin.cast (_ : 0 = 0)) ∘ Sum.inl ∘ g) (default ∘ natAdd 0) =
    BoundedFormula.Realize φ (v ∘ g) default
[PROOFSTEP]
exact congr rfl (funext finZeroElim)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ✝ ψ : Formula L α
v✝ : α → M
φ : Formula L (Fin n)
v : Empty → M
x : Fin n → M
⊢ BoundedFormula.Realize (BoundedFormula.relabel Sum.inr φ) v x ↔ Realize φ x
[PROOFSTEP]
rw [BoundedFormula.realize_relabel, Formula.Realize, Sum.elim_comp_inr, Fin.castAdd_zero, cast_refl,
  Function.comp.right_id, Subsingleton.elim (x ∘ (natAdd n : Fin 0 → Fin n)) default]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
t₁ t₂ : Term L α
x : α → M
⊢ Realize (Term.equal t₁ t₂) x ↔ Term.realize x t₁ = Term.realize x t₂
[PROOFSTEP]
simp [Term.equal, Realize]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
f : Functions L n
x : Fin n → M
y : M
⊢ Realize (graph f) (cons y x) ↔ funMap f x = y
[PROOFSTEP]
simp only [Formula.graph, Term.realize, realize_equal, Fin.cons_zero, Fin.cons_succ]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
f : Functions L n
x : Fin n → M
y : M
⊢ (y = funMap f fun i => x i) ↔ funMap f x = y
[PROOFSTEP]
rw [eq_comm]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
ψ : Formula L α
⊢ setOf (Formula.Realize (onFormula φ ψ)) = setOf (Formula.Realize ψ)
[PROOFSTEP]
ext
[GOAL]
case h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
ψ : Formula L α
x✝ : α → M
⊢ x✝ ∈ setOf (Formula.Realize (onFormula φ ψ)) ↔ x✝ ∈ setOf (Formula.Realize ψ)
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
⊢ (Realize (↑equivSentence.symm φ) fun a => ↑(Language.con L a)) ↔ M ⊨ φ
[PROOFSTEP]
simp only [equivSentence, Equiv.symm_symm, Equiv.coe_trans, Realize, BoundedFormula.realize_relabelEquiv, Function.comp]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
⊢ BoundedFormula.Realize (↑BoundedFormula.constantsVarsEquiv φ)
      (fun x => ↑(Language.con L (↑(Equiv.sumEmpty α Empty) x))) default ↔
    M ⊨ φ
[PROOFSTEP]
refine' _root_.trans _ BoundedFormula.realize_constantsVarsEquiv
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
⊢ BoundedFormula.Realize (↑BoundedFormula.constantsVarsEquiv φ)
      (fun x => ↑(Language.con L (↑(Equiv.sumEmpty α Empty) x))) default ↔
    BoundedFormula.Realize (↑BoundedFormula.constantsVarsEquiv φ) (Sum.elim (fun a => ↑(Language.con L a)) default)
      default
[PROOFSTEP]
rw [iff_iff_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
⊢ BoundedFormula.Realize (↑BoundedFormula.constantsVarsEquiv φ)
      (fun x => ↑(Language.con L (↑(Equiv.sumEmpty α Empty) x))) default =
    BoundedFormula.Realize (↑BoundedFormula.constantsVarsEquiv φ) (Sum.elim (fun a => ↑(Language.con L a)) default)
      default
[PROOFSTEP]
congr with (_ | a)
[GOAL]
case e__v.h.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
val✝ : α
⊢ ↑(Language.con L (↑(Equiv.sumEmpty α Empty) (Sum.inl val✝))) =
    Sum.elim (fun a => ↑(Language.con L a)) default (Sum.inl val✝)
[PROOFSTEP]
simp
[GOAL]
case e__v.h.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Sentence (L[[α]])
a : Empty
⊢ ↑(Language.con L (↑(Equiv.sumEmpty α Empty) (Sum.inr a))) =
    Sum.elim (fun a => ↑(Language.con L a)) default (Sum.inr a)
[PROOFSTEP]
cases a
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
φ : Formula L α
⊢ M ⊨ ↑equivSentence φ ↔ Realize φ fun a => ↑(Language.con L a)
[PROOFSTEP]
rw [← realize_equivSentence_symm_con M (equivSentence φ), _root_.Equiv.symm_apply_apply]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
⊢ M ≅[L] N ↔ ∀ (φ : Sentence L), M ⊨ φ ↔ N ⊨ φ
[PROOFSTEP]
simp only [ElementarilyEquivalent, Set.ext_iff, completeTheory, Set.mem_setOf_eq]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
T✝ : Theory L
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
T : Theory L
⊢ M ⊨ onTheory φ T ↔ M ⊨ T
[PROOFSTEP]
simp [Theory.model_iff, LHom.onTheory]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T T' : Theory L
h : M ⊨ T
h' : M ⊨ T'
⊢ M ⊨ T ∪ T'
[PROOFSTEP]
simp only [model_iff, Set.mem_union] at *
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T T' : Theory L
h : ∀ (φ : Sentence L), φ ∈ T → M ⊨ φ
h' : ∀ (φ : Sentence L), φ ∈ T' → M ⊨ φ
⊢ ∀ (φ : Sentence L), φ ∈ T ∨ φ ∈ T' → M ⊨ φ
[PROOFSTEP]
exact fun φ hφ => hφ.elim (h _) (h' _)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ : Sentence L
⊢ M ⊨ {φ} ↔ M ⊨ φ
[PROOFSTEP]
simp
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
inst✝ : N ⊨ completeTheory L M
φ : Sentence L
⊢ N ⊨ φ ↔ M ⊨ φ
[PROOFSTEP]
refine' ⟨fun h => _, (L.completeTheory M).realize_sentence_of_mem⟩
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
inst✝ : N ⊨ completeTheory L M
φ : Sentence L
h : N ⊨ φ
⊢ M ⊨ φ
[PROOFSTEP]
contrapose! h
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
inst✝ : N ⊨ completeTheory L M
φ : Sentence L
h : ¬M ⊨ φ
⊢ ¬N ⊨ φ
[PROOFSTEP]
rw [← Sentence.realize_not] at *
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
inst✝ : N ⊨ completeTheory L M
φ : Sentence L
h : M ⊨ Formula.not φ
⊢ N ⊨ Formula.not φ
[PROOFSTEP]
exact (L.completeTheory M).realize_sentence_of_mem (mem_completeTheory.2 h)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ : BoundedFormula L α n
v : α → M
⊢ Formula.Realize (alls φ) v ↔ ∀ (xs : Fin n → M), Realize φ v xs
[PROOFSTEP]
induction' n with n ih
[GOAL]
case zero
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ✝ : BoundedFormula L α n
v : α → M
φ : BoundedFormula L α Nat.zero
⊢ Formula.Realize (alls φ) v ↔ ∀ (xs : Fin Nat.zero → M), Realize φ v xs
[PROOFSTEP]
exact Unique.forall_iff.symm
[GOAL]
case succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (alls φ) v ↔ ∀ (xs : Fin n → M), Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ Formula.Realize (alls φ) v ↔ ∀ (xs : Fin (Nat.succ n) → M), Realize φ v xs
[PROOFSTEP]
simp only [alls, ih, Realize]
[GOAL]
case succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (alls φ) v ↔ ∀ (xs : Fin n → M), Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ (∀ (xs : Fin n → M) (x : M), Realize φ v (snoc xs x)) ↔ ∀ (xs : Fin (Nat.succ n) → M), Realize φ v xs
[PROOFSTEP]
exact ⟨fun h xs => Fin.snoc_init_self xs ▸ h _ _, fun h xs x => h (Fin.snoc xs x)⟩
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ : BoundedFormula L α n
v : α → M
⊢ Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
[PROOFSTEP]
induction' n with n ih
[GOAL]
case zero
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ✝ : BoundedFormula L α n
v : α → M
φ : BoundedFormula L α Nat.zero
⊢ Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
[PROOFSTEP]
exact Unique.exists_iff.symm
[GOAL]
case succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
[PROOFSTEP]
simp only [BoundedFormula.exs, ih, realize_ex]
[GOAL]
case succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ (∃ xs a, Realize φ v (snoc xs a)) ↔ ∃ xs, Realize φ v xs
[PROOFSTEP]
constructor
[GOAL]
case succ.mp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ (∃ xs a, Realize φ v (snoc xs a)) → ∃ xs, Realize φ v xs
[PROOFSTEP]
rintro ⟨xs, x, h⟩
[GOAL]
case succ.mp.intro.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
xs : Fin n → M
x : M
h : Realize φ v (snoc xs x)
⊢ ∃ xs, Realize φ v xs
[PROOFSTEP]
exact ⟨_, h⟩
[GOAL]
case succ.mpr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
⊢ (∃ xs, Realize φ v xs) → ∃ xs a, Realize φ v (snoc xs a)
[PROOFSTEP]
rintro ⟨xs, h⟩
[GOAL]
case succ.mpr.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
xs : Fin (Nat.succ n) → M
h : Realize φ v xs
⊢ ∃ xs a, Realize φ v (snoc xs a)
[PROOFSTEP]
rw [← Fin.snoc_init_self xs] at h 
[GOAL]
case succ.mpr.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
φ✝ : BoundedFormula L α n✝
v : α → M
n : ℕ
ih : ∀ {φ : BoundedFormula L α n}, Formula.Realize (exs φ) v ↔ ∃ xs, Realize φ v xs
φ : BoundedFormula L α (Nat.succ n)
xs : Fin (Nat.succ n) → M
h : Realize φ v (snoc (init xs) (xs (last n)))
⊢ ∃ xs a, Realize φ v (snoc xs a)
[PROOFSTEP]
exact ⟨_, _, h⟩
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ : BoundedFormula L α n
v : α ⊕ Fin n → M
⊢ Formula.Realize (toFormula φ) v ↔ Realize φ (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3 a8 a9 a0
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
v : α ⊕ Fin n✝ → M
⊢ Formula.Realize (toFormula falsum) v ↔ Realize falsum (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
v : α ⊕ Fin n✝ → M
⊢ Formula.Realize (toFormula (equal t₁✝ t₂✝)) v ↔ Realize (equal t₁✝ t₂✝) (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
simp [BoundedFormula.Realize]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
v : α ⊕ Fin n✝ → M
⊢ Formula.Realize (toFormula (rel R✝ ts✝)) v ↔ Realize (rel R✝ ts✝) (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
simp [BoundedFormula.Realize]
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 : ∀ (v : α ⊕ Fin n✝ → M), Formula.Realize (toFormula f₁✝) v ↔ Realize f₁✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
ih2 : ∀ (v : α ⊕ Fin n✝ → M), Formula.Realize (toFormula f₂✝) v ↔ Realize f₂✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
⊢ Formula.Realize (toFormula (f₁✝ ⟹ f₂✝)) v ↔ Realize (f₁✝ ⟹ f₂✝) (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
rw [toFormula, Formula.Realize, realize_imp, ← Formula.Realize, ih1, ← Formula.Realize, ih2, realize_imp]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
⊢ Formula.Realize (toFormula (∀'f✝)) v ↔ Realize (∀'f✝) (v ∘ Sum.inl) (v ∘ Sum.inr)
[PROOFSTEP]
rw [toFormula, Formula.Realize, realize_all, realize_all]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
⊢ (∀ (a : M),
      Realize (relabel (Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ↑finSumFinEquiv.symm)) (toFormula f✝)) v
        (snoc default a)) ↔
    ∀ (a : M), Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
[PROOFSTEP]
refine' forall_congr' fun a => _
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
⊢ Realize (relabel (Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ↑finSumFinEquiv.symm)) (toFormula f✝)) v
      (snoc default a) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
[PROOFSTEP]
have h := ih3 (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a))
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a) ∘ Sum.inl)
      (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a) ∘ Sum.inr)
⊢ Realize (relabel (Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ↑finSumFinEquiv.symm)) (toFormula f✝)) v
      (snoc default a) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
[PROOFSTEP]
simp only [Sum.elim_comp_inl, Sum.elim_comp_inr] at h 
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
⊢ Realize (relabel (Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ↑finSumFinEquiv.symm)) (toFormula f✝)) v
      (snoc default a) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
[PROOFSTEP]
rw [← h, realize_relabel, Formula.Realize, iff_iff_eq]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
⊢ Realize (toFormula f✝)
      (Sum.elim v (snoc default a ∘ castAdd 0) ∘
        Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ↑finSumFinEquiv.symm))
      (snoc default a ∘ natAdd 1) =
    Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) default
[PROOFSTEP]
simp only [Function.comp]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
⊢ (Realize (toFormula f✝)
      (fun x =>
        Sum.elim v (fun x => snoc default a (castAdd 0 x))
          (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x)) x))
      fun x => snoc default a (natAdd 1 x)) =
    Realize (toFormula f✝) (Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a)) default
[PROOFSTEP]
congr with x
[GOAL]
case all.e__v.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : α ⊕ Fin (n✝ + 1)
⊢ Sum.elim v (fun x => snoc default a (castAdd 0 x))
      (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x)) x) =
    Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a) x
[PROOFSTEP]
cases' x with _ x
[GOAL]
case all.e__v.h.inl
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
val✝ : α
⊢ Sum.elim v (fun x => snoc default a (castAdd 0 x))
      (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x)) (Sum.inl val✝)) =
    Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a) (Sum.inl val✝)
[PROOFSTEP]
simp
[GOAL]
case all.e__v.h.inr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ Sum.elim v (fun x => snoc default a (castAdd 0 x))
      (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x)) (Sum.inr x)) =
    Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a) (Sum.inr x)
[PROOFSTEP]
refine' Fin.lastCases _ _ x
[GOAL]
case all.e__v.h.inr.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ Sum.elim v (fun x => snoc default a (castAdd 0 x))
      (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x))
        (Sum.inr (last n✝))) =
    Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a) (Sum.inr (last n✝))
[PROOFSTEP]
rw [Sum.elim_inr, Sum.elim_inr, finSumFinEquiv_symm_last, Sum.map_inr, Sum.elim_inr]
[GOAL]
case all.e__v.h.inr.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ snoc default a (castAdd 0 (id 0)) = snoc (fun x => v (Sum.inr x)) a (last n✝)
[PROOFSTEP]
simp [Fin.snoc]
[GOAL]
case all.e__v.h.inr.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ ∀ (i : Fin n✝),
    Sum.elim v (fun x => snoc default a (castAdd 0 x))
        (Sum.elim (fun x => Sum.inl (Sum.inl x)) (fun x => Sum.map Sum.inr id (↑finSumFinEquiv.symm x))
          (Sum.inr (castSucc i))) =
      Sum.elim (fun x => v (Sum.inl x)) (snoc (fun x => v (Sum.inr x)) a) (Sum.inr (castSucc i))
[PROOFSTEP]
simp only [castSucc, Function.comp_apply, Sum.elim_inr, finSumFinEquiv_symm_apply_castAdd, Sum.map_inl, Sum.elim_inl]
[GOAL]
case all.e__v.h.inr.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ ∀ (i : Fin n✝), v (Sum.inr i) = snoc (fun x => v (Sum.inr x)) a (castAdd 1 i)
[PROOFSTEP]
rw [← castSucc]
[GOAL]
case all.e__v.h.inr.refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin (n✝ + 1)
⊢ ∀ (i : Fin n✝), v (Sum.inr i) = snoc (fun x => v (Sum.inr x)) a (castSucc i)
[PROOFSTEP]
simp
[GOAL]
case all.e__xs.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
v✝ : α ⊕ Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), Formula.Realize (toFormula f✝) v ↔ Realize f✝ (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
  Formula.Realize (toFormula f✝) (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔
    Realize f✝ (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
x : Fin 0
⊢ snoc default a (natAdd 1 x) = default x
[PROOFSTEP]
exact Fin.elim0 x
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
φ : BoundedFormula L α n
v : α → M
xs : Fin n → M
⊢ BoundedFormula.Realize φ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize φ v xs
[PROOFSTEP]
induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3
[GOAL]
case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
xs : Fin n✝ → M
⊢ BoundedFormula.Realize BoundedFormula.falsum (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize BoundedFormula.falsum v xs
[PROOFSTEP]
rfl
[GOAL]
case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ BoundedFormula.Realize (BoundedFormula.equal t₁✝ t₂✝) (↑g ∘ v) (↑g ∘ xs) ↔
    BoundedFormula.Realize (BoundedFormula.equal t₁✝ t₂✝) v xs
[PROOFSTEP]
simp only [BoundedFormula.Realize, ← Sum.comp_elim, Equiv.realize_term, g.injective.eq_iff]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ BoundedFormula.Realize (BoundedFormula.rel R✝ ts✝) (↑g ∘ v) (↑g ∘ xs) ↔
    BoundedFormula.Realize (BoundedFormula.rel R✝ ts✝) v xs
[PROOFSTEP]
simp only [BoundedFormula.Realize, ← Sum.comp_elim, Equiv.realize_term]
[GOAL]
case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin n✝ → M
⊢ (RelMap R✝ fun i => ↑g (Term.realize (Sum.elim v xs) (ts✝ i))) ↔
    RelMap R✝ fun i => Term.realize (Sum.elim v xs) (ts✝ i)
[PROOFSTEP]
exact g.map_rel _ _
[GOAL]
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 : ∀ {xs : Fin n✝ → M}, BoundedFormula.Realize f₁✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f₁✝ v xs
ih2 : ∀ {xs : Fin n✝ → M}, BoundedFormula.Realize f₂✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f₂✝ v xs
xs : Fin n✝ → M
⊢ BoundedFormula.Realize (f₁✝ ⟹ f₂✝) (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize (f₁✝ ⟹ f₂✝) v xs
[PROOFSTEP]
rw [BoundedFormula.Realize, ih1, ih2, BoundedFormula.Realize]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
⊢ BoundedFormula.Realize (∀'f✝) (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize (∀'f✝) v xs
[PROOFSTEP]
rw [BoundedFormula.Realize, BoundedFormula.Realize]
[GOAL]
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
⊢ (∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)) ↔
    ∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)
[PROOFSTEP]
constructor
[GOAL]
case all.mp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
⊢ (∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)) →
    ∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)
[PROOFSTEP]
intro h a
[GOAL]
case all.mp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)
a : M
⊢ BoundedFormula.Realize f✝ v (snoc xs a)
[PROOFSTEP]
have h' := h (g a)
[GOAL]
case all.mp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)
a : M
h' : BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) (↑g a))
⊢ BoundedFormula.Realize f✝ v (snoc xs a)
[PROOFSTEP]
rw [← Fin.comp_snoc, ih3] at h' 
[GOAL]
case all.mp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)
a : M
h' : BoundedFormula.Realize f✝ v (snoc xs a)
⊢ BoundedFormula.Realize f✝ v (snoc xs a)
[PROOFSTEP]
exact h'
[GOAL]
case all.mpr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
⊢ (∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)) →
    ∀ (x : N), BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) x)
[PROOFSTEP]
intro h a
[GOAL]
case all.mpr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)
a : N
⊢ BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) a)
[PROOFSTEP]
have h' := h (g.symm a)
[GOAL]
case all.mpr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)
a : N
h' : BoundedFormula.Realize f✝ v (snoc xs (↑(symm g) a))
⊢ BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) a)
[PROOFSTEP]
rw [← ih3, Fin.comp_snoc, g.apply_symm_apply] at h' 
[GOAL]
case all.mpr
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
v : α → M
xs✝ : Fin n → M
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ {xs : Fin (n✝ + 1) → M}, BoundedFormula.Realize f✝ (↑g ∘ v) (↑g ∘ xs) ↔ BoundedFormula.Realize f✝ v xs
xs : Fin n✝ → M
h : ∀ (x : M), BoundedFormula.Realize f✝ v (snoc xs x)
a : N
h' : BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) a)
⊢ BoundedFormula.Realize f✝ (↑g ∘ v) (snoc (↑g ∘ xs) a)
[PROOFSTEP]
exact h'
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
φ : Formula L α
v : α → M
⊢ Formula.Realize φ (↑g ∘ v) ↔ Formula.Realize φ v
[PROOFSTEP]
rw [Formula.Realize, Formula.Realize, ← g.realize_boundedFormula φ, iff_eq_eq, Unique.eq_default (g ∘ default)]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
φ : Sentence L
⊢ M ⊨ φ ↔ N ⊨ φ
[PROOFSTEP]
rw [Sentence.Realize, Sentence.Realize, ← g.realize_formula, Unique.eq_default (g ∘ default)]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
⊢ M ⊨ Sentence.cardGe L n ↔ ↑n ≤ #M
[PROOFSTEP]
rw [← lift_mk_fin, ← lift_le.{0}, lift_lift, lift_mk_le, Sentence.cardGe, Sentence.Realize, BoundedFormula.realize_exs]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
⊢ (∃ xs,
      BoundedFormula.Realize
        (List.foldr (fun x x_1 => x ⊓ x_1) ⊤
          (List.map (fun ij => ∼((var ∘ Sum.inr) ij.fst =' (var ∘ Sum.inr) ij.snd))
            (List.filter (fun ij => decide (ij.fst ≠ ij.snd)) (List.finRange n ×ˢ List.finRange n))))
        default xs) ↔
    Nonempty (Fin n ↪ M)
[PROOFSTEP]
simp_rw [BoundedFormula.realize_foldr_inf]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
⊢ (∃ xs,
      ∀ (φ : BoundedFormula L Empty n),
        φ ∈
            List.map (fun ij => ∼((var ∘ Sum.inr) ij.fst =' (var ∘ Sum.inr) ij.snd))
              (List.filter (fun ij => decide (ij.fst ≠ ij.snd)) (List.finRange n ×ˢ List.finRange n)) →
          BoundedFormula.Realize φ default xs) ↔
    Nonempty (Fin n ↪ M)
[PROOFSTEP]
simp only [Function.comp_apply, List.mem_map, Prod.exists, Ne.def, List.mem_product, List.mem_finRange,
  forall_exists_index, and_imp, List.mem_filter, true_and_iff]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
⊢ (∃ xs,
      ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
        (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs) ↔
    Nonempty (Fin n ↪ M)
[PROOFSTEP]
refine' ⟨_, fun xs => ⟨xs.some, _⟩⟩
[GOAL]
case refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
⊢ (∃ xs,
      ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
        (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs) →
    Nonempty (Fin n ↪ M)
[PROOFSTEP]
rintro ⟨xs, h⟩
[GOAL]
case refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
⊢ Nonempty (Fin n ↪ M)
[PROOFSTEP]
refine' ⟨⟨xs, fun i j ij => _⟩⟩
[GOAL]
case refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
i j : Fin n
ij : xs i = xs j
⊢ i = j
[PROOFSTEP]
contrapose! ij
[GOAL]
case refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
i j : Fin n
ij : i ≠ j
⊢ xs i ≠ xs j
[PROOFSTEP]
have hij := h _ i j (by simpa using ij) rfl
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
i j : Fin n
ij : i ≠ j
⊢ (decide ¬i = j) = true
[PROOFSTEP]
simpa using ij
[GOAL]
case refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
i j : Fin n
ij : i ≠ j
hij : BoundedFormula.Realize (∼(var (Sum.inr i) =' var (Sum.inr j))) default xs
⊢ xs i ≠ xs j
[PROOFSTEP]
simp only [BoundedFormula.realize_not, Term.realize, BoundedFormula.realize_bdEqual, Sum.elim_inr] at hij 
[GOAL]
case refine'_1.intro
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Fin n → M
h :
  ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true → ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default xs
i j : Fin n
ij : i ≠ j
hij : ¬xs i = xs j
⊢ xs i ≠ xs j
[PROOFSTEP]
exact hij
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Nonempty (Fin n ↪ M)
⊢ ∀ (φ : BoundedFormula L Empty n) (x x_1 : Fin n),
    (decide ¬x = x_1) = true →
      ∼(var (Sum.inr x) =' var (Sum.inr x_1)) = φ → BoundedFormula.Realize φ default ↑(Nonempty.some xs)
[PROOFSTEP]
rintro _ i j ij rfl
[GOAL]
case refine'_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ : ℕ
T : Theory L
n : ℕ
xs : Nonempty (Fin n ↪ M)
i j : Fin n
ij : (decide ¬i = j) = true
⊢ BoundedFormula.Realize (∼(var (Sum.inr i) =' var (Sum.inr j))) default ↑(Nonempty.some xs)
[PROOFSTEP]
simpa using ij
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
⊢ M ⊨ infiniteTheory L ↔ Infinite M
[PROOFSTEP]
simp [infiniteTheory, infinite_iff, aleph0_le]
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
⊢ M ⊨ nonemptyTheory L ↔ Nonempty M
[PROOFSTEP]
simp only [nonemptyTheory, Theory.model_iff, Set.mem_singleton_iff, forall_eq, Sentence.realize_cardGe, Nat.cast_one,
  one_le_iff_ne_zero, mk_ne_zero_iff]
[GOAL]
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
⊢ M ⊨ distinctConstantsTheory L s ↔ Set.InjOn (fun i => ↑(Language.con L i)) s
[PROOFSTEP]
simp only [distinctConstantsTheory, Theory.model_iff, Set.mem_image, Set.mem_inter, Set.mem_prod, Set.mem_compl,
  Prod.exists, forall_exists_index, and_imp]
[GOAL]
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
⊢ (∀ (φ : Sentence (L[[α]])) (x x_1 : α),
      (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
        Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ →
          M ⊨ φ) ↔
    Set.InjOn (fun i => ↑(Language.con L i)) s
[PROOFSTEP]
refine' ⟨fun h a as b bs ab => _, _⟩
[GOAL]
case refine'_1
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h :
  ∀ (φ : Sentence (L[[α]])) (x x_1 : α),
    (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
      Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ → M ⊨ φ
a : α
as : a ∈ s
b : α
bs : b ∈ s
ab : (fun i => ↑(Language.con L i)) a = (fun i => ↑(Language.con L i)) b
⊢ a = b
[PROOFSTEP]
contrapose! ab
[GOAL]
case refine'_1
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h :
  ∀ (φ : Sentence (L[[α]])) (x x_1 : α),
    (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
      Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ → M ⊨ φ
a : α
as : a ∈ s
b : α
bs : b ∈ s
ab : a ≠ b
⊢ ↑(Language.con L a) ≠ ↑(Language.con L b)
[PROOFSTEP]
have h' := h _ a b ⟨⟨as, bs⟩, ab⟩ rfl
[GOAL]
case refine'_1
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h :
  ∀ (φ : Sentence (L[[α]])) (x x_1 : α),
    (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
      Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ → M ⊨ φ
a : α
as : a ∈ s
b : α
bs : b ∈ s
ab : a ≠ b
h' : M ⊨ Formula.not (Term.equal (Constants.term (Language.con L a)) (Constants.term (Language.con L b)))
⊢ ↑(Language.con L a) ≠ ↑(Language.con L b)
[PROOFSTEP]
simp only [Sentence.Realize, Formula.realize_not, Formula.realize_equal, Term.realize_constants] at h' 
[GOAL]
case refine'_1
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h :
  ∀ (φ : Sentence (L[[α]])) (x x_1 : α),
    (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
      Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ → M ⊨ φ
a : α
as : a ∈ s
b : α
bs : b ∈ s
ab : a ≠ b
h' : ¬↑(Language.con L a) = ↑(Language.con L b)
⊢ ↑(Language.con L a) ≠ ↑(Language.con L b)
[PROOFSTEP]
exact h'
[GOAL]
case refine'_2
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
⊢ Set.InjOn (fun i => ↑(Language.con L i)) s →
    ∀ (φ : Sentence (L[[α]])) (x x_1 : α),
      (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ →
        Formula.not (Term.equal (Constants.term (Language.con L x)) (Constants.term (Language.con L x_1))) = φ → M ⊨ φ
[PROOFSTEP]
rintro h φ a b ⟨⟨as, bs⟩, ab⟩ rfl
[GOAL]
case refine'_2.intro.intro
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h : Set.InjOn (fun i => ↑(Language.con L i)) s
a b : α
ab : (a, b) ∈ (Set.diagonal α)ᶜ
as : (a, b).fst ∈ s
bs : (a, b).snd ∈ s
⊢ M ⊨ Formula.not (Term.equal (Constants.term (Language.con L a)) (Constants.term (Language.con L b)))
[PROOFSTEP]
simp only [Sentence.Realize, Formula.realize_not, Formula.realize_equal, Term.realize_constants]
[GOAL]
case refine'_2.intro.intro
L : Language
L' : Language
M✝ : Type w
N : Type u_1
P : Type u_2
inst✝³ : Structure L M✝
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
M : Type w
inst✝ : Structure (L[[α]]) M
s : Set α
h : Set.InjOn (fun i => ↑(Language.con L i)) s
a b : α
ab : (a, b) ∈ (Set.diagonal α)ᶜ
as : (a, b).fst ∈ s
bs : (a, b).snd ∈ s
⊢ ¬↑(Language.con L a) = ↑(Language.con L b)
[PROOFSTEP]
exact fun contra => ab (h as bs contra)
[GOAL]
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
h : M ≅[L] N
⊢ M ⊨ T ↔ N ⊨ T
[PROOFSTEP]
rw [Theory.model_iff_subset_completeTheory, Theory.model_iff_subset_completeTheory, h.completeTheory_eq]
