Theorem: Filter.prod_map_seq_comm
File: Mathlib/Order/Filter/Basic.lean

tactic: refine le_antisymm (le_seq fun s hs t ht => ?_) (le_seq fun s hs t ht => ?_)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
⊢ (map Prod.mk f).seq g = (map (fun b a => (a, b)) g).seq f
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
⊢ s.seq t ∈ (map Prod.mk f).seq g

case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
⊢ s.seq t ∈ (map (fun b a => (a, b)) g).seq f

tactic: rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
state_before: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
⊢ s.seq t ∈ (map Prod.mk f).seq g
state_after: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ s.seq t ∈ (map Prod.mk f).seq g

tactic: refine mem_of_superset ?_ (Set.seq_mono hs Subset.rfl)
state_before: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ s.seq t ∈ (map Prod.mk f).seq g
state_after: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ ((fun b a => (a, b)) '' u).seq t ∈ (map Prod.mk f).seq g

tactic: rw [← Set.prod_image_seq_comm]
state_before: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ ((fun b a => (a, b)) '' u).seq t ∈ (map Prod.mk f).seq g
state_after: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ (Prod.mk '' t).seq u ∈ (map Prod.mk f).seq g

tactic: exact seq_mem_seq (image_mem_map ht) hu
state_before: case refine_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ (Prod.mk '' t).seq u ∈ (map Prod.mk f).seq g
state_after: no goals

tactic: rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
state_before: case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
⊢ s.seq t ∈ (map (fun b a => (a, b)) g).seq f
state_after: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ s.seq t ∈ (map (fun b a => (a, b)) g).seq f

tactic: refine mem_of_superset ?_ (Set.seq_mono hs Subset.rfl)
state_before: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ s.seq t ∈ (map (fun b a => (a, b)) g).seq f
state_after: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ (Prod.mk '' u).seq t ∈ (map (fun b a => (a, b)) g).seq f

tactic: rw [Set.prod_image_seq_comm]
state_before: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ (Prod.mk '' u).seq t ∈ (map (fun b a => (a, b)) g).seq f
state_after: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ ((fun b a => (a, b)) '' t).seq u ∈ (map (fun b a => (a, b)) g).seq f

tactic: exact seq_mem_seq (image_mem_map ht) hu
state_before: case refine_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ ((fun b a => (a, b)) '' t).seq u ∈ (map (fun b a => (a, b)) g).seq f
state_after: no goals