ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- WithBot.toDualTopEquiv_symm_coe
@[simp]
theorem toDualTopEquiv_symm_coe [LE α] (a : α) :
    WithBot.toDualTopEquiv.symm (toDual (a : WithTop α)) = ↑(toDual a) 
Arguments: {α : Type u_2} [LE α] (a : α)
Goal: WithBot.toDualTopEquiv.symm (OrderDual.toDual ↑a) = ↑(OrderDual.toDual a)
-- WithBot.toDualTopEquiv_bot
@[simp]
theorem toDualTopEquiv_bot [LE α] : WithBot.toDualTopEquiv (⊥ : WithBot αᵒᵈ) = ⊥ 
Arguments: {α : Type u_2} [LE α]
Goal: WithBot.toDualTopEquiv ⊥ = ⊥
-- WithBot.toDualTopEquiv_symm_bot
@[simp]
theorem toDualTopEquiv_symm_bot [LE α] : WithBot.toDualTopEquiv.symm (⊥ : (WithTop α)ᵒᵈ) = ⊥ 
Arguments: {α : Type u_2} [LE α]
Goal: WithBot.toDualTopEquiv.symm ⊥ = ⊥
-- WithBot.coe_toDualTopEquiv_eq
theorem coe_toDualTopEquiv_eq [LE α] :
    (WithBot.toDualTopEquiv : WithBot αᵒᵈ → (WithTop α)ᵒᵈ) = toDual ∘ WithBot.ofDual 
Arguments: {α : Type u_2} [LE α]
Goal: ⇑WithBot.toDualTopEquiv = ⇑OrderDual.toDual ∘ ⇑WithBot.ofDual
-- WithTop.toDualBotEquiv_coe
@[simp]
theorem toDualBotEquiv_coe [LE α] (a : α) :
    WithTop.toDualBotEquiv ↑(toDual a) = toDual (a : WithBot α) 
Arguments: {α : Type u_2} [LE α] (a : α)
Goal: WithTop.toDualBotEquiv ↑(OrderDual.toDual a) = OrderDual.toDual ↑a
-- WithTop.toDualBotEquiv_symm_coe
@[simp]
theorem toDualBotEquiv_symm_coe [LE α] (a : α) :
    WithTop.toDualBotEquiv.symm (toDual (a : WithBot α)) = ↑(toDual a) 
Arguments: {α : Type u_2} [LE α] (a : α)
Goal: WithTop.toDualBotEquiv.symm (OrderDual.toDual ↑a) = ↑(OrderDual.toDual a)
-- WithTop.toDualBotEquiv_top
@[simp]
theorem toDualBotEquiv_top [LE α] : WithTop.toDualBotEquiv (⊤ : WithTop αᵒᵈ) = ⊤ 
Arguments: {α : Type u_2} [LE α]
Goal: WithTop.toDualBotEquiv ⊤ = ⊤
-- WithTop.toDualBotEquiv_symm_top
@[simp]
theorem toDualBotEquiv_symm_top [LE α] : WithTop.toDualBotEquiv.symm (⊤ : (WithBot α)ᵒᵈ) = ⊤ 
Arguments: {α : Type u_2} [LE α]
Goal: WithTop.toDualBotEquiv.symm ⊤ = ⊤
-- WithTop.coe_toDualBotEquiv
theorem coe_toDualBotEquiv [LE α] :
    (WithTop.toDualBotEquiv : WithTop αᵒᵈ → (WithBot α)ᵒᵈ) = toDual ∘ WithTop.ofDual 
Arguments: {α : Type u_2} [LE α]
Goal: ⇑WithTop.toDualBotEquiv = ⇑OrderDual.toDual ∘ ⇑WithTop.ofDual
-- OrderIso.withTopCongr_apply
@[simps! apply]
def withTopCongr (e : α ≃o β) : WithTop α ≃o WithTop β 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [PartialOrder β] (e : α ≃o β)
Goal: ∀ (a : Option α), e.withTopCongr a = Option.map (⇑e) a
-- OrderIso.withTopCongr_refl
@[simp]
theorem withTopCongr_refl : (OrderIso.refl α).withTopCongr = OrderIso.refl _ 
Arguments: {α : Type u_2} [PartialOrder α]
Goal: (OrderIso.refl α).withTopCongr = OrderIso.refl (WithTop α)
-- OrderIso.withTopCongr_symm
@[simp]
theorem withTopCongr_symm (e : α ≃o β) : e.withTopCongr.symm = e.symm.withTopCongr 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [PartialOrder β] (e : α ≃o β)
Goal: e.withTopCongr.symm = e.symm.withTopCongr
-- OrderIso.withTopCongr_trans
@[simp]
theorem withTopCongr_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) :
    e₁.withTopCongr.trans e₂.withTopCongr = (e₁.trans e₂).withTopCongr 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [PartialOrder α] [PartialOrder β] [PartialOrder γ] (e₁ : α ≃o β) (e₂ : β ≃o γ)
