ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- OmegaCompletePartialOrder.ContinuousHom.comp_assoc
@[simp]
theorem comp_assoc (f : γ →𝒄 φ) (g : β →𝒄 γ) (h : α →𝒄 β) : f.comp (g.comp h) = (f.comp g).comp h 
Arguments: {α : Type u} {β : Type v} {γ : Type u_3} {φ : Type u_4} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] [OmegaCompletePartialOrder γ] [OmegaCompletePartialOrder φ] (f : γ →𝒄 φ) (g : β →𝒄 γ) (h : α →𝒄 β)
Goal: f.comp (g.comp h) = (f.comp g).comp h
-- OmegaCompletePartialOrder.ContinuousHom.coe_apply
@[simp]
theorem coe_apply (a : α) (f : α →𝒄 β) : (f : α →o β) a = f a 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (a : α) (f : α →𝒄 β)
Goal: ↑f a = f a
-- OmegaCompletePartialOrder.ContinuousHom.const_apply
@[simps!]
def const (x : β) : α →𝒄 β 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (x : β)
Goal: ∀ (a : α), (OmegaCompletePartialOrder.ContinuousHom.const x) a = x
-- OmegaCompletePartialOrder.ContinuousHom.toMono_coe
@[simps]
def toMono : (α →𝒄 β) →o α →o β 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (f : α →𝒄 β)
Goal: OmegaCompletePartialOrder.ContinuousHom.toMono f = ↑f
-- OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge
@[simp]
theorem forall_forall_merge (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) (z : β) :
    (∀ i j : ℕ, (c₀ i) (c₁ j) ≤ z) ↔ ∀ i : ℕ, (c₀ i) (c₁ i) ≤ z 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α) (z : β)
