ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.piCongrLeft'_symm_update
theorem piCongrLeft'_symm_update [DecidableEq α] [DecidableEq β] (P : α → Sort*) (e : α ≃ β)
    (f : ∀ b, P (e.symm b)) (b : β) (x : P (e.symm b)) :
    (e.piCongrLeft' P).symm (update f b x) = update ((e.piCongrLeft' P).symm f) (e.symm b) x 
Arguments: {α : Sort u_2} {β : Sort u_3} [DecidableEq α] [DecidableEq β] (P : α → Sort u_1) (e : α ≃ β) (f : (b : β) → P (e.symm b)) (b : β) (x : P (e.symm b))
Goal: (Equiv.piCongrLeft' P e).symm (Function.update f b x) = Function.update ((Equiv.piCongrLeft' P e).symm f) (e.symm b) x
-- Nonempty.forall
@[simp]
theorem Nonempty.forall {α} {p : Nonempty α → Prop} : (∀ h : Nonempty α, p h) ↔ ∀ a, p ⟨a⟩ 
Arguments: {α : Sort u_3} {p : Nonempty α → Prop}
Goal: (∀ (h : Nonempty α), p h) ↔ ∀ (a : α), p ⋯
-- Nonempty.exists
@[simp]
theorem Nonempty.exists {α} {p : Nonempty α → Prop} : (∃ h : Nonempty α, p h) ↔ ∃ a, p ⟨a⟩ 
Arguments: {α : Sort u_3} {p : Nonempty α → Prop}
Goal: (∃ h, p h) ↔ ∃ a, p ⋯
-- exists_true_iff_nonempty
theorem exists_true_iff_nonempty {α : Sort*} : (∃ _ : α, True) ↔ Nonempty α 
Arguments: {α : Sort u_3}
Goal: (∃ x, True) ↔ Nonempty α
-- nonempty_Prop
@[simp]
theorem nonempty_Prop {p : Prop} : Nonempty p ↔ p 
Arguments: {p : Prop}
Goal: Nonempty p ↔ p
-- Nonempty.imp
theorem Nonempty.imp {α} {p : Prop} : (Nonempty α → p) ↔ (α → p) 
Arguments: {α : Sort u_3} {p : Prop}
Goal: Nonempty α → p ↔ α → p
-- not_nonempty_iff_imp_false
theorem not_nonempty_iff_imp_false {α : Sort*} : ¬Nonempty α ↔ α → False 
Arguments: {α : Sort u_3}
Goal: ¬Nonempty α ↔ α → False
-- nonempty_psigma
@[simp]
theorem nonempty_psigma {α} {β : α → Sort*} : Nonempty (PSigma β) ↔ ∃ a : α, Nonempty (β a) 
Arguments: {α : Sort u_4} {β : α → Sort u_3}
Goal: Nonempty (PSigma β) ↔ ∃ a, Nonempty (β a)
-- nonempty_subtype
@[simp]
theorem nonempty_subtype {α} {p : α → Prop} : Nonempty (Subtype p) ↔ ∃ a : α, p a 
Arguments: {α : Sort u_3} {p : α → Prop}
Goal: Nonempty (Subtype p) ↔ ∃ a, p a
-- nonempty_pprod
@[simp]
theorem nonempty_pprod {α β} : Nonempty (PProd α β) ↔ Nonempty α ∧ Nonempty β 
Arguments: {α : Sort u_3} {β : Sort u_4}
Goal: Nonempty (PProd α β) ↔ Nonempty α ∧ Nonempty β
-- nonempty_psum
@[simp]
theorem nonempty_psum {α β} : Nonempty (α ⊕' β) ↔ Nonempty α ∨ Nonempty β 
Arguments: {α : Sort u_3} {β : Sort u_4}
Goal: Nonempty (α ⊕' β) ↔ Nonempty α ∨ Nonempty β
-- nonempty_plift
@[simp]
theorem nonempty_plift {α} : Nonempty (PLift α) ↔ Nonempty α 
Arguments: {α : Sort u_3}
Goal: Nonempty (PLift α) ↔ Nonempty α
-- Nonempty.map
theorem Nonempty.map {α β} (f : α → β) : Nonempty α → Nonempty β
  
Arguments: {α : Sort u_3} {β : Sort u_4} (f : α → β)
Goal: Nonempty α → Nonempty β
-- Nonempty.map2
protected theorem Nonempty.map2 {α β γ : Sort*} (f : α → β → γ) :
    Nonempty α → Nonempty β → Nonempty γ
  
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} (f : α → β → γ)
Goal: Nonempty α → Nonempty β → Nonempty γ
-- Nonempty.congr
protected theorem Nonempty.congr {α β} (f : α → β) (g : β → α) : Nonempty α ↔ Nonempty β 
Arguments: {α : Sort u_3} {β : Sort u_4} (f : α → β) (g : β → α)
Goal: Nonempty α ↔ Nonempty β
-- Nonempty.elim_to_inhabited
theorem Nonempty.elim_to_inhabited {α : Sort*} [h : Nonempty α] {p : Prop} (f : Inhabited α → p) :
    p 
Arguments: {α : Sort u_3} [h : Nonempty α] {p : Prop} (f : Inhabited α → p)
Goal: p
-- Classical.nonempty_pi
theorem Classical.nonempty_pi {ι} {α : ι → Sort*} : Nonempty (∀ i, α i) ↔ ∀ i, Nonempty (α i) 
Arguments: {ι : Sort u_4} {α : ι → Sort u_3}
Goal: Nonempty ((i : ι) → α i) ↔ ∀ (i : ι), Nonempty (α i)
-- subsingleton_of_not_nonempty
theorem subsingleton_of_not_nonempty {α : Sort*} (h : ¬Nonempty α) : Subsingleton α 
Arguments: {α : Sort u_3} (h : ¬Nonempty α)
Goal: Subsingleton α
-- Function.Surjective.nonempty
theorem Function.Surjective.nonempty [h : Nonempty β] {f : α → β} (hf : Function.Surjective f) :
    Nonempty α 
Arguments: {α : Sort u_1} {β : Sort u_2} [h : Nonempty β] {f : α → β} (hf : Function.Surjective f)
Goal: Nonempty α
-- nonempty_sigma
@[simp]
theorem nonempty_sigma : Nonempty (Σa : α, γ a) ↔ ∃ a : α, Nonempty (γ a) 
Arguments: {α : Type u_1} {γ : α → Type u_3}
Goal: Nonempty ((a : α) × γ a) ↔ ∃ a, Nonempty (γ a)
-- nonempty_sum
@[simp]
theorem nonempty_sum : Nonempty (α ⊕ β) ↔ Nonempty α ∨ Nonempty β 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Nonempty (α ⊕ β) ↔ Nonempty α ∨ Nonempty β
-- nonempty_prod
@[simp]
theorem nonempty_prod : Nonempty (α × β) ↔ Nonempty α ∧ Nonempty β 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Nonempty (α × β) ↔ Nonempty α ∧ Nonempty β
-- nonempty_ulift
@[simp]
theorem nonempty_ulift : Nonempty (ULift α) ↔ Nonempty α 
Arguments: {α : Type u_1}
Goal: Nonempty (ULift.{u_4, u_1} α) ↔ Nonempty α
-- Nontrivial.exists_pair_ne
class Nontrivial (α : Type*) : Prop where
    exists_pair_ne : ∃ x y : α, x ≠ y
Arguments: {α : Type u_3} [self : Nontrivial α]
Goal: ∃ x y, x ≠ y
-- nontrivial_iff
theorem nontrivial_iff : Nontrivial α ↔ ∃ x y : α, x ≠ y 
Arguments: {α : Type u_1}
Goal: Nontrivial α ↔ ∃ x y, x ≠ y
-- exists_pair_ne
theorem exists_pair_ne (α : Type*) [Nontrivial α] : ∃ x y : α, x ≠ y 
Arguments: (α : Type u_3) [Nontrivial α]
Goal: ∃ x y, x ≠ y
-- Decidable.exists_ne
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x 
Arguments: {α : Type u_1} [Nontrivial α] [DecidableEq α] (x : α)
Goal: ∃ y, y ≠ x
-- exists_ne
theorem exists_ne [Nontrivial α] (x : α) : ∃ y, y ≠ x 
Arguments: {α : Type u_1} [Nontrivial α] (x : α)
Goal: ∃ y, y ≠ x
-- nontrivial_of_ne
theorem nontrivial_of_ne (x y : α) (h : x ≠ y) : Nontrivial α 
Arguments: {α : Type u_1} (x y : α) (h : x ≠ y)
Goal: Nontrivial α
-- nontrivial_iff_exists_ne
theorem nontrivial_iff_exists_ne (x : α) : Nontrivial α ↔ ∃ y, y ≠ x 
Arguments: {α : Type u_1} (x : α)
Goal: Nontrivial α ↔ ∃ y, y ≠ x
-- subsingleton_iff
theorem subsingleton_iff : Subsingleton α ↔ ∀ x y : α, x = y 
Arguments: {α : Type u_1}
Goal: Subsingleton α ↔ ∀ (x y : α), x = y
-- not_nontrivial_iff_subsingleton
theorem not_nontrivial_iff_subsingleton : ¬Nontrivial α ↔ Subsingleton α 
Arguments: {α : Type u_1}
Goal: ¬Nontrivial α ↔ Subsingleton α
-- not_nontrivial
theorem not_nontrivial (α) [Subsingleton α] : ¬Nontrivial α 
Arguments: (α : Type u_3) [Subsingleton α]
Goal: ¬Nontrivial α
-- not_subsingleton
theorem not_subsingleton (α) [Nontrivial α] : ¬Subsingleton α 
Arguments: (α : Type u_3) [Nontrivial α]
Goal: ¬Subsingleton α
-- not_subsingleton_iff_nontrivial
lemma not_subsingleton_iff_nontrivial : ¬ Subsingleton α ↔ Nontrivial α 
Arguments: {α : Type u_1}
Goal: ¬Subsingleton α ↔ Nontrivial α
-- subsingleton_or_nontrivial
theorem subsingleton_or_nontrivial (α : Type*) : Subsingleton α ∨ Nontrivial α 
Arguments: (α : Type u_3)
Goal: Subsingleton α ∨ Nontrivial α
-- false_of_nontrivial_of_subsingleton
theorem false_of_nontrivial_of_subsingleton (α : Type*) [Nontrivial α] [Subsingleton α] : False 
Arguments: (α : Type u_3) [Nontrivial α] [Subsingleton α]
Goal: False
-- Function.Surjective.nontrivial
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α 
Arguments: {α : Type u_1} {β : Type u_2} [Nontrivial β] {f : α → β} (hf : Function.Surjective f)
Goal: Nontrivial α
-- nontrivial_of_lt
theorem nontrivial_of_lt [Preorder α] (x y : α) (h : x < y) : Nontrivial α 
Arguments: {α : Type u_1} [Preorder α] (x y : α) (h : x < y)
Goal: Nontrivial α
-- exists_pair_lt
theorem exists_pair_lt (α : Type*) [Nontrivial α] [LinearOrder α] : ∃ x y : α, x < y 
Arguments: (α : Type u_3) [Nontrivial α] [LinearOrder α]
Goal: ∃ x y, x < y
-- nontrivial_iff_lt
theorem nontrivial_iff_lt [LinearOrder α] : Nontrivial α ↔ ∃ x y : α, x < y 
Arguments: {α : Type u_1} [LinearOrder α]
Goal: Nontrivial α ↔ ∃ x y, x < y
-- Subtype.nontrivial_iff_exists_ne
theorem Subtype.nontrivial_iff_exists_ne (p : α → Prop) (x : Subtype p) :
    Nontrivial (Subtype p) ↔ ∃ (y : α) (_ : p y), y ≠ x 
Arguments: {α : Type u_1} (p : α → Prop) (x : Subtype p)
Goal: Nontrivial (Subtype p) ↔ ∃ y x_1, y ≠ ↑x
-- Function.Injective.nontrivial
protected theorem Function.Injective.nontrivial [Nontrivial α] {f : α → β}
    (hf : Function.Injective f) : Nontrivial β 
Arguments: {α : Type u_1} {β : Type u_2} [Nontrivial α] {f : α → β} (hf : Function.Injective f)
Goal: Nontrivial β
-- Function.Injective.exists_ne
protected theorem Function.Injective.exists_ne [Nontrivial α] {f : α → β}
    (hf : Function.Injective f) (y : β) : ∃ x, f x ≠ y 
Arguments: {α : Type u_1} {β : Type u_2} [Nontrivial α] {f : α → β} (hf : Function.Injective f) (y : β)
Goal: ∃ x, f x ≠ y
-- Pi.nontrivial_at
theorem nontrivial_at (i' : I) [inst : ∀ i, Nonempty (f i)] [Nontrivial (f i')] :
    Nontrivial (∀ i : I, f i) 