Goal: e₁.withTopCongr.trans e₂.withTopCongr = (e₁.trans e₂).withTopCongr
-- OrderIso.withBotCongr_apply
@[simps! apply]
def withBotCongr (e : α ≃o β) : WithBot α ≃o WithBot β 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [PartialOrder β] (e : α ≃o β)
Goal: ∀ (a : Option α), e.withBotCongr a = Option.map (⇑e) a
-- OrderIso.withBotCongr_refl
@[simp]
theorem withBotCongr_refl : (OrderIso.refl α).withBotCongr = OrderIso.refl _ 
Arguments: {α : Type u_2} [PartialOrder α]
Goal: (OrderIso.refl α).withBotCongr = OrderIso.refl (WithBot α)
-- OrderIso.withBotCongr_symm
@[simp]
theorem withBotCongr_symm (e : α ≃o β) : e.withBotCongr.symm = e.symm.withBotCongr 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [PartialOrder β] (e : α ≃o β)
Goal: e.withBotCongr.symm = e.symm.withBotCongr
-- OrderIso.withBotCongr_trans
@[simp]
theorem withBotCongr_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) :
    e₁.withBotCongr.trans e₂.withBotCongr = (e₁.trans e₂).withBotCongr 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [PartialOrder α] [PartialOrder β] [PartialOrder γ] (e₁ : α ≃o β) (e₂ : β ≃o γ)
Goal: e₁.withBotCongr.trans e₂.withBotCongr = (e₁.trans e₂).withBotCongr
-- OrderIso.isCompl
theorem OrderIso.isCompl {x y : α} (h : IsCompl x y) : IsCompl (f x) (f y) 
Arguments: {α : Type u_2} {β : Type u_3} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] (f : α ≃o β) {x y : α} (h : IsCompl x y)
Goal: IsCompl (f x) (f y)
-- OrderIso.isCompl_iff
theorem OrderIso.isCompl_iff {x y : α} : IsCompl x y ↔ IsCompl (f x) (f y) 
Arguments: {α : Type u_2} {β : Type u_3} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] (f : α ≃o β) {x y : α}
Goal: IsCompl x y ↔ IsCompl (f x) (f y)
-- OrderIso.complementedLattice
theorem OrderIso.complementedLattice [ComplementedLattice α] (f : α ≃o β) : ComplementedLattice β 
Arguments: {α : Type u_2} {β : Type u_3} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] [ComplementedLattice α] (f : α ≃o β)
Goal: ComplementedLattice β
-- OrderIso.complementedLattice_iff
theorem OrderIso.complementedLattice_iff (f : α ≃o β) :
    ComplementedLattice α ↔ ComplementedLattice β 
Arguments: {α : Type u_2} {β : Type u_3} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] (f : α ≃o β)
Goal: ComplementedLattice α ↔ ComplementedLattice β
-- Filter.mem_map₂_iff
@[simp 900]
theorem mem_map₂_iff : u ∈ map₂ m f g ↔ ∃ s ∈ f, ∃ t ∈ g, image2 m s t ⊆ u 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {u : Set γ}
Goal: u ∈ Filter.map₂ m f g ↔ ∃ s ∈ f, ∃ t ∈ g, Set.image2 m s t ⊆ u
-- Filter.image2_mem_map₂
theorem image2_mem_map₂ (hs : s ∈ f) (ht : t ∈ g) : image2 m s t ∈ map₂ m f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {s : Set α} {t : Set β} (hs : s ∈ f) (ht : t ∈ g)
Goal: Set.image2 m s t ∈ Filter.map₂ m f g
-- Filter.map_prod_eq_map₂
theorem map_prod_eq_map₂ (m : α → β → γ) (f : Filter α) (g : Filter β) :
    Filter.map (fun p : α × β => m p.1 p.2) (f ×ˢ g) = map₂ m f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map (fun p => m p.1 p.2) (f ×ˢ g) = Filter.map₂ m f g
