Theorem: tendsto_ite
File: Mathlib/Topology/IndicatorConstPointwise.lean

tactic: constructor <;> intro h
state_before: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G) ↔ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case mp
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G)

tactic: by_cases hq : q
state_before: case mp
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
⊢ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
hq : q
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
hq : ¬q
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

tactic: simp only [hq, ite_true] at h
state_before: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
hq : q
⊢ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

tactic: filter_upwards [mem_map.mp (h hbF)] with i hi
state_before: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
⊢ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
i : ι
hi : i ∈ (fun i => if p i then a else b) ⁻¹' {b}ᶜ
⊢ p i ↔ q

tactic: simp only [Set.preimage_compl, Set.mem_compl_iff, Set.mem_preimage, Set.mem_singleton_iff,
  ite_eq_right_iff, not_forall, exists_prop] at hi
state_before: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
i : ι
hi : i ∈ (fun i => if p i then a else b) ⁻¹' {b}ᶜ
⊢ p i ↔ q
state_after: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
i : ι
hi : p i ∧ ¬a = b
⊢ p i ↔ q

tactic: tauto
state_before: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : q
h : Tendsto (fun i => if p i then a else b) L F
i : ι
hi : p i ∧ ¬a = b
⊢ p i ↔ q
state_after: no goals

tactic: simp only [hq, ite_false] at h
state_before: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
hq : ¬q
⊢ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

tactic: filter_upwards [mem_map.mp (h haG)] with i hi
state_before: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
⊢ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
i : ι
hi : i ∈ (fun i => if p i then a else b) ⁻¹' {a}ᶜ
⊢ p i ↔ q

tactic: simp only [Set.preimage_compl, Set.mem_compl_iff, Set.mem_preimage, Set.mem_singleton_iff,
  ite_eq_left_iff, not_forall, exists_prop] at hi
state_before: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
i : ι
hi : i ∈ (fun i => if p i then a else b) ⁻¹' {a}ᶜ
⊢ p i ↔ q
state_after: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
i : ι
hi : ¬p i ∧ ¬b = a
⊢ p i ↔ q

tactic: tauto
state_before: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
hq : ¬q
h : Tendsto (fun i => if p i then a else b) L G
i : ι
hi : ¬p i ∧ ¬b = a
⊢ p i ↔ q
state_after: no goals

tactic: have obs : (fun _ ↦ if q then a else b) =ᶠ[L] (fun i ↦ if p i then a else b) := by
  filter_upwards [h] with i hi
  simp only [hi]
state_before: case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G)
state_after: case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G)

tactic: apply Tendsto.congr' obs
state_before: case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G)
state_after: case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)

tactic: by_cases hq : q
state_before: case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)
state_after: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)

case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)

tactic: filter_upwards [h] with i hi
state_before: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
⊢ (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
state_after: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
i : ι
hi : p i ↔ q
⊢ (if q then a else b) = if p i then a else b

tactic: simp only [hi]
state_before: case h
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
i : ι
hi : p i ↔ q
⊢ (if q then a else b) = if p i then a else b
state_after: no goals

tactic: simp only [hq, iff_true, ite_true]
state_before: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)
state_after: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ Tendsto (fun x => a) L F

tactic: apply le_trans _ haF
state_before: case pos
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ Tendsto (fun x => a) L F
state_after: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ map (fun x => a) L ≤ 𝓟 {a}

tactic: simp only [principal_singleton, le_pure_iff, mem_map, Set.mem_singleton_iff,
  Set.preimage_const_of_mem, univ_mem]
state_before: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : q
⊢ map (fun x => a) L ≤ 𝓟 {a}
state_after: no goals

tactic: simp only [hq, ite_false]
state_before: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ Tendsto (fun x => if q then a else b) L (if q then F else G)
state_after: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ Tendsto (fun x => b) L G

tactic: apply le_trans _ hbG
state_before: case neg
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ Tendsto (fun x => b) L G
state_after: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ map (fun x => b) L ≤ 𝓟 {b}

tactic: simp only [principal_singleton, le_pure_iff, mem_map, Set.mem_singleton_iff,
  Set.preimage_const_of_mem, univ_mem]
state_before: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
obs : (fun x => if q then a else b) =ᶠ[L] fun i => if p i then a else b
hq : ¬q
⊢ map (fun x => b) L ≤ 𝓟 {b}
state_after: no goals