ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.sublistsLen_zero
@[simp]
theorem sublistsLen_zero (l : List α) : sublistsLen 0 l = [[]] 
Arguments: {α : Type u} (l : List α)
Goal: List.sublistsLen 0 l = [[]]
-- List.sublistsLen_succ_nil
@[simp]
theorem sublistsLen_succ_nil (n) : sublistsLen (n + 1) (@nil α) = [] 
Arguments: {α : Type u} (n : ℕ)
Goal: List.sublistsLen (n + 1) [] = []
-- List.sublistsLen_succ_cons
@[simp]
theorem sublistsLen_succ_cons (n) (a : α) (l) :
    sublistsLen (n + 1) (a :: l) = sublistsLen (n + 1) l ++ (sublistsLen n l).map (cons a) 
Arguments: {α : Type u} (n : ℕ) (a : α) (l : List α)
Goal: List.sublistsLen (n + 1) (a :: l) = List.sublistsLen (n + 1) l ++ List.map (List.cons a) (List.sublistsLen n l)
-- List.sublistsLen_one
theorem sublistsLen_one (l : List α) : sublistsLen 1 l = l.reverse.map ([·]) 
Arguments: {α : Type u} (l : List α)
Goal: List.sublistsLen 1 l = List.map (fun x => [x]) l.reverse
-- List.length_sublistsLen
@[simp]
theorem length_sublistsLen :
    ∀ (n) (l : List α), length (sublistsLen n l) = Nat.choose (length l) n
  
Arguments: {α : Type u} (n : ℕ) (l : List α)
Goal: (List.sublistsLen n l).length = l.length.choose n
-- List.sublistsLen_sublist_sublists'
theorem sublistsLen_sublist_sublists' :
    ∀ (n) (l : List α), sublistsLen n l <+ sublists' l
  
Arguments: {α : Type u} (n : ℕ) (l : List α)
Goal: (List.sublistsLen n l).Sublist l.sublists'
-- List.sublistsLen_sublist_of_sublist
theorem sublistsLen_sublist_of_sublist (n) {l₁ l₂ : List α} (h : l₁ <+ l₂) :
    sublistsLen n l₁ <+ sublistsLen n l₂ 
