ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Stream'.get_nats
theorem get_nats (n : ℕ) : get nats n = n 
Arguments: (n : ℕ)
Goal: Stream'.nats.get n = n
-- Stream'.nats_eq
theorem nats_eq : nats = cons 0 (map succ nats) 
Goal: Stream'.nats = Stream'.cons 0 (Stream'.map Nat.succ Stream'.nats)
-- Sym.coe_injective
theorem coe_injective : Injective ((↑) : Sym α n → Multiset α) 
Arguments: {α : Type u_1} {n : ℕ}
Goal: Function.Injective Sym.toMultiset
-- Sym.coe_inj
@[simp, norm_cast]
theorem coe_inj {s₁ s₂ : Sym α n} : (s₁ : Multiset α) = s₂ ↔ s₁ = s₂ 
Arguments: {α : Type u_1} {n : ℕ} {s₁ s₂ : Sym α n}
Goal: ↑s₁ = ↑s₂ ↔ s₁ = s₂
-- Sym.ext
@[ext] theorem ext {s₁ s₂ : Sym α n} (h : (s₁ : Multiset α) = ↑s₂) : s₁ = s₂ 
Arguments: {α : Type u_1} {n : ℕ} {s₁ s₂ : Sym α n} (h : ↑s₁ = ↑s₂)
Goal: s₁ = s₂
-- Sym.val_eq_coe
@[simp]
theorem val_eq_coe (s : Sym α n) : s.1 = ↑s 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n)
Goal: ↑s = ↑s
-- Sym.coe_nil
@[simp]
theorem coe_nil : ↑(@Sym.nil α) = (0 : Multiset α) 
Arguments: {α : Type u_1}
Goal: ↑Sym.nil = 0
-- Sym.cons_inj_right
@[simp]
theorem cons_inj_right (a : α) (s s' : Sym α n) : a ::ₛ s = a ::ₛ s' ↔ s = s' 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (s s' : Sym α n)
Goal: a ::ₛ s = a ::ₛ s' ↔ s = s'
-- Sym.cons_inj_left
@[simp]
theorem cons_inj_left (a a' : α) (s : Sym α n) : a ::ₛ s = a' ::ₛ s ↔ a = a' 
Arguments: {α : Type u_1} {n : ℕ} (a a' : α) (s : Sym α n)
Goal: a ::ₛ s = a' ::ₛ s ↔ a = a'
-- Sym.cons_swap
theorem cons_swap (a b : α) (s : Sym α n) : a ::ₛ b ::ₛ s = b ::ₛ a ::ₛ s 
Arguments: {α : Type u_1} {n : ℕ} (a b : α) (s : Sym α n)
Goal: a ::ₛ b ::ₛ s = b ::ₛ a ::ₛ s
-- Sym.coe_cons
theorem coe_cons (s : Sym α n) (a : α) : (a ::ₛ s : Multiset α) = a ::ₘ s 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n) (a : α)
Goal: ↑(a ::ₛ s) = a ::ₘ ↑s
-- Sym.ofVector_nil
@[simp]
theorem ofVector_nil : ↑(Vector.nil : Vector α 0) = (Sym.nil : Sym α 0) 
Arguments: {α : Type u_1}
Goal: Sym.ofVector Mathlib.Vector.nil = Sym.nil
-- Sym.ofVector_cons
@[simp]
theorem ofVector_cons (a : α) (v : Vector α n) : ↑(Vector.cons a v) = a ::ₛ (↑v : Sym α n) 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Mathlib.Vector α n)
Goal: Sym.ofVector (a ::ᵥ v) = a ::ₛ Sym.ofVector v
-- Sym.card_coe
@[simp]
theorem card_coe : Multiset.card (s : Multiset α) = n 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n}
Goal: Multiset.card ↑s = n
-- Sym.coe_mk
@[simp, norm_cast] lemma coe_mk (s : Multiset α) (h : Multiset.card s = n) : mk s h = s 
Arguments: {α : Type u_1} {n : ℕ} (s : Multiset α) (h : Multiset.card s = n)
Goal: ↑(Sym.mk s h) = s
-- Sym.mem_mk
@[simp]
theorem mem_mk (a : α) (s : Multiset α) (h : Multiset.card s = n) : a ∈ mk s h ↔ a ∈ s 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (s : Multiset α) (h : Multiset.card s = n)
Goal: a ∈ Sym.mk s h ↔ a ∈ s
-- Sym.forall
lemma «forall» {p : Sym α n → Prop} :
    (∀ s : Sym α n, p s) ↔ ∀ (s : Multiset α) (hs : Multiset.card s = n), p (Sym.mk s hs) 