-- Filter.map_prod_eq_map₂'
theorem map_prod_eq_map₂' (m : α × β → γ) (f : Filter α) (g : Filter β) :
    Filter.map m (f ×ˢ g) = map₂ (fun a b => m (a, b)) f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α × β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map m (f ×ˢ g) = Filter.map₂ (fun a b => m (a, b)) f g
-- Filter.map₂_mk_eq_prod
@[simp]
theorem map₂_mk_eq_prod (f : Filter α) (g : Filter β) : map₂ Prod.mk f g = f ×ˢ g 
Arguments: {α : Type u_1} {β : Type u_3} (f : Filter α) (g : Filter β)
Goal: Filter.map₂ Prod.mk f g = f ×ˢ g
-- Filter.map₂_mono
theorem map₂_mono (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) : map₂ m f₁ g₁ ≤ map₂ m f₂ g₂ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂)
Goal: Filter.map₂ m f₁ g₁ ≤ Filter.map₂ m f₂ g₂
-- Filter.map₂_mono_left
theorem map₂_mono_left (h : g₁ ≤ g₂) : map₂ m f g₁ ≤ map₂ m f g₂ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g₁ g₂ : Filter β} (h : g₁ ≤ g₂)
Goal: Filter.map₂ m f g₁ ≤ Filter.map₂ m f g₂
-- Filter.map₂_mono_right
theorem map₂_mono_right (h : f₁ ≤ f₂) : map₂ m f₁ g ≤ map₂ m f₂ g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β} (h : f₁ ≤ f₂)
Goal: Filter.map₂ m f₁ g ≤ Filter.map₂ m f₂ g
-- Filter.le_map₂_iff
@[simp]
theorem le_map₂_iff {h : Filter γ} :
    h ≤ map₂ m f g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → image2 m s t ∈ h 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ}
Goal: h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h
-- Filter.map₂_eq_bot_iff
@[simp]
theorem map₂_eq_bot_iff : map₂ m f g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β}
Goal: Filter.map₂ m f g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.map₂_bot_left
@[simp]
theorem map₂_bot_left : map₂ m ⊥ g = ⊥ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {g : Filter β}
Goal: Filter.map₂ m ⊥ g = ⊥
-- Filter.map₂_bot_right
@[simp]
theorem map₂_bot_right : map₂ m f ⊥ = ⊥ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α}
Goal: Filter.map₂ m f ⊥ = ⊥
-- Filter.map₂_neBot_iff
@[simp]
theorem map₂_neBot_iff : (map₂ m f g).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β}
Goal: (Filter.map₂ m f g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.map₂
protected theorem NeBot.map₂ (hf : f.NeBot) (hg : g.NeBot) : (map₂ m f g).NeBot 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} (hf : f.NeBot) (hg : g.NeBot)
Goal: (Filter.map₂ m f g).NeBot
-- Filter.NeBot.of_map₂_left
theorem NeBot.of_map₂_left (h : (map₂ m f g).NeBot) : f.NeBot 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} (h : (Filter.map₂ m f g).NeBot)
Goal: f.NeBot
-- Filter.NeBot.of_map₂_right
theorem NeBot.of_map₂_right (h : (map₂ m f g).NeBot) : g.NeBot 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} (h : (Filter.map₂ m f g).NeBot)
Goal: g.NeBot
-- Filter.map₂_sup_left
theorem map₂_sup_left : map₂ m (f₁ ⊔ f₂) g = map₂ m f₁ g ⊔ map₂ m f₂ g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β}
Goal: Filter.map₂ m (f₁ ⊔ f₂) g = Filter.map₂ m f₁ g ⊔ Filter.map₂ m f₂ g
-- Filter.map₂_sup_right
theorem map₂_sup_right : map₂ m f (g₁ ⊔ g₂) = map₂ m f g₁ ⊔ map₂ m f g₂ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g₁ g₂ : Filter β}
Goal: Filter.map₂ m f (g₁ ⊔ g₂) = Filter.map₂ m f g₁ ⊔ Filter.map₂ m f g₂
-- Filter.map₂_inf_subset_left
theorem map₂_inf_subset_left : map₂ m (f₁ ⊓ f₂) g ≤ map₂ m f₁ g ⊓ map₂ m f₂ g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β}
Goal: Filter.map₂ m (f₁ ⊓ f₂) g ≤ Filter.map₂ m f₁ g ⊓ Filter.map₂ m f₂ g
-- Filter.map₂_inf_subset_right
theorem map₂_inf_subset_right : map₂ m f (g₁ ⊓ g₂) ≤ map₂ m f g₁ ⊓ map₂ m f g₂ 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g₁ g₂ : Filter β}
Goal: Filter.map₂ m f (g₁ ⊓ g₂) ≤ Filter.map₂ m f g₁ ⊓ Filter.map₂ m f g₂
-- Filter.map₂_pure_left
@[simp]
theorem map₂_pure_left : map₂ m (pure a) g = g.map (m a) 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {g : Filter β} {a : α}
Goal: Filter.map₂ m (pure a) g = Filter.map (m a) g
-- Filter.map₂_pure_right
@[simp]
theorem map₂_pure_right : map₂ m f (pure b) = f.map (m · b) 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {b : β}
Goal: Filter.map₂ m f (pure b) = Filter.map (fun x => m x b) f
-- Filter.map₂_pure
theorem map₂_pure : map₂ m (pure a) (pure b) = pure (m a b) 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {a : α} {b : β}
Goal: Filter.map₂ m (pure a) (pure b) = pure (m a b)
-- Filter.map₂_swap
theorem map₂_swap (m : α → β → γ) (f : Filter α) (g : Filter β) :
    map₂ m f g = map₂ (fun a b => m b a) g f 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map₂ m f g = Filter.map₂ (fun a b => m b a) g f
