ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib.Vector.not_mem_nil
theorem not_mem_nil : a ∉ (Vector.nil : Vector α 0).toList 
Arguments: {α : Type u_1} (a : α)
Goal: a ∉ Mathlib.Vector.nil.toList
-- Mathlib.Vector.not_mem_zero
theorem not_mem_zero (v : Vector α 0) : a ∉ v.toList 
Arguments: {α : Type u_1} (a : α) (v : Mathlib.Vector α 0)
Goal: a ∉ v.toList
-- Mathlib.Vector.mem_cons_iff
theorem mem_cons_iff (v : Vector α n) : a' ∈ (a ::ᵥ v).toList ↔ a' = a ∨ a' ∈ v.toList 
Arguments: {α : Type u_1} {n : ℕ} (a a' : α) (v : Mathlib.Vector α n)
Goal: a' ∈ (a ::ᵥ v).toList ↔ a' = a ∨ a' ∈ v.toList
-- Mathlib.Vector.mem_succ_iff
theorem mem_succ_iff (v : Vector α (n + 1)) : a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Mathlib.Vector α (n + 1))
Goal: a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
-- Mathlib.Vector.mem_cons_self
theorem mem_cons_self (v : Vector α n) : a ∈ (a ::ᵥ v).toList 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Mathlib.Vector α n)
Goal: a ∈ (a ::ᵥ v).toList
-- Mathlib.Vector.head_mem
@[simp]
theorem head_mem (v : Vector α (n + 1)) : v.head ∈ v.toList 
Arguments: {α : Type u_1} {n : ℕ} (v : Mathlib.Vector α (n + 1))
Goal: v.head ∈ v.toList
-- Mathlib.Vector.mem_cons_of_mem
theorem mem_cons_of_mem (v : Vector α n) (ha' : a' ∈ v.toList) : a' ∈ (a ::ᵥ v).toList 
Arguments: {α : Type u_1} {n : ℕ} (a a' : α) (v : Mathlib.Vector α n) (ha' : a' ∈ v.toList)
Goal: a' ∈ (a ::ᵥ v).toList
-- Mathlib.Vector.mem_of_mem_tail
theorem mem_of_mem_tail (v : Vector α n) (ha : a ∈ v.tail.toList) : a ∈ v.toList 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Mathlib.Vector α n) (ha : a ∈ v.tail.toList)
Goal: a ∈ v.toList
-- Mathlib.Vector.mem_map_iff
theorem mem_map_iff (b : β) (v : Vector α n) (f : α → β) :
    b ∈ (v.map f).toList ↔ ∃ a : α, a ∈ v.toList ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (b : β) (v : Mathlib.Vector α n) (f : α → β)
Goal: b ∈ (Mathlib.Vector.map f v).toList ↔ ∃ a ∈ v.toList, f a = b
-- Mathlib.Vector.not_mem_map_zero
theorem not_mem_map_zero (b : β) (v : Vector α 0) (f : α → β) : b ∉ (v.map f).toList 
Arguments: {α : Type u_1} {β : Type u_2} (b : β) (v : Mathlib.Vector α 0) (f : α → β)
Goal: b ∉ (Mathlib.Vector.map f v).toList
-- Mathlib.Vector.mem_map_succ_iff
theorem mem_map_succ_iff (b : β) (v : Vector α (n + 1)) (f : α → β) :
    b ∈ (v.map f).toList ↔ f v.head = b ∨ ∃ a : α, a ∈ v.tail.toList ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {n : ℕ} (b : β) (v : Mathlib.Vector α (n + 1)) (f : α → β)
