ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fintype.bijective_bijInv
theorem bijective_bijInv (f_bij : Bijective f) : Bijective (bijInv f_bij) 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (f_bij : Function.Bijective f)
Goal: Function.Bijective (Fintype.bijInv f_bij)
-- Multiset.count_univ
@[simp]
theorem count_univ [DecidableEq α] (a : α) : count a Finset.univ.val = 1 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (a : α)
Goal: Multiset.count a Finset.univ.val = 1
-- Multiset.map_univ_val_equiv
@[simp]
theorem map_univ_val_equiv (e : α ≃ β) :
    map e univ.val = univ.val 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (e : α ≃ β)
Goal: Multiset.map (⇑e) Finset.univ.val = Finset.univ.val
-- Multiset.bijective_iff_map_univ_eq_univ
@[simp]
theorem bijective_iff_map_univ_eq_univ (f : α → β) :
    f.Bijective ↔ map f (Finset.univ : Finset α).val = univ.val 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (f : α → β)
Goal: Function.Bijective f ↔ Multiset.map f Finset.univ.val = Finset.univ.val
-- exists_seq_of_forall_finset_exists
theorem exists_seq_of_forall_finset_exists {α : Type*} (P : α → Prop) (r : α → α → Prop)
    (h : ∀ s : Finset α, (∀ x ∈ s, P x) → ∃ y, P y ∧ ∀ x ∈ s, r x y) :
    ∃ f : ℕ → α, (∀ n, P (f n)) ∧ ∀ m n, m < n → r (f m) (f n) 
Arguments: {α : Type u_4} (P : α → Prop) (r : α → α → Prop) (h : ∀ (s : Finset α), (∀ x ∈ s, P x) → ∃ y, P y ∧ ∀ x ∈ s, r x y)
Goal: ∃ f, (∀ (n : ℕ), P (f n)) ∧ ∀ (m n : ℕ), m < n → r (f m) (f n)
-- exists_seq_of_forall_finset_exists'
theorem exists_seq_of_forall_finset_exists' {α : Type*} (P : α → Prop) (r : α → α → Prop)
    [IsSymm α r] (h : ∀ s : Finset α, (∀ x ∈ s, P x) → ∃ y, P y ∧ ∀ x ∈ s, r x y) :
    ∃ f : ℕ → α, (∀ n, P (f n)) ∧ Pairwise fun m n => r (f m) (f n) 
Arguments: {α : Type u_4} (P : α → Prop) (r : α → α → Prop) [IsSymm α r] (h : ∀ (s : Finset α), (∀ x ∈ s, P x) → ∃ y, P y ∧ ∀ x ∈ s, r x y)
Goal: ∃ f, (∀ (n : ℕ), P (f n)) ∧ Pairwise fun m n => r (f m) (f n)
-- LazyList.bind_singleton
@[deprecated (since := "2024-07-22"), simp]
theorem bind_singleton {α} (x : LazyList α) : x.bind singleton = x 
Arguments: {α : Type u_1} (x : LazyList α)
Goal: x.bind LazyList.singleton = x
-- Equiv.pnatEquivNat_apply
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ 
Goal: ⇑Equiv.pnatEquivNat = PNat.natPred
-- Equiv.pnatEquivNat_symm_apply
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ 
Goal: ⇑Equiv.pnatEquivNat.symm = Nat.succPNat
-- Option.coe_def
theorem coe_def : (fun a ↦ ↑a : α → Option α) = some 
Arguments: {α : Type u_1}
Goal: (fun a => some a) = some
-- Option.mem_map
theorem mem_map {f : α → β} {y : β} {o : Option α} : y ∈ o.map f ↔ ∃ x ∈ o, f x = y 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {y : β} {o : Option α}
Goal: y ∈ Option.map f o ↔ ∃ x, x ∈ o ∧ f x = y
-- Option.mem_map_of_injective
@[simp 1100, nolint simpNF]
theorem mem_map_of_injective {f : α → β} (H : Function.Injective f) {a : α} {o : Option α} :
    f a ∈ o.map f ↔ a ∈ o 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (H : Function.Injective f) {a : α} {o : Option α}