Arguments: {α : Type u} (n : ℕ) {l₁ l₂ : List α} (h : l₁.Sublist l₂)
Goal: (List.sublistsLen n l₁).Sublist (List.sublistsLen n l₂)
-- List.length_of_sublistsLen
theorem length_of_sublistsLen :
    ∀ {n} {l l' : List α}, l' ∈ sublistsLen n l → length l' = n
  
Arguments: {α : Type u} {n : ℕ} {l l' : List α}
Goal: l' ∈ List.sublistsLen n l → l'.length = n
-- List.mem_sublistsLen_self
theorem mem_sublistsLen_self {l l' : List α} (h : l' <+ l) :
    l' ∈ sublistsLen (length l') l 
Arguments: {α : Type u} {l l' : List α} (h : l'.Sublist l)
Goal: l' ∈ List.sublistsLen l'.length l
-- List.mem_sublistsLen
@[simp]
theorem mem_sublistsLen {n} {l l' : List α} :
    l' ∈ sublistsLen n l ↔ l' <+ l ∧ length l' = n 
Arguments: {α : Type u} {n : ℕ} {l l' : List α}
Goal: l' ∈ List.sublistsLen n l ↔ l'.Sublist l ∧ l'.length = n
-- List.sublistsLen_of_length_lt
theorem sublistsLen_of_length_lt {n} {l : List α} (h : l.length < n) : sublistsLen n l = [] 
Arguments: {α : Type u} {n : ℕ} {l : List α} (h : l.length < n)
Goal: List.sublistsLen n l = []
-- List.sublistsLen_length
@[simp]
theorem sublistsLen_length : ∀ l : List α, sublistsLen l.length l = [l]
  
Arguments: {α : Type u} (l : List α)
Goal: List.sublistsLen l.length l = [l]
-- List.Pairwise.sublists'
theorem Pairwise.sublists' {R} :
    ∀ {l : List α}, Pairwise R l → Pairwise (Lex (swap R)) (sublists' l)
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Pairwise R l → List.Pairwise (List.Lex (Function.swap R)) l.sublists'
-- List.pairwise_sublists
theorem pairwise_sublists {R} {l : List α} (H : Pairwise R l) :
    Pairwise (fun l₁ l₂ => Lex R (reverse l₁) (reverse l₂)) (sublists l) 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} (H : List.Pairwise R l)
Goal: List.Pairwise (fun l₁ l₂ => List.Lex R l₁.reverse l₂.reverse) l.sublists
-- List.nodup_sublists
@[simp]
theorem nodup_sublists {l : List α} : Nodup (sublists l) ↔ Nodup l 
Arguments: {α : Type u} {l : List α}
Goal: l.sublists.Nodup ↔ l.Nodup
-- List.nodup_sublists'
@[simp]
theorem nodup_sublists' {l : List α} : Nodup (sublists' l) ↔ Nodup l 
Arguments: {α : Type u} {l : List α}
Goal: l.sublists'.Nodup ↔ l.Nodup
-- List.nodup_sublistsLen
theorem nodup_sublistsLen (n : ℕ) {l : List α} (h : Nodup l) : (sublistsLen n l).Nodup 
Arguments: {α : Type u} (n : ℕ) {l : List α} (h : l.Nodup)
Goal: (List.sublistsLen n l).Nodup
-- List.sublists_map
theorem sublists_map (f : α → β) : ∀ (l : List α),
    sublists (map f l) = map (map f) (sublists l)
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α)
Goal: (List.map f l).sublists = List.map (List.map f) l.sublists
-- List.sublists'_map
theorem sublists'_map (f : α → β) : ∀ (l : List α),
    sublists' (map f l) = map (map f) (sublists' l)
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α)
Goal: (List.map f l).sublists' = List.map (List.map f) l.sublists'
-- List.sublists_perm_sublists'
theorem sublists_perm_sublists' (l : List α) : sublists l ~ sublists' l 
Arguments: {α : Type u} (l : List α)
Goal: l.sublists.Perm l.sublists'
-- List.sublists_cons_perm_append
theorem sublists_cons_perm_append (a : α) (l : List α) :
    sublists (a :: l) ~ sublists l ++ map (cons a) (sublists l) 
Arguments: {α : Type u} (a : α) (l : List α)
Goal: (a :: l).sublists.Perm (l.sublists ++ List.map (List.cons a) l.sublists)
-- List.revzip_sublists
theorem revzip_sublists (l : List α) : ∀ l₁ l₂, (l₁, l₂) ∈ revzip l.sublists → l₁ ++ l₂ ~ l 
Arguments: {α : Type u} (l l₁ l₂ : List α)
Goal: (l₁, l₂) ∈ l.sublists.revzip → (l₁ ++ l₂).Perm l
-- List.revzip_sublists'
theorem revzip_sublists' (l : List α) : ∀ l₁ l₂, (l₁, l₂) ∈ revzip l.sublists' → l₁ ++ l₂ ~ l 
Arguments: {α : Type u} (l l₁ l₂ : List α)
Goal: (l₁, l₂) ∈ l.sublists'.revzip → (l₁ ++ l₂).Perm l
-- List.range_bind_sublistsLen_perm
theorem range_bind_sublistsLen_perm (l : List α) :
    ((List.range (l.length + 1)).bind fun n => sublistsLen n l) ~ sublists' l 
Arguments: {α : Type u} (l : List α)
Goal: ((List.range (l.length + 1)).bind fun n => List.sublistsLen n l).Perm l.sublists'
-- Countable.exists_injective_nat'
@[mk_iff countable_iff_exists_injective]
class Countable (α : Sort u) : Prop where
    exists_injective_nat' : ∃ f : α → ℕ, Injective f
Arguments: {α : Sort u} [self : Countable α]
Goal: ∃ f, Function.Injective f
-- countable_iff_exists_injective
@[mk_iff countable_iff_exists_injective]
class Countable (α : Sort u) : Prop where
    exists_injective_nat' : ∃ f : α → ℕ, Injective f
