ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.not_mem_sigmaLift_of_ne_left
theorem not_mem_sigmaLift_of_ne_left (f : ∀ ⦃i⦄, α i → β i → Finset (γ i)) (a : Sigma α)
    (b : Sigma β) (x : Sigma γ) (h : a.1 ≠ x.1) : x ∉ sigmaLift f a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] (f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : Sigma α) (b : Sigma β) (x : Sigma γ) (h : a.fst ≠ x.fst)
Goal: x ∉ Finset.sigmaLift f a b
-- Finset.not_mem_sigmaLift_of_ne_right
theorem not_mem_sigmaLift_of_ne_right (f : ∀ ⦃i⦄, α i → β i → Finset (γ i)) {a : Sigma α}
    (b : Sigma β) {x : Sigma γ} (h : b.1 ≠ x.1) : x ∉ sigmaLift f a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] (f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) {a : Sigma α} (b : Sigma β) {x : Sigma γ} (h : b.fst ≠ x.fst)
Goal: x ∉ Finset.sigmaLift f a b
-- Finset.sigmaLift_nonempty
theorem sigmaLift_nonempty :
    (sigmaLift f a b).Nonempty ↔ ∃ h : a.1 = b.1, (f (h ▸ a.2) b.2).Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] {f : ⦃i : ι⦄ → α i → β i → Finset (γ i)} {a : (i : ι) × α i} {b : (i : ι) × β i}
Goal: (Finset.sigmaLift f a b).Nonempty ↔ ∃ (h : a.fst = b.fst), (f (h ▸ a.snd) b.snd).Nonempty
-- Finset.sigmaLift_eq_empty
theorem sigmaLift_eq_empty : sigmaLift f a b = ∅ ↔ ∀ h : a.1 = b.1, f (h ▸ a.2) b.2 = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] {f : ⦃i : ι⦄ → α i → β i → Finset (γ i)} {a : (i : ι) × α i} {b : (i : ι) × β i}
Goal: Finset.sigmaLift f a b = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
-- Finset.sigmaLift_mono
theorem sigmaLift_mono (h : ∀ ⦃i⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b) (a : Σi, α i) (b : Σi, β i) :
    sigmaLift f a b ⊆ sigmaLift g a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] {f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)} (h : ∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b) (a : (i : ι) × α i) (b : (i : ι) × β i)
Goal: Finset.sigmaLift f a b ⊆ Finset.sigmaLift g a b
-- Finset.card_sigmaLift
theorem card_sigmaLift :
    (sigmaLift f a b).card = dite (a.1 = b.1) (fun h => (f (h ▸ a.2) b.2).card) fun _ => 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [DecidableEq ι] (f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : (i : ι) × α i) (b : (i : ι) × β i)