Goal: b ∈ (Mathlib.Vector.map f v).toList ↔ f v.head = b ∨ ∃ a ∈ v.tail.toList, f a = b
-- Mathlib.Vector.snoc_cons
@[simp]
theorem snoc_cons : (x ::ᵥ xs).snoc y = x ::ᵥ (xs.snoc y) 
Arguments: {α : Type u_1} {n : ℕ} (xs : Mathlib.Vector α n) {x y : α}
Goal: (x ::ᵥ xs).snoc y = x ::ᵥ xs.snoc y
-- Mathlib.Vector.snoc_nil
@[simp]
theorem snoc_nil : (nil.snoc x) = x ::ᵥ nil 
Goal: ∀ {α : Type u_1} {x : α}, Mathlib.Vector.nil.snoc x = x ::ᵥ Mathlib.Vector.nil
-- Mathlib.Vector.reverse_cons
@[simp]
theorem reverse_cons : reverse (x ::ᵥ xs) = (reverse xs).snoc x 
Arguments: {α : Type u_1} {n : ℕ} (xs : Mathlib.Vector α n) {x : α}
Goal: (x ::ᵥ xs).reverse = xs.reverse.snoc x
-- Mathlib.Vector.reverse_snoc
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) 
Arguments: {α : Type u_1} {n : ℕ} (xs : Mathlib.Vector α n) {x : α}
Goal: (xs.snoc x).reverse = x ::ᵥ xs.reverse
-- Mathlib.Vector.replicate_succ_to_snoc
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val 
Arguments: {α : Type u_1} {n : ℕ} (val : α)
Goal: Mathlib.Vector.replicate (n + 1) val = (Mathlib.Vector.replicate n val).snoc val
-- Mathlib.Vector.map_snoc
@[simp]
theorem map_snoc : map f (xs.snoc x) = (map f xs).snoc (f x) 
Arguments: {α : Type u_2} {n : ℕ} (xs : Mathlib.Vector α n)
Goal: ∀ {α_1 : Type u_1} {f : α → α_1} {x : α}, Mathlib.Vector.map f (xs.snoc x) = (Mathlib.Vector.map f xs).snoc (f x)
-- Mathlib.Vector.mapAccumr_nil
@[simp]
theorem mapAccumr_nil : mapAccumr f Vector.nil s = (s, Vector.nil) 
Goal: ∀ {α : Type u_1} {α_1 : Type} {β : Type u_2} {f : α → α_1 → α_1 × β} {s : α_1},
  Mathlib.Vector.mapAccumr f Mathlib.Vector.nil s = (s, Mathlib.Vector.nil)
-- Mathlib.Vector.mapAccumr_snoc
@[simp]
theorem mapAccumr_snoc :
    mapAccumr f (xs.snoc x) s
    = let q := f x s
      let r := mapAccumr f xs q.1
      (r.1, r.2.snoc q.2) 
Arguments: {α : Type u_2} {n : ℕ} (xs : Mathlib.Vector α n)
Goal: ∀ {α_1 : Type} {β : Type u_1} {f : α → α_1 → α_1 × β} {x : α} {s : α_1},
  Mathlib.Vector.mapAccumr f (xs.snoc x) s =
    let q := f x s;
    let r := Mathlib.Vector.mapAccumr f xs q.1;
    (r.1, r.2.snoc q.2)
-- Mathlib.Vector.map₂_snoc
@[simp]
theorem map₂_snoc : map₂ f (xs.snoc x) (ys.snoc y) = (map₂ f xs ys).snoc (f x y) 
Arguments: {α : Type u_2} {n : ℕ} {β : Type u_3} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n)
Goal: ∀ {α_1 : Type u_1} {f : α → β → α_1} {x : α} {y : β},
  Mathlib.Vector.map₂ f (xs.snoc x) (ys.snoc y) = (Mathlib.Vector.map₂ f xs ys).snoc (f x y)
-- Mathlib.Vector.mapAccumr₂_nil
@[simp]
theorem mapAccumr₂_nil : mapAccumr₂ f Vector.nil Vector.nil s = (s, Vector.nil) 
Goal: ∀ {α β α_1 β_1 : Type} {f : α → β → α_1 → α_1 × β_1} {s : α_1},
  Mathlib.Vector.mapAccumr₂ f Mathlib.Vector.nil Mathlib.Vector.nil s = (s, Mathlib.Vector.nil)
-- Mathlib.Vector.mapAccumr₂_snoc
@[simp]
theorem mapAccumr₂_snoc (f : α → β → σ → σ × φ) (x : α) (y : β) :
    mapAccumr₂ f (xs.snoc x) (ys.snoc y) c
    = let q := f x y c
      let r := mapAccumr₂ f xs ys q.1
      (r.1, r.2.snoc q.2) 