Arguments: (α : Sort u)
Goal: Countable α ↔ ∃ f, Function.Injective f
-- Countable.exists_injective_nat
lemma Countable.exists_injective_nat (α : Sort u) [Countable α] : ∃ f : α → ℕ, Injective f 
Arguments: (α : Sort u) [Countable α]
Goal: ∃ f, Function.Injective f
-- Function.Injective.countable
protected theorem Function.Injective.countable [Countable β] {f : α → β} (hf : Injective f) :
    Countable α 
Arguments: {α : Sort u} {β : Sort v} [Countable β] {f : α → β} (hf : Function.Injective f)
Goal: Countable α
-- Function.Surjective.countable
protected theorem Function.Surjective.countable [Countable α] {f : α → β} (hf : Surjective f) :
    Countable β 
Arguments: {α : Sort u} {β : Sort v} [Countable α] {f : α → β} (hf : Function.Surjective f)
Goal: Countable β
-- exists_surjective_nat
theorem exists_surjective_nat (α : Sort u) [Nonempty α] [Countable α] : ∃ f : ℕ → α, Surjective f 
Arguments: (α : Sort u) [Nonempty α] [Countable α]
Goal: ∃ f, Function.Surjective f
-- countable_iff_exists_surjective
theorem countable_iff_exists_surjective [Nonempty α] : Countable α ↔ ∃ f : ℕ → α, Surjective f 
Arguments: {α : Sort u} [Nonempty α]
Goal: Countable α ↔ ∃ f, Function.Surjective f
-- Countable.of_equiv
theorem Countable.of_equiv (α : Sort*) [Countable α] (e : α ≃ β) : Countable β 
Arguments: {β : Sort v} (α : Sort u_1) [Countable α] (e : α ≃ β)
Goal: Countable β
-- Equiv.countable_iff
theorem Equiv.countable_iff (e : α ≃ β) : Countable α ↔ Countable β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Countable α ↔ Countable β
-- Uncountable.not_countable
@[mk_iff uncountable_iff_not_countable]
class Uncountable (α : Sort*) : Prop where
    not_countable : ¬Countable α
Arguments: {α : Sort u_1} [self : Uncountable α]
Goal: ¬Countable α
-- uncountable_iff_not_countable
@[mk_iff uncountable_iff_not_countable]
class Uncountable (α : Sort*) : Prop where
    not_countable : ¬Countable α
Arguments: (α : Sort u_1)
Goal: Uncountable α ↔ ¬Countable α
-- not_uncountable_iff
lemma not_uncountable_iff : ¬Uncountable α ↔ Countable α 
Arguments: {α : Sort u}
Goal: ¬Uncountable α ↔ Countable α
-- not_countable_iff
lemma not_countable_iff : ¬Countable α ↔ Uncountable α 
Arguments: {α : Sort u}
Goal: ¬Countable α ↔ Uncountable α
-- not_uncountable
@[simp]
lemma not_uncountable [Countable α] : ¬Uncountable α 
Arguments: {α : Sort u} [Countable α]
Goal: ¬Uncountable α
-- not_countable
@[simp]
lemma not_countable [Uncountable α] : ¬Countable α 
Arguments: {α : Sort u} [Uncountable α]
Goal: ¬Countable α
-- Function.Injective.uncountable
protected theorem Function.Injective.uncountable [Uncountable α] {f : α → β} (hf : Injective f) :
    Uncountable β 
Arguments: {α : Sort u} {β : Sort v} [Uncountable α] {f : α → β} (hf : Function.Injective f)
Goal: Uncountable β
-- Function.Surjective.uncountable
protected theorem Function.Surjective.uncountable [Uncountable β] {f : α → β} (hf : Surjective f) :
    Uncountable α 
Arguments: {α : Sort u} {β : Sort v} [Uncountable β] {f : α → β} (hf : Function.Surjective f)
Goal: Uncountable α
-- not_injective_uncountable_countable
lemma not_injective_uncountable_countable [Uncountable α] [Countable β] (f : α → β) :
    ¬Injective f 
Arguments: {α : Sort u} {β : Sort v} [Uncountable α] [Countable β] (f : α → β)
Goal: ¬Function.Injective f
-- not_surjective_countable_uncountable
lemma not_surjective_countable_uncountable [Countable α] [Uncountable β] (f : α → β) :
    ¬Surjective f 
