ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Part.mem_eq
theorem mem_eq (a : α) (o : Part α) : (a ∈ o) = ∃ h, o.get h = a 
Arguments: {α : Type u_1} (a : α) (o : Part α)
Goal: (a ∈ o) = ∃ (h : o.Dom), o.get h = a
-- Part.dom_iff_mem
theorem dom_iff_mem : ∀ {o : Part α}, o.Dom ↔ ∃ y, y ∈ o
  
Arguments: {α : Type u_1} {o : Part α}
Goal: o.Dom ↔ ∃ y, y ∈ o
-- Part.get_mem
theorem get_mem {o : Part α} (h) : get o h ∈ o 
Arguments: {α : Type u_1} {o : Part α} (h : o.Dom)
Goal: o.get h ∈ o
-- Part.mem_mk_iff
@[simp]
theorem mem_mk_iff {p : Prop} {o : p → α} {a : α} : a ∈ Part.mk p o ↔ ∃ h, o h = a 
Arguments: {α : Type u_1} {p : Prop} {o : p → α} {a : α}
Goal: a ∈ { Dom := p, get := o } ↔ ∃ (h : p), o h = a
-- Part.ext
@[ext]
theorem ext {o p : Part α} (H : ∀ a, a ∈ o ↔ a ∈ p) : o = p 
Arguments: {α : Type u_1} {o p : Part α} (H : ∀ (a : α), a ∈ o ↔ a ∈ p)
Goal: o = p
-- Part.not_mem_none
@[simp]
theorem not_mem_none (a : α) : a ∉ @none α 
Arguments: {α : Type u_1} (a : α)
Goal: a ∉ Part.none
-- Part.some_dom
@[simp]
theorem some_dom (a : α) : (some a).Dom 
Arguments: {α : Type u_1} (a : α)
Goal: (Part.some a).Dom
-- Part.mem_unique
theorem mem_unique : ∀ {a b : α} {o : Part α}, a ∈ o → b ∈ o → a = b
  