Arguments: {I : Type u_3} {f : I → Type u_4} (i' : I) [inst : ∀ (i : I), Nonempty (f i)] [Nontrivial (f i')]
Goal: Nontrivial ((i : I) → f i)
-- Subsingleton.le
@[nontriviality]
protected theorem Subsingleton.le [Preorder α] [Subsingleton α] (x y : α) : x ≤ y 
Arguments: {α : Type u_1} [Preorder α] [Subsingleton α] (x y : α)
Goal: x ≤ y
-- Subsingleton.eq_zero
@[to_additive]
theorem Subsingleton.eq_one [One α] [Subsingleton α] (a : α) : a = 1 
Arguments: {α : Type u_1} [Zero α] [Subsingleton α] (a : α)
Goal: a = 0
-- Subsingleton.eq_one
@[to_additive]
theorem Subsingleton.eq_one [One α] [Subsingleton α] (a : α) : a = 1 
Arguments: {α : Type u_1} [One α] [Subsingleton α] (a : α)
Goal: a = 1
-- Pairwise.mono
theorem Pairwise.mono (hr : Pairwise r) (h : ∀ ⦃i j⦄, r i j → p i j) : Pairwise p 
Arguments: {α : Type u_1} {r p : α → α → Prop} (hr : Pairwise r) (h : ∀ ⦃i j : α⦄, r i j → p i j)
Goal: Pairwise p
-- Pairwise.eq
protected theorem Pairwise.eq (h : Pairwise r) : ¬r a b → a = b 
Arguments: {α : Type u_1} {r : α → α → Prop} {a b : α} (h : Pairwise r)
Goal: ¬r a b → a = b
-- Subsingleton.pairwise
protected lemma Subsingleton.pairwise [Subsingleton α] : Pairwise r 
Arguments: {α : Type u_1} {r : α → α → Prop} [Subsingleton α]
Goal: Pairwise r
-- Function.injective_iff_pairwise_ne
theorem Function.injective_iff_pairwise_ne : Injective f ↔ Pairwise ((· ≠ ·) on f) 
Arguments: {α : Type u_1} {ι : Type u_4} {f : ι → α}
Goal: Function.Injective f ↔ Pairwise ((fun x x_1 => x ≠ x_1) on f)
-- Pairwise.comp_of_injective
lemma Pairwise.comp_of_injective (hr : Pairwise r) {f : β → α} (hf : Injective f) :
    Pairwise (r on f) 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} (hr : Pairwise r) {f : β → α} (hf : Function.Injective f)