Arguments: {α : Sort u} {β : Sort v} [Countable α] [Uncountable β] (f : α → β)
Goal: ¬Function.Surjective f
-- uncountable_iff_forall_not_surjective
theorem uncountable_iff_forall_not_surjective [Nonempty α] :
    Uncountable α ↔ ∀ f : ℕ → α, ¬Surjective f 
Arguments: {α : Sort u} [Nonempty α]
Goal: Uncountable α ↔ ∀ (f : ℕ → α), ¬Function.Surjective f
-- Uncountable.of_equiv
theorem Uncountable.of_equiv (α : Sort*) [Uncountable α] (e : α ≃ β) : Uncountable β 
Arguments: {β : Sort v} (α : Sort u_1) [Uncountable α] (e : α ≃ β)
Goal: Uncountable β
-- Equiv.uncountable_iff
theorem Equiv.uncountable_iff (e : α ≃ β) : Uncountable α ↔ Uncountable β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Uncountable α ↔ Uncountable β
-- Opposite.op_injective
theorem op_injective : Function.Injective (op : α → αᵒᵖ) 
Arguments: {α : Sort u}
Goal: Function.Injective Opposite.op
-- Opposite.unop_injective
theorem unop_injective : Function.Injective (unop : αᵒᵖ → α) 
Arguments: {α : Sort u}
Goal: Function.Injective Opposite.unop
-- Opposite.op_unop
@[simp]
theorem op_unop (x : αᵒᵖ) : op (unop x) = x 
Arguments: {α : Sort u} (x : αᵒᵖ)
Goal: Opposite.op (Opposite.unop x) = x
-- Opposite.unop_op
theorem unop_op (x : α) : unop (op x) = x 
Arguments: {α : Sort u} (x : α)
Goal: Opposite.unop (Opposite.op x) = x
-- Opposite.op_inj_iff
theorem op_inj_iff (x y : α) : op x = op y ↔ x = y 
Arguments: {α : Sort u} (x y : α)
Goal: Opposite.op x = Opposite.op y ↔ x = y
-- Opposite.unop_inj_iff
@[simp]
theorem unop_inj_iff (x y : αᵒᵖ) : unop x = unop y ↔ x = y 
Arguments: {α : Sort u} (x y : αᵒᵖ)
Goal: Opposite.unop x = Opposite.unop y ↔ x = y
-- Opposite.op_surjective
theorem op_surjective : Function.Surjective (op : α → αᵒᵖ) 
Arguments: {α : Sort u}
Goal: Function.Surjective Opposite.op
-- Opposite.unop_surjective
theorem unop_surjective : Function.Surjective (unop : αᵒᵖ → α) 
Arguments: {α : Sort u}
Goal: Function.Surjective Opposite.unop
-- Opposite.equivToOpposite_coe
@[simp]
theorem equivToOpposite_coe : (equivToOpposite : α → αᵒᵖ) = op 
Arguments: {α : Sort u}
Goal: ⇑Opposite.equivToOpposite = Opposite.op
-- Opposite.equivToOpposite_symm_coe
@[simp]
theorem equivToOpposite_symm_coe : (equivToOpposite.symm : αᵒᵖ → α) = unop 
Arguments: {α : Sort u}
Goal: ⇑Opposite.equivToOpposite.symm = Opposite.unop
-- Opposite.op_eq_iff_eq_unop
theorem op_eq_iff_eq_unop {x : α} {y} : op x = y ↔ x = unop y 
Arguments: {α : Sort u} {x : α} {y : αᵒᵖ}
Goal: Opposite.op x = y ↔ x = Opposite.unop y
-- Opposite.unop_eq_iff_eq_op
theorem unop_eq_iff_eq_op {x} {y : α} : unop x = y ↔ x = op y 
Arguments: {α : Sort u} {x : αᵒᵖ} {y : α}
Goal: Opposite.unop x = y ↔ x = Opposite.op y
-- Semiquot.ext_s
theorem ext_s {q₁ q₂ : Semiquot α} : q₁ = q₂ ↔ q₁.s = q₂.s 
Arguments: {α : Type u_1} {q₁ q₂ : Semiquot α}
Goal: q₁ = q₂ ↔ q₁.s = q₂.s
-- Semiquot.ext
theorem ext {q₁ q₂ : Semiquot α} : q₁ = q₂ ↔ ∀ a, a ∈ q₁ ↔ a ∈ q₂ 
Arguments: {α : Type u_1} {q₁ q₂ : Semiquot α}
Goal: q₁ = q₂ ↔ ∀ (a : α), a ∈ q₁ ↔ a ∈ q₂
-- Semiquot.exists_mem
theorem exists_mem (q : Semiquot α) : ∃ a, a ∈ q 
Arguments: {α : Type u_1} (q : Semiquot α)
Goal: ∃ a, a ∈ q
-- Semiquot.eq_mk_of_mem
theorem eq_mk_of_mem {q : Semiquot α} {a : α} (h : a ∈ q) : q = @mk _ a q.1 h 
Arguments: {α : Type u_1} {q : Semiquot α} {a : α} (h : a ∈ q)
Goal: q = Semiquot.mk h
-- Semiquot.nonempty
theorem nonempty (q : Semiquot α) : q.s.Nonempty 
Arguments: {α : Type u_1} (q : Semiquot α)
Goal: q.s.Nonempty
-- Semiquot.mem_pure'
@[simp]
theorem mem_pure' {a b : α} : a ∈ Semiquot.pure b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: a ∈ Semiquot.pure b ↔ a = b
-- Semiquot.blur_eq_blur'
theorem blur_eq_blur' (q : Semiquot α) (s : Set α) (h : q.s ⊆ s) : blur s q = blur' q h 
Arguments: {α : Type u_1} (q : Semiquot α) (s : Set α) (h : q.s ⊆ s)
Goal: Semiquot.blur s q = q.blur' h
-- Semiquot.mem_blur'
@[simp]
theorem mem_blur' (q : Semiquot α) {s : Set α} (h : q.s ⊆ s) {a : α} : a ∈ blur' q h ↔ a ∈ s 
Arguments: {α : Type u_1} (q : Semiquot α) {s : Set α} (h : q.s ⊆ s) {a : α}
Goal: a ∈ q.blur' h ↔ a ∈ s
-- Semiquot.liftOn_ofMem
theorem liftOn_ofMem (q : Semiquot α) (f : α → β)
    (h : ∀ a ∈ q, ∀ b ∈ q, f a = f b) (a : α) (aq : a ∈ q) : liftOn q f h = f a 