Arguments: {α : Type u_1} {a b : α} {o : Part α}
Goal: a ∈ o → b ∈ o → a = b
-- Part.Mem.left_unique
theorem Mem.left_unique : Relator.LeftUnique ((· ∈ ·) : α → Part α → Prop) 
Arguments: {α : Type u_1}
Goal: Relator.LeftUnique fun x x_1 => x ∈ x_1
-- Part.get_eq_of_mem
theorem get_eq_of_mem {o : Part α} {a} (h : a ∈ o) (h') : get o h' = a 
Arguments: {α : Type u_1} {o : Part α} {a : α} (h : a ∈ o) (h' : o.Dom)
Goal: o.get h' = a
-- Part.subsingleton
protected theorem subsingleton (o : Part α) : Set.Subsingleton { a | a ∈ o } 
Arguments: {α : Type u_1} (o : Part α)
Goal: {a | a ∈ o}.Subsingleton
-- Part.get_some
@[simp]
theorem get_some {a : α} (ha : (some a).Dom) : get (some a) ha = a 
Arguments: {α : Type u_1} {a : α} (ha : (Part.some a).Dom)
Goal: (Part.some a).get ha = a
-- Part.mem_some
theorem mem_some (a : α) : a ∈ some a 
Arguments: {α : Type u_1} (a : α)
Goal: a ∈ Part.some a
-- Part.mem_some_iff
@[simp]
theorem mem_some_iff {a b} : b ∈ (some a : Part α) ↔ b = a 
Arguments: {α : Type u_1} {a b : α}
Goal: b ∈ Part.some a ↔ b = a
-- Part.eq_some_iff
theorem eq_some_iff {a : α} {o : Part α} : o = some a ↔ a ∈ o 
Arguments: {α : Type u_1} {a : α} {o : Part α}
Goal: o = Part.some a ↔ a ∈ o
-- Part.eq_none_iff
theorem eq_none_iff {o : Part α} : o = none ↔ ∀ a, a ∉ o 
Arguments: {α : Type u_1} {o : Part α}
Goal: o = Part.none ↔ ∀ (a : α), a ∉ o
-- Part.eq_none_iff'
theorem eq_none_iff' {o : Part α} : o = none ↔ ¬o.Dom 
Arguments: {α : Type u_1} {o : Part α}
Goal: o = Part.none ↔ ¬o.Dom
-- Part.not_none_dom
@[simp]
theorem not_none_dom : ¬(none : Part α).Dom 
Arguments: {α : Type u_1}
Goal: ¬Part.none.Dom
-- Part.some_ne_none
@[simp]
theorem some_ne_none (x : α) : some x ≠ none 
Arguments: {α : Type u_1} (x : α)
Goal: Part.some x ≠ Part.none
-- Part.none_ne_some
@[simp]
theorem none_ne_some (x : α) : none ≠ some x 
Arguments: {α : Type u_1} (x : α)
Goal: Part.none ≠ Part.some x
-- Part.ne_none_iff
theorem ne_none_iff {o : Part α} : o ≠ none ↔ ∃ x, o = some x 
Arguments: {α : Type u_1} {o : Part α}
Goal: o ≠ Part.none ↔ ∃ x, o = Part.some x
-- Part.eq_none_or_eq_some
theorem eq_none_or_eq_some (o : Part α) : o = none ∨ ∃ x, o = some x 
Arguments: {α : Type u_1} (o : Part α)
Goal: o = Part.none ∨ ∃ x, o = Part.some x
-- Part.some_injective
theorem some_injective : Injective (@Part.some α) 
Arguments: {α : Type u_1}
Goal: Function.Injective Part.some
-- Part.some_inj
@[simp]
theorem some_inj {a b : α} : Part.some a = some b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: Part.some a = Part.some b ↔ a = b
-- Part.some_get
@[simp]
theorem some_get {a : Part α} (ha : a.Dom) : Part.some (Part.get a ha) = a 
Arguments: {α : Type u_1} {a : Part α} (ha : a.Dom)
Goal: Part.some (a.get ha) = a
-- Part.get_eq_iff_eq_some
theorem get_eq_iff_eq_some {a : Part α} {ha : a.Dom} {b : α} : a.get ha = b ↔ a = some b 
Arguments: {α : Type u_1} {a : Part α} {ha : a.Dom} {b : α}
Goal: a.get ha = b ↔ a = Part.some b
-- Part.get_eq_get_of_eq
theorem get_eq_get_of_eq (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b) :
    a.get ha = b.get (h ▸ ha) 
Arguments: {α : Type u_1} (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b)
Goal: a.get ha = b.get ⋯
-- Part.get_eq_iff_mem
theorem get_eq_iff_mem {o : Part α} {a : α} (h : o.Dom) : o.get h = a ↔ a ∈ o 
Arguments: {α : Type u_1} {o : Part α} {a : α} (h : o.Dom)
Goal: o.get h = a ↔ a ∈ o
-- Part.eq_get_iff_mem
theorem eq_get_iff_mem {o : Part α} {a : α} (h : o.Dom) : a = o.get h ↔ a ∈ o 
Arguments: {α : Type u_1} {o : Part α} {a : α} (h : o.Dom)
Goal: a = o.get h ↔ a ∈ o
-- Part.none_toOption
@[simp]
theorem none_toOption [Decidable (@none α).Dom] : (none : Part α).toOption = Option.none 
Arguments: {α : Type u_1} [Decidable Part.none.Dom]
Goal: Part.none.toOption = none
-- Part.some_toOption
@[simp]
theorem some_toOption (a : α) [Decidable (some a).Dom] : (some a).toOption = Option.some a 
Arguments: {α : Type u_1} (a : α) [Decidable (Part.some a).Dom]
Goal: (Part.some a).toOption = some a
-- Part.getOrElse_of_dom
theorem getOrElse_of_dom (a : Part α) (h : a.Dom) [Decidable a.Dom] (d : α) :
    getOrElse a d = a.get h 
Arguments: {α : Type u_1} (a : Part α) (h : a.Dom) [Decidable a.Dom] (d : α)
Goal: a.getOrElse d = a.get h
-- Part.getOrElse_of_not_dom
theorem getOrElse_of_not_dom (a : Part α) (h : ¬a.Dom) [Decidable a.Dom] (d : α) :
    getOrElse a d = d 
Arguments: {α : Type u_1} (a : Part α) (h : ¬a.Dom) [Decidable a.Dom] (d : α)
Goal: a.getOrElse d = d
-- Part.getOrElse_none
@[simp]
theorem getOrElse_none (d : α) [Decidable (none : Part α).Dom] : getOrElse none d = d 
Arguments: {α : Type u_1} (d : α) [Decidable Part.none.Dom]
Goal: Part.none.getOrElse d = d
-- Part.getOrElse_some
@[simp]
theorem getOrElse_some (a : α) (d : α) [Decidable (some a).Dom] : getOrElse (some a) d = a 
Arguments: {α : Type u_1} (a d : α) [Decidable (Part.some a).Dom]
Goal: (Part.some a).getOrElse d = a
-- Part.mem_toOption
theorem mem_toOption {o : Part α} [Decidable o.Dom] {a : α} : a ∈ toOption o ↔ a ∈ o 
Arguments: {α : Type u_1} {o : Part α} [Decidable o.Dom] {a : α}
Goal: a ∈ o.toOption ↔ a ∈ o
-- Part.toOption_eq_some_iff
@[simp]
theorem toOption_eq_some_iff {o : Part α} [Decidable o.Dom] {a : α} :
    toOption o = Option.some a ↔ a ∈ o 
Arguments: {α : Type u_1} {o : Part α} [Decidable o.Dom] {a : α}
Goal: o.toOption = some a ↔ a ∈ o
-- Part.Dom.toOption
protected theorem Dom.toOption {o : Part α} [Decidable o.Dom] (h : o.Dom) : o.toOption = o.get h 
Arguments: {α : Type u_1} {o : Part α} [Decidable o.Dom] (h : o.Dom)
Goal: o.toOption = some (o.get h)
-- Part.toOption_eq_none_iff
theorem toOption_eq_none_iff {a : Part α} [Decidable a.Dom] : a.toOption = Option.none ↔ ¬a.Dom 
Arguments: {α : Type u_1} {a : Part α} [Decidable a.Dom]
Goal: a.toOption = none ↔ ¬a.Dom
-- Part.elim_toOption
theorem elim_toOption {α β : Type*} (a : Part α) [Decidable a.Dom] (b : β) (f : α → β) :
    a.toOption.elim b f = if h : a.Dom then f (a.get h) else b 
Arguments: {α : Type u_4} {β : Type u_5} (a : Part α) [Decidable a.Dom] (b : β) (f : α → β)
Goal: a.toOption.elim b f = if h : a.Dom then f (a.get h) else b
-- Part.mem_ofOption
@[simp]
theorem mem_ofOption {a : α} : ∀ {o : Option α}, a ∈ ofOption o ↔ a ∈ o
  
Arguments: {α : Type u_1} {a : α} {o : Option α}
Goal: a ∈ ↑o ↔ a ∈ o
-- Part.ofOption_dom
@[simp]
theorem ofOption_dom {α} : ∀ o : Option α, (ofOption o).Dom ↔ o.isSome
  
Arguments: {α : Type u_4} (o : Option α)
Goal: (↑o).Dom ↔ o.isSome = true
-- Part.ofOption_eq_get
theorem ofOption_eq_get {α} (o : Option α) : ofOption o = ⟨_, @Option.get _ o⟩ 
Arguments: {α : Type u_4} (o : Option α)
Goal: ↑o = { Dom := o.isSome = true, get := o.get }
-- Part.mem_coe
theorem mem_coe {a : α} {o : Option α} : a ∈ (o : Part α) ↔ a ∈ o 
Arguments: {α : Type u_1} {a : α} {o : Option α}
Goal: a ∈ ↑o ↔ a ∈ o
-- Part.coe_none
@[simp]
theorem coe_none : (@Option.none α : Part α) = none 
Arguments: {α : Type u_1}
Goal: ↑none = Part.none
-- Part.coe_some
@[simp]
theorem coe_some (a : α) : (Option.some a : Part α) = some a 
Arguments: {α : Type u_1} (a : α)
Goal: ↑(some a) = Part.some a
-- Part.induction_on
@[elab_as_elim]
protected theorem induction_on {P : Part α → Prop} (a : Part α) (hnone : P none)
    (hsome : ∀ a : α, P (some a)) : P a 
Arguments: {α : Type u_1} {P : Part α → Prop} (a : Part α) (hnone : P Part.none) (hsome : ∀ (a : α), P (Part.some a))
Goal: P a
-- Part.to_ofOption
@[simp]
theorem to_ofOption (o : Option α) : toOption (ofOption o) = o 
Arguments: {α : Type u_1} (o : Option α)
Goal: (↑o).toOption = o
-- Part.of_toOption
@[simp]
theorem of_toOption (o : Part α) [Decidable o.Dom] : ofOption (toOption o) = o 
Arguments: {α : Type u_1} (o : Part α) [Decidable o.Dom]
Goal: ↑o.toOption = o
-- Part.le_total_of_le_of_le
theorem le_total_of_le_of_le {x y : Part α} (z : Part α) (hx : x ≤ z) (hy : y ≤ z) :
    x ≤ y ∨ y ≤ x 
Arguments: {α : Type u_1} {x y : Part α} (z : Part α) (hx : x ≤ z) (hy : y ≤ z)
Goal: x ≤ y ∨ y ≤ x
-- Part.map_get
@[simps]
def map (f : α → β) (o : Part α) : Part β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (o : Part α)
Goal: ∀ (a : o.Dom), (Part.map f o).get a = (f ∘ o.get) a
-- Part.map_Dom
@[simps]
def map (f : α → β) (o : Part α) : Part β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (o : Part α)
Goal: (Part.map f o).Dom = o.Dom
-- Part.mem_map
theorem mem_map (f : α → β) {o : Part α} : ∀ {a}, a ∈ o → f a ∈ map f o
  
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) {o : Part α} {a : α}
Goal: a ∈ o → f a ∈ Part.map f o
-- Part.mem_map_iff
@[simp]
theorem mem_map_iff (f : α → β) {o : Part α} {b} : b ∈ map f o ↔ ∃ a ∈ o, f a = b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) {o : Part α} {b : β}
Goal: b ∈ Part.map f o ↔ ∃ a ∈ o, f a = b
-- Part.map_none
@[simp]
theorem map_none (f : α → β) : map f none = none 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Part.map f Part.none = Part.none
-- Part.map_some
@[simp]
theorem map_some (f : α → β) (a : α) : map f (some a) = some (f a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : α)
Goal: Part.map f (Part.some a) = Part.some (f a)
-- Part.mem_assert
theorem mem_assert {p : Prop} {f : p → Part α} : ∀ {a} (h : p), a ∈ f h → a ∈ assert p f
  
