Theorem: FirstOrder.Language.Theory.isSatisfiable_union_distinctConstantsTheory_of_infinite
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [distinctConstantsTheory_eq_iUnion, Set.union_iUnion, isSatisfiable_directed_union_iff]
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ ((L.lhomWithConstants α).onTheory T ∪ L.distinctConstantsTheory s).IsSatisfiable
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ ∀ (i : Finset ↑s),
    IsSatisfiable
      ((L.lhomWithConstants α).onTheory T ∪
        L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i))

L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Directed (fun x x_1 => x ⊆ x_1) fun i =>
    (L.lhomWithConstants α).onTheory T ∪
      L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)

tactic: exact fun t =>
  isSatisfiable_union_distinctConstantsTheory_of_card_le T _ M
    ((lift_le_aleph0.2 (finset_card_lt_aleph0 _).le).trans
      (aleph0_le_lift.2 (aleph0_le_mk M)))
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ ∀ (i : Finset ↑s),
    IsSatisfiable
      ((L.lhomWithConstants α).onTheory T ∪
        L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i))
state_after: no goals

tactic: apply Monotone.directed_le
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Directed (fun x x_1 => x ⊆ x_1) fun i =>
    (L.lhomWithConstants α).onTheory T ∪
      L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)
state_after: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i =>
    (L.lhomWithConstants α).onTheory T ∪
      L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)

tactic: refine monotone_const.union (monotone_distinctConstantsTheory.comp ?_)
state_before: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i =>
    (L.lhomWithConstants α).onTheory T ∪
      L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)
state_after: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i => ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)

tactic: simp only [Finset.coe_map, Function.Embedding.coe_subtype]
state_before: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i => ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) i)
state_after: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i => (fun a => ↑a) '' ↑i

tactic: exact Monotone.comp (g := Set.image ((↑) : s → α)) (f := ((↑) : Finset s → Set s))
  Set.monotone_image fun _ _ => Finset.coe_subset.2
state_before: case a
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' T : L.Theory
s : Set α
M : Type w'
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Infinite M
⊢ Monotone fun i => (fun a => ↑a) '' ↑i
state_after: no goals