Arguments: {α : Type u_1} {n : ℕ} {p : Sym α n → Prop}
Goal: (∀ (s : Sym α n), p s) ↔ ∀ (s : Multiset α) (hs : Multiset.card s = n), p (Sym.mk s hs)
-- Sym.exists
lemma «exists» {p : Sym α n → Prop} :
    (∃ s : Sym α n, p s) ↔ ∃ (s : Multiset α) (hs : Multiset.card s = n), p (Sym.mk s hs) 
Arguments: {α : Type u_1} {n : ℕ} {p : Sym α n → Prop}
Goal: (∃ s, p s) ↔ ∃ s, ∃ (hs : Multiset.card s = n), p (Sym.mk s hs)
-- Sym.not_mem_nil
@[simp]
theorem not_mem_nil (a : α) : ¬ a ∈ (nil : Sym α 0) 
Arguments: {α : Type u_1} (a : α)
Goal: a ∉ Sym.nil
-- Sym.mem_cons
@[simp]
theorem mem_cons : a ∈ b ::ₛ s ↔ a = b ∨ a ∈ s 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n} {a b : α}
Goal: a ∈ b ::ₛ s ↔ a = b ∨ a ∈ s
-- Sym.mem_coe
@[simp]
theorem mem_coe : a ∈ (s : Multiset α) ↔ a ∈ s 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n} {a : α}
Goal: a ∈ ↑s ↔ a ∈ s
-- Sym.mem_cons_of_mem
theorem mem_cons_of_mem (h : a ∈ s) : a ∈ b ::ₛ s 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n} {a b : α} (h : a ∈ s)
Goal: a ∈ b ::ₛ s
-- Sym.mem_cons_self
theorem mem_cons_self (a : α) (s : Sym α n) : a ∈ a ::ₛ s 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (s : Sym α n)
Goal: a ∈ a ::ₛ s
-- Sym.cons_of_coe_eq
theorem cons_of_coe_eq (a : α) (v : Vector α n) : a ::ₛ (↑v : Sym α n) = ↑(a ::ᵥ v) 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Mathlib.Vector α n)
Goal: a ::ₛ Sym.ofVector v = Sym.ofVector (a ::ᵥ v)
-- Sym.sound
theorem sound {a b : Vector α n} (h : a.val ~ b.val) : (↑a : Sym α n) = ↑b 
Arguments: {α : Type u_1} {n : ℕ} {a b : Mathlib.Vector α n} (h : (↑a).Perm ↑b)
Goal: Sym.ofVector a = Sym.ofVector b
-- Sym.erase_mk
@[simp]
theorem erase_mk [DecidableEq α] (m : Multiset α)
    (hc : Multiset.card m = n + 1) (a : α) (h : a ∈ m) :
    (mk m hc).erase a h =mk (m.erase a)
        (by rw [Multiset.card_erase_of_mem h, hc, Nat.add_one, Nat.pred_succ]) 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (m : Multiset α) (hc : Multiset.card m = n + 1) (a : α) (h : a ∈ m)
Goal: (Sym.mk m hc).erase a h = Sym.mk (m.erase a) ⋯
-- Sym.coe_erase
@[simp]
theorem coe_erase [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s) :
    (s.erase a h : Multiset α) = Multiset.erase s a 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s)
Goal: ↑(s.erase a h) = (↑s).erase a
-- Sym.cons_erase
@[simp]
theorem cons_erase [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s) : a ::ₛ s.erase a h = s 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s)
Goal: a ::ₛ s.erase a h = s
-- Sym.erase_cons_head
@[simp]
theorem erase_cons_head [DecidableEq α] (s : Sym α n) (a : α)
    (h : a ∈ a ::ₛ s := mem_cons_self a s) : (a ::ₛ s).erase a h = s 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (s : Sym α n) (a : α) (h : a ∈ a ::ₛ s := ⋯)