Arguments: {α : Type u_1} {p : Prop} {f : p → Part α} {a : α} (h : p)
Goal: a ∈ f h → a ∈ Part.assert p f
-- Part.mem_assert_iff
@[simp]
theorem mem_assert_iff {p : Prop} {f : p → Part α} {a} : a ∈ assert p f ↔ ∃ h : p, a ∈ f h 
Arguments: {α : Type u_1} {p : Prop} {f : p → Part α} {a : α}
Goal: a ∈ Part.assert p f ↔ ∃ (h : p), a ∈ f h
-- Part.assert_pos
theorem assert_pos {p : Prop} {f : p → Part α} (h : p) : assert p f = f h 
Arguments: {α : Type u_1} {p : Prop} {f : p → Part α} (h : p)
Goal: Part.assert p f = f h
-- Part.assert_neg
theorem assert_neg {p : Prop} {f : p → Part α} (h : ¬p) : assert p f = none 
Arguments: {α : Type u_1} {p : Prop} {f : p → Part α} (h : ¬p)
Goal: Part.assert p f = Part.none
-- Part.mem_bind
theorem mem_bind {f : Part α} {g : α → Part β} : ∀ {a b}, a ∈ f → b ∈ g a → b ∈ f.bind g
  
Arguments: {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {a : α} {b : β}
Goal: a ∈ f → b ∈ g a → b ∈ f.bind g
-- Part.mem_bind_iff
@[simp]
theorem mem_bind_iff {f : Part α} {g : α → Part β} {b} : b ∈ f.bind g ↔ ∃ a ∈ f, b ∈ g a 
Arguments: {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {b : β}
Goal: b ∈ f.bind g ↔ ∃ a ∈ f, b ∈ g a
-- Part.Dom.bind
protected theorem Dom.bind {o : Part α} (h : o.Dom) (f : α → Part β) : o.bind f = f (o.get h) 
Arguments: {α : Type u_1} {β : Type u_2} {o : Part α} (h : o.Dom) (f : α → Part β)
Goal: o.bind f = f (o.get h)
-- Part.Dom.of_bind
theorem Dom.of_bind {f : α → Part β} {a : Part α} (h : (a.bind f).Dom) : a.Dom 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → Part β} {a : Part α} (h : (a.bind f).Dom)
Goal: a.Dom
-- Part.bind_none
@[simp]
theorem bind_none (f : α → Part β) : none.bind f = none 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Part β)
Goal: Part.none.bind f = Part.none
-- Part.bind_some
@[simp]
theorem bind_some (a : α) (f : α → Part β) : (some a).bind f = f a 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (f : α → Part β)
Goal: (Part.some a).bind f = f a
-- Part.bind_of_mem
theorem bind_of_mem {o : Part α} {a : α} (h : a ∈ o) (f : α → Part β) : o.bind f = f a 
Arguments: {α : Type u_1} {β : Type u_2} {o : Part α} {a : α} (h : a ∈ o) (f : α → Part β)
Goal: o.bind f = f a
-- Part.bind_some_eq_map
theorem bind_some_eq_map (f : α → β) (x : Part α) : x.bind (some ∘ f) = map f x 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : Part α)
Goal: x.bind (Part.some ∘ f) = Part.map f x
-- Part.bind_toOption
theorem bind_toOption (f : α → Part β) (o : Part α) [Decidable o.Dom] [∀ a, Decidable (f a).Dom]
    [Decidable (o.bind f).Dom] :
    (o.bind f).toOption = o.toOption.elim Option.none fun a => (f a).toOption 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Part β) (o : Part α) [Decidable o.Dom] [(a : α) → Decidable (f a).Dom] [Decidable (o.bind f).Dom]