Arguments: {α : Type u_1} {β : Type u_2} (q : Semiquot α) (f : α → β) (h : ∀ a ∈ q, ∀ b ∈ q, f a = f b) (a : α) (aq : a ∈ q)
Goal: q.liftOn f h = f a
-- Semiquot.mem_map
@[simp]
theorem mem_map (f : α → β) (q : Semiquot α) (b : β) : b ∈ map f q ↔ ∃ a, a ∈ q ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (q : Semiquot α) (b : β)
Goal: b ∈ Semiquot.map f q ↔ ∃ a ∈ q, f a = b
-- Semiquot.mem_bind
@[simp]
theorem mem_bind (q : Semiquot α) (f : α → Semiquot β) (b : β) :
    b ∈ bind q f ↔ ∃ a ∈ q, b ∈ f a 
Arguments: {α : Type u_1} {β : Type u_2} (q : Semiquot α) (f : α → Semiquot β) (b : β)
Goal: b ∈ q.bind f ↔ ∃ a ∈ q, b ∈ f a
-- Semiquot.map_def
@[simp]
theorem map_def {β} : ((· <$> ·) : (α → β) → Semiquot α → Semiquot β) = map 
Arguments: {α β : Type u_1}
Goal: (fun x x_1 => x <$> x_1) = Semiquot.map
-- Semiquot.bind_def
@[simp]
theorem bind_def {β} : ((· >>= ·) : Semiquot α → (α → Semiquot β) → Semiquot β) = bind 
Arguments: {α β : Type u_1}
Goal: (fun x x_1 => x >>= x_1) = Semiquot.bind
-- Semiquot.mem_pure
@[simp]
theorem mem_pure {a b : α} : a ∈ (pure b : Semiquot α) ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: a ∈ pure b ↔ a = b
-- Semiquot.mem_pure_self
theorem mem_pure_self (a : α) : a ∈ (pure a : Semiquot α) 
Arguments: {α : Type u_1} (a : α)
Goal: a ∈ pure a
-- Semiquot.pure_inj
@[simp]
theorem pure_inj {a b : α} : (pure a : Semiquot α) = pure b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: pure a = pure b ↔ a = b
-- Semiquot.pure_le
@[simp]
theorem pure_le {a : α} {s : Semiquot α} : pure a ≤ s ↔ a ∈ s 
Arguments: {α : Type u_1} {a : α} {s : Semiquot α}
Goal: pure a ≤ s ↔ a ∈ s
-- Semiquot.get_mem
theorem get_mem {q : Semiquot α} (p) : get q p ∈ q 
Arguments: {α : Type u_1} {q : Semiquot α} (p : q.IsPure)
Goal: q.get p ∈ q
-- Semiquot.eq_pure
theorem eq_pure {q : Semiquot α} (p) : q = pure (get q p) 
Arguments: {α : Type u_1} {q : Semiquot α} (p : q.IsPure)
Goal: q = pure (q.get p)
-- Semiquot.pure_isPure
@[simp]
theorem pure_isPure (a : α) : IsPure (pure a)
  