Arguments: {α : Type} {n : ℕ} {β : Type} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {σ φ : Type} {c : σ} (f : α → β → σ → σ × φ) (x : α) (y : β)
Goal: Mathlib.Vector.mapAccumr₂ f (xs.snoc x) (ys.snoc y) c =
  let q := f x y c;
  let r := Mathlib.Vector.mapAccumr₂ f xs ys q.1;
  (r.1, r.2.snoc q.2)
-- Mathlib.Vector.zipWith_toList
@[simp]
theorem zipWith_toList (x : Vector α n) (y : Vector β n) :
    (Vector.zipWith f x y).toList = List.zipWith f x.toList y.toList 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} (f : α → β → γ) (x : Mathlib.Vector α n) (y : Mathlib.Vector β n)
Goal: (Mathlib.Vector.zipWith f x y).toList = List.zipWith f x.toList y.toList
-- Mathlib.Vector.zipWith_get
@[simp]
theorem zipWith_get (x : Vector α n) (y : Vector β n) (i) :
    (Vector.zipWith f x y).get i = f (x.get i) (y.get i) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} (f : α → β → γ) (x : Mathlib.Vector α n) (y : Mathlib.Vector β n) (i : Fin n)
Goal: (Mathlib.Vector.zipWith f x y).get i = f (x.get i) (y.get i)
-- Mathlib.Vector.zipWith_tail
@[simp]
theorem zipWith_tail (x : Vector α n) (y : Vector β n) :
    (Vector.zipWith f x y).tail = Vector.zipWith f x.tail y.tail 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} (f : α → β → γ) (x : Mathlib.Vector α n) (y : Mathlib.Vector β n)
Goal: (Mathlib.Vector.zipWith f x y).tail = Mathlib.Vector.zipWith f x.tail y.tail
-- Mathlib.Vector.sum_add_sum_eq_sum_zipWith
@[to_additive]
theorem prod_mul_prod_eq_prod_zipWith [CommMonoid α] (x y : Vector α n) :
    x.toList.prod * y.toList.prod = (Vector.zipWith (· * ·) x y).toList.prod 
Arguments: {α : Type u_1} {n : ℕ} [AddCommMonoid α] (x y : Mathlib.Vector α n)
Goal: x.toList.sum + y.toList.sum = (Mathlib.Vector.zipWith (fun x x_1 => x + x_1) x y).toList.sum
-- Mathlib.Vector.prod_mul_prod_eq_prod_zipWith
@[to_additive]
theorem prod_mul_prod_eq_prod_zipWith [CommMonoid α] (x y : Vector α n) :
    x.toList.prod * y.toList.prod = (Vector.zipWith (· * ·) x y).toList.prod 
Arguments: {α : Type u_1} {n : ℕ} [CommMonoid α] (x y : Mathlib.Vector α n)
Goal: x.toList.prod * y.toList.prod = (Mathlib.Vector.zipWith (fun x x_1 => x * x_1) x y).toList.prod
-- Set.range_sigmaMk
@[simp]
theorem range_sigmaMk (i : ι) : range (Sigma.mk i : α i → Sigma α) = Sigma.fst ⁻¹' {i} 
Arguments: {ι : Type u_1} {α : ι → Type u_3} (i : ι)
Goal: Set.range (Sigma.mk i) = Sigma.fst ⁻¹' {i}
-- Set.preimage_image_sigmaMk_of_ne
theorem preimage_image_sigmaMk_of_ne (h : i ≠ j) (s : Set (α j)) :
    Sigma.mk i ⁻¹' (Sigma.mk j '' s) = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {i j : ι} (h : i ≠ j) (s : Set (α j))