Goal: (∀ (i j : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z
-- OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge'
@[simp]
theorem forall_forall_merge' (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) (z : β) :
    (∀ j i : ℕ, (c₀ i) (c₁ j) ≤ z) ↔ ∀ i : ℕ, (c₀ i) (c₁ i) ≤ z 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α) (z : β)
Goal: (∀ (j i : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z
-- OmegaCompletePartialOrder.ContinuousHom.ωSup_apply
@[simps!]
protected def ωSup (c : Chain (α →𝒄 β)) : α →𝒄 β 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (a : α)
Goal: (OmegaCompletePartialOrder.ContinuousHom.ωSup c) a =
  OmegaCompletePartialOrder.ωSup ((c.map OmegaCompletePartialOrder.ContinuousHom.toMono).map (OrderHom.apply a))
-- OmegaCompletePartialOrder.ContinuousHom.inst_ωSup
@[simps ωSup]
instance : OmegaCompletePartialOrder (α →𝒄 β) 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c : OmegaCompletePartialOrder.Chain (α →𝒄 β))
Goal: OmegaCompletePartialOrder.ωSup c = OmegaCompletePartialOrder.ContinuousHom.ωSup c
-- OmegaCompletePartialOrder.ContinuousHom.Prod.apply_apply
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (f : (α →𝒄 β) × α)
Goal: OmegaCompletePartialOrder.ContinuousHom.Prod.apply f = f.1 f.2
-- OmegaCompletePartialOrder.ContinuousHom.ωSup_def
theorem ωSup_def (c : Chain (α →𝒄 β)) (x : α) : ωSup c x = ContinuousHom.ωSup c x 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (x : α)
Goal: (OmegaCompletePartialOrder.ωSup c) x = (OmegaCompletePartialOrder.ContinuousHom.ωSup c) x
-- OmegaCompletePartialOrder.ContinuousHom.ωSup_apply_ωSup
theorem ωSup_apply_ωSup (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) :
    ωSup c₀ (ωSup c₁) = Prod.apply (ωSup (c₀.zip c₁)) 
Arguments: {α : Type u} {β : Type v} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β] (c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α)
Goal: (OmegaCompletePartialOrder.ωSup c₀) (OmegaCompletePartialOrder.ωSup c₁) =
  OmegaCompletePartialOrder.ContinuousHom.Prod.apply (OmegaCompletePartialOrder.ωSup (c₀.zip c₁))
-- OmegaCompletePartialOrder.ContinuousHom.flip_apply
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ 
Arguments: {β : Type v} {γ : Type u_3} [OmegaCompletePartialOrder β] [OmegaCompletePartialOrder γ] {α : Type u_5} (f : α → β →𝒄 γ) (x : β) (y : α)
Goal: (OmegaCompletePartialOrder.ContinuousHom.flip f) x y = (f y) x
-- OmegaCompletePartialOrder.ContinuousHom.bind_apply
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def bind {β γ : Type v} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ) : α →𝒄 Part γ 
Arguments: {α : Type u} [OmegaCompletePartialOrder α] {β γ : Type v} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ) (x : α)
Goal: (f.bind g) x = (f x).bind (g x)
-- OmegaCompletePartialOrder.ContinuousHom.map_apply
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def map {β γ : Type v} (f : β → γ) (g : α →𝒄 Part β) : α →𝒄 Part γ 
Arguments: {α : Type u} [OmegaCompletePartialOrder α] {β γ : Type v} (f : β → γ) (g : α →𝒄 Part β) (x : α)
Goal: (OmegaCompletePartialOrder.ContinuousHom.map f g) x = Part.map f (g x)
-- OmegaCompletePartialOrder.ContinuousHom.seq_apply
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def seq {β γ : Type v} (f : α →𝒄 Part (β → γ)) (g : α →𝒄 Part β) : α →𝒄 Part γ 
Arguments: {α : Type u} [OmegaCompletePartialOrder α] {β γ : Type v} (f : α →𝒄 Part (β → γ)) (g : α →𝒄 Part β) (x : α)
Goal: (f.seq g) x = Seq.seq (f x) fun x_1 => g x
-- Filter.ker_def
lemma ker_def (f : Filter α) : f.ker = ⋂ s ∈ f, s 
Arguments: {α : Type u_2} (f : Filter α)
Goal: f.ker = ⋂ s ∈ f, s
-- Filter.mem_ker
@[simp] lemma mem_ker : a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s 
Arguments: {α : Type u_2} {f : Filter α} {a : α}
Goal: a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s
-- Filter.subset_ker
@[simp] lemma subset_ker : s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t 
Arguments: {α : Type u_2} {f : Filter α} {s : Set α}
Goal: s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t
-- Filter.ker_mono
lemma ker_mono : Monotone (ker : Filter α → Set α) 
Arguments: {α : Type u_2}
Goal: Monotone Filter.ker
-- Filter.ker_surjective
lemma ker_surjective : Surjective (ker : Filter α → Set α) 
Arguments: {α : Type u_2}
Goal: Function.Surjective Filter.ker
-- Filter.ker_bot
@[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ 
Arguments: {α : Type u_2}
Goal: ⊥.ker = ∅
-- Filter.ker_top
@[simp] lemma ker_top : ker (⊤ : Filter α) = univ 
Arguments: {α : Type u_2}
Goal: ⊤.ker = Set.univ
-- Filter.ker_eq_univ
@[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ 
Arguments: {α : Type u_2} {f : Filter α}
Goal: f.ker = Set.univ ↔ f = ⊤
-- Filter.ker_inf
@[simp] lemma ker_inf (f g : Filter α) : ker (f ⊓ g) = ker f ∩ ker g 
Arguments: {α : Type u_2} (f g : Filter α)
Goal: (f ⊓ g).ker = f.ker ∩ g.ker
-- Filter.ker_iInf
@[simp] lemma ker_iInf (f : ι → Filter α) : ker (⨅ i, f i) = ⨅ i, ker (f i) 
Arguments: {ι : Sort u_1} {α : Type u_2} (f : ι → Filter α)
Goal: (⨅ i, f i).ker = ⨅ i, (f i).ker
-- Filter.ker_sInf
@[simp] lemma ker_sInf (S : Set (Filter α)) : ker (sInf S) = ⨅ f ∈ S, ker f 
Arguments: {α : Type u_2} (S : Set (Filter α))
Goal: (sInf S).ker = ⨅ f ∈ S, f.ker
-- Filter.ker_principal
@[simp] lemma ker_principal (s : Set α) : ker (𝓟 s) = s 
Arguments: {α : Type u_2} (s : Set α)
Goal: (Filter.principal s).ker = s
-- Filter.ker_pure
@[simp] lemma ker_pure (a : α) : ker (pure a) = {a} 
Arguments: {α : Type u_2} (a : α)
Goal: (pure a).ker = {a}
-- Filter.ker_comap
@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f 
Arguments: {α : Type u_2} {β : Type u_3} (m : α → β) (f : Filter β)
Goal: (Filter.comap m f).ker = m ⁻¹' f.ker
-- Nat.frequently_modEq
theorem frequently_modEq {n : ℕ} (h : n ≠ 0) (d : ℕ) : ∃ᶠ m in atTop, m ≡ d [MOD n] 
Arguments: {n : ℕ} (h : n ≠ 0) (d : ℕ)
Goal: ∃ᶠ (m : ℕ) in Filter.atTop, m ≡ d [MOD n]
-- Nat.frequently_mod_eq
theorem frequently_mod_eq {d n : ℕ} (h : d < n) : ∃ᶠ m in atTop, m % n = d 
Arguments: {d n : ℕ} (h : d < n)
Goal: ∃ᶠ (m : ℕ) in Filter.atTop, m % n = d
-- Nat.frequently_even
theorem frequently_even : ∃ᶠ m : ℕ in atTop, Even m 
Goal: ∃ᶠ (m : ℕ) in Filter.atTop, Even m
-- Nat.frequently_odd
theorem frequently_odd : ∃ᶠ m : ℕ in atTop, Odd m 
Goal: ∃ᶠ (m : ℕ) in Filter.atTop, Odd m
-- Filter.nonneg_of_eventually_pow_nonneg
theorem Filter.nonneg_of_eventually_pow_nonneg {α : Type*} [LinearOrderedRing α] {a : α}
    (h : ∀ᶠ n in atTop, 0 ≤ a ^ (n : ℕ)) : 0 ≤ a 
Arguments: {α : Type u_1} [LinearOrderedRing α] {a : α} (h : ∀ᶠ (n : ℕ) in Filter.atTop, 0 ≤ a ^ n)
Goal: 0 ≤ a
-- OrderHom.monotone'
structure OrderHom (α β : Type*) [Preorder α] [Preorder β] where
    toFun : α → β
    monotone' : Monotone toFun
Arguments: {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] (self : α →o β)
Goal: Monotone self.toFun
-- OrderIsoClass.map_le_map_iff
class OrderIsoClass (F α β : Type*) [LE α] [LE β] [EquivLike F α β] : Prop where
    map_le_map_iff (f : F) {a b : α} : f a ≤ f b ↔ a ≤ b
Arguments: {F : Type u_6} {α : Type u_7} {β : Type u_8} [LE α] [LE β] [EquivLike F α β] [self : OrderIsoClass F α β] (f : F) {a b : α}
Goal: f a ≤ f b ↔ a ≤ b
-- OrderHomClass.monotone
protected theorem monotone (f : F) : Monotone f 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [FunLike F α β] [OrderHomClass F α β] (f : F)
Goal: Monotone ⇑f
-- OrderHomClass.mono
protected theorem mono (f : F) : Monotone f 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [FunLike F α β] [OrderHomClass F α β] (f : F)
Goal: Monotone ⇑f
-- map_inv_le_iff
@[simp]
theorem map_inv_le_iff (f : F) {a : α} {b : β} : EquivLike.inv f b ≤ a ↔ b ≤ f a 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [LE α] [LE β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) {a : α} {b : β}
Goal: EquivLike.inv f b ≤ a ↔ b ≤ f a
-- le_map_inv_iff
@[simp]
theorem le_map_inv_iff (f : F) {a : α} {b : β} : a ≤ EquivLike.inv f b ↔ f a ≤ b 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [LE α] [LE β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) {a : α} {b : β}
Goal: a ≤ EquivLike.inv f b ↔ f a ≤ b
-- map_lt_map_iff
theorem map_lt_map_iff (f : F) {a b : α} : f a < f b ↔ a < b 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) {a b : α}
Goal: f a < f b ↔ a < b
-- map_inv_lt_iff
@[simp]
theorem map_inv_lt_iff (f : F) {a : α} {b : β} : EquivLike.inv f b < a ↔ b < f a 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) {a : α} {b : β}
Goal: EquivLike.inv f b < a ↔ b < f a
-- lt_map_inv_iff
@[simp]
theorem lt_map_inv_iff (f : F) {a : α} {b : β} : a < EquivLike.inv f b ↔ f a < b 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) {a : α} {b : β}
Goal: a < EquivLike.inv f b ↔ f a < b
-- OrderHom.coe_mk
@[simp] theorem coe_mk (f : α → β) (hf : Monotone f) : ⇑(mk f hf) = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α → β) (hf : Monotone f)
Goal: ⇑{ toFun := f, monotone' := hf } = f
-- OrderHom.monotone
protected theorem monotone (f : α →o β) : Monotone f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: Monotone ⇑f
-- OrderHom.mono
protected theorem mono (f : α →o β) : Monotone f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: Monotone ⇑f
-- OrderHom.toFun_eq_coe
@[simp] theorem toFun_eq_coe (f : α →o β) : f.toFun = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: f.toFun = ⇑f
-- OrderHom.ext
@[ext]
theorem ext (f g : α →o β) (h : (f : α → β) = g) : f = g 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f g : α →o β) (h : ⇑f = ⇑g)
Goal: f = g
-- OrderHom.coe_eq
@[simp] theorem coe_eq (f : α →o β) : OrderHomClass.toOrderHom f = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: ↑f = f
-- OrderHomClass.coe_coe
@[simp] theorem _root_.OrderHomClass.coe_coe {F} [FunLike F α β] [OrderHomClass F α β] (f : F) :
    ⇑(f : α →o β) = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {F : Type u_6} [FunLike F α β] [OrderHomClass F α β] (f : F)