-- Filter.map₂_left
@[simp]
theorem map₂_left [NeBot g] : map₂ (fun x _ => x) f g = f 
Arguments: {α : Type u_1} {β : Type u_3} {f : Filter α} {g : Filter β} [g.NeBot]
Goal: Filter.map₂ (fun x x_1 => x) f g = f
-- Filter.map₂_right
@[simp]
theorem map₂_right [NeBot f] : map₂ (fun _ y => y) f g = g 
Arguments: {α : Type u_1} {β : Type u_3} {f : Filter α} {g : Filter β} [f.NeBot]
Goal: Filter.map₂ (fun x y => y) f g = g
-- Filter.map_map₂
theorem map_map₂ (m : α → β → γ) (n : γ → δ) :
    (map₂ m f g).map n = map₂ (fun a b => n (m a b)) f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : α → β → γ) (n : γ → δ)
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ (fun a b => n (m a b)) f g
-- Filter.map₂_map_left
theorem map₂_map_left (m : γ → β → δ) (n : α → γ) :
    map₂ m (f.map n) g = map₂ (fun a b => m (n a) b) f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : γ → β → δ) (n : α → γ)
Goal: Filter.map₂ m (Filter.map n f) g = Filter.map₂ (fun a b => m (n a) b) f g
-- Filter.map₂_map_right
theorem map₂_map_right (m : α → γ → δ) (n : β → γ) :
    map₂ m f (g.map n) = map₂ (fun a b => m a (n b)) f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : α → γ → δ) (n : β → γ)
Goal: Filter.map₂ m f (Filter.map n g) = Filter.map₂ (fun a b => m a (n b)) f g
-- Filter.map₂_curry
@[simp]
theorem map₂_curry (m : α × β → γ) (f : Filter α) (g : Filter β) :
    map₂ (curry m) f g = (f ×ˢ g).map m 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α × β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map₂ (Function.curry m) f g = Filter.map m (f ×ˢ g)
-- Filter.map_uncurry_prod
@[simp]
theorem map_uncurry_prod (m : α → β → γ) (f : Filter α) (g : Filter β) :
    (f ×ˢ g).map (uncurry m) = map₂ m f g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map (Function.uncurry m) (f ×ˢ g) = Filter.map₂ m f g