Goal: Pairwise (r on f)
-- Pairwise.of_comp_of_surjective
lemma Pairwise.of_comp_of_surjective {f : β → α} (hr : Pairwise (r on f)) (hf : Surjective f) :
    Pairwise r 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {f : β → α} (hr : Pairwise (r on f)) (hf : Function.Surjective f)
Goal: Pairwise r
-- Function.Bijective.pairwise_comp_iff
lemma Function.Bijective.pairwise_comp_iff {f : β → α} (hf : Bijective f) :
    Pairwise (r on f) ↔ Pairwise r 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {f : β → α} (hf : Function.Bijective f)
Goal: Pairwise (r on f) ↔ Pairwise r
-- Set.pairwise_of_forall
theorem pairwise_of_forall (s : Set α) (r : α → α → Prop) (h : ∀ a b, r a b) : s.Pairwise r 
Arguments: {α : Type u_1} (s : Set α) (r : α → α → Prop) (h : ∀ (a b : α), r a b)
Goal: s.Pairwise r
-- Set.Pairwise.imp_on
theorem Pairwise.imp_on (h : s.Pairwise r) (hrp : s.Pairwise fun ⦃a b : α⦄ => r a b → p a b) :
    s.Pairwise p 
Arguments: {α : Type u_1} {r p : α → α → Prop} {s : Set α} (h : s.Pairwise r) (hrp : s.Pairwise fun ⦃a b⦄ => r a b → p a b)
Goal: s.Pairwise p
-- Set.Pairwise.imp
theorem Pairwise.imp (h : s.Pairwise r) (hpq : ∀ ⦃a b : α⦄, r a b → p a b) : s.Pairwise p 
Arguments: {α : Type u_1} {r p : α → α → Prop} {s : Set α} (h : s.Pairwise r) (hpq : ∀ ⦃a b : α⦄, r a b → p a b)
Goal: s.Pairwise p
-- Set.Pairwise.eq
protected theorem Pairwise.eq (hs : s.Pairwise r) (ha : a ∈ s) (hb : b ∈ s) (h : ¬r a b) : a = b 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α} (hs : s.Pairwise r) (ha : a ∈ s) (hb : b ∈ s) (h : ¬r a b)
Goal: a = b
-- Reflexive.set_pairwise_iff
theorem _root_.Reflexive.set_pairwise_iff (hr : Reflexive r) :
    s.Pairwise r ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → r a b 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (hr : Reflexive r)