Goal: f a ∈ Option.map f o ↔ a ∈ o
-- Option.forall_mem_map
theorem forall_mem_map {f : α → β} {o : Option α} {p : β → Prop} :
    (∀ y ∈ o.map f, p y) ↔ ∀ x ∈ o, p (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {o : Option α} {p : β → Prop}
Goal: (∀ (y : β), y ∈ Option.map f o → p y) ↔ ∀ (x : α), x ∈ o → p (f x)
-- Option.exists_mem_map
theorem exists_mem_map {f : α → β} {o : Option α} {p : β → Prop} :
    (∃ y ∈ o.map f, p y) ↔ ∃ x ∈ o, p (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {o : Option α} {p : β → Prop}
Goal: (∃ y, y ∈ Option.map f o ∧ p y) ↔ ∃ x, x ∈ o ∧ p (f x)
-- Option.coe_get
theorem coe_get {o : Option α} (h : o.isSome) : ((Option.get _ h : α) : Option α) = o 
Arguments: {α : Type u_1} {o : Option α} (h : o.isSome = true)
Goal: some (o.get h) = o
-- Option.eq_of_mem_of_mem
theorem eq_of_mem_of_mem {a : α} {o1 o2 : Option α} (h1 : a ∈ o1) (h2 : a ∈ o2) : o1 = o2 
Arguments: {α : Type u_1} {a : α} {o1 o2 : Option α} (h1 : a ∈ o1) (h2 : a ∈ o2)
Goal: o1 = o2
-- Option.Mem.leftUnique
theorem Mem.leftUnique : Relator.LeftUnique ((· ∈ ·) : α → Option α → Prop) 
Arguments: {α : Type u_1}
Goal: Relator.LeftUnique fun x x_1 => x ∈ x_1
-- Option.some_injective
theorem some_injective (α : Type*) : Function.Injective (@some α) 
Arguments: (α : Type u_5)
Goal: Function.Injective some
-- Option.map_injective
theorem map_injective {f : α → β} (Hf : Function.Injective f) : Function.Injective (Option.map f)
  
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (Hf : Function.Injective f)
Goal: Function.Injective (Option.map f)
-- Option.map_comp_some
@[simp]
theorem map_comp_some (f : α → β) : Option.map f ∘ some = some ∘ f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Option.map f ∘ some = some ∘ f
-- Option.none_bind'
@[simp]
theorem none_bind' (f : α → Option β) : none.bind f = none 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β)
Goal: none.bind f = none
-- Option.some_bind'
@[simp]
theorem some_bind' (a : α) (f : α → Option β) : (some a).bind f = f a 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (f : α → Option β)
Goal: (some a).bind f = f a
-- Option.bind_eq_some'
theorem bind_eq_some' {x : Option α} {f : α → Option β} {b : β} :
    x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b 
Arguments: {α : Type u_1} {β : Type u_2} {x : Option α} {f : α → Option β} {b : β}
Goal: x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b
-- Option.bind_congr
theorem bind_congr {f g : α → Option β} {x : Option α}
    (h : ∀ a ∈ x, f a = g a) : x.bind f = x.bind g 
Arguments: {α : Type u_1} {β : Type u_2} {f g : α → Option β} {x : Option α} (h : ∀ (a : α), a ∈ x → f a = g a)
Goal: x.bind f = x.bind g
-- Option.bind_congr'
@[congr]
theorem bind_congr' {f g : α → Option β} {x y : Option α} (hx : x = y)
    (hf : ∀ a ∈ y, f a = g a) : x.bind f = y.bind g 
Arguments: {α : Type u_1} {β : Type u_2} {f g : α → Option β} {x y : Option α} (hx : x = y) (hf : ∀ (a : α), a ∈ y → f a = g a)
Goal: x.bind f = y.bind g
-- Option.joinM_eq_join
theorem joinM_eq_join : joinM = @join α 
Arguments: {α : Type u_1}
Goal: joinM = Option.join
-- Option.bind_eq_bind'
theorem bind_eq_bind' {α β : Type u} {f : α → Option β} {x : Option α} : x >>= f = x.bind f 
Arguments: {α β : Type u} {f : α → Option β} {x : Option α}
Goal: x >>= f = x.bind f
-- Option.map_coe
theorem map_coe {α β} {a : α} {f : α → β} : f <$> (a : Option α) = ↑(f a) 
Arguments: {α β : Type u_5} {a : α} {f : α → β}
Goal: f <$> some a = some (f a)
-- Option.map_coe'
@[simp]
theorem map_coe' {a : α} {f : α → β} : Option.map f (a : Option α) = ↑(f a) 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {f : α → β}
Goal: Option.map f (some a) = some (f a)
-- Option.map_injective'
theorem map_injective' : Function.Injective (@Option.map α β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Injective Option.map
-- Option.map_inj
@[simp]
theorem map_inj {f g : α → β} : Option.map f = Option.map g ↔ f = g 
Arguments: {α : Type u_1} {β : Type u_2} {f g : α → β}
Goal: Option.map f = Option.map g ↔ f = g
-- Option.map_eq_id
@[simp]
theorem map_eq_id {f : α → α} : Option.map f = id ↔ f = id 
Arguments: {α : Type u_1} {f : α → α}
Goal: Option.map f = id ↔ f = id
-- Option.map_comm
theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂)
    (a : α) :
    (Option.map f₁ a).map g₁ = (Option.map f₂ a).map g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂) (a : α)
Goal: Option.map g₁ (Option.map f₁ (some a)) = Option.map g₂ (Option.map f₂ (some a))
-- Option.pbind_eq_bind
theorem pbind_eq_bind (f : α → Option β) (x : Option α) : (x.pbind fun a _ ↦ f a) = x.bind f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (x : Option α)
Goal: (x.pbind fun a x => f a) = x.bind f
-- Option.map_bind
theorem map_bind {α β γ} (f : β → γ) (x : Option α) (g : α → Option β) :
    Option.map f (x >>= g) = x >>= fun a ↦ Option.map f (g a) 
Arguments: {α β γ : Type u_5} (f : β → γ) (x : Option α) (g : α → Option β)
Goal: Option.map f (x >>= g) = do
  let a ← x
  Option.map f (g a)
-- Option.map_bind'
theorem map_bind' (f : β → γ) (x : Option α) (g : α → Option β) :
    Option.map f (x.bind g) = x.bind fun a ↦ Option.map f (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β → γ) (x : Option α) (g : α → Option β)
Goal: Option.map f (x.bind g) = x.bind fun a => Option.map f (g a)
-- Option.map_pbind
theorem map_pbind (f : β → γ) (x : Option α) (g : ∀ a, a ∈ x → Option β) :
    Option.map f (x.pbind g) = x.pbind fun a H ↦ Option.map f (g a H) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β → γ) (x : Option α) (g : (a : α) → a ∈ x → Option β)
Goal: Option.map f (x.pbind g) = x.pbind fun a H => Option.map f (g a H)
-- Option.pbind_map
theorem pbind_map (f : α → β) (x : Option α) (g : ∀ b : β, b ∈ x.map f → Option γ) :
    pbind (Option.map f x) g = x.pbind fun a h ↦ g (f a) (mem_map_of_mem _ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (x : Option α) (g : (b : β) → b ∈ Option.map f x → Option γ)
Goal: (Option.map f x).pbind g = x.pbind fun a h => g (f a) ⋯
-- Option.pmap_none
@[simp]
theorem pmap_none (f : ∀ a : α, p a → β) {H} : pmap f (@none α) H = none 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) {H : ∀ (a : α), a ∈ none → p a}
Goal: Option.pmap f none H = none
-- Option.pmap_some
@[simp]
theorem pmap_some (f : ∀ a : α, p a → β) {x : α} (h : p x) :
    pmap f (some x) = fun _ ↦ some (f x h) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) {x : α} (h : p x)