Goal: (a ::ₛ s).erase a h = s
-- Sym.cons_equiv_eq_equiv_cons
theorem cons_equiv_eq_equiv_cons (α : Type*) (n : ℕ) (a : α) (s : Sym α n) :
    (a::symEquivSym' s) = symEquivSym' (a ::ₛ s) 
Arguments: (α : Type u_3) (n : ℕ) (a : α) (s : Sym α n)
Goal: Sym.cons' a (Sym.symEquivSym' s) = Sym.symEquivSym' (a ::ₛ s)
-- Sym.toMultiset_zero
@[simp] theorem toMultiset_zero : toMultiset (0 : Sym α 0) = 0 
Arguments: {α : Type u_1}
Goal: ↑0 = 0
-- Sym.eq_nil_of_card_zero
theorem eq_nil_of_card_zero (s : Sym α 0) : s = nil 
Arguments: {α : Type u_1} (s : Sym α 0)
Goal: s = Sym.nil
-- Sym.replicate_succ
theorem replicate_succ {a : α} {n : ℕ} : replicate n.succ a = a ::ₛ replicate n a 
Arguments: {α : Type u_1} {a : α} {n : ℕ}
Goal: Sym.replicate n.succ a = a ::ₛ Sym.replicate n a
-- Sym.coe_replicate
theorem coe_replicate : (replicate n a : Multiset α) = Multiset.replicate n a 
Arguments: {α : Type u_1} {n : ℕ} {a : α}
Goal: ↑(Sym.replicate n a) = Multiset.replicate n a
-- Sym.mem_replicate
@[simp]
theorem mem_replicate : b ∈ replicate n a ↔ n ≠ 0 ∧ b = a 
Arguments: {α : Type u_1} {n : ℕ} {a b : α}
Goal: b ∈ Sym.replicate n a ↔ n ≠ 0 ∧ b = a
-- Sym.eq_replicate_iff
theorem eq_replicate_iff : s = replicate n a ↔ ∀ b ∈ s, b = a 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n} {a : α}
Goal: s = Sym.replicate n a ↔ ∀ b ∈ s, b = a
-- Sym.exists_mem
theorem exists_mem (s : Sym α n.succ) : ∃ a, a ∈ s 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n.succ)
Goal: ∃ a, a ∈ s
-- Sym.exists_cons_of_mem
theorem exists_cons_of_mem {s : Sym α (n + 1)} {a : α} (h : a ∈ s) : ∃ t, s = a ::ₛ t 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α (n + 1)} {a : α} (h : a ∈ s)
Goal: ∃ t, s = a ::ₛ t
-- Sym.exists_eq_cons_of_succ
theorem exists_eq_cons_of_succ (s : Sym α n.succ) : ∃ (a : α) (s' : Sym α n), s = a ::ₛ s' 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n.succ)
Goal: ∃ a s', s = a ::ₛ s'
-- Sym.eq_replicate
theorem eq_replicate {a : α} {n : ℕ} {s : Sym α n} : s = replicate n a ↔ ∀ b ∈ s, b = a 
Arguments: {α : Type u_1} {a : α} {n : ℕ} {s : Sym α n}
Goal: s = Sym.replicate n a ↔ ∀ b ∈ s, b = a
-- Sym.eq_replicate_of_subsingleton
theorem eq_replicate_of_subsingleton [Subsingleton α] (a : α) {n : ℕ} (s : Sym α n) :
    s = replicate n a 
Arguments: {α : Type u_1} [Subsingleton α] (a : α) {n : ℕ} (s : Sym α n)
Goal: s = Sym.replicate n a
-- Sym.replicate_right_inj
theorem replicate_right_inj {a b : α} {n : ℕ} (h : n ≠ 0) : replicate n a = replicate n b ↔ a = b 
Arguments: {α : Type u_1} {a b : α} {n : ℕ} (h : n ≠ 0)
Goal: Sym.replicate n a = Sym.replicate n b ↔ a = b
-- Sym.replicate_right_injective
theorem replicate_right_injective {n : ℕ} (h : n ≠ 0) :
    Function.Injective (replicate n : α → Sym α n) 
Arguments: {α : Type u_1} {n : ℕ} (h : n ≠ 0)
Goal: Function.Injective (Sym.replicate n)
-- Sym.mem_map
@[simp]
theorem mem_map {n : ℕ} {f : α → β} {b : β} {l : Sym α n} :
    b ∈ Sym.map f l ↔ ∃ a, a ∈ l ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {b : β} {l : Sym α n}