Arguments: {α : Type u_1} (a : α)
Goal: (pure a).IsPure
-- Semiquot.isPure_iff
theorem isPure_iff {s : Semiquot α} : IsPure s ↔ ∃ a, s = pure a 
Arguments: {α : Type u_1} {s : Semiquot α}
Goal: s.IsPure ↔ ∃ a, s = pure a
-- Semiquot.IsPure.mono
theorem IsPure.mono {s t : Semiquot α} (st : s ≤ t) (h : IsPure t) : IsPure s
  
Arguments: {α : Type u_1} {s t : Semiquot α} (st : s ≤ t) (h : t.IsPure)
Goal: s.IsPure
-- Semiquot.IsPure.min
theorem IsPure.min {s t : Semiquot α} (h : IsPure t) : s ≤ t ↔ s = t 
Arguments: {α : Type u_1} {s t : Semiquot α} (h : t.IsPure)
Goal: s ≤ t ↔ s = t
-- Semiquot.isPure_of_subsingleton
theorem isPure_of_subsingleton [Subsingleton α] (q : Semiquot α) : IsPure q
  
Arguments: {α : Type u_1} [Subsingleton α] (q : Semiquot α)
Goal: q.IsPure
-- Semiquot.mem_univ
@[simp]
theorem mem_univ [Inhabited α] : ∀ a, a ∈ @univ α _ 
Arguments: {α : Type u_1} [Inhabited α] (a : α)
Goal: a ∈ Semiquot.univ
-- Semiquot.univ_unique
@[congr]
theorem univ_unique (I J : Inhabited α) : @univ _ I = @univ _ J 
Arguments: {α : Type u_1} (I J : Inhabited α)
Goal: Semiquot.univ = Semiquot.univ
-- Semiquot.isPure_univ
@[simp]
theorem isPure_univ [Inhabited α] : @IsPure α univ ↔ Subsingleton α 
Arguments: {α : Type u_1} [Inhabited α]
Goal: Semiquot.univ.IsPure ↔ Subsingleton α
-- Set.BddAbove.add
@[to_additive]
theorem BddAbove.mul [OrderedCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
    BddAbove (A * B) 
Arguments: {α : Type u_1} [OrderedAddCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B)
Goal: BddAbove (A + B)
-- Set.BddAbove.mul
@[to_additive]
theorem BddAbove.mul [OrderedCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
    BddAbove (A * B) 
Arguments: {α : Type u_1} [OrderedCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B)
Goal: BddAbove (A * B)
-- mulSupport_comp_inv_smul
theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
    (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Group α] [MulAction α β] [One γ] (c : α) (f : β → γ)
Goal: (Function.mulSupport fun x => f (c⁻¹ • x)) = c • Function.mulSupport f
-- support_comp_inv_smul
theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
    (support fun x ↦ f (c⁻¹ • x)) = c • support f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Group α] [MulAction α β] [Zero γ] (c : α) (f : β → γ)
Goal: (Function.support fun x => f (c⁻¹ • x)) = c • Function.support f
-- mulSupport_comp_inv_smul₀
theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
    (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [GroupWithZero α] [MulAction α β] [One γ] {c : α} (hc : c ≠ 0) (f : β → γ)
Goal: (Function.mulSupport fun x => f (c⁻¹ • x)) = c • Function.mulSupport f
-- support_comp_inv_smul₀
theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
    (support fun x ↦ f (c⁻¹ • x)) = c • support f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [GroupWithZero α] [MulAction α β] [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ)
Goal: (Function.support fun x => f (c⁻¹ • x)) = c • Function.support f
-- vadd_eq_self_of_preimage_zsmul_eq_self
@[to_additive
      "Let `n : ℤ` and `s` a subset of an additive commutative group `G` that is invariant
      under preimage for the map `x ↦ n • x`. Then `s` is invariant under the pointwise action of
      the additive subgroup of elements `g : G` such that `(n^j) • g = 0` for some `j : ℕ`.
      (This additive subgroup is called the Prüfer subgroup when `G` is the `AddCircle` and `n` is
      prime.)"]
theorem smul_eq_self_of_preimage_zpow_eq_self {G : Type*} [CommGroup G] {n : ℤ} {s : Set G}
    (hs : (fun x => x ^ n) ⁻¹' s = s) {g : G} {j : ℕ} (hg : g ^ n ^ j = 1) : g • s = s 
Arguments: {G : Type u_1} [AddCommGroup G] {n : ℤ} {s : Set G} (hs : (fun x => n • x) ⁻¹' s = s) {g : G} {j : ℕ} (hg : n ^ j • g = 0)
Goal: g +ᵥ s = s
-- smul_eq_self_of_preimage_zpow_eq_self
@[to_additive
      "Let `n : ℤ` and `s` a subset of an additive commutative group `G` that is invariant
      under preimage for the map `x ↦ n • x`. Then `s` is invariant under the pointwise action of
      the additive subgroup of elements `g : G` such that `(n^j) • g = 0` for some `j : ℕ`.
      (This additive subgroup is called the Prüfer subgroup when `G` is the `AddCircle` and `n` is
      prime.)"]
theorem smul_eq_self_of_preimage_zpow_eq_self {G : Type*} [CommGroup G] {n : ℤ} {s : Set G}
    (hs : (fun x => x ^ n) ⁻¹' s = s) {g : G} {j : ℕ} (hg : g ^ n ^ j = 1) : g • s = s 
Arguments: {G : Type u_1} [CommGroup G] {n : ℤ} {s : Set G} (hs : (fun x => x ^ n) ⁻¹' s = s) {g : G} {j : ℕ} (hg : g ^ n ^ j = 1)
Goal: g • s = s
-- Set.equitableOn_empty
@[simp]
theorem equitableOn_empty [LE β] [Add β] [One β] (f : α → β) : EquitableOn ∅ f 
Arguments: {α : Type u_1} {β : Type u_2} [LE β] [Add β] [One β] (f : α → β)
Goal: ∅.EquitableOn f
-- Set.equitableOn_iff_exists_le_le_add_one
theorem equitableOn_iff_exists_le_le_add_one {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, b ≤ f a ∧ f a ≤ b + 1 
Arguments: {α : Type u_1} {s : Set α} {f : α → ℕ}
Goal: s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, b ≤ f a ∧ f a ≤ b + 1
-- Set.equitableOn_iff_exists_image_subset_icc
theorem equitableOn_iff_exists_image_subset_icc {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, f '' s ⊆ Icc b (b + 1) 
Arguments: {α : Type u_1} {s : Set α} {f : α → ℕ}
Goal: s.EquitableOn f ↔ ∃ b, f '' s ⊆ Set.Icc b (b + 1)
-- Set.equitableOn_iff_exists_eq_eq_add_one
theorem equitableOn_iff_exists_eq_eq_add_one {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, f a = b ∨ f a = b + 1 
Arguments: {α : Type u_1} {s : Set α} {f : α → ℕ}
Goal: s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, f a = b ∨ f a = b + 1
-- Set.not_equitableOn
@[simp]
lemma not_equitableOn : ¬s.EquitableOn f ↔ ∃ a ∈ s, ∃ b ∈ s, f b + 1 < f a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] [Add β] [One β] {s : Set α} {f : α → β}
Goal: ¬s.EquitableOn f ↔ ∃ a ∈ s, ∃ b ∈ s, f b + 1 < f a
-- Set.Subsingleton.equitableOn
theorem Subsingleton.equitableOn {s : Set α} (hs : s.Subsingleton) (f : α → β) : s.EquitableOn f 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedSemiring β] {s : Set α} (hs : s.Subsingleton) (f : α → β)
Goal: s.EquitableOn f
-- Set.equitableOn_singleton
theorem equitableOn_singleton (a : α) (f : α → β) : Set.EquitableOn {a} f 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedSemiring β] (a : α) (f : α → β)
Goal: {a}.EquitableOn f
-- Finset.equitableOn_iff_le_le_add_one
theorem equitableOn_iff_le_le_add_one :
    EquitableOn (s : Set α) f ↔
      ∀ a ∈ s, (∑ i ∈ s, f i) / s.card ≤ f a ∧ f a ≤ (∑ i ∈ s, f i) / s.card + 1 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℕ}
Goal: (↑s).EquitableOn f ↔ ∀ a ∈ s, (∑ i ∈ s, f i) / s.card ≤ f a ∧ f a ≤ (∑ i ∈ s, f i) / s.card + 1
-- Finset.EquitableOn.le
theorem EquitableOn.le (h : EquitableOn (s : Set α) f) (ha : a ∈ s) :
    (∑ i ∈ s, f i) / s.card ≤ f a 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℕ} {a : α} (h : (↑s).EquitableOn f) (ha : a ∈ s)
Goal: (∑ i ∈ s, f i) / s.card ≤ f a
-- Finset.EquitableOn.le_add_one
theorem EquitableOn.le_add_one (h : EquitableOn (s : Set α) f) (ha : a ∈ s) :
    f a ≤ (∑ i ∈ s, f i) / s.card + 1 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℕ} {a : α} (h : (↑s).EquitableOn f) (ha : a ∈ s)
Goal: f a ≤ (∑ i ∈ s, f i) / s.card + 1
-- Finset.equitableOn_iff
theorem equitableOn_iff :
    EquitableOn (s : Set α) f ↔
      ∀ a ∈ s, f a = (∑ i ∈ s, f i) / s.card ∨ f a = (∑ i ∈ s, f i) / s.card + 1 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℕ}
Goal: (↑s).EquitableOn f ↔ ∀ a ∈ s, f a = (∑ i ∈ s, f i) / s.card ∨ f a = (∑ i ∈ s, f i) / s.card + 1
-- Part.toOption_isSome
@[simp] lemma toOption_isSome (o : Part α) [Decidable o.Dom] : o.toOption.isSome ↔ o.Dom 
Arguments: {α : Type u_1} (o : Part α) [Decidable o.Dom]
Goal: o.toOption.isSome = true ↔ o.Dom
-- Part.toOption_eq_none
@[simp] lemma toOption_eq_none (o : Part α) [Decidable o.Dom] : o.toOption = none ↔ ¬o.Dom 
Arguments: {α : Type u_1} (o : Part α) [Decidable o.Dom]
Goal: o.toOption = none ↔ ¬o.Dom
-- Part.ext'
theorem ext' : ∀ {o p : Part α}, (o.Dom ↔ p.Dom) → (∀ h₁ h₂, o.get h₁ = p.get h₂) → o = p
  
Arguments: {α : Type u_1} {o p : Part α}
Goal: (o.Dom ↔ p.Dom) → (∀ (h₁ : o.Dom) (h₂ : p.Dom), o.get h₁ = p.get h₂) → o = p
-- Part.eta
@[simp]
theorem eta : ∀ o : Part α, (⟨o.Dom, fun h => o.get h⟩ : Part α) = o
  
Arguments: {α : Type u_1} (o : Part α)
Goal: { Dom := o.Dom, get := fun h => o.get h } = o