Goal: ⇑↑f = ⇑f
-- OrderHom.coe_copy
@[simp]
theorem coe_copy (f : α →o β) (f' : α → β) (h : f' = f) : (f.copy f' h) = f' 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β) (f' : α → β) (h : f' = ⇑f)
Goal: ⇑(f.copy f' h) = f'
-- OrderHom.copy_eq
theorem copy_eq (f : α →o β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β) (f' : α → β) (h : f' = ⇑f)
Goal: f.copy f' h = f
-- OrderHom.id_coe
@[simps (config := .asFn)]
def id : α →o α 
Arguments: {α : Type u_2} [Preorder α]
Goal: ⇑OrderHom.id = id
-- OrderHom.le_def
theorem le_def {f g : α →o β} : f ≤ g ↔ ∀ x, f x ≤ g x 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {f g : α →o β}
Goal: f ≤ g ↔ ∀ (x : α), f x ≤ g x
-- OrderHom.coe_le_coe
@[simp, norm_cast]
theorem coe_le_coe {f g : α →o β} : (f : α → β) ≤ g ↔ f ≤ g 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {f g : α →o β}
Goal: ⇑f ≤ ⇑g ↔ f ≤ g
-- OrderHom.mk_le_mk
@[simp]
theorem mk_le_mk {f g : α → β} {hf hg} : mk f hf ≤ mk g hg ↔ f ≤ g 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {f g : α → β} {hf : Monotone f} {hg : Monotone g}
Goal: { toFun := f, monotone' := hf } ≤ { toFun := g, monotone' := hg } ↔ f ≤ g
-- OrderHom.apply_mono
@[mono]
theorem apply_mono {f g : α →o β} {x y : α} (h₁ : f ≤ g) (h₂ : x ≤ y) : f x ≤ g y 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {f g : α →o β} {x y : α} (h₁ : f ≤ g) (h₂ : x ≤ y)
Goal: f x ≤ g y
-- OrderHom.curry_apply
@[simp]
theorem curry_apply (f : α × β →o γ) (x : α) (y : β) : curry f x y = f (x, y) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α × β →o γ) (x : α) (y : β)
Goal: ((OrderHom.curry f) x) y = f (x, y)
-- OrderHom.curry_symm_apply
@[simp]
theorem curry_symm_apply (f : α →o β →o γ) (x : α × β) : curry.symm f x = f x.1 x.2 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β →o γ) (x : α × β)
Goal: ((RelIso.symm OrderHom.curry) f) x = (f x.1) x.2
-- OrderHom.comp_coe
@[simps (config := .asFn)]
def comp (g : β →o γ) (f : α →o β) : α →o γ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (g : β →o γ) (f : α →o β)
Goal: ⇑(g.comp f) = ⇑g ∘ ⇑f
-- OrderHom.comp_mono
@[mono]
theorem comp_mono ⦃g₁ g₂ : β →o γ⦄ (hg : g₁ ≤ g₂) ⦃f₁ f₂ : α →o β⦄ (hf : f₁ ≤ f₂) :
    g₁.comp f₁ ≤ g₂.comp f₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] ⦃g₁ g₂ : β →o γ⦄ (hg : g₁ ≤ g₂) ⦃f₁ f₂ : α →o β⦄ (hf : f₁ ≤ f₂)