Goal: b ∈ Sym.map f l ↔ ∃ a ∈ l, f a = b
-- Sym.map_id'
@[simp]
theorem map_id' {α : Type*} {n : ℕ} (s : Sym α n) : Sym.map (fun x : α => x) s = s 
Arguments: {α : Type u_3} {n : ℕ} (s : Sym α n)
Goal: Sym.map (fun x => x) s = s
-- Sym.map_id
theorem map_id {α : Type*} {n : ℕ} (s : Sym α n) : Sym.map id s = s 
Arguments: {α : Type u_3} {n : ℕ} (s : Sym α n)
Goal: Sym.map id s = s
-- Sym.map_map
@[simp]
theorem map_map {α β γ : Type*} {n : ℕ} (g : β → γ) (f : α → β) (s : Sym α n) :
    Sym.map g (Sym.map f s) = Sym.map (g ∘ f) s 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} {n : ℕ} (g : β → γ) (f : α → β) (s : Sym α n)
Goal: Sym.map g (Sym.map f s) = Sym.map (g ∘ f) s
-- Sym.map_zero
@[simp]
theorem map_zero (f : α → β) : Sym.map f (0 : Sym α 0) = (0 : Sym β 0) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Sym.map f 0 = 0
-- Sym.map_cons
@[simp]
theorem map_cons {n : ℕ} (f : α → β) (a : α) (s : Sym α n) : (a ::ₛ s).map f = f a ::ₛ s.map f 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (f : α → β) (a : α) (s : Sym α n)
Goal: Sym.map f (a ::ₛ s) = f a ::ₛ Sym.map f s
-- Sym.map_congr
@[congr]
theorem map_congr {f g : α → β} {s : Sym α n} (h : ∀ x ∈ s, f x = g x) : map f s = map g s 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} {f g : α → β} {s : Sym α n} (h : ∀ x ∈ s, f x = g x)
Goal: Sym.map f s = Sym.map g s
-- Sym.map_mk
@[simp]
theorem map_mk {f : α → β} {m : Multiset α} {hc : Multiset.card m = n} :
    map f (mk m hc) = mk (m.map f) (by simp [hc]) 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {m : Multiset α} {hc : Multiset.card m = n}
Goal: Sym.map f (Sym.mk m hc) = Sym.mk (Multiset.map f m) ⋯
-- Sym.coe_map
@[simp]
theorem coe_map (s : Sym α n) (f : α → β) : ↑(s.map f) = Multiset.map f s 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (s : Sym α n) (f : α → β)
Goal: ↑(Sym.map f s) = Multiset.map f ↑s
-- Sym.map_injective
theorem map_injective {f : α → β} (hf : Injective f) (n : ℕ) :
    Injective (map f : Sym α n → Sym β n) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (hf : Function.Injective f) (n : ℕ)
Goal: Function.Injective (Sym.map f)
-- Sym.equivCongr_symm_apply
@[simps]
def equivCongr (e : α ≃ β) : Sym α n ≃ Sym β n 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (e : α ≃ β) (x : Sym β n)
Goal: (Sym.equivCongr e).symm x = Sym.map (⇑e.symm) x
-- Sym.equivCongr_apply
@[simps]
def equivCongr (e : α ≃ β) : Sym α n ≃ Sym β n 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (e : α ≃ β) (x : Sym α n)
Goal: (Sym.equivCongr e) x = Sym.map (⇑e) x
-- Sym.attach_mk
@[simp]
theorem attach_mk {m : Multiset α} {hc : Multiset.card m = n} :
    attach (mk m hc) = mk m.attach (Multiset.card_attach.trans hc) 