Goal: s.Pairwise r ↔ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → r a b
-- Set.Pairwise.on_injective
theorem Pairwise.on_injective (hs : s.Pairwise r) (hf : Function.Injective f) (hfs : ∀ x, f x ∈ s) :
    Pairwise (r on f) 
Arguments: {α : Type u_1} {ι : Type u_4} {r : α → α → Prop} {f : ι → α} {s : Set α} (hs : s.Pairwise r) (hf : Function.Injective f) (hfs : ∀ (x : ι), f x ∈ s)
Goal: Pairwise (r on f)
-- Pairwise.set_pairwise
theorem Pairwise.set_pairwise (h : Pairwise r) (s : Set α) : s.Pairwise r 
Arguments: {α : Type u_1} {r : α → α → Prop} (h : Pairwise r) (s : Set α)
Goal: s.Pairwise r
-- Encodable.iSup_decode₂
theorem iSup_decode₂ [CompleteLattice α] (f : β → α) :
    ⨆ (i : ℕ) (b ∈ decode₂ β i), f b = (⨆ b, f b) 
Arguments: {α : Type u_1} {β : Type u_2} [Encodable β] [CompleteLattice α] (f : β → α)
Goal: ⨆ i, ⨆ b ∈ Encodable.decode₂ β i, f b = ⨆ b, f b
-- Encodable.iUnion_decode₂
theorem iUnion_decode₂ (f : β → Set α) : ⋃ (i : ℕ) (b ∈ decode₂ β i), f b = ⋃ b, f b 
Arguments: {α : Type u_1} {β : Type u_2} [Encodable β] (f : β → Set α)
Goal: ⋃ i, ⋃ b ∈ Encodable.decode₂ β i, f b = ⋃ b, f b
-- Encodable.iUnion_decode₂_cases
theorem iUnion_decode₂_cases {f : β → Set α} {C : Set α → Prop} (H0 : C ∅) (H1 : ∀ b, C (f b)) {n} :
    C (⋃ b ∈ decode₂ β n, f b) 