-- Filter.map₂_assoc
theorem map₂_assoc {m : δ → γ → ε} {n : α → β → δ} {m' : α → ε' → ε} {n' : β → γ → ε'}
    {h : Filter γ} (h_assoc : ∀ a b c, m (n a b) c = m' a (n' b c)) :
    map₂ m (map₂ n f g) h = map₂ m' f (map₂ n' g h) 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} {f : Filter α} {g : Filter β} {m : δ → γ → ε} {n : α → β → δ} {m' : α → ε' → ε} {n' : β → γ → ε'} {h : Filter γ} (h_assoc : ∀ (a : α) (b : β) (c : γ), m (n a b) c = m' a (n' b c))
Goal: Filter.map₂ m (Filter.map₂ n f g) h = Filter.map₂ m' f (Filter.map₂ n' g h)
-- Filter.map₂_comm
theorem map₂_comm {n : β → α → γ} (h_comm : ∀ a b, m a b = n b a) : map₂ m f g = map₂ n g f 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : β → α → γ} (h_comm : ∀ (a : α) (b : β), m a b = n b a)
Goal: Filter.map₂ m f g = Filter.map₂ n g f
-- Filter.map₂_left_comm
theorem map₂_left_comm {m : α → δ → ε} {n : β → γ → δ} {m' : α → γ → δ'} {n' : β → δ' → ε}
    (h_left_comm : ∀ a b c, m a (n b c) = n' b (m' a c)) :
    map₂ m f (map₂ n g h) = map₂ n' g (map₂ m' f h) 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} {f : Filter α} {g : Filter β} {h : Filter γ} {m : α → δ → ε} {n : β → γ → δ} {m' : α → γ → δ'} {n' : β → δ' → ε} (h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c))
Goal: Filter.map₂ m f (Filter.map₂ n g h) = Filter.map₂ n' g (Filter.map₂ m' f h)
-- Filter.map₂_right_comm
theorem map₂_right_comm {m : δ → γ → ε} {n : α → β → δ} {m' : α → γ → δ'} {n' : δ' → β → ε}
    (h_right_comm : ∀ a b c, m (n a b) c = n' (m' a c) b) :
    map₂ m (map₂ n f g) h = map₂ n' (map₂ m' f h) g 
Arguments: {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} {f : Filter α} {g : Filter β} {h : Filter γ} {m : δ → γ → ε} {n : α → β → δ} {m' : α → γ → δ'} {n' : δ' → β → ε} (h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b)
Goal: Filter.map₂ m (Filter.map₂ n f g) h = Filter.map₂ n' (Filter.map₂ m' f h) g
-- Filter.map_map₂_distrib
theorem map_map₂_distrib {n : γ → δ} {m' : α' → β' → δ} {n₁ : α → α'} {n₂ : β → β'}
    (h_distrib : ∀ a b, n (m a b) = m' (n₁ a) (n₂ b)) :
    (map₂ m f g).map n = map₂ m' (f.map n₁) (g.map n₂) 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : α' → β' → δ} {n₁ : α → α'} {n₂ : β → β'} (h_distrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ a) (n₂ b))
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n₁ f) (Filter.map n₂ g)
-- Filter.map_map₂_distrib_left
theorem map_map₂_distrib_left {n : γ → δ} {m' : α' → β → δ} {n' : α → α'}
    (h_distrib : ∀ a b, n (m a b) = m' (n' a) b) : (map₂ m f g).map n = map₂ m' (f.map n') g 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : α' → β → δ} {n' : α → α'} (h_distrib : ∀ (a : α) (b : β), n (m a b) = m' (n' a) b)
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' f) g
-- Filter.map_map₂_distrib_right
theorem map_map₂_distrib_right {n : γ → δ} {m' : α → β' → δ} {n' : β → β'}
    (h_distrib : ∀ a b, n (m a b) = m' a (n' b)) : (map₂ m f g).map n = map₂ m' f (g.map n') 
Arguments: {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : α → β' → δ} {n' : β → β'} (h_distrib : ∀ (a : α) (b : β), n (m a b) = m' a (n' b))
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' f (Filter.map n' g)
-- Filter.map₂_map_left_comm
theorem map₂_map_left_comm {m : α' → β → γ} {n : α → α'} {m' : α → β → δ} {n' : δ → γ}
    (h_left_comm : ∀ a b, m (n a) b = n' (m' a b)) : map₂ m (f.map n) g = (map₂ m' f g).map n' 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} {m : α' → β → γ} {n : α → α'} {m' : α → β → δ} {n' : δ → γ} (h_left_comm : ∀ (a : α) (b : β), m (n a) b = n' (m' a b))