Goal: g₁.comp f₁ ≤ g₂.comp f₂
-- OrderHom.mk_comp_mk
@[simp] lemma mk_comp_mk (g : β → γ) (f : α → β) (hg hf) :
    comp ⟨g, hg⟩ ⟨f, hf⟩ = ⟨g ∘ f, hg.comp hf⟩ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (g : β → γ) (f : α → β) (hg : Monotone g) (hf : Monotone f)
Goal: { toFun := g, monotone' := hg }.comp { toFun := f, monotone' := hf } = { toFun := g ∘ f, monotone' := ⋯ }
-- OrderHom.compₘ_coe_coe_coe
@[simps! (config := .asFn)]
def compₘ : (β →o γ) →o (α →o β) →o α →o γ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (x : β →o γ)
Goal: ∀ (a : α →o β), ⇑((OrderHom.compₘ x) a) = ⇑x ∘ ⇑a
-- OrderHom.comp_id
@[simp]
theorem comp_id (f : α →o β) : comp f id = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: f.comp OrderHom.id = f
-- OrderHom.id_comp
@[simp]
theorem id_comp (f : α →o β) : comp id f = f 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: OrderHom.id.comp f = f
-- OrderHom.const_coe_coe
@[simps (config := .asFn)]
def const (α : Type*) [Preorder α] {β : Type*} [Preorder β] : β →o α →o β 
Arguments: (α : Type u_6) [Preorder α] {β : Type u_7} [Preorder β] (b : β)
Goal: ⇑((OrderHom.const α) b) = Function.const α b
-- OrderHom.const_comp
@[simp]
theorem const_comp (f : α →o β) (c : γ) : (const β c).comp f = const α c 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β) (c : γ)
Goal: ((OrderHom.const β) c).comp f = (OrderHom.const α) c
-- OrderHom.comp_const
@[simp]
theorem comp_const (γ : Type*) [Preorder γ] (f : α →o β) (c : α) :
    f.comp (const γ c) = const γ (f c) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (γ : Type u_6) [Preorder γ] (f : α →o β) (c : α)