Arguments: {α : Type u_1} {β : Type u_2} [Encodable β] {f : β → Set α} {C : Set α → Prop} (H0 : C ∅) (H1 : ∀ (b : β), C (f b)) {n : ℕ}
Goal: C (⋃ b ∈ Encodable.decode₂ β n, f b)
-- Encodable.iUnion_decode₂_disjoint_on
theorem iUnion_decode₂_disjoint_on {f : β → Set α} (hd : Pairwise (Disjoint on f)) :
    Pairwise (Disjoint on fun i => ⋃ b ∈ decode₂ β i, f b) 
Arguments: {α : Type u_1} {β : Type u_2} [Encodable β] {f : β → Set α} (hd : Pairwise (Disjoint on f))
Goal: Pairwise (Disjoint on fun i => ⋃ b ∈ Encodable.decode₂ β i, f b)
-- Relator.RightTotal.rel_forall
lemma RightTotal.rel_forall (h : RightTotal R) :
    ((R ⇒ (· → ·)) ⇒ (· → ·)) (fun p => ∀i, p i) (fun q => ∀i, q i) 
Arguments: {α : Type u₁} {β : Type u₂} {R : α → β → Prop} (h : Relator.RightTotal R)
Goal: ((R ⇒ fun x x_1 => x → x_1) ⇒ fun x x_1 => x → x_1) (fun p => (i : α) → p i) fun q => ∀ (i : β), q i
-- Relator.LeftTotal.rel_exists
lemma LeftTotal.rel_exists (h : LeftTotal R) :
    ((R ⇒ (· → ·)) ⇒ (· → ·)) (fun p => ∃i, p i) (fun q => ∃i, q i) 
Arguments: {α : Type u₁} {β : Type u₂} {R : α → β → Prop} (h : Relator.LeftTotal R)
Goal: ((R ⇒ fun x x_1 => x → x_1) ⇒ fun x x_1 => x → x_1) (fun p => ∃ i, p i) fun q => ∃ i, q i
-- Relator.BiTotal.rel_forall
lemma BiTotal.rel_forall (h : BiTotal R) :
    ((R ⇒ Iff) ⇒ Iff) (fun p => ∀i, p i) (fun q => ∀i, q i) 