Goal: Filter.map₂ m (Filter.map n f) g = Filter.map n' (Filter.map₂ m' f g)
-- Filter.map_map₂_right_comm
theorem map_map₂_right_comm {m : α → β' → γ} {n : β → β'} {m' : α → β → δ} {n' : δ → γ}
    (h_right_comm : ∀ a b, m a (n b) = n' (m' a b)) : map₂ m f (g.map n) = (map₂ m' f g).map n' 
Arguments: {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} {m : α → β' → γ} {n : β → β'} {m' : α → β → δ} {n' : δ → γ} (h_right_comm : ∀ (a : α) (b : β), m a (n b) = n' (m' a b))
Goal: Filter.map₂ m f (Filter.map n g) = Filter.map n' (Filter.map₂ m' f g)
-- Filter.map₂_distrib_le_left
theorem map₂_distrib_le_left {m : α → δ → ε} {n : β → γ → δ} {m₁ : α → β → β'} {m₂ : α → γ → γ'}
    {n' : β' → γ' → ε} (h_distrib : ∀ a b c, m a (n b c) = n' (m₁ a b) (m₂ a c)) :
    map₂ m f (map₂ n g h) ≤ map₂ n' (map₂ m₁ f g) (map₂ m₂ f h) 
Arguments: {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {γ' : Type u_6} {δ : Type u_7} {ε : Type u_9} {f : Filter α} {g : Filter β} {h : Filter γ} {m : α → δ → ε} {n : β → γ → δ} {m₁ : α → β → β'} {m₂ : α → γ → γ'} {n' : β' → γ' → ε} (h_distrib : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' (m₁ a b) (m₂ a c))
Goal: Filter.map₂ m f (Filter.map₂ n g h) ≤ Filter.map₂ n' (Filter.map₂ m₁ f g) (Filter.map₂ m₂ f h)
-- Filter.map₂_distrib_le_right
theorem map₂_distrib_le_right {m : δ → γ → ε} {n : α → β → δ} {m₁ : α → γ → α'} {m₂ : β → γ → β'}
    {n' : α' → β' → ε} (h_distrib : ∀ a b c, m (n a b) c = n' (m₁ a c) (m₂ b c)) :
    map₂ m (map₂ n f g) h ≤ map₂ n' (map₂ m₁ f h) (map₂ m₂ g h) 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {f : Filter α} {g : Filter β} {h : Filter γ} {m : δ → γ → ε} {n : α → β → δ} {m₁ : α → γ → α'} {m₂ : β → γ → β'} {n' : α' → β' → ε} (h_distrib : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m₁ a c) (m₂ b c))
Goal: Filter.map₂ m (Filter.map₂ n f g) h ≤ Filter.map₂ n' (Filter.map₂ m₁ f h) (Filter.map₂ m₂ g h)
-- Filter.map_map₂_antidistrib
theorem map_map₂_antidistrib {n : γ → δ} {m' : β' → α' → δ} {n₁ : β → β'} {n₂ : α → α'}
    (h_antidistrib : ∀ a b, n (m a b) = m' (n₁ b) (n₂ a)) :
    (map₂ m f g).map n = map₂ m' (g.map n₁) (f.map n₂) 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : β' → α' → δ} {n₁ : β → β'} {n₂ : α → α'} (h_antidistrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ b) (n₂ a))
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n₁ g) (Filter.map n₂ f)
-- Filter.map_map₂_antidistrib_left
theorem map_map₂_antidistrib_left {n : γ → δ} {m' : β' → α → δ} {n' : β → β'}
    (h_antidistrib : ∀ a b, n (m a b) = m' (n' b) a) : (map₂ m f g).map n = map₂ m' (g.map n') f 
