ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Set/Pointwise/Iterate.lean

full_name: vadd_eq_self_of_preimage_zsmul_eq_self
code: /-- Let `n : ℤ` and `s` a subset of a commutative group `G` that is invariant under preimage for
the map `x ↦ x^n`. Then `s` is invariant under the pointwise action of the subgroup of elements
`g : G` such that `g^(n^j) = 1` for some `j : ℕ`. (This subgroup is called the Prüfer subgroup when
 `G` is the `Circle` and `n` is prime.) -/
@[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 
goal: g +ᵥ s = s

full_name: smul_eq_self_of_preimage_zpow_eq_self
code: /-- Let `n : ℤ` and `s` a subset of a commutative group `G` that is invariant under preimage for
the map `x ↦ x^n`. Then `s` is invariant under the pointwise action of the subgroup of elements
`g : G` such that `g^(n^j) = 1` for some `j : ℕ`. (This subgroup is called the Prüfer subgroup when
 `G` is the `Circle` and `n` is prime.) -/
@[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 
goal: g • s = s
File: Mathlib/Data/Set/Equitable.lean

full_name: Set.EquitableOn
code: /-- A set is equitable if no element value is more than one bigger than another. -/
def EquitableOn [LE β] [Add β] [One β] (s : Set α) (f : α → β) : Prop 
goal: Prop

full_name: Set.equitableOn_empty
code: @[simp]
theorem equitableOn_empty [LE β] [Add β] [One β] (f : α → β) : EquitableOn ∅ f 
goal: ∅.EquitableOn f

full_name: Set.equitableOn_iff_exists_le_le_add_one
code: theorem equitableOn_iff_exists_le_le_add_one {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, b ≤ f a ∧ f a ≤ b + 1 
goal: s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, b ≤ f a ∧ f a ≤ b + 1

full_name: Set.equitableOn_iff_exists_image_subset_icc
code: theorem equitableOn_iff_exists_image_subset_icc {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, f '' s ⊆ Icc b (b + 1) 
goal: s.EquitableOn f ↔ ∃ b, f '' s ⊆ Set.Icc b (b + 1)

full_name: Set.equitableOn_iff_exists_eq_eq_add_one
code: theorem equitableOn_iff_exists_eq_eq_add_one {s : Set α} {f : α → ℕ} :
    s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, f a = b ∨ f a = b + 1 
goal: s.EquitableOn f ↔ ∃ b, ∀ a ∈ s, f a = b ∨ f a = b + 1

full_name: Set.not_equitableOn
code: @[simp]
lemma not_equitableOn : ¬s.EquitableOn f ↔ ∃ a ∈ s, ∃ b ∈ s, f b + 1 < f a 
goal: ¬s.EquitableOn f ↔ ∃ a ∈ s, ∃ b ∈ s, f b + 1 < f a

full_name: Set.Subsingleton.equitableOn
code: theorem Subsingleton.equitableOn {s : Set α} (hs : s.Subsingleton) (f : α → β) : s.EquitableOn f 
goal: s.EquitableOn f

full_name: Set.equitableOn_singleton
code: theorem equitableOn_singleton (a : α) (f : α → β) : Set.EquitableOn {a} f 
goal: {a}.EquitableOn f

full_name: Finset.equitableOn_iff_le_le_add_one
code: 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 
goal: (↑s).EquitableOn f ↔ ∀ a ∈ s, (∑ i ∈ s, f i) / s.card ≤ f a ∧ f a ≤ (∑ i ∈ s, f i) / s.card + 1

full_name: Finset.EquitableOn.le
code: theorem EquitableOn.le (h : EquitableOn (s : Set α) f) (ha : a ∈ s) :
    (∑ i ∈ s, f i) / s.card ≤ f a 
goal: (∑ i ∈ s, f i) / s.card ≤ f a

full_name: Finset.EquitableOn.le_add_one
code: theorem EquitableOn.le_add_one (h : EquitableOn (s : Set α) f) (ha : a ∈ s) :
    f a ≤ (∑ i ∈ s, f i) / s.card + 1 
goal: f a ≤ (∑ i ∈ s, f i) / s.card + 1

full_name: Finset.equitableOn_iff
code: 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 
goal: (↑s).EquitableOn f ↔ ∀ a ∈ s, f a = (∑ i ∈ s, f i) / s.card ∨ f a = (∑ i ∈ s, f i) / s.card + 1
File: Mathlib/Data/Set/Pointwise/ListOfFn.lean

full_name: Set.mem_prod_list_ofFn
code: @[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a 
goal: a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

full_name: Set.mem_sum_list_ofFn
code: @[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a 
goal: a ∈ (List.ofFn s).sum ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a

full_name: Set.mem_list_prod
code: @[to_additive]
theorem mem_list_prod {l : List (Set α)} {a : α} :
    a ∈ l.prod ↔
      ∃ l' : List (Σs : Set α, ↥s),
        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l 
goal: a ∈ l.prod ↔ ∃ l', (List.map (fun x => ↑x.snd) l').prod = a ∧ List.map Sigma.fst l' = l

full_name: Set.mem_list_sum
code: @[to_additive]
theorem mem_list_prod {l : List (Set α)} {a : α} :
    a ∈ l.prod ↔
      ∃ l' : List (Σs : Set α, ↥s),
        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l 
goal: a ∈ l.sum ↔ ∃ l', (List.map (fun x => ↑x.snd) l').sum = a ∧ List.map Sigma.fst l' = l

full_name: Set.mem_pow
code: @[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a 
goal: a ∈ s ^ n ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

full_name: Set.mem_nsmul
code: @[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a 
goal: a ∈ n • s ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a
File: Mathlib/Data/Set/Notation.lean

full_name: Set.Notation.«_aux_Mathlib_Data_Set_Notation___macroRules_Set_Notation_term_↓∩__1»
code: /--
Given two sets `A` and `B`, `A ↓∩ B` denotes the intersection of `A` and `B` as a set in `Set A`.

The notation is short for `((↑) ⁻¹' B : Set A)`, while giving hints to the elaborator
that both `A` and `B` are terms of `Set α` for the same `α`.
This set is the same as `{x : ↑A | ↑x ∈ B}`.
-/
scoped notation3 A:67 " ↓∩ " B:67 => (Subtype.val ⁻¹' (B : type_of% A) : Set (A : Set _))
goal: Lean.Macro

full_name: Set.Notation.instCoeHeadElem
code: /-- Coercion using `(Subtype.val '' ·)` -/
instance {α : Type*} {s : Set α} : CoeHead (Set s) (Set α) 
goal: CoeHead (Set ↑s) (Set α)

full_name: Set.Notation.delab_set_image_subtype
code: /--
If the `Set.Notation` namespace is open, sets of a subtype coerced to the ambient type are
represented with `↑`.
-/
@[scoped delab app.Set.image]
def delab_set_image_subtype : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab
File: Mathlib/Data/Set/Opposite.lean

full_name: Set.op
code: /-- The opposite of a set `s` is the set obtained by taking the opposite of each member of `s`. -/
protected def op (s : Set α) : Set αᵒᵖ 
goal: Set αᵒᵖ

full_name: Set.unop
code: /-- The unop of a set `s` is the set obtained by taking the unop of each member of `s`. -/
protected def unop (s : Set αᵒᵖ) : Set α 
goal: Set α

full_name: Set.mem_op
code: @[simp]
theorem mem_op {s : Set α} {a : αᵒᵖ} : a ∈ s.op ↔ unop a ∈ s 
goal: a ∈ s.op ↔ Opposite.unop a ∈ s

full_name: Set.op_mem_op
code: @[simp 1100]
theorem op_mem_op {s : Set α} {a : α} : op a ∈ s.op ↔ a ∈ s 
goal: Opposite.op a ∈ s.op ↔ a ∈ s

full_name: Set.mem_unop
code: @[simp]
theorem mem_unop {s : Set αᵒᵖ} {a : α} : a ∈ s.unop ↔ op a ∈ s 
goal: a ∈ s.unop ↔ Opposite.op a ∈ s

full_name: Set.unop_mem_unop
code: @[simp 1100]
theorem unop_mem_unop {s : Set αᵒᵖ} {a : αᵒᵖ} : unop a ∈ s.unop ↔ a ∈ s 
goal: Opposite.unop a ∈ s.unop ↔ a ∈ s

full_name: Set.op_unop
code: @[simp]
theorem op_unop (s : Set α) : s.op.unop = s 
goal: s.op.unop = s

full_name: Set.unop_op
code: @[simp]
theorem unop_op (s : Set αᵒᵖ) : s.unop.op = s 
goal: s.unop.op = s

full_name: Set.opEquiv_self_apply_coe
code: /-- The members of the opposite of a set are in bijection with the members of the set itself. -/
@[simps]
def opEquiv_self (s : Set α) : s.op ≃ s 
goal: ↑(s.opEquiv_self x) = Opposite.unop ↑x

full_name: Set.opEquiv_self
code: /-- The members of the opposite of a set are in bijection with the members of the set itself. -/
@[simps]
def opEquiv_self (s : Set α) : s.op ≃ s 
goal: ↑s.op ≃ ↑s

full_name: Set.opEquiv_self_symm_apply_coe
code: /-- The members of the opposite of a set are in bijection with the members of the set itself. -/
@[simps]
def opEquiv_self (s : Set α) : s.op ≃ s 
goal: ↑(s.opEquiv_self.symm x) = Opposite.op ↑x

full_name: Set.opEquiv
code: /-- Taking opposites as an equivalence of powersets. -/
@[simps]
def opEquiv : Set α ≃ Set αᵒᵖ 
goal: Set α ≃ Set αᵒᵖ

full_name: Set.opEquiv_symm_apply
code: /-- Taking opposites as an equivalence of powersets. -/
@[simps]
def opEquiv : Set α ≃ Set αᵒᵖ 
goal: Set.opEquiv.symm s = s.unop

full_name: Set.opEquiv_apply
code: /-- Taking opposites as an equivalence of powersets. -/
@[simps]
def opEquiv : Set α ≃ Set αᵒᵖ 
goal: Set.opEquiv s = s.op

full_name: Set.singleton_op
code: @[simp]
theorem singleton_op (x : α) : ({x} : Set α).op = {op x} 
goal: {x}.op = {Opposite.op x}

full_name: Set.singleton_unop
code: @[simp]
theorem singleton_unop (x : αᵒᵖ) : ({x} : Set αᵒᵖ).unop = {unop x} 
goal: {x}.unop = {Opposite.unop x}

full_name: Set.singleton_op_unop
code: @[simp 1100]
theorem singleton_op_unop (x : α) : ({op x} : Set αᵒᵖ).unop = {x} 
goal: {Opposite.op x}.unop = {x}

full_name: Set.singleton_unop_op
code: @[simp 1100]
theorem singleton_unop_op (x : αᵒᵖ) : ({unop x} : Set α).op = {x} 
goal: {Opposite.unop x}.op = {x}
File: Mathlib/Data/Set/List.lean

full_name: Set.range_list_map
code: theorem range_list_map (f : α → β) : range (map f) = { l | ∀ x ∈ l, x ∈ range f } 
goal: Set.range (List.map f) = {l | ∀ x ∈ l, x ∈ Set.range f}

full_name: Set.range_list_map_coe
code: theorem range_list_map_coe (s : Set α) : range (map ((↑) : s → α)) = { l | ∀ x ∈ l, x ∈ s } 
goal: Set.range (List.map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}

full_name: Set.range_list_get
code: @[simp]
theorem range_list_get : range l.get = { x | x ∈ l } 
goal: Set.range l.get = {x | x ∈ l}

full_name: Set.range_list_get?
code: theorem range_list_get? : range l.get? = insert none (some '' { x | x ∈ l }) 
goal: Set.range l.get? = insert none (some '' {x | x ∈ l})

full_name: Set.range_list_getD
code: @[simp]
theorem range_list_getD (d : α) : (range fun n : Nat => l[n]?.getD d) = insert d { x | x ∈ l } 
goal: (Set.range fun n => l[n]?.getD d) = insert d {x | x ∈ l}

full_name: Set.range_list_getI
code: @[simp]
theorem range_list_getI [Inhabited α] (l : List α) :
    range l.getI = insert default { x | x ∈ l } 
goal: Set.range l.getI = insert default {x | x ∈ l}

full_name: List.canLift
code: /-- If each element of a list can be lifted to some type, then the whole list can be
lifted to this type. -/
instance List.canLift (c) (p) [CanLift α β c p] :
    CanLift (List α) (List β) (List.map c) fun l => ∀ x ∈ l, p x 
goal: CanLift (List α) (List β) (List.map c) fun l => ∀ x ∈ l, p x
File: Mathlib/Data/Set/Enumerate.lean

full_name: Set.enumerate
code: /-- Given a choice function `sel`, enumerates the elements of a set in the order
`a 0 = sel s`, `a 1 = sel (s \ {a 0})`, `a 2 = sel (s \ {a 0, a 1})`, ... and stops when
`sel (s \ {a 0, ..., a n}) = none`. Note that we don't require `sel` to be a choice function. -/
def enumerate : Set α → ℕ → Option α
  
goal: Set α → ℕ → Option α

full_name: Set.enumerate_eq_none_of_sel
code: theorem enumerate_eq_none_of_sel {s : Set α} (h : sel s = none) : ∀ {n}, enumerate sel s n = none
  
goal: Set.enumerate sel s n = none

full_name: Set.enumerate_eq_none
code: theorem enumerate_eq_none :
    ∀ {s n₁ n₂}, enumerate sel s n₁ = none → n₁ ≤ n₂ → enumerate sel s n₂ = none
  
goal: Set.enumerate sel s n₁ = none → n₁ ≤ n₂ → Set.enumerate sel s n₂ = none

full_name: Set.enumerate_mem
code: theorem enumerate_mem (h_sel : ∀ s a, sel s = some a → a ∈ s) :
    ∀ {s n a}, enumerate sel s n = some a → a ∈ s
  
goal: Set.enumerate sel s n = some a → a ∈ s

full_name: Set.enumerate_inj
code: theorem enumerate_inj {n₁ n₂ : ℕ} {a : α} {s : Set α} (h_sel : ∀ s a, sel s = some a → a ∈ s)
    (h₁ : enumerate sel s n₁ = some a) (h₂ : enumerate sel s n₂ = some a) : n₁ = n₂ 
goal: n₁ = n₂
File: Mathlib/Data/Set/BoolIndicator.lean

full_name: Set.boolIndicator
code: /-- `boolIndicator` maps `x` to `true` if `x ∈ s`, else to `false` -/
noncomputable def boolIndicator (x : α) 
goal: Bool

full_name: Set.mem_iff_boolIndicator
code: theorem mem_iff_boolIndicator (x : α) : x ∈ s ↔ s.boolIndicator x = true 
goal: x ∈ s ↔ s.boolIndicator x = true

full_name: Set.not_mem_iff_boolIndicator
code: theorem not_mem_iff_boolIndicator (x : α) : x ∉ s ↔ s.boolIndicator x = false 
goal: x ∉ s ↔ s.boolIndicator x = false

full_name: Set.preimage_boolIndicator_true
code: theorem preimage_boolIndicator_true : s.boolIndicator ⁻¹' {true} = s 
goal: s.boolIndicator ⁻¹' {true} = s

full_name: Set.preimage_boolIndicator_false
code: theorem preimage_boolIndicator_false : s.boolIndicator ⁻¹' {false} = sᶜ 
goal: s.boolIndicator ⁻¹' {false} = sᶜ

full_name: Set.preimage_boolIndicator_eq_union
code: theorem preimage_boolIndicator_eq_union (t : Set Bool) :
    s.boolIndicator ⁻¹' t = (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅ 
goal: s.boolIndicator ⁻¹' t = (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅

full_name: Set.preimage_boolIndicator
code: theorem preimage_boolIndicator (t : Set Bool) :
    s.boolIndicator ⁻¹' t = univ ∨
      s.boolIndicator ⁻¹' t = s ∨ s.boolIndicator ⁻¹' t = sᶜ ∨ s.boolIndicator ⁻¹' t = ∅ 
goal: s.boolIndicator ⁻¹' t = Set.univ ∨ s.boolIndicator ⁻¹' t = s ∨ s.boolIndicator ⁻¹' t = sᶜ ∨ s.boolIndicator ⁻¹' t = ∅
File: Mathlib/Data/Tree/Basic.lean

full_name: Tree.nil
code: /-- A binary tree with values stored in non-leaf nodes. -/
inductive Tree.{u} (α : Type u) : Type u
  | nil : Tree α
  | node : α → Tree α → Tree α → Tree α
  deriving DecidableEq, Repr
goal: Tree α

full_name: instReprTree
code: /-- A binary tree with values stored in non-leaf nodes. -/
inductive Tree.{u} (α : Type u) : Type u
  | nil : Tree α
  | node : α → Tree α → Tree α → Tree α
  deriving DecidableEq, Repr
goal: {α : Type u_1} → [inst : Repr α] → Repr (Tree α)

full_name: Tree.node
code: /-- A binary tree with values stored in non-leaf nodes. -/
inductive Tree.{u} (α : Type u) : Type u
  | nil : Tree α
  | node : α → Tree α → Tree α → Tree α
  deriving DecidableEq, Repr
goal: α → Tree α → Tree α → Tree α

full_name: Tree.instInhabited
code: instance : Inhabited (Tree α) 
goal: Inhabited (Tree α)

full_name: Tree.ofRBNode
code: /-- Makes a `Tree α` out of a red-black tree. -/
def ofRBNode : RBNode α → Tree α
  
goal: Batteries.RBNode α → Tree α

full_name: Tree.map
code: /-- Apply a function to each value in the tree.  This is the `map` function for the `Tree` functor.
-/
def map {β} (f : α → β) : Tree α → Tree β
  
goal: Tree α → Tree β

full_name: Tree.numNodes
code: /-- The number of internal nodes (i.e. not including leaves) of a binary tree -/
@[simp]
def numNodes : Tree α → ℕ
  
goal: Tree α → ℕ

full_name: Tree.numLeaves
code: /-- The number of leaves of a binary tree -/
@[simp]
def numLeaves : Tree α → ℕ
  
goal: Tree α → ℕ

full_name: Tree.height
code: /-- The height - length of the longest path from the root - of a binary tree -/
@[simp]
def height : Tree α → ℕ
  
goal: Tree α → ℕ

full_name: Tree.numLeaves_eq_numNodes_succ
code: theorem numLeaves_eq_numNodes_succ (x : Tree α) : x.numLeaves = x.numNodes + 1 
goal: x.numLeaves = x.numNodes + 1

full_name: Tree.numLeaves_pos
code: theorem numLeaves_pos (x : Tree α) : 0 < x.numLeaves 
goal: 0 < x.numLeaves

full_name: Tree.height_le_numNodes
code: theorem height_le_numNodes : ∀ x : Tree α, x.height ≤ x.numNodes
  
goal: x.height ≤ x.numNodes

full_name: Tree.left
code: /-- The left child of the tree, or `nil` if the tree is `nil` -/
@[simp]
def left : Tree α → Tree α
  
goal: Tree α → Tree α

full_name: Tree.right
code: /-- The right child of the tree, or `nil` if the tree is `nil` -/
@[simp]
def right : Tree α → Tree α
  
goal: Tree α → Tree α

full_name: Tree.«_aux_Mathlib_Data_Tree_Basic___macroRules_Tree_term_△__1»
code: /-- A node with `Unit` data -/
scoped infixr:65 " △ " => Tree.node ()
goal: Lean.Macro

full_name: Tree.unitRecOn
code: @[elab_as_elim]
def unitRecOn {motive : Tree Unit → Sort*} (t : Tree Unit) (base : motive nil)
    (ind : ∀ x y, motive x → motive y → motive (x △ y)) : motive t 
goal: motive t

full_name: Tree.left_node_right_eq_self
code: theorem left_node_right_eq_self : ∀ {x : Tree Unit} (_hx : x ≠ nil), x.left △ x.right = x
  
goal: Tree.node () x.left x.right = x
File: Mathlib/Data/Set/Accumulate.lean

full_name: Set.Accumulate
code: /-- `Accumulate s` is the union of `s y` for `y ≤ x`. -/
def Accumulate [LE α] (s : α → Set β) (x : α) : Set β 
goal: Set β

full_name: Set.accumulate_def
code: theorem accumulate_def [LE α] {x : α} : Accumulate s x = ⋃ y ≤ x, s y 
goal: Set.Accumulate s x = ⋃ y, ⋃ (_ : y ≤ x), s y

full_name: Set.mem_accumulate
code: @[simp]
theorem mem_accumulate [LE α] {x : α} {z : β} : z ∈ Accumulate s x ↔ ∃ y ≤ x, z ∈ s y 
goal: z ∈ Set.Accumulate s x ↔ ∃ y ≤ x, z ∈ s y

full_name: Set.subset_accumulate
code: theorem subset_accumulate [Preorder α] {x : α} : s x ⊆ Accumulate s x 
goal: s x ⊆ Set.Accumulate s x

full_name: Set.accumulate_subset_iUnion
code: theorem accumulate_subset_iUnion [Preorder α] (x : α) : Accumulate s x ⊆ ⋃ i, s i 
goal: Set.Accumulate s x ⊆ ⋃ i, s i

full_name: Set.monotone_accumulate
code: theorem monotone_accumulate [Preorder α] : Monotone (Accumulate s) 
goal: Monotone (Set.Accumulate s)

full_name: Set.accumulate_subset_accumulate
code: @[gcongr]
theorem accumulate_subset_accumulate [Preorder α] {x y} (h : x ≤ y) :
    Accumulate s x ⊆ Accumulate s y 
goal: Set.Accumulate s x ⊆ Set.Accumulate s y

full_name: Set.biUnion_accumulate
code: theorem biUnion_accumulate [Preorder α] (x : α) : ⋃ y ≤ x, Accumulate s y = ⋃ y ≤ x, s y 
goal: ⋃ y, ⋃ (_ : y ≤ x), Set.Accumulate s y = ⋃ y, ⋃ (_ : y ≤ x), s y

full_name: Set.iUnion_accumulate
code: theorem iUnion_accumulate [Preorder α] : ⋃ x, Accumulate s x = ⋃ x, s x 
goal: ⋃ x, Set.Accumulate s x = ⋃ x, s x
File: Mathlib/Data/Tree/Get.lean

full_name: Tree.indexOf
code: /-- Finds the index of an element in the tree assuming the tree has been
constructed according to the provided decidable order on its elements.
If it hasn't, the result will be incorrect. If it has, but the element
is not in the tree, returns none. -/
def indexOf (lt : α → α → Prop) [DecidableRel lt] (x : α) : Tree α → Option PosNum
  
goal: Tree α → Option PosNum

full_name: Tree.get
code: /-- Retrieves an element uniquely determined by a `PosNum` from the tree,
taking the following path to get to the element:
- `bit0` - go to left child
- `bit1` - go to right child
- `PosNum.one` - retrieve from here -/
def get : PosNum → Tree α → Option α
  
goal: PosNum → Tree α → Option α

full_name: Tree.getOrElse
code: /-- Retrieves an element from the tree, or the provided default value
if the index is invalid. See `Tree.get`. -/
def getOrElse (n : PosNum) (t : Tree α) (v : α) : α 
goal: α
File: Mathlib/Data/Set/MemPartition.lean

full_name: memPartition
code: /-- `memPartition f n` is the partition containing at most `2^(n+1)` sets, where each set contains
the points that for all `i` belong to one of `f i` or its complement. -/
def memPartition (f : ℕ → Set α) : ℕ → Set (Set α)
  
goal: ℕ → Set (Set α)

full_name: memPartition_zero
code: @[simp]
lemma memPartition_zero (f : ℕ → Set α) : memPartition f 0 = {univ} 
goal: memPartition f 0 = {Set.univ}

full_name: memPartition_succ
code: lemma memPartition_succ (f : ℕ → Set α) (n : ℕ) :
    memPartition f (n + 1) = {s | ∃ u ∈ memPartition f n, s = u ∩ f n ∨ s = u \ f n} 
goal: memPartition f (n + 1) = {s | ∃ u ∈ memPartition f n, s = u ∩ f n ∨ s = u \ f n}

full_name: disjoint_memPartition
code: lemma disjoint_memPartition (f : ℕ → Set α) (n : ℕ) {u v : Set α}
    (hu : u ∈ memPartition f n) (hv : v ∈ memPartition f n) (huv : u ≠ v) :
    Disjoint u v 
goal: Disjoint u v

full_name: sUnion_memPartition
code: @[simp]
lemma sUnion_memPartition (f : ℕ → Set α) (n : ℕ) : ⋃₀ memPartition f n = univ 
goal: ⋃₀ memPartition f n = Set.univ

full_name: finite_memPartition
code: lemma finite_memPartition (f : ℕ → Set α) (n : ℕ) : Set.Finite (memPartition f n) 
goal: (memPartition f n).Finite

full_name: instFinite_memPartition
code: instance instFinite_memPartition (f : ℕ → Set α) (n : ℕ) : Finite (memPartition f n) 
goal: Finite ↑(memPartition f n)

full_name: instFintype_memPartition
code: noncomputable
instance instFintype_memPartition (f : ℕ → Set α) (n : ℕ) : Fintype (memPartition f n) 
goal: Fintype ↑(memPartition f n)

full_name: memPartitionSet
code: /-- The set in `memPartition f n` to which `a : α` belongs. -/
def memPartitionSet (f : ℕ → Set α) : ℕ → α → Set α
  
goal: ℕ → α → Set α

full_name: memPartitionSet_zero
code: @[simp]
lemma memPartitionSet_zero (f : ℕ → Set α) (a : α) : memPartitionSet f 0 a = univ 
goal: memPartitionSet f 0 a = Set.univ

full_name: memPartitionSet_succ
code: lemma memPartitionSet_succ (f : ℕ → Set α) (n : ℕ) (a : α) [Decidable (a ∈ f n)] :
    memPartitionSet f (n + 1) a
      = if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n 
goal: memPartitionSet f (n + 1) a = if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n

full_name: memPartitionSet_mem
code: lemma memPartitionSet_mem (f : ℕ → Set α) (n : ℕ) (a : α) :
    memPartitionSet f n a ∈ memPartition f n 
goal: memPartitionSet f n a ∈ memPartition f n

full_name: mem_memPartitionSet
code: lemma mem_memPartitionSet (f : ℕ → Set α) (n : ℕ) (a : α) : a ∈ memPartitionSet f n a 
goal: a ∈ memPartitionSet f n a

full_name: memPartitionSet_eq_iff
code: lemma memPartitionSet_eq_iff {f : ℕ → Set α} {n : ℕ} (a : α) {s : Set α}
    (hs : s ∈ memPartition f n) :
    memPartitionSet f n a = s ↔ a ∈ s 
goal: memPartitionSet f n a = s ↔ a ∈ s

full_name: memPartitionSet_of_mem
code: lemma memPartitionSet_of_mem {f : ℕ → Set α} {n : ℕ} {a : α} {s : Set α}
    (hs : s ∈ memPartition f n) (ha : a ∈ s) :
    memPartitionSet f n a = s 
goal: memPartitionSet f n a = s