Arguments: {α : Type u₁} {β : Type u₂} {R : α → β → Prop} (h : Relator.BiTotal R)
Goal: ((R ⇒ Iff) ⇒ Iff) (fun p => ∀ (i : α), p i) fun q => ∀ (i : β), q i
-- Relator.BiTotal.rel_exists
lemma BiTotal.rel_exists (h : BiTotal R) :
    ((R ⇒ Iff) ⇒ Iff) (fun p => ∃i, p i) (fun q => ∃i, q i) 
Arguments: {α : Type u₁} {β : Type u₂} {R : α → β → Prop} (h : Relator.BiTotal R)
Goal: ((R ⇒ Iff) ⇒ Iff) (fun p => ∃ i, p i) fun q => ∃ i, q i
-- Relator.left_unique_of_rel_eq
lemma left_unique_of_rel_eq {eq' : β → β → Prop} (he : (R ⇒ (R ⇒ Iff)) Eq eq') : LeftUnique R 
Arguments: {α : Type u₁} {β : Type u₂} {R : α → β → Prop} {eq' : β → β → Prop} (he : (R ⇒ R ⇒ Iff) Eq eq')
Goal: Relator.LeftUnique R
-- Relator.rel_imp
lemma rel_imp : (Iff ⇒ (Iff ⇒ Iff)) (· → ·) (· → ·) 
Goal: (Iff ⇒ Iff ⇒ Iff) (fun x x_1 => x → x_1) fun x x_1 => x → x_1
-- Relator.rel_not
lemma rel_not : (Iff ⇒ Iff) Not Not 
Goal: (Iff ⇒ Iff) Not Not
-- Relator.bi_total_eq
lemma bi_total_eq {α : Type u₁} : Relator.BiTotal (@Eq α) 
Arguments: {α : Type u₁}
Goal: Relator.BiTotal Eq
-- Relator.LeftUnique.flip
lemma LeftUnique.flip (h : LeftUnique r) : RightUnique (flip r) 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → β → Prop} (h : Relator.LeftUnique r)
Goal: Relator.RightUnique (flip r)
-- Relator.rel_and
lemma rel_and : ((·↔·) ⇒ (·↔·) ⇒ (·↔·)) (·∧·) (·∧·) 
Goal: ((fun x x_1 => x ↔ x_1) ⇒ (fun x x_1 => x ↔ x_1) ⇒ fun x x_1 => x ↔ x_1) (fun x x_1 => x ∧ x_1) fun x x_1 => x ∧ x_1
-- Relator.rel_or
lemma rel_or : ((·↔·) ⇒ (·↔·) ⇒ (·↔·)) (·∨·) (·∨·) 
Goal: ((fun x x_1 => x ↔ x_1) ⇒ (fun x x_1 => x ↔ x_1) ⇒ fun x x_1 => x ↔ x_1) (fun x x_1 => x ∨ x_1) fun x x_1 => x ∨ x_1
-- Relator.rel_iff
lemma rel_iff : ((·↔·) ⇒ (·↔·) ⇒ (·↔·)) (·↔·) (·↔·) 
Goal: ((fun x x_1 => x ↔ x_1) ⇒ (fun x x_1 => x ↔ x_1) ⇒ fun x x_1 => x ↔ x_1) (fun x x_1 => x ↔ x_1) fun x x_1 => x ↔ x_1
-- Relator.rel_eq
lemma rel_eq {r : α → β → Prop} (hr : BiUnique r) : (r ⇒ r ⇒ (·↔·)) (·=·) (·=·) 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → β → Prop} (hr : Relator.BiUnique r)
Goal: (r ⇒ r ⇒ fun x x_1 => x ↔ x_1) (fun x x_1 => x = x_1) fun x x_1 => x = x_1
-- Relator.LeftTotal.refl
protected lemma refl (hr : ∀ a : α, r₁₁ a a) :
    LeftTotal r₁₁ 
Arguments: {α : Type u_5} {r₁₁ : α → α → Prop} (hr : ∀ (a : α), r₁₁ a a)
Goal: Relator.LeftTotal r₁₁
-- Relator.LeftTotal.symm
protected lemma symm (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a) :
    LeftTotal r₁₂ → RightTotal r₂₁ 
Arguments: {β : Type u_2} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₁ : β → α → Prop} (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a)
Goal: Relator.LeftTotal r₁₂ → Relator.RightTotal r₂₁
-- Relator.LeftTotal.trans
protected lemma trans (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c) :
    LeftTotal r₁₂ → LeftTotal r₂₃ → LeftTotal r₁₃ 
