fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
realize_liftAt {n n' m : ℕ} {t : L.Term (α ⊕ (Fin n))} {v : α ⊕ (Fin (n + n')) → M} :
(t.liftAt n' m).realize v =
t.realize (v ∘ Sum.map id fun i : Fin _ =>
if ↑i < m then Fin.castAdd n' i else Fin.addNat i n') :=
realize_relabel
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_liftAt | null |
realize_constants {c : L.Constants} {v : α → M} : c.term.realize v = c :=
funMap_eq_coe_constants
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_constants | null |
realize_functions_apply₁ {f : L.Functions 1} {t : L.Term α} {v : α → M} :
(f.apply₁ t).realize v = funMap f ![t.realize v] := by
rw [Functions.apply₁, Term.realize]
refine congr rfl (funext fun i => ?_)
simp only [Matrix.cons_val_fin_one]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_functions_apply₁ | null |
realize_functions_apply₂ {f : L.Functions 2} {t₁ t₂ : L.Term α} {v : α → M} :
(f.apply₂ t₁ t₂).realize v = funMap f ![t₁.realize v, t₂.realize v] := by
rw [Functions.apply₂, Term.realize]
refine congr rfl (funext (Fin.cases ?_ ?_))
· simp only [Matrix.cons_val_zero]
· simp only [Matrix.cons_val_succ, Matrix... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_functions_apply₂ | null |
realize_con {A : Set M} {a : A} {v : α → M} : (L.con a).term.realize v = a :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_con | null |
realize_subst {t : L.Term α} {tf : α → L.Term β} {v : β → M} :
(t.subst tf).realize v = t.realize fun a => (tf a).realize v := by
induction t with
| var => rfl
| func _ _ ih => simp [ih] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_subst | null |
realize_restrictVar [DecidableEq α] {t : L.Term α} {f : t.varFinset → β}
{v : β → M} (v' : α → M) (hv' : ∀ a, v (f a) = v' a) :
(t.restrictVar f).realize v = t.realize v' := by
induction t with
| var => simp [restrictVar, hv']
| func _ _ ih =>
exact congr rfl (funext fun i => ih i ((by simp [Function.... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictVar | null |
@[simp]
realize_restrictVar' [DecidableEq α] {t : L.Term α} {s : Set α} (h : ↑t.varFinset ⊆ s)
{v : α → M} : (t.restrictVar (Set.inclusion h)).realize (v ∘ (↑)) = t.realize v :=
realize_restrictVar _ (by simp) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictVar' | A special case of `realize_restrictVar`, included because we can add the `simp` attribute
to it |
realize_restrictVarLeft [DecidableEq α] {γ : Type*} {t : L.Term (α ⊕ γ)}
{f : t.varFinsetLeft → β}
{xs : β ⊕ γ → M} (xs' : α → M) (hxs' : ∀ a, xs (Sum.inl (f a)) = xs' a) :
(t.restrictVarLeft f).realize xs = t.realize (Sum.elim xs' (xs ∘ Sum.inr)) := by
induction t with
| var a => cases a <;> simp [rest... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictVarLeft | null |
@[simp]
realize_restrictVarLeft' [DecidableEq α] {γ : Type*} {t : L.Term (α ⊕ γ)} {s : Set α}
(h : ↑t.varFinsetLeft ⊆ s) {v : α → M} {xs : γ → M} :
(t.restrictVarLeft (Set.inclusion h)).realize (Sum.elim (v ∘ (↑)) xs) =
t.realize (Sum.elim v xs) :=
realize_restrictVarLeft _ (by simp)
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictVarLeft' | A special case of `realize_restrictVarLeft`, included because we can add the `simp` attribute
to it |
realize_constantsToVars [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
{t : L[[α]].Term β} {v : β → M} :
t.constantsToVars.realize (Sum.elim (fun a => ↑(L.con a)) v) = t.realize v := by
induction t with
| var => simp
| @func n f ts ih =>
cases n
· cases f
· simp only [realize... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_constantsToVars | null |
realize_varsToConstants [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
{t : L.Term (α ⊕ β)} {v : β → M} :
t.varsToConstants.realize v = t.realize (Sum.elim (fun a => ↑(L.con a)) v) := by
induction t with
| var ab => rcases ab with a | b <;> simp [Language.con]
| func f ts ih =>
simp on... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_varsToConstants | null |
realize_constantsVarsEquivLeft [L[[α]].Structure M]
[(lhomWithConstants L α).IsExpansionOn M] {n} {t : L[[α]].Term (β ⊕ (Fin n))} {v : β → M}
{xs : Fin n → M} :
(constantsVarsEquivLeft t).realize (Sum.elim (Sum.elim (fun a => ↑(L.con a)) v) xs) =
t.realize (Sum.elim v xs) := by
simp only [constantsV... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_constantsVarsEquivLeft | null |
@[simp]
realize_onTerm [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (t : L.Term α)
(v : α → M) : (φ.onTerm t).realize v = t.realize v := by
induction t with
| var => rfl
| func f ts ih => simp only [Term.realize, LHom.onTerm, LHom.map_onFunction, ih] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_onTerm | null |
@[simp]
HomClass.realize_term {F : Type*} [FunLike F M N] [HomClass L F M N]
(g : F) {t : L.Term α} {v : α → M} :
t.realize (g ∘ v) = g (t.realize v) := by
induction t
· rfl
· rw [Term.realize, Term.realize, HomClass.map_fun]
refine congr rfl ?_
ext x
simp [*]
variable {n : ℕ} | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | HomClass.realize_term | null |
Realize : ∀ {l} (_f : L.BoundedFormula α l) (_v : α → M) (_xs : Fin l → M), Prop
| _, falsum, _v, _xs => False
| _, equal t₁ t₂, v, xs => t₁.realize (Sum.elim v xs) = t₂.realize (Sum.elim v xs)
| _, rel R ts, v, xs => RelMap R fun i => (ts i).realize (Sum.elim v xs)
| _, imp f₁ f₂, v, xs => Realize f₁ v xs → Re... | def | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Realize | A bounded formula can be evaluated as true or false by giving values to each free and bound
variable. |
realize_bot : (⊥ : L.BoundedFormula α l).Realize v xs ↔ False :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_bot | null |
realize_not : φ.not.Realize v xs ↔ ¬φ.Realize v xs :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_not | null |
realize_bdEqual (t₁ t₂ : L.Term (α ⊕ (Fin l))) :
(t₁.bdEqual t₂).Realize v xs ↔ t₁.realize (Sum.elim v xs) = t₂.realize (Sum.elim v xs) :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_bdEqual | null |
realize_top : (⊤ : L.BoundedFormula α l).Realize v xs ↔ True := by simp [Top.top]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_top | null |
realize_inf : (φ ⊓ ψ).Realize v xs ↔ φ.Realize v xs ∧ ψ.Realize v xs := by
simp [Realize]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_inf | null |
realize_foldr_inf (l : List (L.BoundedFormula α n)) (v : α → M) (xs : Fin n → M) :
(l.foldr (· ⊓ ·) ⊤).Realize v xs ↔ ∀ φ ∈ l, BoundedFormula.Realize φ v xs := by
induction l with
| nil => simp
| cons φ l ih => simp [ih]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_foldr_inf | null |
realize_imp : (φ.imp ψ).Realize v xs ↔ φ.Realize v xs → ψ.Realize v xs := by
simp only [Realize] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_imp | null |
realize_foldr_imp {k : ℕ} (l : List (L.BoundedFormula α k))
(f : L.BoundedFormula α k) :
∀ (v : α → M) xs,
(l.foldr BoundedFormula.imp f).Realize v xs =
((∀ i ∈ l, i.Realize v xs) → f.Realize v xs) := by
intro v xs
induction l
next => simp
next f' _ _ => by_cases f'.Realize v xs <;> simp [*]... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_foldr_imp | List.foldr on BoundedFormula.imp gives a big "And" of input conditions. |
realize_rel {k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term _} :
(R.boundedFormula ts).Realize v xs ↔ RelMap R fun i => (ts i).realize (Sum.elim v xs) :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_rel | null |
realize_rel₁ {R : L.Relations 1} {t : L.Term _} :
(R.boundedFormula₁ t).Realize v xs ↔ RelMap R ![t.realize (Sum.elim v xs)] := by
rw [Relations.boundedFormula₁, realize_rel, iff_eq_eq]
refine congr rfl (funext fun _ => ?_)
simp only [Matrix.cons_val_fin_one]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_rel₁ | null |
realize_rel₂ {R : L.Relations 2} {t₁ t₂ : L.Term _} :
(R.boundedFormula₂ t₁ t₂).Realize v xs ↔
RelMap R ![t₁.realize (Sum.elim v xs), t₂.realize (Sum.elim v xs)] := by
rw [Relations.boundedFormula₂, realize_rel, iff_eq_eq]
refine congr rfl (funext (Fin.cases ?_ ?_))
· simp only [Matrix.cons_val_zero]
... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_rel₂ | null |
realize_sup : (φ ⊔ ψ).Realize v xs ↔ φ.Realize v xs ∨ ψ.Realize v xs := by
simp only [max]
tauto
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_sup | null |
realize_foldr_sup (l : List (L.BoundedFormula α n)) (v : α → M) (xs : Fin n → M) :
(l.foldr (· ⊔ ·) ⊥).Realize v xs ↔ ∃ φ ∈ l, BoundedFormula.Realize φ v xs := by
induction l with
| nil => simp
| cons φ l ih =>
simp_rw [List.foldr_cons, realize_sup, ih, List.mem_cons, or_and_right, exists_or,
exists... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_foldr_sup | null |
realize_all : (all θ).Realize v xs ↔ ∀ a : M, θ.Realize v (Fin.snoc xs a) :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_all | null |
realize_ex : θ.ex.Realize v xs ↔ ∃ a : M, θ.Realize v (Fin.snoc xs a) := by
rw [BoundedFormula.ex, realize_not, realize_all, not_forall]
simp_rw [realize_not, Classical.not_not]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_ex | null |
realize_iff : (φ.iff ψ).Realize v xs ↔ (φ.Realize v xs ↔ ψ.Realize v xs) := by
simp only [BoundedFormula.iff, realize_inf, realize_imp, ← iff_def] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iff | null |
realize_castLE_of_eq {m n : ℕ} (h : m = n) {h' : m ≤ n} {φ : L.BoundedFormula α m}
{v : α → M} {xs : Fin n → M} : (φ.castLE h').Realize v xs ↔ φ.Realize v (xs ∘ Fin.cast h) := by
subst h
simp only [castLE_rfl, cast_refl, Function.comp_id] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_castLE_of_eq | null |
realize_mapTermRel_id [L'.Structure M]
{ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin n))}
{fr : ∀ n, L.Relations n → L'.Relations n} {n} {φ : L.BoundedFormula α n} {v : α → M}
{v' : β → M} {xs : Fin n → M}
(h1 :
∀ (n) (t : L.Term (α ⊕ (Fin n))) (xs : Fin n → M),
(ft n t).realize (Sum... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_mapTermRel_id | null |
realize_mapTermRel_add_castLe [L'.Structure M] {k : ℕ}
{ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin (k + n)))}
{fr : ∀ n, L.Relations n → L'.Relations n} {n} {φ : L.BoundedFormula α n}
(v : ∀ {n}, (Fin (k + n) → M) → α → M) {v' : β → M} (xs : Fin (k + n) → M)
(h1 :
∀ (n) (t : L.Term (α ⊕ (F... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_mapTermRel_add_castLe | null |
realize_relabel {m n : ℕ} {φ : L.BoundedFormula α n} {g : α → β ⊕ (Fin m)} {v : β → M}
{xs : Fin (m + n) → M} :
(φ.relabel g).Realize v xs ↔
φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAdd m) := by
apply realize_mapTermRel_add_castLe <;> simp | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_relabel | null |
realize_liftAt {n n' m : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + n') → M}
(hmn : m + n' ≤ n + 1) :
(φ.liftAt n' m).Realize v xs ↔
φ.Realize v (xs ∘ fun i => if ↑i < m then Fin.castAdd n' i else Fin.addNat i n') := by
rw [liftAt]
induction φ with
| falsum => simp [mapTermRel, Realize... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_liftAt | null |
realize_liftAt_one {n m : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + 1) → M}
(hmn : m ≤ n) :
(φ.liftAt 1 m).Realize v xs ↔
φ.Realize v (xs ∘ fun i => if ↑i < m then castSucc i else i.succ) := by
simp [realize_liftAt (add_le_add_right hmn 1), castSucc]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_liftAt_one | null |
realize_liftAt_one_self {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
{xs : Fin (n + 1) → M} : (φ.liftAt 1 n).Realize v xs ↔ φ.Realize v (xs ∘ castSucc) := by
rw [realize_liftAt_one (refl n), iff_eq_eq]
refine congr rfl (congr rfl (funext fun i => ?_))
rw [if_pos i.is_lt]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_liftAt_one_self | null |
realize_subst {φ : L.BoundedFormula α n} {tf : α → L.Term β} {v : β → M} {xs : Fin n → M} :
(φ.subst tf).Realize v xs ↔ φ.Realize (fun a => (tf a).realize v) xs :=
realize_mapTermRel_id
(fun n t x => by
rw [Term.realize_subst]
rcongr a
cases a
· simp only [Sum.elim_inl, Function.comp_a... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_subst | null |
realize_restrictFreeVar [DecidableEq α] {n : ℕ} {φ : L.BoundedFormula α n}
{f : φ.freeVarFinset → β} {v : β → M} {xs : Fin n → M}
(v' : α → M) (hv' : ∀ a, v (f a) = v' a) :
(φ.restrictFreeVar f).Realize v xs ↔ φ.Realize v' xs := by
induction φ with
| falsum => rfl
| equal =>
simp only [Realize, re... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictFreeVar | null |
@[simp]
realize_restrictFreeVar' [DecidableEq α] {n : ℕ} {φ : L.BoundedFormula α n} {s : Set α}
(h : ↑φ.freeVarFinset ⊆ s) {v : α → M} {xs : Fin n → M} :
(φ.restrictFreeVar (Set.inclusion h)).Realize (v ∘ (↑)) xs ↔ φ.Realize v xs :=
realize_restrictFreeVar _ (by simp) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_restrictFreeVar' | A special case of `realize_restrictFreeVar`, included because we can add the `simp` attribute
to it |
realize_constantsVarsEquiv [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
{n} {φ : L[[α]].BoundedFormula β n} {v : β → M} {xs : Fin n → M} :
(constantsVarsEquiv φ).Realize (Sum.elim (fun a => ↑(L.con a)) v) xs ↔ φ.Realize v xs := by
refine realize_mapTermRel_id (fun n t xs => realize_constants... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_constantsVarsEquiv | null |
realize_relabelEquiv {g : α ≃ β} {k} {φ : L.BoundedFormula α k} {v : β → M}
{xs : Fin k → M} : (relabelEquiv g φ).Realize v xs ↔ φ.Realize (v ∘ g) xs := by
simp only [relabelEquiv, mapTermRelEquiv_apply, Equiv.coe_refl]
refine realize_mapTermRel_id (fun n t xs => ?_) fun _ _ _ => rfl
simp only [relabelEquiv_a... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_relabelEquiv | null |
realize_all_liftAt_one_self {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
{xs : Fin n → M} : (φ.liftAt 1 n).all.Realize v xs ↔ φ.Realize v xs := by
simp | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_all_liftAt_one_self | null |
@[simp]
realize_onBoundedFormula [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ}
(ψ : L.BoundedFormula α n) {v : α → M} {xs : Fin n → M} :
(φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs := by
induction ψ with
| falsum => rfl
| equal => simp only [onBoundedFormula, realize_bdEqual, realize... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_onBoundedFormula | null |
completeTheory : L.Theory :=
{ φ | M ⊨ φ }
variable (N) | def | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | completeTheory | A formula can be evaluated as true or false by giving values to each free variable. -/
nonrec def Realize (φ : L.Formula α) (v : α → M) : Prop :=
φ.Realize v default
variable {φ ψ : L.Formula α} {v : α → M}
@[simp]
theorem realize_not : φ.not.Realize v ↔ ¬φ.Realize v :=
Iff.rfl
@[simp]
theorem realize_bot : (⊥ :... |
ElementarilyEquivalent : Prop :=
L.completeTheory M = L.completeTheory N
@[inherit_doc FirstOrder.Language.ElementarilyEquivalent]
scoped[FirstOrder]
notation:25 A " ≅[" L "] " B:50 => FirstOrder.Language.ElementarilyEquivalent L A B
variable {L} {M} {N}
@[simp] | def | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | ElementarilyEquivalent | Two structures are elementarily equivalent when they satisfy the same sentences. |
mem_completeTheory {φ : Sentence L} : φ ∈ L.completeTheory M ↔ M ⊨ φ :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | mem_completeTheory | null |
elementarilyEquivalent_iff : M ≅[L] N ↔ ∀ φ : L.Sentence, M ⊨ φ ↔ N ⊨ φ := by
simp only [ElementarilyEquivalent, Set.ext_iff, completeTheory, Set.mem_setOf_eq]
variable (M) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | elementarilyEquivalent_iff | null |
Theory.Model (T : L.Theory) : Prop where
realize_of_mem : ∀ φ ∈ T, M ⊨ φ
@[inherit_doc Theory.Model]
infixl:51 " ⊨ " => Theory.Model
variable {M} (T : L.Theory)
@[simp default - 10] | class | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Theory.Model | A model of a theory is a structure in which every sentence is realized as true. |
Theory.model_iff : M ⊨ T ↔ ∀ φ ∈ T, M ⊨ φ :=
⟨fun h => h.realize_of_mem, fun h => ⟨h⟩⟩ | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Theory.model_iff | null |
Theory.realize_sentence_of_mem [M ⊨ T] {φ : L.Sentence} (h : φ ∈ T) : M ⊨ φ :=
Theory.Model.realize_of_mem φ h
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Theory.realize_sentence_of_mem | null |
LHom.onTheory_model [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (T : L.Theory) :
M ⊨ φ.onTheory T ↔ M ⊨ T := by simp [Theory.model_iff, LHom.onTheory]
variable {T} | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | LHom.onTheory_model | null |
model_empty : M ⊨ (∅ : L.Theory) :=
⟨fun φ hφ => (Set.notMem_empty φ hφ).elim⟩ | instance | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_empty | null |
Model.mono {T' : L.Theory} (_h : M ⊨ T') (hs : T ⊆ T') : M ⊨ T :=
⟨fun _φ hφ => T'.realize_sentence_of_mem (hs hφ)⟩ | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Model.mono | null |
Model.union {T' : L.Theory} (h : M ⊨ T) (h' : M ⊨ T') : M ⊨ T ∪ T' := by
simp only [model_iff, Set.mem_union] at *
exact fun φ hφ => hφ.elim (h _) (h' _)
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Model.union | null |
model_union_iff {T' : L.Theory} : M ⊨ T ∪ T' ↔ M ⊨ T ∧ M ⊨ T' :=
⟨fun h => ⟨h.mono Set.subset_union_left, h.mono Set.subset_union_right⟩, fun h =>
h.1.union h.2⟩
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_union_iff | null |
model_singleton_iff {φ : L.Sentence} : M ⊨ ({φ} : L.Theory) ↔ M ⊨ φ := by simp | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_singleton_iff | null |
model_insert_iff {φ : L.Sentence} : M ⊨ insert φ T ↔ M ⊨ φ ∧ M ⊨ T := by
rw [Set.insert_eq, model_union_iff, model_singleton_iff] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_insert_iff | null |
model_iff_subset_completeTheory : M ⊨ T ↔ T ⊆ L.completeTheory M :=
T.model_iff | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_iff_subset_completeTheory | null |
completeTheory.subset [MT : M ⊨ T] : T ⊆ L.completeTheory M :=
model_iff_subset_completeTheory.1 MT | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | completeTheory.subset | null |
model_completeTheory : M ⊨ L.completeTheory M :=
Theory.model_iff_subset_completeTheory.2 subset_rfl
variable (M N) | instance | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_completeTheory | null |
realize_iff_of_model_completeTheory [N ⊨ L.completeTheory M] (φ : L.Sentence) :
N ⊨ φ ↔ M ⊨ φ := by
refine ⟨fun h => ?_, (L.completeTheory M).realize_sentence_of_mem⟩
contrapose! h
rw [← Sentence.realize_not] at *
exact (L.completeTheory M).realize_sentence_of_mem (mem_completeTheory.2 h)
variable {M N} | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iff_of_model_completeTheory | null |
@[simp]
realize_alls {φ : L.BoundedFormula α n} {v : α → M} :
φ.alls.Realize v ↔ ∀ xs : Fin n → M, φ.Realize v xs := by
induction n with
| zero => exact Unique.forall_iff.symm
| succ n ih =>
simp only [alls, ih, Realize]
exact ⟨fun h xs => Fin.snoc_init_self xs ▸ h _ _, fun h xs x => h (Fin.snoc xs x)... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_alls | null |
realize_exs {φ : L.BoundedFormula α n} {v : α → M} :
φ.exs.Realize v ↔ ∃ xs : Fin n → M, φ.Realize v xs := by
induction n with
| zero => exact Unique.exists_iff.symm
| succ n ih =>
simp only [BoundedFormula.exs, ih, realize_ex]
constructor
· rintro ⟨xs, x, h⟩
exact ⟨_, h⟩
· rintro ⟨xs, h... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_exs | null |
_root_.FirstOrder.Language.Formula.realize_iAlls
[Finite β] {φ : L.Formula (α ⊕ β)} {v : α → M} : (φ.iAlls β).Realize v ↔
∀ (i : β → M), φ.Realize (fun a => Sum.elim v i a) := by
let e := Classical.choice (Classical.choose_spec (Finite.exists_equiv_fin β))
rw [Formula.iAlls]
simp only [Nat.add_zero, rea... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | _root_.FirstOrder.Language.Formula.realize_iAlls | null |
realize_iAlls [Finite β] {φ : L.Formula (α ⊕ β)} {v : α → M} {v' : Fin 0 → M} :
BoundedFormula.Realize (φ.iAlls β) v v' ↔
∀ (i : β → M), φ.Realize (fun a => Sum.elim v i a) := by
rw [← Formula.realize_iAlls, iff_iff_eq]; congr; simp [eq_iff_true_of_subsingleton]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iAlls | null |
_root_.FirstOrder.Language.Formula.realize_iExs
[Finite γ] {φ : L.Formula (α ⊕ γ)} {v : α → M} : (φ.iExs γ).Realize v ↔
∃ (i : γ → M), φ.Realize (Sum.elim v i) := by
let e := Classical.choice (Classical.choose_spec (Finite.exists_equiv_fin γ))
rw [Formula.iExs]
simp only [Nat.add_zero, realize_exs, real... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | _root_.FirstOrder.Language.Formula.realize_iExs | null |
realize_iExs [Finite γ] {φ : L.Formula (α ⊕ γ)} {v : α → M} {v' : Fin 0 → M} :
BoundedFormula.Realize (φ.iExs γ) v v' ↔
∃ (i : γ → M), φ.Realize (Sum.elim v i) := by
rw [← Formula.realize_iExs, iff_iff_eq]; congr; simp [eq_iff_true_of_subsingleton]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iExs | null |
realize_toFormula (φ : L.BoundedFormula α n) (v : α ⊕ (Fin n) → M) :
φ.toFormula.Realize v ↔ φ.Realize (v ∘ Sum.inl) (v ∘ Sum.inr) := by
induction φ with
| falsum => rfl
| equal => simp [BoundedFormula.Realize]
| rel => simp [BoundedFormula.Realize]
| imp _ _ ih1 ih2 =>
rw [toFormula, Formula.Realize,... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_toFormula | null |
realize_iSup [Finite β] {f : β → L.BoundedFormula α n}
{v : α → M} {v' : Fin n → M} :
(iSup f).Realize v v' ↔ ∃ b, (f b).Realize v v' := by
simp only [iSup, realize_foldr_sup, List.mem_map, Finset.mem_toList, Finset.mem_univ, true_and,
exists_exists_eq_and]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iSup | null |
realize_iInf [Finite β] {f : β → L.BoundedFormula α n}
{v : α → M} {v' : Fin n → M} :
(iInf f).Realize v v' ↔ ∀ b, (f b).Realize v v' := by
simp only [iInf, realize_foldr_inf, List.mem_map, Finset.mem_toList, Finset.mem_univ, true_and,
forall_exists_index, forall_apply_eq_imp_iff]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iInf | null |
_root_.FirstOrder.Language.Formula.realize_iSup [Finite β] {f : β → L.Formula α}
{v : α → M} : (Formula.iSup f).Realize v ↔ ∃ b, (f b).Realize v := by
simp [Formula.iSup, Formula.Realize]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | _root_.FirstOrder.Language.Formula.realize_iSup | null |
_root_.FirstOrder.Language.Formula.realize_iInf [Finite β] {f : β → L.Formula α}
{v : α → M} : (Formula.iInf f).Realize v ↔ ∀ b, (f b).Realize v := by
simp [Formula.iInf, Formula.Realize] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | _root_.FirstOrder.Language.Formula.realize_iInf | null |
_root_.FirstOrder.Language.Formula.realize_iExsUnique [Finite γ]
{φ : L.Formula (α ⊕ γ)} {v : α → M} : (φ.iExsUnique γ).Realize v ↔
∃! (i : γ → M), φ.Realize (Sum.elim v i) := by
rw [Formula.iExsUnique, ExistsUnique]
simp only [Formula.realize_iExs, Formula.realize_inf, Formula.realize_iAlls, Formula.real... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | _root_.FirstOrder.Language.Formula.realize_iExsUnique | null |
realize_iExsUnique [Finite γ] {φ : L.Formula (α ⊕ γ)} {v : α → M} {v' : Fin 0 → M} :
BoundedFormula.Realize (φ.iExsUnique γ) v v' ↔
∃! (i : γ → M), φ.Realize (Sum.elim v i) := by
rw [← Formula.realize_iExsUnique, iff_iff_eq]; congr; simp [eq_iff_true_of_subsingleton] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_iExsUnique | null |
@[simp]
realize_boundedFormula (φ : L.BoundedFormula α n) {v : α → M}
{xs : Fin n → M} : φ.Realize (g ∘ v) (g ∘ xs) ↔ φ.Realize v xs := by
induction φ with
| falsum => rfl
| equal =>
simp only [BoundedFormula.Realize, ← Sum.comp_elim, HomClass.realize_term,
EmbeddingLike.apply_eq_iff_eq g]
| rel =... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_boundedFormula | null |
realize_formula (φ : L.Formula α) {v : α → M} :
φ.Realize (g ∘ v) ↔ φ.Realize v := by
rw [Formula.Realize, Formula.Realize, ← realize_boundedFormula g φ, iff_eq_eq,
Unique.eq_default (g ∘ default)]
include g | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_formula | null |
realize_sentence (φ : L.Sentence) : M ⊨ φ ↔ N ⊨ φ := by
rw [Sentence.Realize, Sentence.Realize, ← realize_formula g,
Unique.eq_default (g ∘ default)] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_sentence | null |
theory_model [M ⊨ T] : N ⊨ T :=
⟨fun φ hφ => (realize_sentence g φ).1 (Theory.realize_sentence_of_mem T hφ)⟩ | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | theory_model | null |
elementarilyEquivalent : M ≅[L] N :=
elementarilyEquivalent_iff.2 (realize_sentence g) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | elementarilyEquivalent | null |
@[simp]
realize_reflexive : M ⊨ r.reflexive ↔ Reflexive fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ => realize_rel₂
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_reflexive | null |
realize_irreflexive : M ⊨ r.irreflexive ↔ Irreflexive fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ => not_congr realize_rel₂
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_irreflexive | null |
realize_symmetric : M ⊨ r.symmetric ↔ Symmetric fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ => forall_congr' fun _ => imp_congr realize_rel₂ realize_rel₂
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_symmetric | null |
realize_antisymmetric :
M ⊨ r.antisymmetric ↔ AntiSymmetric fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ =>
forall_congr' fun _ => imp_congr realize_rel₂ (imp_congr realize_rel₂ Iff.rfl)
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_antisymmetric | null |
realize_transitive : M ⊨ r.transitive ↔ Transitive fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ =>
forall_congr' fun _ =>
forall_congr' fun _ => imp_congr realize_rel₂ (imp_congr realize_rel₂ realize_rel₂)
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_transitive | null |
realize_total : M ⊨ r.total ↔ Total fun x y : M => RelMap r ![x, y] :=
forall_congr' fun _ =>
forall_congr' fun _ => realize_sup.trans (or_congr realize_rel₂ realize_rel₂) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_total | null |
@[simp]
Sentence.realize_cardGe (n) : M ⊨ Sentence.cardGe L n ↔ ↑n ≤ #M := by
rw [← lift_mk_fin, ← lift_le.{0}, lift_lift, lift_mk_le, Sentence.cardGe, Sentence.Realize,
BoundedFormula.realize_exs]
simp_rw [BoundedFormula.realize_foldr_inf]
simp only [Function.comp_apply, List.mem_map, Prod.exists, Ne, List.m... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | Sentence.realize_cardGe | null |
model_infiniteTheory_iff : M ⊨ L.infiniteTheory ↔ Infinite M := by
simp [infiniteTheory, infinite_iff, aleph0_le] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_infiniteTheory_iff | null |
model_infiniteTheory [h : Infinite M] : M ⊨ L.infiniteTheory :=
L.model_infiniteTheory_iff.2 h
@[simp] | instance | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_infiniteTheory | null |
model_nonemptyTheory_iff : M ⊨ L.nonemptyTheory ↔ Nonempty M := by
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] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_nonemptyTheory_iff | null |
model_nonempty [h : Nonempty M] : M ⊨ L.nonemptyTheory :=
L.model_nonemptyTheory_iff.2 h | instance | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_nonempty | null |
model_distinctConstantsTheory {M : Type w} [L[[α]].Structure M] (s : Set α) :
M ⊨ L.distinctConstantsTheory s ↔ Set.InjOn (fun i : α => (L.con i : M)) s := by
simp only [distinctConstantsTheory, Theory.model_iff, Set.mem_image,
Prod.exists, forall_exists_index, and_imp]
refine ⟨fun h a as b bs ab => ?_, ?_⟩... | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | model_distinctConstantsTheory | null |
card_le_of_model_distinctConstantsTheory (s : Set α) (M : Type w) [L[[α]].Structure M]
[h : M ⊨ L.distinctConstantsTheory s] : Cardinal.lift.{w} #s ≤ Cardinal.lift.{u'} #M :=
lift_mk_le'.2 ⟨⟨_, Set.injOn_iff_injective.1 ((L.model_distinctConstantsTheory s).1 h)⟩⟩ | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | card_le_of_model_distinctConstantsTheory | null |
completeTheory_eq (h : M ≅[L] N) : L.completeTheory M = L.completeTheory N :=
h | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | completeTheory_eq | null |
realize_sentence (h : M ≅[L] N) (φ : L.Sentence) : M ⊨ φ ↔ N ⊨ φ :=
(elementarilyEquivalent_iff.1 h) φ | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | realize_sentence | null |
theory_model_iff (h : M ≅[L] N) : M ⊨ T ↔ N ⊨ T := by
rw [Theory.model_iff_subset_completeTheory, Theory.model_iff_subset_completeTheory,
h.completeTheory_eq] | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | theory_model_iff | null |
theory_model [MT : M ⊨ T] (h : M ≅[L] N) : N ⊨ T :=
h.theory_model_iff.1 MT | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | theory_model | null |
nonempty_iff (h : M ≅[L] N) : Nonempty M ↔ Nonempty N :=
(model_nonemptyTheory_iff L).symm.trans (h.theory_model_iff.trans (model_nonemptyTheory_iff L)) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | nonempty_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.