Goal: Option.pmap f (some x) = fun x_1 => some (f x h)
-- Option.mem_pmem
theorem mem_pmem {a : α} (h : ∀ a ∈ x, p a) (ha : a ∈ x) : f a (h a ha) ∈ pmap f x h 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) (x : Option α) {a : α} (h : ∀ (a : α), a ∈ x → p a) (ha : a ∈ x)
Goal: f a ⋯ ∈ Option.pmap f x h
-- Option.pmap_map
theorem pmap_map (g : γ → α) (x : Option γ) (H) :
    pmap f (x.map g) H = pmap (fun a h ↦ f (g a) h) x fun a h ↦ H _ (mem_map_of_mem _ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {p : α → Prop} (f : (a : α) → p a → β) (g : γ → α) (x : Option γ) (H : ∀ (a : α), a ∈ Option.map g x → p a)
Goal: Option.pmap f (Option.map g x) H = Option.pmap (fun a h => f (g a) h) x ⋯
-- Option.map_pmap
theorem map_pmap (g : β → γ) (f : ∀ a, p a → β) (x H) :
    Option.map g (pmap f x H) = pmap (fun a h ↦ g (f a h)) x H 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {p : α → Prop} (g : β → γ) (f : (a : α) → p a → β) (x : Option α) (H : ∀ (a : α), a ∈ x → p a)
Goal: Option.map g (Option.pmap f x H) = Option.pmap (fun a h => g (f a h)) x H
-- Option.pmap_eq_map
theorem pmap_eq_map (p : α → Prop) (f : α → β) (x H) :
    @pmap _ _ p (fun a _ ↦ f a) x H = Option.map f x 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → Prop) (f : α → β) (x : Option α) (H : ∀ (a : α), a ∈ x → p a)