Goal: (o.bind f).toOption = o.toOption.elim none fun a => (f a).toOption
-- Part.bind_assoc
theorem bind_assoc {γ} (f : Part α) (g : α → Part β) (k : β → Part γ) :
    (f.bind g).bind k = f.bind fun x => (g x).bind k 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_4} (f : Part α) (g : α → Part β) (k : β → Part γ)
Goal: (f.bind g).bind k = f.bind fun x => (g x).bind k
-- Part.bind_map
@[simp]
theorem bind_map {γ} (f : α → β) (x) (g : β → Part γ) :
    (map f x).bind g = x.bind fun y => g (f y) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_4} (f : α → β) (x : Part α) (g : β → Part γ)
Goal: (Part.map f x).bind g = x.bind fun y => g (f y)
-- Part.map_bind
@[simp]
theorem map_bind {γ} (f : α → Part β) (x : Part α) (g : β → γ) :
    map g (x.bind f) = x.bind fun y => map g (f y) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_4} (f : α → Part β) (x : Part α) (g : β → γ)
Goal: Part.map g (x.bind f) = x.bind fun y => Part.map g (f y)
-- Part.map_map
theorem map_map (g : β → γ) (f : α → β) (o : Part α) : map g (map f o) = map (g ∘ f) o 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) (o : Part α)
Goal: Part.map g (Part.map f o) = Part.map (g ∘ f) o
-- Part.map_id'
theorem map_id' {f : α → α} (H : ∀ x : α, f x = x) (o) : map f o = o 
Arguments: {α : Type u_1} {f : α → α} (H : ∀ (x : α), f x = x) (o : Part α)
Goal: Part.map f o = o
-- Part.bind_some_right
@[simp]
theorem bind_some_right (x : Part α) : x.bind some = x 
Arguments: {α : Type u_1} (x : Part α)
Goal: x.bind Part.some = x
-- Part.pure_eq_some
@[simp]
theorem pure_eq_some (a : α) : pure a = some a 
Arguments: {α : Type u_1} (a : α)
Goal: pure a = Part.some a
-- Part.ret_eq_some
@[simp]
theorem ret_eq_some (a : α) : (return a : Part α) = some a 
Arguments: {α : Type u_1} (a : α)
Goal: pure a = Part.some a
-- Part.map_eq_map
@[simp]
theorem map_eq_map {α β} (f : α → β) (o : Part α) : f <$> o = map f o 
Arguments: {α β : Type u_4} (f : α → β) (o : Part α)
Goal: f <$> o = Part.map f o
-- Part.bind_eq_bind
@[simp]
theorem bind_eq_bind {α β} (f : Part α) (g : α → Part β) : f >>= g = f.bind g 
Arguments: {α β : Type u_4} (f : Part α) (g : α → Part β)
Goal: f >>= g = f.bind g
-- Part.bind_le
theorem bind_le {α} (x : Part α) (f : α → Part β) (y : Part β) :
    x >>= f ≤ y ↔ ∀ a, a ∈ x → f a ≤ y 