Goal: f.comp ((OrderHom.const γ) c) = (OrderHom.const γ) (f c)
-- OrderHom.prod_coe
@[simps]
protected def prod (f : α →o β) (g : α →o γ) : α →o β × γ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β) (g : α →o γ) (x : α)
Goal: (f.prod g) x = (f x, g x)
-- OrderHom.prod_mono
@[mono]
theorem prod_mono {f₁ f₂ : α →o β} (hf : f₁ ≤ f₂) {g₁ g₂ : α →o γ} (hg : g₁ ≤ g₂) :
    f₁.prod g₁ ≤ f₂.prod g₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] {f₁ f₂ : α →o β} (hf : f₁ ≤ f₂) {g₁ g₂ : α →o γ} (hg : g₁ ≤ g₂)
Goal: f₁.prod g₁ ≤ f₂.prod g₂
-- OrderHom.comp_prod_comp_same
theorem comp_prod_comp_same (f₁ f₂ : β →o γ) (g : α →o β) :
    (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f₁ f₂ : β →o γ) (g : α →o β)
Goal: (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g
-- OrderHom.prodₘ_coe_coe_coe
@[simps!]
def prodₘ : (α →o β) →o (α →o γ) →o α →o β × γ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (x : α →o β)
Goal: ∀ (a : α →o γ) (x_1 : α), ((OrderHom.prodₘ x) a) x_1 = (x x_1, a x_1)
-- OrderHom.diag_coe
@[simps!]
def diag : α →o α × α 
Arguments: {α : Type u_2} [Preorder α] (x : α)
Goal: OrderHom.diag x = (x, x)
-- OrderHom.onDiag_coe
@[simps! (config := { simpRhs := true })]
def onDiag (f : α →o α →o β) : α →o β 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o α →o β)
Goal: ∀ (a : α), f.onDiag a = (f a) a
-- OrderHom.fst_coe
@[simps]
def fst : α × β →o α 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (self : α × β)
Goal: OrderHom.fst self = self.1
-- OrderHom.snd_coe
@[simps]
def snd : α × β →o β 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (self : α × β)
Goal: OrderHom.snd self = self.2
-- OrderHom.fst_prod_snd
@[simp]
theorem fst_prod_snd : (fst : α × β →o α).prod snd = id 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β]
Goal: OrderHom.fst.prod OrderHom.snd = OrderHom.id
-- OrderHom.fst_comp_prod
@[simp]
theorem fst_comp_prod (f : α →o β) (g : α →o γ) : fst.comp (f.prod g) = f 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β) (g : α →o γ)
Goal: OrderHom.fst.comp (f.prod g) = f
-- OrderHom.snd_comp_prod
@[simp]
theorem snd_comp_prod (f : α →o β) (g : α →o γ) : snd.comp (f.prod g) = g 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β) (g : α →o γ)
Goal: OrderHom.snd.comp (f.prod g) = g
-- OrderHom.prodIso_apply
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : α →o β × γ)
Goal: OrderHom.prodIso f = (OrderHom.fst.comp f, OrderHom.snd.comp f)
-- OrderHom.prodIso_symm_apply
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (f : (α →o β) × (α →o γ))
Goal: (RelIso.symm OrderHom.prodIso) f = f.1.prod f.2
-- OrderHom.prodMap_coe
@[simps]
def prodMap (f : α →o β) (g : γ →o δ) : α × γ →o β × δ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] (f : α →o β) (g : γ →o δ)
Goal: ∀ (a : α × γ), (f.prodMap g) a = Prod.map (⇑f) (⇑g) a
-- Pi.evalOrderHom_coe
@[simps (config := .asFn)]
def _root_.Pi.evalOrderHom (i : ι) : (∀ j, π j) →o π i 
Arguments: {ι : Type u_6} {π : ι → Type u_7} [(i : ι) → Preorder (π i)] (i : ι)
Goal: ⇑(Pi.evalOrderHom i) = Function.eval i
-- OrderHom.coeFnHom_coe
@[simps (config := .asFn)]
def coeFnHom : (α →o β) →o α → β 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β]
Goal: ⇑OrderHom.coeFnHom = fun f => ⇑f
-- OrderHom.apply_coe
@[simps! (config := .asFn)]
def apply (x : α) : (α →o β) →o β 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (x : α)
Goal: ⇑(OrderHom.apply x) = Function.eval x ∘ fun f => ⇑f
-- OrderHom.pi_coe
@[simps]
def pi (f : ∀ i, α →o π i) : α →o ∀ i, π i 
Arguments: {α : Type u_2} [Preorder α] {ι : Type u_6} {π : ι → Type u_7} [(i : ι) → Preorder (π i)] (f : (i : ι) → α →o π i) (x : α) (i : ι)
Goal: (OrderHom.pi f) x i = (f i) x
-- OrderHom.piIso_apply
@[simps]
def piIso : (α →o ∀ i, π i) ≃o ∀ i, α →o π i 
Arguments: {α : Type u_2} [Preorder α] {ι : Type u_6} {π : ι → Type u_7} [(i : ι) → Preorder (π i)] (f : α →o (i : ι) → π i) (i : ι)
Goal: OrderHom.piIso f i = (Pi.evalOrderHom i).comp f
-- OrderHom.piIso_symm_apply
@[simps]
def piIso : (α →o ∀ i, π i) ≃o ∀ i, α →o π i 
Arguments: {α : Type u_2} [Preorder α] {ι : Type u_6} {π : ι → Type u_7} [(i : ι) → Preorder (π i)] (f : (i : ι) → α →o π i)
Goal: (RelIso.symm OrderHom.piIso) f = OrderHom.pi f
-- OrderHom.Subtype.val_coe
@[simps (config := .asFn)]
def Subtype.val (p : α → Prop) : Subtype p →o α 
Arguments: {α : Type u_2} [Preorder α] (p : α → Prop)
Goal: ⇑(OrderHom.Subtype.val p) = Subtype.val
-- Subtype.orderEmbedding_apply_coe
@[simps!]
def _root_.Subtype.orderEmbedding {p q : α → Prop} (h : ∀ a, p a → q a) :
    {x // p x} ↪o {x // q x} 
Arguments: {α : Type u_2} [Preorder α] {p q : α → Prop} (h : ∀ (a : α), p a → q a) (x : { x // p x })
Goal: ↑((Subtype.orderEmbedding h) x) = ↑x
-- OrderHom.orderHom_eq_id
theorem orderHom_eq_id [Subsingleton α] (g : α →o α) : g = OrderHom.id 
Arguments: {α : Type u_2} [Preorder α] [Subsingleton α] (g : α →o α)
Goal: g = OrderHom.id
-- OrderHom.dual_symm_apply_coe
@[simps]
protected def dual : (α →o β) ≃ (αᵒᵈ →o βᵒᵈ) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : αᵒᵈ →o βᵒᵈ)
Goal: ∀ (a : α), (OrderHom.dual.symm f) a = (⇑OrderDual.ofDual ∘ ⇑f ∘ ⇑OrderDual.toDual) a
-- OrderHom.dual_apply_coe
@[simps]
protected def dual : (α →o β) ≃ (αᵒᵈ →o βᵒᵈ) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] (f : α →o β)
Goal: ∀ (a : αᵒᵈ), (OrderHom.dual f) a = (⇑OrderDual.toDual ∘ ⇑f ∘ ⇑OrderDual.ofDual) a
-- OrderHom.dual_id
@[simp]
theorem dual_id : OrderHom.dual (OrderHom.id : α →o α) = OrderHom.id 
Arguments: {α : Type u_2} [Preorder α]
Goal: OrderHom.dual OrderHom.id = OrderHom.id
-- OrderHom.dual_comp
@[simp]
theorem dual_comp (g : β →o γ) (f : α →o β) :
    OrderHom.dual (g.comp f) = (OrderHom.dual g).comp (OrderHom.dual f) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (g : β →o γ) (f : α →o β)
Goal: OrderHom.dual (g.comp f) = (OrderHom.dual g).comp (OrderHom.dual f)
-- OrderHom.symm_dual_id
@[simp]
theorem symm_dual_id : OrderHom.dual.symm OrderHom.id = (OrderHom.id : α →o α) 
Arguments: {α : Type u_2} [Preorder α]
Goal: OrderHom.dual.symm OrderHom.id = OrderHom.id
-- OrderHom.symm_dual_comp
@[simp]
theorem symm_dual_comp (g : βᵒᵈ →o γᵒᵈ) (f : αᵒᵈ →o βᵒᵈ) :
    OrderHom.dual.symm (g.comp f) = (OrderHom.dual.symm g).comp (OrderHom.dual.symm f) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] (g : βᵒᵈ →o γᵒᵈ) (f : αᵒᵈ →o βᵒᵈ)
Goal: OrderHom.dual.symm (g.comp f) = (OrderHom.dual.symm g).comp (OrderHom.dual.symm f)