Goal: Option.pmap (fun a x => f a) x H = Option.map f x
-- Option.pmap_bind
theorem pmap_bind {α β γ} {x : Option α} {g : α → Option β} {p : β → Prop} {f : ∀ b, p b → γ} (H)
    (H' : ∀ (a : α), ∀ b ∈ g a, b ∈ x >>= g) :
    pmap f (x >>= g) H = x >>= fun a ↦ pmap f (g a) fun b h ↦ H _ (H' a _ h) 
Arguments: {α β γ : Type u_5} {x : Option α} {g : α → Option β} {p : β → Prop} {f : (b : β) → p b → γ} (H : ∀ (a : β), a ∈ x >>= g → p a) (H' : ∀ (a : α) (b : β), b ∈ g a → b ∈ x >>= g)
Goal: Option.pmap f (x >>= g) H = do
  let a ← x
  Option.pmap f (g a) ⋯
-- Option.bind_pmap
theorem bind_pmap {α β γ} {p : α → Prop} (f : ∀ a, p a → β) (x : Option α) (g : β → Option γ) (H) :
    pmap f x H >>= g = x.pbind fun a h ↦ g (f a (H _ h)) 
Arguments: {α : Type u_5} {β γ : Type u_6} {p : α → Prop} (f : (a : α) → p a → β) (x : Option α) (g : β → Option γ) (H : ∀ (a : α), a ∈ x → p a)
Goal: Option.pmap f x H >>= g = x.pbind fun a h => g (f a ⋯)
-- Option.pbind_eq_none
theorem pbind_eq_none {f : ∀ a : α, a ∈ x → Option β}
    (h' : ∀ a (H : a ∈ x), f a H = none → x = none) : x.pbind f = none ↔ x = none 
Arguments: {α : Type u_1} {β : Type u_2} {x : Option α} {f : (a : α) → a ∈ x → Option β} (h' : ∀ (a : α) (H : a ∈ x), f a H = none → x = none)
Goal: x.pbind f = none ↔ x = none
-- Option.pbind_eq_some
theorem pbind_eq_some {f : ∀ a : α, a ∈ x → Option β} {y : β} :
    x.pbind f = some y ↔ ∃ (z : α) (H : z ∈ x), f z H = some y 
Arguments: {α : Type u_1} {β : Type u_2} {x : Option α} {f : (a : α) → a ∈ x → Option β} {y : β}
Goal: x.pbind f = some y ↔ ∃ z H, f z H = some y
-- Option.pmap_eq_none_iff
theorem pmap_eq_none_iff {h} : pmap f x h = none ↔ x = none 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {x : Option α} {h : ∀ (a : α), a ∈ x → p a}
Goal: Option.pmap f x h = none ↔ x = none
-- Option.pmap_eq_some_iff
theorem pmap_eq_some_iff {hf} {y : β} :
    pmap f x hf = some y ↔ ∃ (a : α) (H : x = some a), f a (hf a H) = y 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {x : Option α} {hf : ∀ (a : α), a ∈ x → p a} {y : β}
Goal: Option.pmap f x hf = some y ↔ ∃ a H, f a ⋯ = y
-- Option.join_pmap_eq_pmap_join
theorem join_pmap_eq_pmap_join {f : ∀ a, p a → β} {x : Option (Option α)} (H) :
    (pmap (pmap f) x H).join = pmap f x.join fun a h ↦ H (some a) (mem_of_mem_join h) _ rfl 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {x : Option (Option α)} (H : ∀ (a : Option α), a ∈ x → ∀ (a_2 : α), a_2 ∈ a → p a_2)
Goal: (Option.pmap (Option.pmap f) x H).join = Option.pmap f x.join ⋯
-- Option.seq_some
@[simp]
theorem seq_some {α β} {a : α} {f : α → β} : some f <*> some a = some (f a) 
Arguments: {α β : Type u_5} {a : α} {f : α → β}
Goal: (Seq.seq (some f) fun x => some a) = some (f a)
-- Option.some_orElse'
@[simp]
theorem some_orElse' (a : α) (x : Option α) : (some a).orElse (fun _ ↦ x) = some a 
Arguments: {α : Type u_1} (a : α) (x : Option α)
Goal: ((some a).orElse fun x_1 => x) = some a
-- Option.none_orElse'
@[simp]
theorem none_orElse' (x : Option α) : none.orElse (fun _ ↦ x) = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: (none.orElse fun x_1 => x) = x
-- Option.orElse_none'
@[simp]
theorem orElse_none' (x : Option α) : x.orElse (fun _ ↦ none) = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: (x.orElse fun x => none) = x
-- Option.exists_ne_none
theorem exists_ne_none {p : Option α → Prop} : (∃ x ≠ none, p x) ↔ (∃ x : α, p x) 
Arguments: {α : Type u_1} {p : Option α → Prop}
Goal: (∃ x, x ≠ none ∧ p x) ↔ ∃ x, p (some x)
-- Option.isSome_map
@[simp]
theorem isSome_map (f : α → β) (o : Option α) : isSome (o.map f) = isSome o 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (o : Option α)
Goal: (Option.map f o).isSome = o.isSome
-- Option.get_map
@[simp]
theorem get_map (f : α → β) {o : Option α} (h : isSome (o.map f)) :
    (o.map f).get h = f (o.get (by rwa [← isSome_map])) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) {o : Option α} (h : (Option.map f o).isSome = true)
Goal: (Option.map f o).get h = f (o.get ⋯)
-- Option.iget_mem
theorem iget_mem [Inhabited α] : ∀ {o : Option α}, isSome o → o.iget ∈ o
  
Arguments: {α : Type u_1} [Inhabited α] {o : Option α}
Goal: o.isSome = true → o.iget ∈ o
-- Option.iget_of_mem
theorem iget_of_mem [Inhabited α] {a : α} : ∀ {o : Option α}, a ∈ o → o.iget = a
  
Arguments: {α : Type u_1} [Inhabited α] {a : α} {o : Option α}
Goal: a ∈ o → o.iget = a
-- Option.getD_default_eq_iget
theorem getD_default_eq_iget [Inhabited α] (o : Option α) :
    o.getD default = o.iget 
Arguments: {α : Type u_1} [Inhabited α] (o : Option α)
Goal: o.getD default = o.iget
-- Option.guard_eq_some'
@[simp]
theorem guard_eq_some' {p : Prop} [Decidable p] (u) : _root_.guard p = some u ↔ p 
Arguments: {p : Prop} [Decidable p] (u : Unit)
Goal: guard p = some u ↔ p
-- Option.liftOrGet_choice
theorem liftOrGet_choice {f : α → α → α} (h : ∀ a b, f a b = a ∨ f a b = b) :
    ∀ o₁ o₂, liftOrGet f o₁ o₂ = o₁ ∨ liftOrGet f o₁ o₂ = o₂
  
Arguments: {α : Type u_1} {f : α → α → α} (h : ∀ (a b : α), f a b = a ∨ f a b = b) (o₁ o₂ : Option α)
Goal: Option.liftOrGet f o₁ o₂ = o₁ ∨ Option.liftOrGet f o₁ o₂ = o₂
-- Option.casesOn'_none
@[simp]
theorem casesOn'_none (x : β) (f : α → β) : casesOn' none x f = x 
Arguments: {α : Type u_1} {β : Type u_2} (x : β) (f : α → β)
Goal: none.casesOn' x f = x
-- Option.casesOn'_some
@[simp]
theorem casesOn'_some (x : β) (f : α → β) (a : α) : casesOn' (some a) x f = f a 
Arguments: {α : Type u_1} {β : Type u_2} (x : β) (f : α → β) (a : α)
Goal: (some a).casesOn' x f = f a
-- Option.casesOn'_coe
@[simp]
theorem casesOn'_coe (x : β) (f : α → β) (a : α) : casesOn' (a : Option α) x f = f a 
Arguments: {α : Type u_1} {β : Type u_2} (x : β) (f : α → β) (a : α)
Goal: (some a).casesOn' x f = f a
-- Option.casesOn'_none_coe
theorem casesOn'_none_coe (f : Option α → β) (o : Option α) :
    casesOn' o (f none) (f ∘ (fun a ↦ ↑a)) = f o 
Arguments: {α : Type u_1} {β : Type u_2} (f : Option α → β) (o : Option α)
Goal: o.casesOn' (f none) (f ∘ fun a => some a) = f o
-- Option.casesOn'_eq_elim
lemma casesOn'_eq_elim (b : β) (f : α → β) (a : Option α) :
    Option.casesOn' a b f = Option.elim a b f 
Arguments: {α : Type u_1} {β : Type u_2} (b : β) (f : α → β) (a : Option α)
Goal: a.casesOn' b f = a.elim b f
-- Option.orElse_eq_some
theorem orElse_eq_some (o o' : Option α) (x : α) :
    (o <|> o') = some x ↔ o = some x ∨ o = none ∧ o' = some x 
Arguments: {α : Type u_1} (o o' : Option α) (x : α)
Goal: (HOrElse.hOrElse o fun x => o') = some x ↔ o = some x ∨ o = none ∧ o' = some x
-- Option.orElse_eq_some'
theorem orElse_eq_some' (o o' : Option α) (x : α) :
    o.orElse (fun _ ↦ o') = some x ↔ o = some x ∨ o = none ∧ o' = some x 
Arguments: {α : Type u_1} (o o' : Option α) (x : α)
Goal: (o.orElse fun x => o') = some x ↔ o = some x ∨ o = none ∧ o' = some x
-- Option.orElse_eq_none
@[simp]
theorem orElse_eq_none (o o' : Option α) : (o <|> o') = none ↔ o = none ∧ o' = none 
Arguments: {α : Type u_1} (o o' : Option α)
Goal: (HOrElse.hOrElse o fun x => o') = none ↔ o = none ∧ o' = none
-- Option.orElse_eq_none'
@[simp]
theorem orElse_eq_none' (o o' : Option α) : o.orElse (fun _ ↦ o') = none ↔ o = none ∧ o' = none 
Arguments: {α : Type u_1} (o o' : Option α)
Goal: (o.orElse fun x => o') = none ↔ o = none ∧ o' = none
-- Option.choice_eq_none
theorem choice_eq_none (α : Type*) [IsEmpty α] : choice α = none 
Arguments: (α : Type u_5) [IsEmpty α]
Goal: Option.choice α = none
-- Option.elim_none_some
theorem elim_none_some (f : Option α → β) : (fun x ↦ Option.elim x (f none) (f ∘ some)) = f 
Arguments: {α : Type u_1} {β : Type u_2} (f : Option α → β)
Goal: (fun x => x.elim (f none) (f ∘ some)) = f
-- Option.elim_comp
theorem elim_comp (h : α → β) {f : γ → α} {x : α} {i : Option γ} :
    (i.elim (h x) fun j => h (f j)) = h (i.elim x f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (h : α → β) {f : γ → α} {x : α} {i : Option γ}
Goal: (i.elim (h x) fun j => h (f j)) = h (i.elim x f)
-- Option.elim_comp₂
theorem elim_comp₂ (h : α → β → γ) {f : γ → α} {x : α} {g : γ → β} {y : β}
    {i : Option γ} : (i.elim (h x y) fun j => h (f j) (g j)) = h (i.elim x f) (i.elim y g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (h : α → β → γ) {f : γ → α} {x : α} {g : γ → β} {y : β} {i : Option γ}
Goal: (i.elim (h x y) fun j => h (f j) (g j)) = h (i.elim x f) (i.elim y g)
-- Option.elim_apply
theorem elim_apply {f : γ → α → β} {x : α → β} {i : Option γ} {y : α} :
    i.elim x f y = i.elim (x y) fun j => f j y 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : γ → α → β} {x : α → β} {i : Option γ} {y : α}
Goal: i.elim x f y = i.elim (x y) fun j => f j y
-- Option.get!_some
@[simp]
theorem get!_some [Inhabited α] (a : α) : (some a).get! = a 
Arguments: {α : Type u_1} [Inhabited α] (a : α)
Goal: (some a).get! = a
-- Option.get!_none
@[simp]
theorem get!_none [Inhabited α] : (none : Option α).get! = default 
Arguments: {α : Type u_1} [Inhabited α]
Goal: none.get! = default
-- Option.bnot_isSome
@[simp]
lemma bnot_isSome (a : Option α) : (! a.isSome) = a.isNone 
Arguments: {α : Type u_1} (a : Option α)
Goal: (!a.isSome) = a.isNone
-- Option.bnot_comp_isSome
@[simp]
lemma bnot_comp_isSome : (! ·) ∘ @Option.isSome α = Option.isNone 
Arguments: {α : Type u_1}
Goal: (fun x => !x) ∘ Option.isSome = Option.isNone
-- Option.bnot_isNone
@[simp]
lemma bnot_isNone (a : Option α) : (! a.isNone) = a.isSome 
Arguments: {α : Type u_1} (a : Option α)
Goal: (!a.isNone) = a.isSome
-- Option.bnot_comp_isNone
@[simp]
lemma bnot_comp_isNone : (! ·) ∘ @Option.isNone α = Option.isSome 
Arguments: {α : Type u_1}
Goal: (fun x => !x) ∘ Option.isNone = Option.isSome
-- Option.isNone_eq_false_iff
@[simp]
lemma isNone_eq_false_iff (a : Option α) : Option.isNone a = false ↔ Option.isSome a 
Arguments: {α : Type u_1} (a : Option α)
Goal: a.isNone = false ↔ a.isSome = true
-- Option.eq_none_or_eq_some
lemma eq_none_or_eq_some (a : Option α) : a = none ∨ ∃ x, a = some x 
Arguments: {α : Type u_1} (a : Option α)
Goal: a = none ∨ ∃ x, a = some x
-- Option.forall_some_ne_iff_eq_none
lemma forall_some_ne_iff_eq_none {o : Option α} : (∀ (x : α), some x ≠ o) ↔ o = none 
Arguments: {α : Type u_1} {o : Option α}
Goal: (∀ (x : α), some x ≠ o) ↔ o = none
-- length_permsOfList
theorem length_permsOfList : ∀ l : List α, length (permsOfList l) = l.length !
  
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: (permsOfList l).length = l.length !
-- mem_permsOfList_of_mem
theorem mem_permsOfList_of_mem {l : List α} {f : Perm α} (h : ∀ x, f x ≠ x → x ∈ l) :
    f ∈ permsOfList l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {f : Equiv.Perm α} (h : ∀ (x : α), f x ≠ x → x ∈ l)
Goal: f ∈ permsOfList l
-- mem_of_mem_permsOfList
theorem mem_of_mem_permsOfList :
    -- Porting note: was `∀ {x}` but need to capture the `x`
    ∀ {l : List α} {f : Perm α}, f ∈ permsOfList l → (x : α ) → f x ≠ x → x ∈ l
  
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {f : Equiv.Perm α}
Goal: f ∈ permsOfList l → ∀ (x : α), f x ≠ x → x ∈ l
-- mem_permsOfList_iff
theorem mem_permsOfList_iff {l : List α} {f : Perm α} :
    f ∈ permsOfList l ↔ ∀ {x}, f x ≠ x → x ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {f : Equiv.Perm α}
Goal: f ∈ permsOfList l ↔ ∀ {x : α}, f x ≠ x → x ∈ l
-- nodup_permsOfList
theorem nodup_permsOfList : ∀ {l : List α}, l.Nodup → (permsOfList l).Nodup
  
Arguments: {α : Type u_1} [DecidableEq α] {l : List α}
Goal: l.Nodup → (permsOfList l).Nodup
-- mem_perms_of_finset_iff
theorem mem_perms_of_finset_iff :
    ∀ {s : Finset α} {f : Perm α}, f ∈ permsOfFinset s ↔ ∀ {x}, f x ≠ x → x ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {f : Equiv.Perm α}
Goal: f ∈ permsOfFinset s ↔ ∀ {x : α}, f x ≠ x → x ∈ s
-- card_perms_of_finset
theorem card_perms_of_finset : ∀ s : Finset α, (permsOfFinset s).card = s.card ! 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: (permsOfFinset s).card = s.card !
-- Fintype.card_perm
theorem Fintype.card_perm [Fintype α] : Fintype.card (Perm α) = (Fintype.card α)! 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: Fintype.card (Equiv.Perm α) = (Fintype.card α)!
-- Fintype.card_equiv
theorem Fintype.card_equiv [Fintype α] [Fintype β] (e : α ≃ β) :
    Fintype.card (α ≃ β) = (Fintype.card α)! 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] [Fintype α] [Fintype β] (e : α ≃ β)
Goal: Fintype.card (α ≃ β) = (Fintype.card α)!
-- Set.biUnion_finsetSigma_univ
lemma Set.biUnion_finsetSigma_univ (s : Finset ι) (f : Sigma κ → Set α) :
    ⋃ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij = ⋃ i ∈ s, ⋃ j, f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_5} [(i : ι) → Fintype (κ i)] (s : Finset ι) (f : Sigma κ → Set α)
Goal: ⋃ ij ∈ s.sigma fun x => Finset.univ, f ij = ⋃ i ∈ s, ⋃ j, f ⟨i, j⟩