Arguments: {β α : Type u_2} (x : Part α) (f : α → Part β) (y : Part β)
Goal: x >>= f ≤ y ↔ ∀ a ∈ x, f a ≤ y
-- Part.mem_restrict
@[simp]
theorem mem_restrict (p : Prop) (o : Part α) (h : p → o.Dom) (a : α) :
    a ∈ restrict p o h ↔ p ∧ a ∈ o 
Arguments: {α : Type u_1} (p : Prop) (o : Part α) (h : p → o.Dom) (a : α)
Goal: a ∈ Part.restrict p o h ↔ p ∧ a ∈ o
-- Part.assert_defined
theorem assert_defined {p : Prop} {f : p → Part α} : ∀ h : p, (f h).Dom → (assert p f).Dom 
Arguments: {α : Type u_1} {p : Prop} {f : p → Part α} (h : p)
Goal: (f h).Dom → (Part.assert p f).Dom
-- Part.bind_defined
theorem bind_defined {f : Part α} {g : α → Part β} :
    ∀ h : f.Dom, (g (f.get h)).Dom → (f.bind g).Dom 
Arguments: {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} (h : f.Dom)
Goal: (g (f.get h)).Dom → (f.bind g).Dom
-- Part.bind_dom
@[simp]
theorem bind_dom {f : Part α} {g : α → Part β} : (f.bind g).Dom ↔ ∃ h : f.Dom, (g (f.get h)).Dom 
Arguments: {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β}
Goal: (f.bind g).Dom ↔ ∃ (h : f.Dom), (g (f.get h)).Dom
-- Part.mul_def
theorem mul_def [Mul α] (a b : Part α) : a * b = bind a fun y ↦ map (y * ·) b 
Arguments: {α : Type u_1} [Mul α] (a b : Part α)
Goal: a * b = do
  let y ← a
  Part.map (fun x => y * x) b