Goal: (Finset.sigmaLift f a b).card = if h : a.fst = b.fst then (f (h ▸ a.snd) b.snd).card else 0
-- Subtype.prop
theorem prop (x : Subtype p) : p x 
Arguments: {α : Sort u_1} {p : α → Prop} (x : Subtype p)
Goal: p ↑x
-- Subtype.forall
@[simp]
protected theorem «forall» {q : { a // p a } → Prop} : (∀ x, q x) ↔ ∀ a b, q ⟨a, b⟩ 
Arguments: {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop}
Goal: (∀ (x : { a // p a }), q x) ↔ ∀ (a : α) (b : p a), q ⟨a, b⟩
-- Subtype.forall'
protected theorem forall' {q : ∀ x, p x → Prop} : (∀ x h, q x h) ↔ ∀ x : { a // p a }, q x x.2 
Arguments: {α : Sort u_1} {p : α → Prop} {q : (x : α) → p x → Prop}
Goal: (∀ (x : α) (h : p x), q x h) ↔ ∀ (x : { a // p a }), q ↑x ⋯
-- Subtype.exists
@[simp]
protected theorem «exists» {q : { a // p a } → Prop} : (∃ x, q x) ↔ ∃ a b, q ⟨a, b⟩ 
Arguments: {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop}
Goal: (∃ x, q x) ↔ ∃ a b, q ⟨a, b⟩
-- Subtype.exists'
protected theorem exists' {q : ∀ x, p x → Prop} : (∃ x h, q x h) ↔ ∃ x : { a // p a }, q x x.2 
Arguments: {α : Sort u_1} {p : α → Prop} {q : (x : α) → p x → Prop}
Goal: (∃ x h, q x h) ↔ ∃ x, q ↑x ⋯
-- Subtype.ext
@[ext]
protected theorem ext : ∀ {a1 a2 : { x // p x }}, (a1 : α) = (a2 : α) → a1 = a2
  
Arguments: {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}
Goal: ↑a1 = ↑a2 → a1 = a2
-- Subtype.ext_iff
protected theorem ext_iff {a1 a2 : { x // p x }} : a1 = a2 ↔ (a1 : α) = (a2 : α) 
Arguments: {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}
Goal: a1 = a2 ↔ ↑a1 = ↑a2
-- Subtype.heq_iff_coe_eq
theorem heq_iff_coe_eq (h : ∀ x, p x ↔ q x) {a1 : { x // p x }} {a2 : { x // q x }} :
    HEq a1 a2 ↔ (a1 : α) = (a2 : α) 
Arguments: {α : Sort u_1} {p q : α → Prop} (h : ∀ (x : α), p x ↔ q x) {a1 : { x // p x }} {a2 : { x // q x }}
Goal: HEq a1 a2 ↔ ↑a1 = ↑a2
-- Subtype.heq_iff_coe_heq
lemma heq_iff_coe_heq {α β : Sort _} {p : α → Prop} {q : β → Prop} {a : {x // p x}}
    {b : {y // q y}} (h : α = β) (h' : HEq p q) : HEq a b ↔ HEq (a : α) (b : β) 
Arguments: {α β : Sort u_4} {p : α → Prop} {q : β → Prop} {a : { x // p x }} {b : { y // q y }} (h : α = β) (h' : HEq p q)
Goal: HEq a b ↔ HEq ↑a ↑b
-- Subtype.ext_val
theorem ext_val {a1 a2 : { x // p x }} : a1.1 = a2.1 → a1 = a2 
Arguments: {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}
Goal: ↑a1 = ↑a2 → a1 = a2
-- Subtype.ext_iff_val
theorem ext_iff_val {a1 a2 : { x // p x }} : a1 = a2 ↔ a1.1 = a2.1 
Arguments: {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}
Goal: a1 = a2 ↔ ↑a1 = ↑a2
-- Subtype.coe_eta
@[simp]
theorem coe_eta (a : { a // p a }) (h : p a) : mk (↑a) h = a 
Arguments: {α : Sort u_1} {p : α → Prop} (a : { a // p a }) (h : p ↑a)
Goal: ⟨↑a, h⟩ = a
-- Subtype.coe_mk
theorem coe_mk (a h) : (@mk α p a h : α) = a 
Arguments: {α : Sort u_1} {p : α → Prop} (a : α) (h : p a)
Goal: ↑⟨a, h⟩ = a
-- Subtype.mk_eq_mk
theorem mk_eq_mk {a h a' h'} : @mk α p a h = @mk α p a' h' ↔ a = a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a : α} {h : p a} {a' : α} {h' : p a'}
Goal: ⟨a, h⟩ = ⟨a', h'⟩ ↔ a = a'
-- Subtype.coe_eq_of_eq_mk
theorem coe_eq_of_eq_mk {a : { a // p a }} {b : α} (h : ↑a = b) : a = ⟨b, h ▸ a.2⟩ 
Arguments: {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α} (h : ↑a = b)
Goal: a = ⟨b, ⋯⟩
-- Subtype.coe_eq_iff
theorem coe_eq_iff {a : { a // p a }} {b : α} : ↑a = b ↔ ∃ h, a = ⟨b, h⟩ 
Arguments: {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α}
Goal: ↑a = b ↔ ∃ h, a = ⟨b, h⟩
-- Subtype.coe_injective
theorem coe_injective : Injective (fun (a : Subtype p) ↦ (a : α)) 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: Function.Injective fun a => ↑a
-- Subtype.val_injective
theorem val_injective : Injective (@val _ p) 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: Function.Injective Subtype.val
-- Subtype.coe_inj
theorem coe_inj {a b : Subtype p} : (a : α) = b ↔ a = b 
Arguments: {α : Sort u_1} {p : α → Prop} {a b : Subtype p}
Goal: ↑a = ↑b ↔ a = b
-- Subtype.val_inj
theorem val_inj {a b : Subtype p} : a.val = b.val ↔ a = b 
Arguments: {α : Sort u_1} {p : α → Prop} {a b : Subtype p}
Goal: ↑a = ↑b ↔ a = b
-- Subtype.coe_ne_coe
lemma coe_ne_coe {a b : Subtype p} : (a : α) ≠ b ↔ a ≠ b 
Arguments: {α : Sort u_1} {p : α → Prop} {a b : Subtype p}
Goal: ↑a ≠ ↑b ↔ a ≠ b
-- exists_eq_subtype_mk_iff
@[simp, nolint simpNF]
theorem _root_.exists_eq_subtype_mk_iff {a : Subtype p} {b : α} :
    (∃ h : p b, a = Subtype.mk b h) ↔ ↑a = b 
Arguments: {α : Sort u_1} {p : α → Prop} {a : Subtype p} {b : α}
Goal: (∃ h, a = ⟨b, h⟩) ↔ ↑a = b
-- exists_subtype_mk_eq_iff
@[simp, nolint simpNF]
theorem _root_.exists_subtype_mk_eq_iff {a : Subtype p} {b : α} :
    (∃ h : p b, Subtype.mk b h = a) ↔ b = a 
Arguments: {α : Sort u_1} {p : α → Prop} {a : Subtype p} {b : α}
Goal: (∃ h, ⟨b, h⟩ = a) ↔ b = ↑a
-- Subtype.restrict_apply
theorem restrict_apply {α} {β : α → Type*} (f : ∀ x, β x) (p : α → Prop) (x : Subtype p) :
    restrict p f x = f x.1 
Arguments: {α : Sort u_5} {β : α → Type u_4} (f : (x : α) → β x) (p : α → Prop) (x : Subtype p)
Goal: Subtype.restrict p f x = f ↑x
-- Subtype.restrict_def
theorem restrict_def {α β} (f : α → β) (p : α → Prop) :
    restrict p f = f ∘ (fun (a : Subtype p) ↦ a) 
Arguments: {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop)
Goal: Subtype.restrict p f = f ∘ fun a => ↑a
-- Subtype.restrict_injective
theorem restrict_injective {α β} {f : α → β} (p : α → Prop) (h : Injective f) :
    Injective (restrict p f) 
Arguments: {α : Sort u_4} {β : Type u_5} {f : α → β} (p : α → Prop) (h : Function.Injective f)
Goal: Function.Injective (Subtype.restrict p f)
-- Subtype.surjective_restrict
theorem surjective_restrict {α} {β : α → Type*} [ne : ∀ a, Nonempty (β a)] (p : α → Prop) :
    Surjective fun f : ∀ x, β x ↦ restrict p f 
Arguments: {α : Sort u_5} {β : α → Type u_4} [ne : ∀ (a : α), Nonempty (β a)] (p : α → Prop)
Goal: Function.Surjective fun f => Subtype.restrict p f
-- Subtype.coind_coe
@[simps]
def coind {α β} (f : α → β) {p : β → Prop} (h : ∀ a, p (f a)) : α → Subtype p 
Arguments: {α : Sort u_4} {β : Sort u_5} (f : α → β) {p : β → Prop} (h : ∀ (a : α), p (f a))
Goal: ∀ (a : α), ↑(Subtype.coind f h a) = f a
-- Subtype.coind_injective
theorem coind_injective {α β} {f : α → β} {p : β → Prop} (h : ∀ a, p (f a)) (hf : Injective f) :
    Injective (coind f h) 
Arguments: {α : Sort u_4} {β : Sort u_5} {f : α → β} {p : β → Prop} (h : ∀ (a : α), p (f a)) (hf : Function.Injective f)
Goal: Function.Injective (Subtype.coind f h)
-- Subtype.coind_surjective
theorem coind_surjective {α β} {f : α → β} {p : β → Prop} (h : ∀ a, p (f a)) (hf : Surjective f) :
    Surjective (coind f h) 
Arguments: {α : Sort u_4} {β : Sort u_5} {f : α → β} {p : β → Prop} (h : ∀ (a : α), p (f a)) (hf : Function.Surjective f)
Goal: Function.Surjective (Subtype.coind f h)
-- Subtype.coind_bijective
theorem coind_bijective {α β} {f : α → β} {p : β → Prop} (h : ∀ a, p (f a)) (hf : Bijective f) :
    Bijective (coind f h) 
Arguments: {α : Sort u_4} {β : Sort u_5} {f : α → β} {p : β → Prop} (h : ∀ (a : α), p (f a)) (hf : Function.Bijective f)
Goal: Function.Bijective (Subtype.coind f h)
-- Subtype.map_coe
@[simps]
def map {p : α → Prop} {q : β → Prop} (f : α → β) (h : ∀ a, p a → q (f a)) :
    Subtype p → Subtype q 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (f : α → β) (h : ∀ (a : α), p a → q (f a))
Goal: ∀ (a : Subtype p), ↑(Subtype.map f h a) = f ↑a
-- Subtype.map_def
theorem map_def {p : α → Prop} {q : β → Prop} (f : α → β) (h : ∀ a, p a → q (f a)) :
    map f h = fun x ↦ ⟨f x, h x x.prop⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (f : α → β) (h : ∀ (a : α), p a → q (f a))
Goal: Subtype.map f h = fun x => ⟨f ↑x, ⋯⟩
-- Subtype.map_comp
theorem map_comp {p : α → Prop} {q : β → Prop} {r : γ → Prop} {x : Subtype p}
    (f : α → β) (h : ∀ a, p a → q (f a)) (g : β → γ) (l : ∀ a, q a → r (g a)) :
    map g l (map f h x) = map (g ∘ f) (fun a ha ↦ l (f a) <| h a ha) x 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {p : α → Prop} {q : β → Prop} {r : γ → Prop} {x : Subtype p} (f : α → β) (h : ∀ (a : α), p a → q (f a)) (g : β → γ) (l : ∀ (a : β), q a → r (g a))
Goal: Subtype.map g l (Subtype.map f h x) = Subtype.map (g ∘ f) ⋯ x
-- Subtype.map_id
theorem map_id {p : α → Prop} {h : ∀ a, p a → p (id a)} : map (@id α) h = id 
Arguments: {α : Sort u_1} {p : α → Prop} {h : ∀ (a : α), p a → p (id a)}
Goal: Subtype.map id h = id
-- Subtype.map_injective
theorem map_injective {p : α → Prop} {q : β → Prop} {f : α → β} (h : ∀ a, p a → q (f a))
    (hf : Injective f) : Injective (map f h) 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} {f : α → β} (h : ∀ (a : α), p a → q (f a)) (hf : Function.Injective f)
Goal: Function.Injective (Subtype.map f h)
-- Subtype.map_involutive
theorem map_involutive {p : α → Prop} {f : α → α} (h : ∀ a, p a → p (f a))
    (hf : Involutive f) : Involutive (map f h) 
Arguments: {α : Sort u_1} {p : α → Prop} {f : α → α} (h : ∀ (a : α), p a → p (f a)) (hf : Function.Involutive f)
Goal: Function.Involutive (Subtype.map f h)
-- Subtype.equiv_iff
theorem equiv_iff [HasEquiv α] {p : α → Prop} {s t : Subtype p} : s ≈ t ↔ (s : α) ≈ (t : α) 
Arguments: {α : Sort u_1} [HasEquiv α] {p : α → Prop} {s t : Subtype p}
Goal: s ≈ t ↔ ↑s ≈ ↑t
-- Subtype.refl
protected theorem refl (s : Subtype p) : s ≈ s 
Arguments: {α : Sort u_1} {p : α → Prop} [Setoid α] (s : Subtype p)
Goal: s ≈ s
-- Subtype.symm
protected theorem symm {s t : Subtype p} (h : s ≈ t) : t ≈ s 
Arguments: {α : Sort u_1} {p : α → Prop} [Setoid α] {s t : Subtype p} (h : s ≈ t)
Goal: t ≈ s
-- Subtype.trans
protected theorem trans {s t u : Subtype p} (h₁ : s ≈ t) (h₂ : t ≈ u) : s ≈ u 
Arguments: {α : Sort u_1} {p : α → Prop} [Setoid α] {s t u : Subtype p} (h₁ : s ≈ t) (h₂ : t ≈ u)
Goal: s ≈ u
-- Subtype.equivalence
theorem equivalence (p : α → Prop) : Equivalence (@HasEquiv.Equiv (Subtype p) _) 
Arguments: {α : Sort u_1} [Setoid α] (p : α → Prop)
Goal: Equivalence HasEquiv.Equiv
-- Subtype.coe_prop
@[simp]
theorem coe_prop {S : Set α} (a : { a // a ∈ S }) : ↑a ∈ S 
Arguments: {α : Type u_1} {S : Set α} (a : { a // a ∈ S })
Goal: ↑a ∈ S
-- Subtype.val_prop
theorem val_prop {S : Set α} (a : { a // a ∈ S }) : a.val ∈ S 
Arguments: {α : Type u_1} {S : Set α} (a : { a // a ∈ S })
Goal: ↑a ∈ S
-- Sigma.mk.inj_iff
@[simp] -- @[nolint simpNF]
theorem mk.inj_iff {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂} :
    Sigma.mk a₁ b₁ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂ 
Arguments: {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}
Goal: ⟨a₁, b₁⟩ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂
-- Sigma.eta
@[simp]
theorem eta : ∀ x : Σa, β a, Sigma.mk x.1 x.2 = x
  
Arguments: {α : Type u_1} {β : α → Type u_4} (x : (a : α) × β a)
Goal: ⟨x.fst, x.snd⟩ = x
-- Sigma.ext_iff
protected theorem ext_iff {x₀ x₁ : Sigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2 
Arguments: {α : Type u_1} {β : α → Type u_4} {x₀ x₁ : Sigma β}
Goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd
-- Function.eq_of_sigmaMk_comp
theorem _root_.Function.eq_of_sigmaMk_comp {γ : Type*} [Nonempty γ]
    {a b : α} {f : γ → β a} {g : γ → β b} (h : Sigma.mk a ∘ f = Sigma.mk b ∘ g) :
    a = b ∧ HEq f g 
Arguments: {α : Type u_1} {β : α → Type u_4} {γ : Type u_7} [Nonempty γ] {a b : α} {f : γ → β a} {g : γ → β b} (h : Sigma.mk a ∘ f = Sigma.mk b ∘ g)
Goal: a = b ∧ HEq f g
-- Sigma.subtype_ext
@[ext]
theorem subtype_ext {β : Type*} {p : α → β → Prop} :
    ∀ {x₀ x₁ : Σa, Subtype (p a)}, x₀.fst = x₁.fst → (x₀.snd : β) = x₁.snd → x₀ = x₁
  
Arguments: {α : Type u_1} {β : Type u_7} {p : α → β → Prop} {x₀ x₁ : (a : α) × Subtype (p a)}
Goal: x₀.fst = x₁.fst → x₀.snd.val = x₁.snd.val → x₀ = x₁
-- Sigma.subtype_ext_iff
theorem subtype_ext_iff {β : Type*} {p : α → β → Prop} {x₀ x₁ : Σa, Subtype (p a)} :
    x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ (x₀.snd : β) = x₁.snd 
Arguments: {α : Type u_1} {β : Type u_7} {p : α → β → Prop} {x₀ x₁ : (a : α) × Subtype (p a)}
Goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ x₀.snd.val = x₁.snd.val
-- Sigma.forall
@[simp]
theorem «forall» {p : (Σa, β a) → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
Arguments: {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}
Goal: (∀ (x : (a : α) × β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩
-- Sigma.exists
@[simp]
theorem «exists» {p : (Σa, β a) → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
Arguments: {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}
Goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩
-- Sigma.exists'
lemma exists' {p : ∀ a, β a → Prop} : (∃ a b, p a b) ↔ ∃ x : Σ a, β a, p x.1 x.2 
Arguments: {α : Type u_1} {β : α → Type u_4} {p : (a : α) → β a → Prop}
Goal: (∃ a b, p a b) ↔ ∃ x, p x.fst x.snd
-- Sigma.forall'
lemma forall' {p : ∀ a, β a → Prop} : (∀ a b, p a b) ↔ ∀ x : Σ a, β a, p x.1 x.2 
Arguments: {α : Type u_1} {β : α → Type u_4} {p : (a : α) → β a → Prop}
Goal: (∀ (a : α) (b : β a), p a b) ↔ ∀ (x : (a : α) × β a), p x.fst x.snd
-- sigma_mk_injective
theorem _root_.sigma_mk_injective {i : α} : Injective (@Sigma.mk α β i)
  
Arguments: {α : Type u_1} {β : α → Type u_4} {i : α}
Goal: Function.Injective (Sigma.mk i)
-- Sigma.fst_surjective
theorem fst_surjective [h : ∀ a, Nonempty (β a)] : Surjective (fst : (Σ a, β a) → α) 
Arguments: {α : Type u_1} {β : α → Type u_4} [h : ∀ (a : α), Nonempty (β a)]
Goal: Function.Surjective Sigma.fst
-- Sigma.fst_surjective_iff
theorem fst_surjective_iff : Surjective (fst : (Σ a, β a) → α) ↔ ∀ a, Nonempty (β a) 
Arguments: {α : Type u_1} {β : α → Type u_4}
Goal: Function.Surjective Sigma.fst ↔ ∀ (a : α), Nonempty (β a)
-- Sigma.fst_injective
theorem fst_injective [h : ∀ a, Subsingleton (β a)] : Injective (fst : (Σ a, β a) → α) 
Arguments: {α : Type u_1} {β : α → Type u_4} [h : ∀ (a : α), Subsingleton (β a)]
Goal: Function.Injective Sigma.fst
-- Sigma.fst_injective_iff
theorem fst_injective_iff : Injective (fst : (Σ a, β a) → α) ↔ ∀ a, Subsingleton (β a) 
Arguments: {α : Type u_1} {β : α → Type u_4}
Goal: Function.Injective Sigma.fst ↔ ∀ (a : α), Subsingleton (β a)
-- Sigma.map_mk
lemma map_mk (f₁ : α₁ → α₂) (f₂ : ∀ a, β₁ a → β₂ (f₁ a)) (x : α₁) (y : β₁ x) :
    map f₁ f₂ ⟨x, y⟩ = ⟨f₁ x, f₂ x y⟩ 
Arguments: {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} (f₁ : α₁ → α₂) (f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)) (x : α₁) (y : β₁ x)
Goal: Sigma.map f₁ f₂ ⟨x, y⟩ = ⟨f₁ x, f₂ x y⟩
-- Function.Injective.sigma_map
theorem Function.Injective.sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Injective f₁) (h₂ : ∀ a, Injective (f₂ a)) : Injective (Sigma.map f₁ f₂)
  
Arguments: {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} {f₁ : α₁ → α₂} {f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)} (h₁ : Function.Injective f₁) (h₂ : ∀ (a : α₁), Function.Injective (f₂ a))
Goal: Function.Injective (Sigma.map f₁ f₂)
-- Function.Injective.of_sigma_map
theorem Function.Injective.of_sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h : Injective (Sigma.map f₁ f₂)) (a : α₁) : Injective (f₂ a) 
Arguments: {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} {f₁ : α₁ → α₂} {f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)} (h : Function.Injective (Sigma.map f₁ f₂)) (a : α₁)
Goal: Function.Injective (f₂ a)
-- Function.Injective.sigma_map_iff
theorem Function.Injective.sigma_map_iff {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Injective f₁) : Injective (Sigma.map f₁ f₂) ↔ ∀ a, Injective (f₂ a) 
Arguments: {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} {f₁ : α₁ → α₂} {f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)} (h₁ : Function.Injective f₁)
Goal: Function.Injective (Sigma.map f₁ f₂) ↔ ∀ (a : α₁), Function.Injective (f₂ a)
-- Function.Surjective.sigma_map
theorem Function.Surjective.sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Surjective f₁) (h₂ : ∀ a, Surjective (f₂ a)) : Surjective (Sigma.map f₁ f₂) 
Arguments: {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} {f₁ : α₁ → α₂} {f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)} (h₁ : Function.Surjective f₁) (h₂ : ∀ (a : α₁), Function.Surjective (f₂ a))
Goal: Function.Surjective (Sigma.map f₁ f₂)
-- Sigma.uncurry_curry
@[simp]
theorem Sigma.uncurry_curry {γ : ∀ a, β a → Type*} (f : ∀ x : Sigma β, γ x.1 x.2) :
    Sigma.uncurry (Sigma.curry f) = f 
Arguments: {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} (f : (x : Sigma β) → γ x.fst x.snd)
Goal: Sigma.uncurry (Sigma.curry f) = f
-- Sigma.curry_uncurry
@[simp]
theorem Sigma.curry_uncurry {γ : ∀ a, β a → Type*} (f : ∀ (x) (y : β x), γ x y) :
    Sigma.curry (Sigma.uncurry f) = f 
Arguments: {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} (f : (x : α) → (y : β x) → γ x y)
Goal: Sigma.curry (Sigma.uncurry f) = f
-- Sigma.curry_update
theorem Sigma.curry_update {γ : ∀ a, β a → Type*} [DecidableEq α] [∀ a, DecidableEq (β a)]
    (i : Σ a, β a) (f : (i : Σ a, β a) → γ i.1 i.2) (x : γ i.1 i.2) :
    Sigma.curry (Function.update f i x) =
      Function.update (Sigma.curry f) i.1 (Function.update (Sigma.curry f i.1) i.2 x) 
Arguments: {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} [DecidableEq α] [(a : α) → DecidableEq (β a)] (i : (a : α) × β a) (f : (i : (a : α) × β a) → γ i.fst i.snd) (x : γ i.fst i.snd)
Goal: Sigma.curry (Function.update f i x) =
  Function.update (Sigma.curry f) i.fst (Function.update (Sigma.curry f i.fst) i.snd x)
-- Prod.fst_comp_toSigma
@[simp]
theorem Prod.fst_comp_toSigma {α β} : Sigma.fst ∘ @Prod.toSigma α β = Prod.fst 
Arguments: {α : Type u_7} {β : Type u_8}
Goal: Sigma.fst ∘ Prod.toSigma = Prod.fst
-- Prod.fst_toSigma
@[simp]
theorem Prod.fst_toSigma {α β} (x : α × β) : (Prod.toSigma x).fst = x.fst 
Arguments: {α : Type u_7} {β : Type u_8} (x : α × β)
Goal: x.toSigma.fst = x.fst
-- Prod.snd_toSigma
@[simp]
theorem Prod.snd_toSigma {α β} (x : α × β) : (Prod.toSigma x).snd = x.snd 
Arguments: {α : Type u_7} {β : Type u_8} (x : α × β)
Goal: x.toSigma.snd = x.snd
-- Prod.toSigma_mk
@[simp]
theorem Prod.toSigma_mk {α β} (x : α) (y : β) : (x, y).toSigma = ⟨x, y⟩ 
Arguments: {α : Type u_7} {β : Type u_8} (x : α) (y : β)
Goal: (x, y).toSigma = ⟨x, y⟩
-- PSigma.elim_val
@[simp]
theorem elim_val {γ} (f : ∀ a, β a → γ) (a b) : PSigma.elim f ⟨a, b⟩ = f a b 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : Sort u_3} (f : (a : α) → β a → γ) (a : α) (b : β a)
Goal: PSigma.elim f ⟨a, b⟩ = f a b
-- PSigma.mk.inj_iff
theorem mk.inj_iff {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂} :
    @PSigma.mk α β a₁ b₁ = @PSigma.mk α β a₂ b₂ ↔ a₁ = a₂ ∧ HEq b₁ b₂ 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}
Goal: ⟨a₁, b₁⟩ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂
-- PSigma.ext_iff
theorem ext_iff {x₀ x₁ : PSigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {x₀ x₁ : PSigma β}
Goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd
-- PSigma.forall
@[simp]
theorem «forall» {p : (Σ'a, β a) → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) ×' β a → Prop}
Goal: (∀ (x : (a : α) ×' β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩
-- PSigma.exists
@[simp]
theorem «exists» {p : (Σ'a, β a) → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) ×' β a → Prop}
Goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩
-- PSigma.subtype_ext
@[ext]
theorem subtype_ext {β : Sort*} {p : α → β → Prop} :
    ∀ {x₀ x₁ : Σ'a, Subtype (p a)}, x₀.fst = x₁.fst → (x₀.snd : β) = x₁.snd → x₀ = x₁
  
Arguments: {α : Sort u_1} {β : Sort u_3} {p : α → β → Prop} {x₀ x₁ : (a : α) ×' Subtype (p a)}
Goal: x₀.fst = x₁.fst → x₀.snd.val = x₁.snd.val → x₀ = x₁
-- PSigma.subtype_ext_iff
theorem subtype_ext_iff {β : Sort*} {p : α → β → Prop} {x₀ x₁ : Σ'a, Subtype (p a)} :
    x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ (x₀.snd : β) = x₁.snd 
Arguments: {α : Sort u_1} {β : Sort u_3} {p : α → β → Prop} {x₀ x₁ : (a : α) ×' Subtype (p a)}
Goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ x₀.snd.val = x₁.snd.val
-- Sigma.mk_le_mk_iff
@[simp]
theorem mk_le_mk_iff [∀ i, LE (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Sigma α) ≤ ⟨i, b⟩ ↔ a ≤ b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → LE (α i)] {i : ι} {a b : α i}
Goal: ⟨i, a⟩ ≤ ⟨i, b⟩ ↔ a ≤ b
-- Sigma.mk_lt_mk_iff
@[simp]
theorem mk_lt_mk_iff [∀ i, LT (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Sigma α) < ⟨i, b⟩ ↔ a < b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → LT (α i)] {i : ι} {a b : α i}
Goal: ⟨i, a⟩ < ⟨i, b⟩ ↔ a < b
-- Sigma.le_def
theorem le_def [∀ i, LE (α i)] {a b : Σi, α i} : a ≤ b ↔ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → LE (α i)] {a b : (i : ι) × α i}
Goal: a ≤ b ↔ ∃ h, h ▸ a.snd ≤ b.snd
-- Sigma.lt_def
theorem lt_def [∀ i, LT (α i)] {a b : Σi, α i} : a < b ↔ ∃ h : a.1 = b.1, h.rec a.2 < b.2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → LT (α i)] {a b : (i : ι) × α i}
Goal: a < b ↔ ∃ h, h ▸ a.snd < b.snd
-- Sigma.Lex.le_def
theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
    a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [LT ι] [(i : ι) → LE (α i)] {a b : Σₗ (i : ι), α i}
Goal: a ≤ b ↔ a.fst < b.fst ∨ ∃ h, h ▸ a.snd ≤ b.snd
-- Sigma.Lex.lt_def
theorem lt_def [LT ι] [∀ i, LT (α i)] {a b : Σₗ i, α i} :
    a < b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 < b.2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [LT ι] [(i : ι) → LT (α i)] {a b : Σₗ (i : ι), α i}
Goal: a < b ↔ a.fst < b.fst ∨ ∃ h, h ▸ a.snd < b.snd
-- PProd.mk.eta
@[simp]
theorem mk.eta {p : PProd α β} : PProd.mk p.1 p.2 = p 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : PProd α β}
Goal: ⟨p.fst, p.snd⟩ = p
-- PProd.forall
@[simp]
theorem «forall» {p : PProd α β → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : PProd α β → Prop}
Goal: (∀ (x : PProd α β), p x) ↔ ∀ (a : α) (b : β), p ⟨a, b⟩
-- PProd.exists
@[simp]
theorem «exists» {p : PProd α β → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : PProd α β → Prop}
Goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