Goal: Sigma.mk i ⁻¹' (Sigma.mk j '' s) = ∅
-- Set.image_sigmaMk_preimage_sigmaMap_subset
theorem image_sigmaMk_preimage_sigmaMap_subset {β : ι' → Type*} (f : ι → ι')
    (g : ∀ i, α i → β (f i)) (i : ι) (s : Set (β (f i))) :
    Sigma.mk i '' (g i ⁻¹' s) ⊆ Sigma.map f g ⁻¹' (Sigma.mk (f i) '' s) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {β : ι' → Type u_5} (f : ι → ι') (g : (i : ι) → α i → β (f i)) (i : ι) (s : Set (β (f i)))
Goal: Sigma.mk i '' (g i ⁻¹' s) ⊆ Sigma.map f g ⁻¹' (Sigma.mk (f i) '' s)
-- Set.image_sigmaMk_preimage_sigmaMap
theorem image_sigmaMk_preimage_sigmaMap {β : ι' → Type*} {f : ι → ι'} (hf : Function.Injective f)
    (g : ∀ i, α i → β (f i)) (i : ι) (s : Set (β (f i))) :
    Sigma.mk i '' (g i ⁻¹' s) = Sigma.map f g ⁻¹' (Sigma.mk (f i) '' s) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {β : ι' → Type u_5} {f : ι → ι'} (hf : Function.Injective f) (g : (i : ι) → α i → β (f i)) (i : ι) (s : Set (β (f i)))
Goal: Sigma.mk i '' (g i ⁻¹' s) = Sigma.map f g ⁻¹' (Sigma.mk (f i) '' s)
-- Set.mem_sigma_iff
@[simp] theorem mem_sigma_iff : x ∈ s.sigma t ↔ x.1 ∈ s ∧ x.2 ∈ t x.1 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {x : (i : ι) × α i}
Goal: x ∈ s.sigma t ↔ x.fst ∈ s ∧ x.snd ∈ t x.fst
-- Set.mk_sigma_iff
theorem mk_sigma_iff : (⟨i, a⟩ : Σ i, α i) ∈ s.sigma t ↔ i ∈ s ∧ a ∈ t i 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} {a : α i}
Goal: ⟨i, a⟩ ∈ s.sigma t ↔ i ∈ s ∧ a ∈ t i
-- Set.mk_mem_sigma
theorem mk_mem_sigma (hi : i ∈ s) (ha : a ∈ t i) : (⟨i, a⟩ : Σ i, α i) ∈ s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} {a : α i} (hi : i ∈ s) (ha : a ∈ t i)
Goal: ⟨i, a⟩ ∈ s.sigma t
-- Set.sigma_mono
theorem sigma_mono (hs : s₁ ⊆ s₂) (ht : ∀ i, t₁ i ⊆ t₂ i) : s₁.sigma t₁ ⊆ s₂.sigma t₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} (hs : s₁ ⊆ s₂) (ht : ∀ (i : ι), t₁ i ⊆ t₂ i)
Goal: s₁.sigma t₁ ⊆ s₂.sigma t₂
-- Set.sigma_subset_iff
theorem sigma_subset_iff :
    s.sigma t ⊆ u ↔ ∀ ⦃i⦄, i ∈ s → ∀ ⦃a⦄, a ∈ t i → (⟨i, a⟩ : Σ i, α i) ∈ u 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {u : Set ((i : ι) × α i)}
Goal: s.sigma t ⊆ u ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃a : α i⦄, a ∈ t i → ⟨i, a⟩ ∈ u
-- Set.forall_sigma_iff
theorem forall_sigma_iff {p : (Σ i, α i) → Prop} :
    (∀ x ∈ s.sigma t, p x) ↔ ∀ ⦃i⦄, i ∈ s → ∀ ⦃a⦄, a ∈ t i → p ⟨i, a⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {p : (i : ι) × α i → Prop}
Goal: (∀ x ∈ s.sigma t, p x) ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃a : α i⦄, a ∈ t i → p ⟨i, a⟩
-- Set.exists_sigma_iff
theorem exists_sigma_iff {p : (Σi, α i) → Prop} :
    (∃ x ∈ s.sigma t, p x) ↔ ∃ i ∈ s, ∃ a ∈ t i, p ⟨i, a⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {p : (i : ι) × α i → Prop}
Goal: (∃ x ∈ s.sigma t, p x) ↔ ∃ i ∈ s, ∃ a ∈ t i, p ⟨i, a⟩
-- Set.sigma_empty
@[simp] theorem sigma_empty : s.sigma (fun i ↦ (∅ : Set (α i))) = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι}
Goal: (s.sigma fun i => ∅) = ∅
-- Set.empty_sigma
@[simp] theorem empty_sigma : (∅ : Set ι).sigma t = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {t : (i : ι) → Set (α i)}
Goal: ∅.sigma t = ∅
-- Set.univ_sigma_univ
theorem univ_sigma_univ : (@univ ι).sigma (fun _ ↦ @univ (α i)) = univ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {i : ι}
Goal: (Set.univ.sigma fun x => Set.univ) = Set.univ
-- Set.sigma_univ
@[simp]
theorem sigma_univ : s.sigma (fun _ ↦ univ : ∀ i, Set (α i)) = Sigma.fst ⁻¹' s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι}
Goal: (s.sigma fun x => Set.univ) = Sigma.fst ⁻¹' s
-- Set.univ_sigma_preimage_mk
@[simp] theorem univ_sigma_preimage_mk (s : Set (Σ i, α i)) :
    (univ : Set ι).sigma (fun i ↦ Sigma.mk i ⁻¹' s) = s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} (s : Set ((i : ι) × α i))
Goal: (Set.univ.sigma fun i => Sigma.mk i ⁻¹' s) = s
-- Set.singleton_sigma
@[simp]
theorem singleton_sigma : ({i} : Set ι).sigma t = Sigma.mk i '' t i 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {t : (i : ι) → Set (α i)} {i : ι} {a : α i}
Goal: {i}.sigma t = Sigma.mk i '' t i
-- Set.sigma_singleton
@[simp]
theorem sigma_singleton {a : ∀ i, α i} :
    s.sigma (fun i ↦ ({a i} : Set (α i))) = (fun i ↦ Sigma.mk i <| a i) '' s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {a : (i : ι) → α i}
Goal: (s.sigma fun i => {a i}) = (fun i => ⟨i, a i⟩) '' s
-- Set.singleton_sigma_singleton
theorem singleton_sigma_singleton {a : ∀ i, α i} :
    (({i} : Set ι).sigma fun i ↦ ({a i} : Set (α i))) = {⟨i, a i⟩} 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {i : ι} {a : (i : ι) → α i}
Goal: ({i}.sigma fun i => {a i}) = {⟨i, a i⟩}
-- Set.union_sigma
@[simp]
theorem union_sigma : (s₁ ∪ s₂).sigma t = s₁.sigma t ∪ s₂.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s₁ s₂ : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s₁ ∪ s₂).sigma t = s₁.sigma t ∪ s₂.sigma t
-- Set.sigma_union
@[simp]
theorem sigma_union : s.sigma (fun i ↦ t₁ i ∪ t₂ i) = s.sigma t₁ ∪ s.sigma t₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)}
Goal: (s.sigma fun i => t₁ i ∪ t₂ i) = s.sigma t₁ ∪ s.sigma t₂
-- Set.sigma_inter_sigma
theorem sigma_inter_sigma : s₁.sigma t₁ ∩ s₂.sigma t₂ = (s₁ ∩ s₂).sigma fun i ↦ t₁ i ∩ t₂ i 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)}
Goal: s₁.sigma t₁ ∩ s₂.sigma t₂ = (s₁ ∩ s₂).sigma fun i => t₁ i ∩ t₂ i
-- biSup_sigma
theorem _root_.biSup_sigma (s : Set ι) (t : ∀ i, Set (α i)) (f : Sigma α → β) :
    ⨆ ij ∈ s.sigma t, f ij = ⨆ (i ∈ s) (j ∈ t i), f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_5} [CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i)) (f : Sigma α → β)