-- Part.one_def
theorem one_def [One α] : (1 : Part α) = some 1 
Arguments: {α : Type u_1} [One α]
Goal: 1 = Part.some 1
-- Part.inv_def
theorem inv_def [Inv α] (a : Part α) : a⁻¹ = Part.map (· ⁻¹) a 
Arguments: {α : Type u_1} [Inv α] (a : Part α)
Goal: a⁻¹ = Part.map (fun x => x⁻¹) a
-- Part.div_def
theorem div_def [Div α] (a b : Part α) : a / b = bind a fun y => map (y / ·) b 
Arguments: {α : Type u_1} [Div α] (a b : Part α)
Goal: a / b = do
  let y ← a
  Part.map (fun x => y / x) b
-- Part.mod_def
theorem mod_def [Mod α] (a b : Part α) : a % b = bind a fun y => map (y % ·) b 
Arguments: {α : Type u_1} [Mod α] (a b : Part α)
Goal: a % b = do
  let y ← a
  Part.map (fun x => y % x) b
-- Part.append_def
theorem append_def [Append α] (a b : Part α) : a ++ b = bind a fun y => map (y ++ ·) b 
Arguments: {α : Type u_1} [Append α] (a b : Part α)
Goal: a ++ b = do
  let y ← a
  Part.map (fun x => y ++ x) b