Arguments: {α : Type u_1} {n : ℕ} {m : Multiset α} {hc : Multiset.card m = n}
Goal: (Sym.mk m hc).attach = Sym.mk m.attach ⋯
-- Sym.coe_attach
@[simp]
theorem coe_attach (s : Sym α n) : (s.attach : Multiset { a // a ∈ s }) =
    Multiset.attach (s : Multiset α) 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n)
Goal: ↑s.attach = (↑s).attach
-- Sym.attach_map_coe
theorem attach_map_coe (s : Sym α n) : s.attach.map (↑) = s 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n)
Goal: Sym.map Subtype.val s.attach = s
-- Sym.mem_attach
@[simp]
theorem mem_attach (s : Sym α n) (x : { x // x ∈ s }) : x ∈ s.attach 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n) (x : { x // x ∈ s })
Goal: x ∈ s.attach
-- Sym.attach_nil
@[simp]
theorem attach_nil : (nil : Sym α 0).attach = nil 
Arguments: {α : Type u_1}
Goal: Sym.nil.attach = Sym.nil
-- Sym.attach_cons
@[simp]
theorem attach_cons (x : α) (s : Sym α n) :
    (cons x s).attach =
      cons ⟨x, mem_cons_self _ _⟩ (s.attach.map fun x => ⟨x, mem_cons_of_mem x.prop⟩) 
Arguments: {α : Type u_1} {n : ℕ} (x : α) (s : Sym α n)
Goal: (x ::ₛ s).attach = ⟨x, ⋯⟩ ::ₛ Sym.map (fun x_1 => ⟨↑x_1, ⋯⟩) s.attach
-- Sym.cast_rfl
@[simp]
theorem cast_rfl : Sym.cast rfl s = s 
Arguments: {α : Type u_1} {n : ℕ} {s : Sym α n}
Goal: (Sym.cast ⋯) s = s
-- Sym.cast_cast
@[simp]
theorem cast_cast {n'' : ℕ} (h : n = n') (h' : n' = n'') :
    Sym.cast h' (Sym.cast h s) = Sym.cast (h.trans h') s 
Arguments: {α : Type u_1} {n n' : ℕ} {s : Sym α n} {n'' : ℕ} (h : n = n') (h' : n' = n'')
Goal: (Sym.cast h') ((Sym.cast h) s) = (Sym.cast ⋯) s
-- Sym.coe_cast
@[simp]
theorem coe_cast (h : n = m) : (Sym.cast h s : Multiset α) = s 
Arguments: {α : Type u_1} {n m : ℕ} {s : Sym α n} (h : n = m)
Goal: ↑((Sym.cast h) s) = ↑s
-- Sym.mem_cast
@[simp]
theorem mem_cast (h : n = m) : a ∈ Sym.cast h s ↔ a ∈ s 
Arguments: {α : Type u_1} {n m : ℕ} {s : Sym α n} {a : α} (h : n = m)
Goal: a ∈ (Sym.cast h) s ↔ a ∈ s
-- Sym.append_inj_right
@[simp]
theorem append_inj_right (s : Sym α n) {t t' : Sym α n'} : s.append t = s.append t' ↔ t = t' 
Arguments: {α : Type u_1} {n n' : ℕ} (s : Sym α n) {t t' : Sym α n'}
Goal: s.append t = s.append t' ↔ t = t'
-- Sym.append_inj_left
@[simp]
theorem append_inj_left {s s' : Sym α n} (t : Sym α n') : s.append t = s'.append t ↔ s = s' 
Arguments: {α : Type u_1} {n n' : ℕ} {s s' : Sym α n} (t : Sym α n')
Goal: s.append t = s'.append t ↔ s = s'
-- Sym.append_comm
theorem append_comm (s : Sym α n') (s' : Sym α n') :
    s.append s' = Sym.cast (add_comm _ _) (s'.append s) 
Arguments: {α : Type u_1} {n' : ℕ} (s s' : Sym α n')
Goal: s.append s' = (Sym.cast ⋯) (s'.append s)
-- Sym.coe_append
@[simp, norm_cast]
theorem coe_append (s : Sym α n) (s' : Sym α n') : (s.append s' : Multiset α) = s + s' 
Arguments: {α : Type u_1} {n n' : ℕ} (s : Sym α n) (s' : Sym α n')
Goal: ↑(s.append s') = ↑s + ↑s'
-- Sym.mem_append_iff
theorem mem_append_iff {s' : Sym α m} : a ∈ s.append s' ↔ a ∈ s ∨ a ∈ s' 
Arguments: {α : Type u_1} {n m : ℕ} {s : Sym α n} {a : α} {s' : Sym α m}
Goal: a ∈ s.append s' ↔ a ∈ s ∨ a ∈ s'
-- Sym.oneEquiv_apply
@[simps apply]
def oneEquiv : α ≃ Sym α 1 
Arguments: {α : Type u_1} (a : α)
Goal: Sym.oneEquiv a = ⟨{a}, ⋯⟩
-- Sym.coe_fill
theorem coe_fill {a : α} {i : Fin (n + 1)} {m : Sym α (n - i)} :
    (fill a i m : Multiset α) = m + replicate i a 
Arguments: {α : Type u_1} {n : ℕ} {a : α} {i : Fin (n + 1)} {m : Sym α (n - ↑i)}
Goal: ↑(Sym.fill a i m) = ↑m + ↑(Sym.replicate (↑i) a)
-- Sym.mem_fill_iff
theorem mem_fill_iff {a b : α} {i : Fin (n + 1)} {s : Sym α (n - i)} :
    a ∈ Sym.fill b i s ↔ (i : ℕ) ≠ 0 ∧ a = b ∨ a ∈ s 
Arguments: {α : Type u_1} {n : ℕ} {a b : α} {i : Fin (n + 1)} {s : Sym α (n - ↑i)}
Goal: a ∈ Sym.fill b i s ↔ ↑i ≠ 0 ∧ a = b ∨ a ∈ s
-- Sym.sigma_sub_ext
theorem sigma_sub_ext {m₁ m₂ : Σi : Fin (n + 1), Sym α (n - i)} (h : (m₁.2 : Multiset α) = m₂.2) :
    m₁ = m₂ 
Arguments: {α : Type u_1} {n : ℕ} {m₁ m₂ : (i : Fin (n + 1)) × Sym α (n - ↑i)} (h : ↑m₁.snd = ↑m₂.snd)
Goal: m₁ = m₂
-- Sym.fill_filterNe
theorem fill_filterNe [DecidableEq α] (a : α) (m : Sym α n) :
    (m.filterNe a).2.fill a (m.filterNe a).1 = m 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (a : α) (m : Sym α n)
Goal: Sym.fill a (Sym.filterNe a m).fst (Sym.filterNe a m).snd = m
-- Sym.filter_ne_fill
theorem filter_ne_fill [DecidableEq α] (a : α) (m : Σi : Fin (n + 1), Sym α (n - i)) (h : a ∉ m.2) :
    (m.2.fill a m.1).filterNe a = m 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (a : α) (m : (i : Fin (n + 1)) × Sym α (n - ↑i)) (h : a ∉ m.snd)
Goal: Sym.filterNe a (Sym.fill a m.fst m.snd) = m
-- Sym.count_coe_fill_self_of_not_mem
theorem count_coe_fill_self_of_not_mem [DecidableEq α] {a : α} {i : Fin (n + 1)} {s : Sym α (n - i)}
    (hx : a ∉ s) :
    count a (fill a i s : Multiset α) = i 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] {a : α} {i : Fin (n + 1)} {s : Sym α (n - ↑i)} (hx : a ∉ s)
Goal: Multiset.count a ↑(Sym.fill a i s) = ↑i
-- Sym.count_coe_fill_of_ne
theorem count_coe_fill_of_ne [DecidableEq α] {a x : α} {i : Fin (n + 1)} {s : Sym α (n - i)}
    (hx : x ≠ a) :
    count x (fill a i s : Multiset α) = count x s 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] {a x : α} {i : Fin (n + 1)} {s : Sym α (n - ↑i)} (hx : x ≠ a)
Goal: Multiset.count x ↑(Sym.fill a i s) = Multiset.count x ↑s
-- SymOptionSuccEquiv.encode_of_none_mem
@[simp]
theorem encode_of_none_mem [DecidableEq α] (s : Sym (Option α) n.succ) (h : none ∈ s) :
    encode s = Sum.inl (s.erase none h) 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (s : Sym (Option α) n.succ) (h : none ∈ s)
Goal: SymOptionSuccEquiv.encode s = Sum.inl (s.erase none h)
-- SymOptionSuccEquiv.encode_of_not_none_mem
@[simp]
theorem encode_of_not_none_mem [DecidableEq α] (s : Sym (Option α) n.succ) (h : ¬none ∈ s) :
    encode s =
      Sum.inr
        (s.attach.map fun o =>
          o.1.get <| Option.ne_none_iff_isSome.1 <| ne_of_mem_of_not_mem o.2 h) 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (s : Sym (Option α) n.succ) (h : none ∉ s)
Goal: SymOptionSuccEquiv.encode s = Sum.inr (Sym.map (fun o => (↑o).get ⋯) s.attach)
-- SymOptionSuccEquiv.decode_inl
@[simp]
theorem decode_inl (s : Sym (Option α) n) : decode (Sum.inl s) = none ::ₛ s 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym (Option α) n)
Goal: SymOptionSuccEquiv.decode (Sum.inl s) = none ::ₛ s
-- SymOptionSuccEquiv.decode_inr
@[simp]
theorem decode_inr (s : Sym α n.succ) : decode (Sum.inr s) = s.map Embedding.some 
Arguments: {α : Type u_1} {n : ℕ} (s : Sym α n.succ)
Goal: SymOptionSuccEquiv.decode (Sum.inr s) = Sym.map (⇑Function.Embedding.some) s
-- SymOptionSuccEquiv.decode_encode
@[simp]
theorem decode_encode [DecidableEq α] (s : Sym (Option α) n.succ) : decode (encode s) = s 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (s : Sym (Option α) n.succ)
Goal: SymOptionSuccEquiv.decode (SymOptionSuccEquiv.encode s) = s
-- SymOptionSuccEquiv.encode_decode
@[simp]
theorem encode_decode [DecidableEq α] (s : Sym (Option α) n ⊕ Sym α n.succ) :
    encode (decode s) = s 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (s : Sym (Option α) n ⊕ Sym α n.succ)
Goal: SymOptionSuccEquiv.encode (SymOptionSuccEquiv.decode s) = s
-- AlgebraicGeometry.QuasiCompact.isCompact_preimage
@[mk_iff]
class QuasiCompact (f : X ⟶ Y) : Prop where
    isCompact_preimage : ∀ U : Set Y, IsOpen U → IsCompact U → IsCompact (f.1.base ⁻¹' U)
Arguments: {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.QuasiCompact f] (U : Set ↑↑Y.toPresheafedSpace)
Goal: IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)
-- AlgebraicGeometry.quasiCompact_iff
@[mk_iff]
class QuasiCompact (f : X ⟶ Y) : Prop where
    isCompact_preimage : ∀ U : Set Y, IsOpen U → IsCompact U → IsCompact (f.1.base ⁻¹' U)
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
Goal: AlgebraicGeometry.QuasiCompact f ↔
  ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)
-- AlgebraicGeometry.quasiCompact_iff_spectral
theorem quasiCompact_iff_spectral : QuasiCompact f ↔ IsSpectralMap f.1.base 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
Goal: AlgebraicGeometry.QuasiCompact f ↔ IsSpectralMap ⇑f.val.base
-- AlgebraicGeometry.isCompactOpen_iff_eq_finset_affine_union
theorem isCompactOpen_iff_eq_finset_affine_union {X : Scheme} (U : Set X) :
    IsCompact U ∧ IsOpen U ↔ ∃ s : Set X.affineOpens, s.Finite ∧ U = ⋃ i ∈ s, i 
Arguments: {X : AlgebraicGeometry.Scheme} (U : Set ↑↑X.toPresheafedSpace)
Goal: IsCompact U ∧ IsOpen U ↔ ∃ s, s.Finite ∧ U = ⋃ i ∈ s, ↑↑i
-- AlgebraicGeometry.isCompactOpen_iff_eq_basicOpen_union
theorem isCompactOpen_iff_eq_basicOpen_union {X : Scheme} [IsAffine X] (U : Set X) :
    IsCompact U ∧ IsOpen U ↔
      ∃ s : Set Γ(X, ⊤), s.Finite ∧ U = ⋃ i ∈ s, X.basicOpen i 
Arguments: {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsAffine X] (U : Set ↑↑X.toPresheafedSpace)
Goal: IsCompact U ∧ IsOpen U ↔ ∃ s, s.Finite ∧ U = ⋃ i ∈ s, ↑(X.basicOpen i)
-- AlgebraicGeometry.quasiCompact_iff_forall_affine
theorem quasiCompact_iff_forall_affine :
    QuasiCompact f ↔
      ∀ U : Y.Opens, IsAffineOpen U → IsCompact (f ⁻¹ᵁ U : Set X) 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
Goal: AlgebraicGeometry.QuasiCompact f ↔ ∀ (U : Y.Opens), AlgebraicGeometry.IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
-- AlgebraicGeometry.isCompact_basicOpen
theorem isCompact_basicOpen (X : Scheme) {U : X.Opens} (hU : IsCompact (U : Set X))
    (f : Γ(X, U)) : IsCompact (X.basicOpen f : Set X) 
Arguments: (X : AlgebraicGeometry.Scheme) {U : X.Opens} (hU : IsCompact ↑U) (f : ↑Γ(X, U))
Goal: IsCompact ↑(X.basicOpen f)
-- AlgebraicGeometry.quasiCompact_over_affine_iff
theorem quasiCompact_over_affine_iff {X Y : Scheme} (f : X ⟶ Y) [IsAffine Y] :
    QuasiCompact f ↔ CompactSpace X 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsAffine Y]
Goal: AlgebraicGeometry.QuasiCompact f ↔ CompactSpace ↑↑X.toPresheafedSpace
-- AlgebraicGeometry.compactSpace_iff_quasiCompact
theorem compactSpace_iff_quasiCompact (X : Scheme) :
    CompactSpace X ↔ QuasiCompact (terminal.from X) 
Arguments: (X : AlgebraicGeometry.Scheme)
Goal: CompactSpace ↑↑X.toPresheafedSpace ↔ AlgebraicGeometry.QuasiCompact (CategoryTheory.Limits.terminal.from X)
-- AlgebraicGeometry.quasiCompact_stableUnderBaseChange
theorem quasiCompact_stableUnderBaseChange :
    MorphismProperty.StableUnderBaseChange @QuasiCompact 
Goal: CategoryTheory.MorphismProperty.StableUnderBaseChange @AlgebraicGeometry.QuasiCompact
-- AlgebraicGeometry.compact_open_induction_on
@[elab_as_elim]
theorem compact_open_induction_on {P : X.Opens → Prop} (S : X.Opens)
    (hS : IsCompact S.1) (h₁ : P ⊥)
    (h₂ : ∀ (S : X.Opens) (_ : IsCompact S.1) (U : X.affineOpens), P S → P (S ⊔ U)) :
    P S 
Arguments: {X : AlgebraicGeometry.Scheme} {P : X.Opens → Prop} (S : X.Opens) (hS : IsCompact S.carrier) (h₁ : P ⊥) (h₂ : ∀ (S : X.Opens), IsCompact S.carrier → ∀ (U : ↑X.affineOpens), P S → P (S ⊔ ↑U))
Goal: P S
-- AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isAffineOpen
theorem exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isAffineOpen (X : Scheme)
    {U : X.Opens} (hU : IsAffineOpen U) (x f : Γ(X, U))
    (H : x |_ X.basicOpen f = 0) : ∃ n : ℕ, f ^ n * x = 0 
Arguments: (X : AlgebraicGeometry.Scheme) {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) (x f : ↑Γ(X, U)) (H : (x |_ X.basicOpen f) ⋯ = 0)
Goal: ∃ n, f ^ n * x = 0
-- AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact
theorem exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact (X : Scheme.{u})
    {U : X.Opens} (hU : IsCompact U.1) (x f : Γ(X, U))
    (H : x |_ X.basicOpen f = 0) : ∃ n : ℕ, f ^ n * x = 0 
Arguments: (X : AlgebraicGeometry.Scheme) {U : X.Opens} (hU : IsCompact U.carrier) (x f : ↑Γ(X, U)) (H : (x |_ X.basicOpen f) ⋯ = 0)
Goal: ∃ n, f ^ n * x = 0
-- AlgebraicGeometry.Scheme.isNilpotent_iff_basicOpen_eq_bot_of_isCompact
lemma Scheme.isNilpotent_iff_basicOpen_eq_bot_of_isCompact {X : Scheme.{u}}
    {U : X.Opens} (hU : IsCompact (U : Set X)) (f : Γ(X, U)) :
    IsNilpotent f ↔ X.basicOpen f = ⊥ 
Arguments: {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : IsCompact ↑U) (f : ↑Γ(X, U))
Goal: IsNilpotent f ↔ X.basicOpen f = ⊥
-- AlgebraicGeometry.Scheme.zeroLocus_eq_top_iff_subset_nilradical_of_isCompact
lemma Scheme.zeroLocus_eq_top_iff_subset_nilradical_of_isCompact {X : Scheme.{u}} {U : X.Opens}
    (hU : IsCompact (U : Set X)) (s : Set Γ(X, U)) :
    X.zeroLocus s = ⊤ ↔ s ⊆ nilradical Γ(X, U) 
Arguments: {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : IsCompact ↑U) (s : Set ↑Γ(X, U))
Goal: X.zeroLocus s = ⊤ ↔ s ⊆ ↑(nilradical ↑Γ(X, U))