Goal: ⨆ ij ∈ s.sigma t, f ij = ⨆ i ∈ s, ⨆ j ∈ t i, f ⟨i, j⟩
-- biSup_sigma'
theorem _root_.biSup_sigma' (s : Set ι) (t : ∀ i, Set (α i)) (f : ∀ i, α i → β) :
    ⨆ (i ∈ s) (j ∈ t i), f i j = ⨆ ij ∈ s.sigma t, f ij.fst ij.snd 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_5} [CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i)) (f : (i : ι) → α i → β)
Goal: ⨆ i ∈ s, ⨆ j ∈ t i, f i j = ⨆ ij ∈ s.sigma t, f ij.fst ij.snd
-- biInf_sigma
theorem _root_.biInf_sigma (s : Set ι) (t : ∀ i, Set (α i)) (f : Sigma α → β) :
    ⨅ ij ∈ s.sigma t, f ij = ⨅ (i ∈ s) (j ∈ t i), f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_5} [CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i)) (f : Sigma α → β)
Goal: ⨅ ij ∈ s.sigma t, f ij = ⨅ i ∈ s, ⨅ j ∈ t i, f ⟨i, j⟩
-- biInf_sigma'
theorem _root_.biInf_sigma' (s : Set ι) (t : ∀ i, Set (α i)) (f : ∀ i, α i → β) :
    ⨅ (i ∈ s) (j ∈ t i), f i j = ⨅ ij ∈ s.sigma t, f ij.fst ij.snd 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_5} [CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i)) (f : (i : ι) → α i → β)