Arguments: {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : β' → α → δ} {n' : β → β'} (h_antidistrib : ∀ (a : α) (b : β), n (m a b) = m' (n' b) a)
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' g) f
-- Filter.map_map₂_antidistrib_right
theorem map_map₂_antidistrib_right {n : γ → δ} {m' : β → α' → δ} {n' : α → α'}
    (h_antidistrib : ∀ a b, n (m a b) = m' b (n' a)) : (map₂ m f g).map n = map₂ m' g (f.map n') 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α} {g : Filter β} {n : γ → δ} {m' : β → α' → δ} {n' : α → α'} (h_antidistrib : ∀ (a : α) (b : β), n (m a b) = m' b (n' a))
Goal: Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' g (Filter.map n' f)
-- Filter.map₂_map_left_anticomm
theorem map₂_map_left_anticomm {m : α' → β → γ} {n : α → α'} {m' : β → α → δ} {n' : δ → γ}
    (h_left_anticomm : ∀ a b, m (n a) b = n' (m' b a)) :
    map₂ m (f.map n) g = (map₂ m' g f).map n' 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} {m : α' → β → γ} {n : α → α'} {m' : β → α → δ} {n' : δ → γ} (h_left_anticomm : ∀ (a : α) (b : β), m (n a) b = n' (m' b a))
Goal: Filter.map₂ m (Filter.map n f) g = Filter.map n' (Filter.map₂ m' g f)
-- Filter.map_map₂_right_anticomm
theorem map_map₂_right_anticomm {m : α → β' → γ} {n : β → β'} {m' : β → α → δ} {n' : δ → γ}
    (h_right_anticomm : ∀ a b, m a (n b) = n' (m' b a)) :
    map₂ m f (g.map n) = (map₂ m' g f).map n' 
Arguments: {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} {m : α → β' → γ} {n : β → β'} {m' : β → α → δ} {n' : δ → γ} (h_right_anticomm : ∀ (a : α) (b : β), m a (n b) = n' (m' b a))
Goal: Filter.map₂ m f (Filter.map n g) = Filter.map n' (Filter.map₂ m' g f)
-- Filter.map₂_left_identity
theorem map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (l : Filter β) :
    map₂ f (pure a) l = l 
Arguments: {α : Type u_1} {β : Type u_3} {f : α → β → β} {a : α} (h : ∀ (b : β), f a b = b) (l : Filter β)
Goal: Filter.map₂ f (pure a) l = l
-- Filter.map₂_right_identity
theorem map₂_right_identity {f : α → β → α} {b : β} (h : ∀ a, f a b = a) (l : Filter α) :
    map₂ f l (pure b) = l 
Arguments: {α : Type u_1} {β : Type u_3} {f : α → β → α} {b : β} (h : ∀ (a : α), f a b = a) (l : Filter α)
Goal: Filter.map₂ f l (pure b) = l
-- le_trans'
theorem le_trans' : b ≤ c → a ≤ b → a ≤ c 
Arguments: {α : Type u_2} [Preorder α] {a b c : α}
Goal: b ≤ c → a ≤ b → a ≤ c
-- lt_trans'
theorem lt_trans' : b < c → a < b → a < c 
Arguments: {α : Type u_2} [Preorder α] {a b c : α}
Goal: b < c → a < b → a < c
-- lt_of_le_of_lt'
theorem lt_of_le_of_lt' : b ≤ c → a < b → a < c 
Arguments: {α : Type u_2} [Preorder α] {a b c : α}
Goal: b ≤ c → a < b → a < c
-- lt_of_lt_of_le'
theorem lt_of_lt_of_le' : b < c → a ≤ b → a < c 
Arguments: {α : Type u_2} [Preorder α] {a b c : α}
Goal: b < c → a ≤ b → a < c
-- ge_antisymm
theorem ge_antisymm : a ≤ b → b ≤ a → b = a 
Arguments: {α : Type u_2} [PartialOrder α] {a b : α}
Goal: a ≤ b → b ≤ a → b = a
-- lt_of_le_of_ne'
theorem lt_of_le_of_ne' : a ≤ b → b ≠ a → a < b 
Arguments: {α : Type u_2} [PartialOrder α] {a b : α}
Goal: a ≤ b → b ≠ a → a < b
-- Ne.lt_of_le
theorem Ne.lt_of_le : a ≠ b → a ≤ b → a < b 
Arguments: {α : Type u_2} [PartialOrder α] {a b : α}
Goal: a ≠ b → a ≤ b → a < b