Arguments: {β : Type u_2} {γ : Type u_3} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₃ : β → γ → Prop} {r₁₃ : α → γ → Prop} (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c)
Goal: Relator.LeftTotal r₁₂ → Relator.LeftTotal r₂₃ → Relator.LeftTotal r₁₃
-- Relator.RightTotal.refl
protected lemma refl (hr : ∀ a : α, r₁₁ a a) : RightTotal r₁₁ 
Arguments: {α : Type u_5} {r₁₁ : α → α → Prop} (hr : ∀ (a : α), r₁₁ a a)
Goal: Relator.RightTotal r₁₁
-- Relator.RightTotal.symm
protected lemma symm (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a) :
    RightTotal r₁₂ → LeftTotal r₂₁ 
Arguments: {β : Type u_2} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₁ : β → α → Prop} (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a)
Goal: Relator.RightTotal r₁₂ → Relator.LeftTotal r₂₁
-- Relator.RightTotal.trans
protected lemma trans (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c) :
    RightTotal r₁₂ → RightTotal r₂₃ → RightTotal r₁₃ 
Arguments: {β : Type u_2} {γ : Type u_3} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₃ : β → γ → Prop} {r₁₃ : α → γ → Prop} (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c)
Goal: Relator.RightTotal r₁₂ → Relator.RightTotal r₂₃ → Relator.RightTotal r₁₃
-- Relator.BiTotal.refl
protected lemma refl (hr : ∀ a : α, r₁₁ a a) :
    BiTotal r₁₁ 
Arguments: {α : Type u_5} {r₁₁ : α → α → Prop} (hr : ∀ (a : α), r₁₁ a a)
Goal: Relator.BiTotal r₁₁
-- Relator.BiTotal.symm
protected lemma symm (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a) :
    BiTotal r₁₂ → BiTotal r₂₁ 
Arguments: {β : Type u_2} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₁ : β → α → Prop} (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a)
Goal: Relator.BiTotal r₁₂ → Relator.BiTotal r₂₁
-- Relator.BiTotal.trans
protected lemma trans (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c) :
    BiTotal r₁₂ → BiTotal r₂₃ → BiTotal r₁₃ 
Arguments: {β : Type u_2} {γ : Type u_3} {α : Type u_5} {r₁₂ : α → β → Prop} {r₂₃ : β → γ → Prop} {r₁₃ : α → γ → Prop} (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c)
Goal: Relator.BiTotal r₁₂ → Relator.BiTotal r₂₃ → Relator.BiTotal r₁₃
-- Encodable.encodek
class Encodable (α : Type*) where
    encode : α → ℕ
  -- Porting note: was `decode [] : ℕ → Option α`. This means that `decode` does not take the type
  --explicitly in Lean4
    decode : ℕ → Option α
    encodek : ∀ a, decode (encode a) = some a
Arguments: {α : Type u_1} [self : Encodable α] (a : α)
Goal: Encodable.decode (Encodable.encode a) = some a
-- Encodable.encode_injective
theorem encode_injective [Encodable α] : Function.Injective (@encode α _)
  
Arguments: {α : Type u_1} [Encodable α]
Goal: Function.Injective Encodable.encode
-- Encodable.encode_inj
@[simp]
theorem encode_inj [Encodable α] {a b : α} : encode a = encode b ↔ a = b 
Arguments: {α : Type u_1} [Encodable α] {a b : α}
Goal: Encodable.encode a = Encodable.encode b ↔ a = b
-- Encodable.surjective_decode_iget
theorem surjective_decode_iget (α : Type*) [Encodable α] [Inhabited α] :
    Surjective fun n => ((Encodable.decode n).iget : α) 
Arguments: (α : Type u_3) [Encodable α] [Inhabited α]
Goal: Function.Surjective fun n => (Encodable.decode n).iget
-- Encodable.encode_ofEquiv
theorem encode_ofEquiv {α β} [Encodable α] (e : β ≃ α) (b : β) :
    @encode _ (ofEquiv _ e) b = encode (e b) 
Arguments: {α : Type u_3} {β : Type u_4} [Encodable α] (e : β ≃ α) (b : β)
Goal: Encodable.encode b = Encodable.encode (e b)
-- Encodable.decode_ofEquiv
theorem decode_ofEquiv {α β} [Encodable α] (e : β ≃ α) (n : ℕ) :
    @decode _ (ofEquiv _ e) n = (decode n).map e.symm 