Goal: ⨅ i ∈ s, ⨅ j ∈ t i, f i j = ⨅ ij ∈ s.sigma t, f ij.fst ij.snd
-- Set.biUnion_sigma
theorem biUnion_sigma (s : Set ι) (t : ∀ i, Set (α i)) (f : Sigma α → Set β) :
    ⋃ ij ∈ s.sigma t, f ij = ⋃ i ∈ s, ⋃ j ∈ t i, f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_6} (s : Set ι) (t : (i : ι) → Set (α i)) (f : Sigma α → Set β)
Goal: ⋃ ij ∈ s.sigma t, f ij = ⋃ i ∈ s, ⋃ j ∈ t i, f ⟨i, j⟩
-- Set.biUnion_sigma'
theorem biUnion_sigma' (s : Set ι) (t : ∀ i, Set (α i)) (f : ∀ i, α i → Set β) :
    ⋃ i ∈ s, ⋃ j ∈ t i, f i j = ⋃ ij ∈ s.sigma t, f ij.fst ij.snd 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_6} (s : Set ι) (t : (i : ι) → Set (α i)) (f : (i : ι) → α i → Set β)
Goal: ⋃ i ∈ s, ⋃ j ∈ t i, f i j = ⋃ ij ∈ s.sigma t, f ij.fst ij.snd
-- Set.biInter_sigma
theorem biInter_sigma (s : Set ι) (t : ∀ i, Set (α i)) (f : Sigma α → Set β) :
    ⋂ ij ∈ s.sigma t, f ij = ⋂ i ∈ s, ⋂ j ∈ t i, f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_6} (s : Set ι) (t : (i : ι) → Set (α i)) (f : Sigma α → Set β)
Goal: ⋂ ij ∈ s.sigma t, f ij = ⋂ i ∈ s, ⋂ j ∈ t i, f ⟨i, j⟩
-- Set.biInter_sigma'
theorem biInter_sigma' (s : Set ι) (t : ∀ i, Set (α i)) (f : ∀ i, α i → Set β) :
    ⋂ i ∈ s, ⋂ j ∈ t i, f i j = ⋂ ij ∈ s.sigma t, f ij.fst ij.snd 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : Type u_6} (s : Set ι) (t : (i : ι) → Set (α i)) (f : (i : ι) → α i → Set β)
Goal: ⋂ i ∈ s, ⋂ j ∈ t i, f i j = ⋂ ij ∈ s.sigma t, f ij.fst ij.snd
-- Set.insert_sigma
theorem insert_sigma : (insert i s).sigma t = Sigma.mk i '' t i ∪ s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} {a : α i}
Goal: (insert i s).sigma t = Sigma.mk i '' t i ∪ s.sigma t
-- Set.sigma_insert
theorem sigma_insert {a : ∀ i, α i} :
    s.sigma (fun i ↦ insert (a i) (t i)) = (fun i ↦ ⟨i, a i⟩) '' s ∪ s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {a : (i : ι) → α i}
Goal: (s.sigma fun i => insert (a i) (t i)) = (fun i => ⟨i, a i⟩) '' s ∪ s.sigma t
-- Set.sigma_preimage_eq
theorem sigma_preimage_eq {f : ι' → ι} {g : ∀ i, β i → α i} :
    (f ⁻¹' s).sigma (fun i ↦ g (f i) ⁻¹' t (f i)) =
      (fun p : Σ i, β (f i) ↦ Sigma.mk _ (g _ p.2)) ⁻¹' s.sigma t 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {β : ι → Type u_7} {f : ι' → ι} {g : (i : ι) → β i → α i}