-- Part.inter_def
theorem inter_def [Inter α] (a b : Part α) : a ∩ b = bind a fun y => map (y ∩ ·) b 
Arguments: {α : Type u_1} [Inter α] (a b : Part α)
Goal: a ∩ b = do
  let y ← a
  Part.map (fun x => y ∩ x) b
-- Part.union_def
theorem union_def [Union α] (a b : Part α) : a ∪ b = bind a fun y => map (y ∪ ·) b 
Arguments: {α : Type u_1} [Union α] (a b : Part α)
Goal: a ∪ b = do
  let y ← a
  Part.map (fun x => y ∪ x) b
-- Part.sdiff_def
theorem sdiff_def [SDiff α] (a b : Part α) : a \ b = bind a fun y => map (y \ ·) b 
Arguments: {α : Type u_1} [SDiff α] (a b : Part α)
Goal: a \ b = do
  let y ← a
  Part.map (fun x => y \ x) b
-- Part.one_mem_one
@[to_additive]
theorem one_mem_one [One α] : (1 : α) ∈ (1 : Part α) 
Arguments: {α : Type u_1} [One α]
Goal: 1 ∈ 1
-- Part.zero_mem_zero
@[to_additive]
theorem one_mem_one [One α] : (1 : α) ∈ (1 : Part α) 
Arguments: {α : Type u_1} [Zero α]
Goal: 0 ∈ 0
-- Part.add_mem_add
@[to_additive]
theorem mul_mem_mul [Mul α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma * mb ∈ a * b 
Arguments: {α : Type u_1} [Add α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma + mb ∈ a + b
-- Part.mul_mem_mul
@[to_additive]
theorem mul_mem_mul [Mul α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma * mb ∈ a * b 
Arguments: {α : Type u_1} [Mul α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma * mb ∈ a * b
-- Part.left_dom_of_add_dom
@[to_additive]
theorem left_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : a.Dom 
Arguments: {α : Type u_1} [Add α] {a b : Part α} (hab : (a + b).Dom)
Goal: a.Dom
-- Part.left_dom_of_mul_dom
@[to_additive]
theorem left_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : a.Dom 
Arguments: {α : Type u_1} [Mul α] {a b : Part α} (hab : (a * b).Dom)
Goal: a.Dom
-- Part.right_dom_of_mul_dom
@[to_additive]
theorem right_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : b.Dom 
Arguments: {α : Type u_1} [Mul α] {a b : Part α} (hab : (a * b).Dom)
Goal: b.Dom
-- Part.right_dom_of_add_dom
@[to_additive]
theorem right_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : b.Dom 
Arguments: {α : Type u_1} [Add α] {a b : Part α} (hab : (a + b).Dom)
Goal: b.Dom
-- Part.add_get_eq
@[to_additive (attr := simp)]
theorem mul_get_eq [Mul α] (a b : Part α) (hab : Dom (a * b)) :
    (a * b).get hab = a.get (left_dom_of_mul_dom hab) * b.get (right_dom_of_mul_dom hab) 
Arguments: {α : Type u_1} [Add α] (a b : Part α) (hab : (a + b).Dom)
Goal: (a + b).get hab = a.get ⋯ + b.get ⋯
-- Part.mul_get_eq
@[to_additive (attr := simp)]
theorem mul_get_eq [Mul α] (a b : Part α) (hab : Dom (a * b)) :
    (a * b).get hab = a.get (left_dom_of_mul_dom hab) * b.get (right_dom_of_mul_dom hab) 
Arguments: {α : Type u_1} [Mul α] (a b : Part α) (hab : (a * b).Dom)
Goal: (a * b).get hab = a.get ⋯ * b.get ⋯
-- Part.some_add_some
@[to_additive]
theorem some_mul_some [Mul α] (a b : α) : some a * some b = some (a * b) 
Arguments: {α : Type u_1} [Add α] (a b : α)
Goal: Part.some a + Part.some b = Part.some (a + b)
-- Part.some_mul_some
@[to_additive]
theorem some_mul_some [Mul α] (a b : α) : some a * some b = some (a * b) 
Arguments: {α : Type u_1} [Mul α] (a b : α)
Goal: Part.some a * Part.some b = Part.some (a * b)
-- Part.neg_mem_neg
@[to_additive]
theorem inv_mem_inv [Inv α] (a : Part α) (ma : α) (ha : ma ∈ a) : ma⁻¹ ∈ a⁻¹ 
Arguments: {α : Type u_1} [Neg α] (a : Part α) (ma : α) (ha : ma ∈ a)
Goal: -ma ∈ -a
-- Part.inv_mem_inv
@[to_additive]
theorem inv_mem_inv [Inv α] (a : Part α) (ma : α) (ha : ma ∈ a) : ma⁻¹ ∈ a⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : Part α) (ma : α) (ha : ma ∈ a)
Goal: ma⁻¹ ∈ a⁻¹
-- Part.neg_some
@[to_additive]
theorem inv_some [Inv α] (a : α) : (some a)⁻¹ = some a⁻¹ 
Arguments: {α : Type u_1} [Neg α] (a : α)
Goal: -Part.some a = Part.some (-a)
-- Part.inv_some
@[to_additive]
theorem inv_some [Inv α] (a : α) : (some a)⁻¹ = some a⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : α)
Goal: (Part.some a)⁻¹ = Part.some a⁻¹
-- Part.div_mem_div
@[to_additive]
theorem div_mem_div [Div α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma / mb ∈ a / b 
Arguments: {α : Type u_1} [Div α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma / mb ∈ a / b
-- Part.sub_mem_sub
@[to_additive]
theorem div_mem_div [Div α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma / mb ∈ a / b 
Arguments: {α : Type u_1} [Sub α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma - mb ∈ a - b
-- Part.left_dom_of_sub_dom
@[to_additive]
theorem left_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : a.Dom 
Arguments: {α : Type u_1} [Sub α] {a b : Part α} (hab : (a - b).Dom)
Goal: a.Dom
-- Part.left_dom_of_div_dom
@[to_additive]
theorem left_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : a.Dom 
Arguments: {α : Type u_1} [Div α] {a b : Part α} (hab : (a / b).Dom)
Goal: a.Dom
-- Part.right_dom_of_div_dom
@[to_additive]
theorem right_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : b.Dom 
Arguments: {α : Type u_1} [Div α] {a b : Part α} (hab : (a / b).Dom)
Goal: b.Dom
-- Part.right_dom_of_sub_dom
@[to_additive]
theorem right_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : b.Dom 
Arguments: {α : Type u_1} [Sub α] {a b : Part α} (hab : (a - b).Dom)
Goal: b.Dom
-- Part.div_get_eq
@[to_additive (attr := simp)]
theorem div_get_eq [Div α] (a b : Part α) (hab : Dom (a / b)) :
    (a / b).get hab = a.get (left_dom_of_div_dom hab) / b.get (right_dom_of_div_dom hab) 
Arguments: {α : Type u_1} [Div α] (a b : Part α) (hab : (a / b).Dom)
Goal: (a / b).get hab = a.get ⋯ / b.get ⋯
-- Part.sub_get_eq
@[to_additive (attr := simp)]
theorem div_get_eq [Div α] (a b : Part α) (hab : Dom (a / b)) :
    (a / b).get hab = a.get (left_dom_of_div_dom hab) / b.get (right_dom_of_div_dom hab) 
Arguments: {α : Type u_1} [Sub α] (a b : Part α) (hab : (a - b).Dom)
Goal: (a - b).get hab = a.get ⋯ - b.get ⋯
-- Part.some_sub_some
@[to_additive]
theorem some_div_some [Div α] (a b : α) : some a / some b = some (a / b) 
Arguments: {α : Type u_1} [Sub α] (a b : α)
Goal: Part.some a - Part.some b = Part.some (a - b)
-- Part.some_div_some
@[to_additive]
theorem some_div_some [Div α] (a b : α) : some a / some b = some (a / b) 
Arguments: {α : Type u_1} [Div α] (a b : α)
Goal: Part.some a / Part.some b = Part.some (a / b)
-- Part.mod_mem_mod
theorem mod_mem_mod [Mod α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma % mb ∈ a % b 
Arguments: {α : Type u_1} [Mod α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma % mb ∈ a % b