Arguments: {α : Type u_3} {β : Type u_4} [Encodable α] (e : β ≃ α) (n : ℕ)
Goal: Encodable.decode n = Option.map (⇑e.symm) (Encodable.decode n)
-- Encodable.encode_nat
@[simp]
theorem encode_nat (n : ℕ) : encode n = n 
Arguments: (n : ℕ)
Goal: Encodable.encode n = n
-- Encodable.decode_nat
@[simp 1100]
theorem decode_nat (n : ℕ) : decode n = some n 
Arguments: (n : ℕ)
Goal: Encodable.decode n = some n
-- Encodable.encode_star
@[simp]
theorem encode_star : encode PUnit.unit = 0 
Goal: Encodable.encode PUnit.unit = 0
-- Encodable.decode_unit_zero
@[simp]
theorem decode_unit_zero : decode 0 = some PUnit.unit 
Goal: Encodable.decode 0 = some PUnit.unit
-- Encodable.decode_unit_succ
@[simp]
theorem decode_unit_succ (n) : decode (succ n) = (none : Option PUnit) 
Arguments: (n : ℕ)
Goal: Encodable.decode n.succ = none
-- Encodable.encode_none
@[simp]
theorem encode_none [Encodable α] : encode (@none α) = 0 
Arguments: {α : Type u_1} [Encodable α]
Goal: Encodable.encode none = 0
-- Encodable.encode_some
@[simp]
theorem encode_some [Encodable α] (a : α) : encode (some a) = succ (encode a) 
Arguments: {α : Type u_1} [Encodable α] (a : α)
Goal: Encodable.encode (some a) = (Encodable.encode a).succ
-- Encodable.decode_option_zero
@[simp]
theorem decode_option_zero [Encodable α] : (decode 0 : Option (Option α))= some none 
Arguments: {α : Type u_1} [Encodable α]
Goal: Encodable.decode 0 = some none
-- Encodable.decode_option_succ
@[simp]
theorem decode_option_succ [Encodable α] (n) :
    (decode (succ n) : Option (Option α)) = (decode n).map some 
Arguments: {α : Type u_1} [Encodable α] (n : ℕ)
Goal: Encodable.decode n.succ = Option.map some (Encodable.decode n)
-- Encodable.mem_decode₂'
theorem mem_decode₂' [Encodable α] {n : ℕ} {a : α} :
    a ∈ decode₂ α n ↔ a ∈ decode n ∧ encode a = n 
Arguments: {α : Type u_1} [Encodable α] {n : ℕ} {a : α}
Goal: a ∈ Encodable.decode₂ α n ↔ a ∈ Encodable.decode n ∧ Encodable.encode a = n
-- Encodable.mem_decode₂
theorem mem_decode₂ [Encodable α] {n : ℕ} {a : α} : a ∈ decode₂ α n ↔ encode a = n 
Arguments: {α : Type u_1} [Encodable α] {n : ℕ} {a : α}
Goal: a ∈ Encodable.decode₂ α n ↔ Encodable.encode a = n
-- Encodable.decode₂_eq_some
theorem decode₂_eq_some [Encodable α] {n : ℕ} {a : α} : decode₂ α n = some a ↔ encode a = n 
Arguments: {α : Type u_1} [Encodable α] {n : ℕ} {a : α}
Goal: Encodable.decode₂ α n = some a ↔ Encodable.encode a = n
-- Encodable.decode₂_encode
@[simp]
theorem decode₂_encode [Encodable α] (a : α) : decode₂ α (encode a) = some a 
Arguments: {α : Type u_1} [Encodable α] (a : α)
Goal: Encodable.decode₂ α (Encodable.encode a) = some a
-- Encodable.decode₂_ne_none_iff
theorem decode₂_ne_none_iff [Encodable α] {n : ℕ} :
    decode₂ α n ≠ none ↔ n ∈ Set.range (encode : α → ℕ) 
Arguments: {α : Type u_1} [Encodable α] {n : ℕ}
Goal: Encodable.decode₂ α n ≠ none ↔ n ∈ Set.range Encodable.encode
-- Encodable.decode₂_is_partial_inv
theorem decode₂_is_partial_inv [Encodable α] : IsPartialInv encode (decode₂ α) 
Arguments: {α : Type u_1} [Encodable α]
Goal: Function.IsPartialInv Encodable.encode (Encodable.decode₂ α)