Goal: ((f ⁻¹' s).sigma fun i => g (f i) ⁻¹' t (f i)) = (fun p => ⟨f p.fst, g (f p.fst) p.snd⟩) ⁻¹' s.sigma t
-- Set.sigma_preimage_left
theorem sigma_preimage_left {f : ι' → ι} :
    ((f ⁻¹' s).sigma fun i ↦ t (f i)) = (fun p : Σ i, α (f i) ↦ Sigma.mk _ p.2) ⁻¹' s.sigma t 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {f : ι' → ι}
Goal: ((f ⁻¹' s).sigma fun i => t (f i)) = (fun p => ⟨f p.fst, p.snd⟩) ⁻¹' s.sigma t
-- Set.sigma_preimage_right
theorem sigma_preimage_right {g : ∀ i, β i → α i} :
    (s.sigma fun i ↦ g i ⁻¹' t i) = (fun p : Σ i, β i ↦ Sigma.mk p.1 (g _ p.2)) ⁻¹' s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {β : ι → Type u_7} {g : (i : ι) → β i → α i}
Goal: (s.sigma fun i => g i ⁻¹' t i) = (fun p => ⟨p.fst, g p.fst p.snd⟩) ⁻¹' s.sigma t
-- Set.preimage_sigmaMap_sigma
theorem preimage_sigmaMap_sigma {α' : ι' → Type*} (f : ι → ι') (g : ∀ i, α i → α' (f i))
    (s : Set ι') (t : ∀ i, Set (α' i)) :
    Sigma.map f g ⁻¹' s.sigma t = (f ⁻¹' s).sigma fun i ↦ g i ⁻¹' t (f i) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {α' : ι' → Type u_8} (f : ι → ι') (g : (i : ι) → α i → α' (f i)) (s : Set ι') (t : (i : ι') → Set (α' i))
Goal: Sigma.map f g ⁻¹' s.sigma t = (f ⁻¹' s).sigma fun i => g i ⁻¹' t (f i)
-- Set.mk_preimage_sigma
@[simp]
theorem mk_preimage_sigma (hi : i ∈ s) : Sigma.mk i ⁻¹' s.sigma t = t i 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} (hi : i ∈ s)
Goal: Sigma.mk i ⁻¹' s.sigma t = t i
-- Set.mk_preimage_sigma_eq_empty
@[simp]
theorem mk_preimage_sigma_eq_empty (hi : i ∉ s) : Sigma.mk i ⁻¹' s.sigma t = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} (hi : i ∉ s)
Goal: Sigma.mk i ⁻¹' s.sigma t = ∅
-- Set.mk_preimage_sigma_eq_if
theorem mk_preimage_sigma_eq_if [DecidablePred (· ∈ s)] :
    Sigma.mk i ⁻¹' s.sigma t = if i ∈ s then t i else ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} [DecidablePred fun x => x ∈ s]
Goal: Sigma.mk i ⁻¹' s.sigma t = if i ∈ s then t i else ∅
-- Set.mk_preimage_sigma_fn_eq_if
theorem mk_preimage_sigma_fn_eq_if {β : Type*} [DecidablePred (· ∈ s)] (g : β → α i) :
    (fun b ↦ Sigma.mk i (g b)) ⁻¹' s.sigma t = if i ∈ s then g ⁻¹' t i else ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} {β : Type u_8} [DecidablePred fun x => x ∈ s] (g : β → α i)
Goal: (fun b => ⟨i, g b⟩) ⁻¹' s.sigma t = if i ∈ s then g ⁻¹' t i else ∅
-- Set.sigma_univ_range_eq
theorem sigma_univ_range_eq {f : ∀ i, α i → β i} :
    (univ : Set ι).sigma (fun i ↦ range (f i)) = range fun x : Σ i, α i ↦ ⟨x.1, f _ x.2⟩ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {β : ι → Type u_7} {f : (i : ι) → α i → β i}
Goal: (Set.univ.sigma fun i => Set.range (f i)) = Set.range fun x => ⟨x.fst, f x.fst x.snd⟩
-- Set.Nonempty.sigma
protected theorem Nonempty.sigma :
    s.Nonempty → (∀ i, (t i).Nonempty) → (s.sigma t).Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: s.Nonempty → (∀ (i : ι), (t i).Nonempty) → (s.sigma t).Nonempty
-- Set.Nonempty.sigma_fst
theorem Nonempty.sigma_fst : (s.sigma t).Nonempty → s.Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s.sigma t).Nonempty → s.Nonempty
-- Set.Nonempty.sigma_snd
theorem Nonempty.sigma_snd : (s.sigma t).Nonempty → ∃ i ∈ s, (t i).Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s.sigma t).Nonempty → ∃ i ∈ s, (t i).Nonempty
-- Set.sigma_nonempty_iff
theorem sigma_nonempty_iff : (s.sigma t).Nonempty ↔ ∃ i ∈ s, (t i).Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s.sigma t).Nonempty ↔ ∃ i ∈ s, (t i).Nonempty
-- Set.sigma_eq_empty_iff
theorem sigma_eq_empty_iff : s.sigma t = ∅ ↔ ∀ i ∈ s, t i = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: s.sigma t = ∅ ↔ ∀ i ∈ s, t i = ∅
-- Set.image_sigmaMk_subset_sigma_left
theorem image_sigmaMk_subset_sigma_left {a : ∀ i, α i} (ha : ∀ i, a i ∈ t i) :
    (fun i ↦ Sigma.mk i (a i)) '' s ⊆ s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {a : (i : ι) → α i} (ha : ∀ (i : ι), a i ∈ t i)
Goal: (fun i => ⟨i, a i⟩) '' s ⊆ s.sigma t
-- Set.image_sigmaMk_subset_sigma_right
theorem image_sigmaMk_subset_sigma_right (hi : i ∈ s) : Sigma.mk i '' t i ⊆ s.sigma t 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} (hi : i ∈ s)
Goal: Sigma.mk i '' t i ⊆ s.sigma t
-- Set.sigma_subset_preimage_fst
theorem sigma_subset_preimage_fst (s : Set ι) (t : ∀ i, Set (α i)) : s.sigma t ⊆ Sigma.fst ⁻¹' s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} (s : Set ι) (t : (i : ι) → Set (α i))
Goal: s.sigma t ⊆ Sigma.fst ⁻¹' s
-- Set.fst_image_sigma_subset
theorem fst_image_sigma_subset (s : Set ι) (t : ∀ i, Set (α i)) : Sigma.fst '' s.sigma t ⊆ s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} (s : Set ι) (t : (i : ι) → Set (α i))
Goal: Sigma.fst '' s.sigma t ⊆ s
-- Set.fst_image_sigma
theorem fst_image_sigma (s : Set ι) (ht : ∀ i, (t i).Nonempty) : Sigma.fst '' s.sigma t = s 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {t : (i : ι) → Set (α i)} (s : Set ι) (ht : ∀ (i : ι), (t i).Nonempty)
Goal: Sigma.fst '' s.sigma t = s
-- Set.sigma_diff_sigma
theorem sigma_diff_sigma : s₁.sigma t₁ \ s₂.sigma t₂ = s₁.sigma (t₁ \ t₂) ∪ (s₁ \ s₂).sigma t₁ 
Arguments: {ι : Type u_1} {α : ι → Type u_3} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)}
Goal: s₁.sigma t₁ \ s₂.sigma t₂ = s₁.sigma (t₁ \ t₂) ∪ (s₁ \ s₂).sigma t₁
-- TwoPointing.fst_ne_snd
@[ext]
structure TwoPointing (α : Type*) extends α × α where
    fst_ne_snd : fst ≠ snd
  deriving DecidableEq
Arguments: {α : Type u_3} (self : TwoPointing α)
Goal: self.fst ≠ self.snd
-- TwoPointing.snd_ne_fst
theorem snd_ne_fst : p.snd ≠ p.fst 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: p.snd ≠ p.fst
-- TwoPointing.swap_toProd
@[simps]
def swap : TwoPointing α 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: p.swap.toProd = (p.snd, p.fst)
-- TwoPointing.swap_fst
theorem swap_fst : p.swap.fst = p.snd 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: p.swap.fst = p.snd
-- TwoPointing.swap_snd
theorem swap_snd : p.swap.snd = p.fst 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: p.swap.snd = p.fst
-- TwoPointing.swap_swap
@[simp]
theorem swap_swap : p.swap.swap = p 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: p.swap.swap = p
-- TwoPointing.to_nontrivial
theorem to_nontrivial : Nontrivial α 
Arguments: {α : Type u_1} (p : TwoPointing α)
Goal: Nontrivial α