ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.iInf_of_isEmpty
@[simp] nonrec lemma iInf_of_isEmpty {α : Sort*} [IsEmpty α] (f : α → ℝ) : ⨅ i, f i = 0 
Arguments: {α : Sort u_1} [IsEmpty α] (f : α → ℝ)
Goal: ⨅ i, f i = 0
-- Real.ciInf_const_zero
@[simp]
theorem ciInf_const_zero {α : Sort*} : ⨅ _ : α, (0 : ℝ) = 0 
Arguments: {α : Sort u_1}
Goal: ⨅ x, 0 = 0
-- Real.sInf_of_not_bddBelow
theorem sInf_of_not_bddBelow {s : Set ℝ} (hs : ¬BddBelow s) : sInf s = 0 
Arguments: {s : Set ℝ} (hs : ¬BddBelow s)
Goal: sInf s = 0
-- Real.iInf_of_not_bddBelow
theorem iInf_of_not_bddBelow {α : Sort*} {f : α → ℝ} (hf : ¬BddBelow (Set.range f)) :
    ⨅ i, f i = 0 
Arguments: {α : Sort u_1} {f : α → ℝ} (hf : ¬BddBelow (Set.range f))
Goal: ⨅ i, f i = 0
-- Real.sSup_nonneg
theorem sSup_nonneg (S : Set ℝ) (hS : ∀ x ∈ S, (0 : ℝ) ≤ x) : 0 ≤ sSup S 
Arguments: (S : Set ℝ) (hS : ∀ x ∈ S, 0 ≤ x)
Goal: 0 ≤ sSup S
-- Real.iSup_nonneg
protected theorem iSup_nonneg {ι : Sort*} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ ⨆ i, f i 
Arguments: {ι : Sort u_1} {f : ι → ℝ} (hf : ∀ (i : ι), 0 ≤ f i)
Goal: 0 ≤ ⨆ i, f i
-- Real.sSup_le
protected theorem sSup_le {S : Set ℝ} {a : ℝ} (hS : ∀ x ∈ S, x ≤ a) (ha : 0 ≤ a) : sSup S ≤ a 
Arguments: {S : Set ℝ} {a : ℝ} (hS : ∀ x ∈ S, x ≤ a) (ha : 0 ≤ a)
Goal: sSup S ≤ a
-- Real.iSup_le
protected theorem iSup_le {ι : Sort*} {f : ι → ℝ} {a : ℝ} (hS : ∀ i, f i ≤ a) (ha : 0 ≤ a) :
    ⨆ i, f i ≤ a 
Arguments: {ι : Sort u_1} {f : ι → ℝ} {a : ℝ} (hS : ∀ (i : ι), f i ≤ a) (ha : 0 ≤ a)
Goal: ⨆ i, f i ≤ a
-- Real.sSup_nonpos
theorem sSup_nonpos (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ (0 : ℝ)) : sSup S ≤ 0 
Arguments: (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ 0)
Goal: sSup S ≤ 0
-- Real.sInf_nonneg
theorem sInf_nonneg (S : Set ℝ) (hS : ∀ x ∈ S, (0 : ℝ) ≤ x) : 0 ≤ sInf S 
Arguments: (S : Set ℝ) (hS : ∀ x ∈ S, 0 ≤ x)
Goal: 0 ≤ sInf S
-- Real.iInf_nonneg
theorem iInf_nonneg {ι} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ iInf f 
Arguments: {ι : Sort u_1} {f : ι → ℝ} (hf : ∀ (i : ι), 0 ≤ f i)
Goal: 0 ≤ iInf f
-- Real.sInf_nonpos
theorem sInf_nonpos (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ (0 : ℝ)) : sInf S ≤ 0 
Arguments: (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ 0)
Goal: sInf S ≤ 0
-- Real.sInf_le_sSup
theorem sInf_le_sSup (s : Set ℝ) (h₁ : BddBelow s) (h₂ : BddAbove s) : sInf s ≤ sSup s 
Arguments: (s : Set ℝ) (h₁ : BddBelow s) (h₂ : BddAbove s)
Goal: sInf s ≤ sSup s
-- Real.cauSeq_converges
theorem cauSeq_converges (f : CauSeq ℝ abs) : ∃ x, f ≈ const abs x 
Arguments: (f : CauSeq ℝ abs)
Goal: ∃ x, f ≈ CauSeq.const abs x
-- Real.iInf_Ioi_eq_iInf_rat_gt
theorem iInf_Ioi_eq_iInf_rat_gt {f : ℝ → ℝ} (x : ℝ) (hf : BddBelow (f '' Ioi x))
    (hf_mono : Monotone f) : ⨅ r : Ioi x, f r = ⨅ q : { q' : ℚ // x < q' }, f q 
Arguments: {f : ℝ → ℝ} (x : ℝ) (hf : BddBelow (f '' Set.Ioi x)) (hf_mono : Monotone f)
Goal: ⨅ r, f ↑r = ⨅ q, f ↑↑q
-- Real.not_bddAbove_coe
theorem not_bddAbove_coe : ¬ (BddAbove <| range (fun (x : ℚ) ↦ (x : ℝ))) 
Goal: ¬BddAbove (Set.range fun x => ↑x)
-- Real.not_bddBelow_coe
theorem not_bddBelow_coe : ¬ (BddBelow <| range (fun (x : ℚ) ↦ (x : ℝ))) 
Goal: ¬BddBelow (Set.range fun x => ↑x)
-- Real.iUnion_Iic_rat
theorem iUnion_Iic_rat : ⋃ r : ℚ, Iic (r : ℝ) = univ 
Goal: ⋃ r, Set.Iic ↑r = Set.univ
-- Real.iInter_Iic_rat
theorem iInter_Iic_rat : ⋂ r : ℚ, Iic (r : ℝ) = ∅ 
Goal: ⋂ r, Set.Iic ↑r = ∅
-- DFinsupp.toMultiset_single
@[simp]
theorem toMultiset_single (a : α) (n : ℕ) :
    toMultiset (DFinsupp.single a n) = Multiset.replicate n a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : ℕ)
Goal: DFinsupp.toMultiset (DFinsupp.single a n) = Multiset.replicate n a
-- Multiset.toDFinsupp_apply
@[simp]
theorem toDFinsupp_apply (s : Multiset α) (a : α) : Multiset.toDFinsupp s a = s.count a 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (a : α)
Goal: (Multiset.toDFinsupp s) a = Multiset.count a s
-- Multiset.toDFinsupp_support
@[simp]
theorem toDFinsupp_support (s : Multiset α) : s.toDFinsupp.support = s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: (Multiset.toDFinsupp s).support = s.toFinset
-- Multiset.toDFinsupp_replicate
@[simp]
theorem toDFinsupp_replicate (a : α) (n : ℕ) :
    toDFinsupp (Multiset.replicate n a) = DFinsupp.single a n 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : ℕ)
Goal: Multiset.toDFinsupp (Multiset.replicate n a) = DFinsupp.single a n
-- Multiset.toDFinsupp_singleton
@[simp]
theorem toDFinsupp_singleton (a : α) : toDFinsupp {a} = DFinsupp.single a 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: Multiset.toDFinsupp {a} = DFinsupp.single a 1
-- Multiset.equivDFinsupp_symm_apply
@[simps! apply symm_apply]
def equivDFinsupp : Multiset α ≃+ Π₀ _ : α, ℕ 
Arguments: {α : Type u_1} [DecidableEq α] (a : Π₀ (x : α), ℕ)
Goal: Multiset.equivDFinsupp.symm a = DFinsupp.toMultiset a
-- Multiset.equivDFinsupp_apply
@[simps! apply symm_apply]
def equivDFinsupp : Multiset α ≃+ Π₀ _ : α, ℕ 
Arguments: {α : Type u_1} [DecidableEq α] (a : Multiset α)
Goal: Multiset.equivDFinsupp a = Multiset.toDFinsupp a
-- Multiset.toDFinsupp_toMultiset
@[simp]
theorem toDFinsupp_toMultiset (s : Multiset α) : DFinsupp.toMultiset (Multiset.toDFinsupp s) = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: DFinsupp.toMultiset (Multiset.toDFinsupp s) = s
-- Multiset.toDFinsupp_injective
theorem toDFinsupp_injective : Injective (toDFinsupp : Multiset α → Π₀ _a, ℕ) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Function.Injective ⇑Multiset.toDFinsupp
-- Multiset.toDFinsupp_inj
@[simp]
theorem toDFinsupp_inj : toDFinsupp s = toDFinsupp t ↔ s = t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: Multiset.toDFinsupp s = Multiset.toDFinsupp t ↔ s = t
-- Multiset.toDFinsupp_le_toDFinsupp
@[simp]
theorem toDFinsupp_le_toDFinsupp : toDFinsupp s ≤ toDFinsupp t ↔ s ≤ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: Multiset.toDFinsupp s ≤ Multiset.toDFinsupp t ↔ s ≤ t
-- Multiset.toDFinsupp_lt_toDFinsupp
@[simp]
theorem toDFinsupp_lt_toDFinsupp : toDFinsupp s < toDFinsupp t ↔ s < t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: Multiset.toDFinsupp s < Multiset.toDFinsupp t ↔ s < t
-- Multiset.toDFinsupp_inter
@[simp]
theorem toDFinsupp_inter (s t : Multiset α) : toDFinsupp (s ∩ t) = toDFinsupp s ⊓ toDFinsupp t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: Multiset.toDFinsupp (s ∩ t) = Multiset.toDFinsupp s ⊓ Multiset.toDFinsupp t
-- Multiset.toDFinsupp_union
@[simp]
theorem toDFinsupp_union (s t : Multiset α) : toDFinsupp (s ∪ t) = toDFinsupp s ⊔ toDFinsupp t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: Multiset.toDFinsupp (s ∪ t) = Multiset.toDFinsupp s ⊔ Multiset.toDFinsupp t
-- DFinsupp.toMultiset_toDFinsupp
@[simp]
theorem toMultiset_toDFinsupp (f : Π₀ _ : α, ℕ) :
    Multiset.toDFinsupp (DFinsupp.toMultiset f) = f 
Arguments: {α : Type u_1} [DecidableEq α] (f : Π₀ (x : α), ℕ)
Goal: Multiset.toDFinsupp (DFinsupp.toMultiset f) = f
-- DFinsupp.toMultiset_injective
theorem toMultiset_injective : Injective (toMultiset : (Π₀ _a, ℕ) → Multiset α) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Function.Injective ⇑DFinsupp.toMultiset
-- DFinsupp.toMultiset_inj
@[simp]
theorem toMultiset_inj : toMultiset f = toMultiset g ↔ f = g 
Arguments: {α : Type u_1} [DecidableEq α] {f g : Π₀ (_a : α), ℕ}
Goal: DFinsupp.toMultiset f = DFinsupp.toMultiset g ↔ f = g
-- DFinsupp.toMultiset_le_toMultiset
@[simp]
theorem toMultiset_le_toMultiset : toMultiset f ≤ toMultiset g ↔ f ≤ g 
Arguments: {α : Type u_1} [DecidableEq α] {f g : Π₀ (_a : α), ℕ}
Goal: DFinsupp.toMultiset f ≤ DFinsupp.toMultiset g ↔ f ≤ g
-- DFinsupp.toMultiset_lt_toMultiset
@[simp]
theorem toMultiset_lt_toMultiset : toMultiset f < toMultiset g ↔ f < g 
Arguments: {α : Type u_1} [DecidableEq α] {f g : Π₀ (_a : α), ℕ}
Goal: DFinsupp.toMultiset f < DFinsupp.toMultiset g ↔ f < g
-- DFinsupp.toMultiset_inf
@[simp]
theorem toMultiset_inf : toMultiset (f ⊓ g) = toMultiset f ∩ toMultiset g 
Arguments: {α : Type u_1} [DecidableEq α] (f g : Π₀ (_a : α), ℕ)
Goal: DFinsupp.toMultiset (f ⊓ g) = DFinsupp.toMultiset f ∩ DFinsupp.toMultiset g
-- DFinsupp.toMultiset_sup
@[simp]
theorem toMultiset_sup : toMultiset (f ⊔ g) = toMultiset f∪ toMultiset g 
Arguments: {α : Type u_1} [DecidableEq α] (f g : Π₀ (_a : α), ℕ)
Goal: DFinsupp.toMultiset (f ⊔ g) = DFinsupp.toMultiset f ∪ DFinsupp.toMultiset g
-- DFinsupp.mem_neLocus
@[simp]
theorem mem_neLocus {f g : Π₀ a, N a} {a : α} : a ∈ f.neLocus g ↔ f a ≠ g a 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] {f g : Π₀ (a : α), N a} {a : α}
Goal: a ∈ f.neLocus g ↔ f a ≠ g a
-- DFinsupp.not_mem_neLocus
theorem not_mem_neLocus {f g : Π₀ a, N a} {a : α} : a ∉ f.neLocus g ↔ f a = g a 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] {f g : Π₀ (a : α), N a} {a : α}
Goal: a ∉ f.neLocus g ↔ f a = g a
-- DFinsupp.coe_neLocus
@[simp]
theorem coe_neLocus : ↑(f.neLocus g) = { x | f x ≠ g x } 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] (f g : Π₀ (a : α), N a)
Goal: ↑(f.neLocus g) = {x | f x ≠ g x}
-- DFinsupp.neLocus_eq_empty
@[simp]
theorem neLocus_eq_empty {f g : Π₀ a, N a} : f.neLocus g = ∅ ↔ f = g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] {f g : Π₀ (a : α), N a}
Goal: f.neLocus g = ∅ ↔ f = g
-- DFinsupp.nonempty_neLocus_iff
@[simp]
theorem nonempty_neLocus_iff {f g : Π₀ a, N a} : (f.neLocus g).Nonempty ↔ f ≠ g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] {f g : Π₀ (a : α), N a}
Goal: (f.neLocus g).Nonempty ↔ f ≠ g
-- DFinsupp.neLocus_comm
theorem neLocus_comm : f.neLocus g = g.neLocus f 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] (f g : Π₀ (a : α), N a)
Goal: f.neLocus g = g.neLocus f
-- DFinsupp.neLocus_zero_right
@[simp]
theorem neLocus_zero_right : f.neLocus 0 = f.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] (f : Π₀ (a : α), N a)
Goal: f.neLocus 0 = f.support
-- DFinsupp.neLocus_zero_left
@[simp]
theorem neLocus_zero_left : (0 : Π₀ a, N a).neLocus f = f.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → Zero (N a)] (f : Π₀ (a : α), N a)
Goal: DFinsupp.neLocus 0 f = f.support
-- DFinsupp.subset_mapRange_neLocus
theorem subset_mapRange_neLocus [∀ a, DecidableEq (N a)] [∀ a, DecidableEq (M a)] (f g : Π₀ a, N a)
    {F : ∀ a, N a → M a} (F0 : ∀ a, F a 0 = 0) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) ⊆ f.neLocus g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] {M : α → Type u_3} [(a : α) → Zero (N a)] [(a : α) → Zero (M a)] [(a : α) → DecidableEq (N a)] [(a : α) → DecidableEq (M a)] (f g : Π₀ (a : α), N a) {F : (a : α) → N a → M a} (F0 : ∀ (a : α), F a 0 = 0)
Goal: (DFinsupp.mapRange F F0 f).neLocus (DFinsupp.mapRange F F0 g) ⊆ f.neLocus g
-- DFinsupp.zipWith_neLocus_eq_left
theorem zipWith_neLocus_eq_left [∀ a, DecidableEq (N a)] [∀ a, DecidableEq (P a)]
    {F : ∀ a, M a → N a → P a} (F0 : ∀ a, F a 0 0 = 0) (f : Π₀ a, M a) (g₁ g₂ : Π₀ a, N a)
    (hF : ∀ a f, Function.Injective fun g ↦ F a f g) :
    (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂ 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] {M : α → Type u_3} {P : α → Type u_4} [(a : α) → Zero (N a)] [(a : α) → Zero (M a)] [(a : α) → Zero (P a)] [(a : α) → DecidableEq (N a)] [(a : α) → DecidableEq (P a)] {F : (a : α) → M a → N a → P a} (F0 : ∀ (a : α), F a 0 0 = 0) (f : Π₀ (a : α), M a) (g₁ g₂ : Π₀ (a : α), N a) (hF : ∀ (a : α) (f : M a), Function.Injective fun g => F a f g)
Goal: (DFinsupp.zipWith F F0 f g₁).neLocus (DFinsupp.zipWith F F0 f g₂) = g₁.neLocus g₂
-- DFinsupp.zipWith_neLocus_eq_right
theorem zipWith_neLocus_eq_right [∀ a, DecidableEq (M a)] [∀ a, DecidableEq (P a)]
    {F : ∀ a, M a → N a → P a} (F0 : ∀ a, F a 0 0 = 0) (f₁ f₂ : Π₀ a, M a) (g : Π₀ a, N a)
    (hF : ∀ a g, Function.Injective fun f ↦ F a f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂ 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] {M : α → Type u_3} {P : α → Type u_4} [(a : α) → Zero (N a)] [(a : α) → Zero (M a)] [(a : α) → Zero (P a)] [(a : α) → DecidableEq (M a)] [(a : α) → DecidableEq (P a)] {F : (a : α) → M a → N a → P a} (F0 : ∀ (a : α), F a 0 0 = 0) (f₁ f₂ : Π₀ (a : α), M a) (g : Π₀ (a : α), N a) (hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g)
Goal: (DFinsupp.zipWith F F0 f₁ g).neLocus (DFinsupp.zipWith F F0 f₂ g) = f₁.neLocus f₂
-- DFinsupp.mapRange_neLocus_eq
theorem mapRange_neLocus_eq [∀ a, DecidableEq (N a)] [∀ a, DecidableEq (M a)] (f g : Π₀ a, N a)
    {F : ∀ a, N a → M a} (F0 : ∀ a, F a 0 = 0) (hF : ∀ a, Function.Injective (F a)) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) = f.neLocus g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] {M : α → Type u_3} [(a : α) → Zero (N a)] [(a : α) → Zero (M a)] [(a : α) → DecidableEq (N a)] [(a : α) → DecidableEq (M a)] (f g : Π₀ (a : α), N a) {F : (a : α) → N a → M a} (F0 : ∀ (a : α), F a 0 = 0) (hF : ∀ (a : α), Function.Injective (F a))
Goal: (DFinsupp.mapRange F F0 f).neLocus (DFinsupp.mapRange F F0 g) = f.neLocus g
-- DFinsupp.neLocus_add_left
@[simp]
theorem neLocus_add_left [∀ a, AddLeftCancelMonoid (N a)] (f g h : Π₀ a, N a) :
    (f + g).neLocus (f + h) = g.neLocus h 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddLeftCancelMonoid (N a)] (f g h : Π₀ (a : α), N a)
Goal: (f + g).neLocus (f + h) = g.neLocus h
-- DFinsupp.neLocus_add_right
@[simp]
theorem neLocus_add_right [∀ a, AddRightCancelMonoid (N a)] (f g h : Π₀ a, N a) :
    (f + h).neLocus (g + h) = f.neLocus g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddRightCancelMonoid (N a)] (f g h : Π₀ (a : α), N a)
Goal: (f + h).neLocus (g + h) = f.neLocus g
-- DFinsupp.neLocus_neg_neg
@[simp]
theorem neLocus_neg_neg : neLocus (-f) (-g) = f.neLocus g 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: (-f).neLocus (-g) = f.neLocus g
-- DFinsupp.neLocus_neg
theorem neLocus_neg : neLocus (-f) g = f.neLocus (-g) 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: (-f).neLocus g = f.neLocus (-g)
-- DFinsupp.neLocus_eq_support_sub
theorem neLocus_eq_support_sub : f.neLocus g = (f - g).support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: f.neLocus g = (f - g).support
-- DFinsupp.neLocus_sub_left
@[simp]
theorem neLocus_sub_left : neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂ 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g₁ g₂ : Π₀ (a : α), N a)
Goal: (f - g₁).neLocus (f - g₂) = g₁.neLocus g₂
-- DFinsupp.neLocus_sub_right
@[simp]
theorem neLocus_sub_right : neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂ 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f₁ f₂ g : Π₀ (a : α), N a)
Goal: (f₁ - g).neLocus (f₂ - g) = f₁.neLocus f₂
-- DFinsupp.neLocus_self_add_right
@[simp]
theorem neLocus_self_add_right : neLocus f (f + g) = g.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: f.neLocus (f + g) = g.support
-- DFinsupp.neLocus_self_add_left
@[simp]
theorem neLocus_self_add_left : neLocus (f + g) f = g.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: (f + g).neLocus f = g.support
-- DFinsupp.neLocus_self_sub_right
@[simp]
theorem neLocus_self_sub_right : neLocus f (f - g) = g.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: f.neLocus (f - g) = g.support
-- DFinsupp.neLocus_self_sub_left
@[simp]
theorem neLocus_self_sub_left : neLocus (f - g) f = g.support 
Arguments: {α : Type u_1} {N : α → Type u_2} [DecidableEq α] [(a : α) → DecidableEq (N a)] [(a : α) → AddGroup (N a)] (f g : Π₀ (a : α), N a)
Goal: (f - g).neLocus f = g.support
-- Rel.ext
@[ext] theorem ext {r s : Rel α β} : (∀ a, r a = s a) → r = s 
Arguments: {α : Type u_1} {β : Type u_2} {r s : Rel α β}
Goal: (∀ (a : α), r a = s a) → r = s
-- Rel.inv_def
theorem inv_def (x : α) (y : β) : r.inv y x ↔ r x y 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (x : α) (y : β)
Goal: r.inv y x ↔ r x y
-- Rel.inv_inv
theorem inv_inv : inv (inv r) = r 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.inv.inv = r
-- Rel.dom_mono
theorem dom_mono {r s : Rel α β} (h : r ≤ s) : dom r ⊆ dom s 
Arguments: {α : Type u_1} {β : Type u_2} {r s : Rel α β} (h : r ≤ s)
Goal: r.dom ⊆ s.dom
-- Rel.codom_inv
theorem codom_inv : r.inv.codom = r.dom 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.inv.codom = r.dom
-- Rel.dom_inv
theorem dom_inv : r.inv.dom = r.codom 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.inv.dom = r.codom
-- Rel.comp_assoc
theorem comp_assoc {δ : Type*} (r : Rel α β) (s : Rel β γ) (t : Rel γ δ) :
    (r • s) • t = r • (s • t) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (r : Rel α β) (s : Rel β γ) (t : Rel γ δ)
Goal: (r.comp s).comp t = r.comp (s.comp t)
-- Rel.comp_right_id
@[simp]
theorem comp_right_id (r : Rel α β) : r • @Eq β = r 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.comp Eq = r
-- Rel.comp_left_id
@[simp]
theorem comp_left_id (r : Rel α β) : @Eq α • r = r 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: Rel.comp Eq r = r
-- Rel.comp_right_bot
@[simp]
theorem comp_right_bot (r : Rel α β) : r • (⊥ : Rel β γ) = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β)
Goal: r.comp ⊥ = ⊥
-- Rel.comp_left_bot
@[simp]
theorem comp_left_bot (r : Rel α β) : (⊥ : Rel γ α) • r = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β)
Goal: ⊥.comp r = ⊥
-- Rel.comp_right_top
@[simp]
theorem comp_right_top (r : Rel α β) : r • (⊤ : Rel β γ) = fun x _ ↦ x ∈ r.dom 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β)
Goal: r.comp ⊤ = fun x x_1 => x ∈ r.dom
-- Rel.comp_left_top
@[simp]
theorem comp_left_top (r : Rel α β) : (⊤ : Rel γ α) • r = fun _ y ↦ y ∈ r.codom 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β)
Goal: ⊤.comp r = fun x y => y ∈ r.codom
-- Rel.inv_id
theorem inv_id : inv (@Eq α) = @Eq α 
Arguments: {α : Type u_1}
Goal: Rel.inv Eq = Eq
-- Rel.inv_comp
theorem inv_comp (r : Rel α β) (s : Rel β γ) : inv (r • s) = inv s • inv r 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β) (s : Rel β γ)
Goal: (r.comp s).inv = s.inv.comp r.inv
-- Rel.inv_bot
@[simp]
theorem inv_bot : (⊥ : Rel α β).inv = (⊥ : Rel β α) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ⊥.inv = ⊥
-- Rel.inv_top
@[simp]
theorem inv_top : (⊤ : Rel α β).inv = (⊤ : Rel β α) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ⊤.inv = ⊤
-- Rel.mem_image
theorem mem_image (y : β) (s : Set α) : y ∈ image r s ↔ ∃ x ∈ s, r x y 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (y : β) (s : Set α)
Goal: y ∈ r.image s ↔ ∃ x ∈ s, r x y
-- Rel.image_subset
theorem image_subset : ((· ⊆ ·) ⇒ (· ⊆ ·)) r.image r.image 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: ((fun x x_1 => x ⊆ x_1) ⇒ fun x x_1 => x ⊆ x_1) r.image r.image
-- Rel.image_mono
theorem image_mono : Monotone r.image 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: Monotone r.image
-- Rel.image_inter
theorem image_inter (s t : Set α) : r.image (s ∩ t) ⊆ r.image s ∩ r.image t 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s t : Set α)
Goal: r.image (s ∩ t) ⊆ r.image s ∩ r.image t
-- Rel.image_union
theorem image_union (s t : Set α) : r.image (s ∪ t) = r.image s ∪ r.image t 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s t : Set α)
Goal: r.image (s ∪ t) = r.image s ∪ r.image t
-- Rel.image_id
@[simp]
theorem image_id (s : Set α) : image (@Eq α) s = s 
Arguments: {α : Type u_1} (s : Set α)
Goal: Rel.image Eq s = s
-- Rel.image_comp
theorem image_comp (s : Rel β γ) (t : Set α) : image (r • s) t = image s (image r t) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β) (s : Rel β γ) (t : Set α)
Goal: (r.comp s).image t = s.image (r.image t)
-- Rel.image_univ
theorem image_univ : r.image Set.univ = r.codom 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.image Set.univ = r.codom
-- Rel.image_empty
@[simp]
theorem image_empty : r.image ∅ = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.image ∅ = ∅
-- Rel.image_bot
@[simp]
theorem image_bot (s : Set α) : (⊥ : Rel α β).image s = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α)
Goal: ⊥.image s = ∅
-- Rel.image_top
@[simp]
theorem image_top {s : Set α} (h : Set.Nonempty s) :
    (⊤ : Rel α β).image s = Set.univ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} (h : s.Nonempty)
Goal: ⊤.image s = Set.univ
-- Rel.mem_preimage
theorem mem_preimage (x : α) (s : Set β) : x ∈ r.preimage s ↔ ∃ y ∈ s, r x y 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (x : α) (s : Set β)
Goal: x ∈ r.preimage s ↔ ∃ y ∈ s, r x y
-- Rel.preimage_def
theorem preimage_def (s : Set β) : preimage r s = { x | ∃ y ∈ s, r x y } 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s : Set β)
Goal: r.preimage s = {x | ∃ y ∈ s, r x y}
-- Rel.preimage_mono
theorem preimage_mono {s t : Set β} (h : s ⊆ t) : r.preimage s ⊆ r.preimage t 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) {s t : Set β} (h : s ⊆ t)
Goal: r.preimage s ⊆ r.preimage t
-- Rel.preimage_inter
theorem preimage_inter (s t : Set β) : r.preimage (s ∩ t) ⊆ r.preimage s ∩ r.preimage t 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s t : Set β)
Goal: r.preimage (s ∩ t) ⊆ r.preimage s ∩ r.preimage t
-- Rel.preimage_union
theorem preimage_union (s t : Set β) : r.preimage (s ∪ t) = r.preimage s ∪ r.preimage t 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s t : Set β)
Goal: r.preimage (s ∪ t) = r.preimage s ∪ r.preimage t
-- Rel.preimage_id
theorem preimage_id (s : Set α) : preimage (@Eq α) s = s 
Arguments: {α : Type u_1} (s : Set α)
Goal: Rel.preimage Eq s = s
-- Rel.preimage_comp
theorem preimage_comp (s : Rel β γ) (t : Set γ) :
    preimage (r • s) t = preimage r (preimage s t) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (r : Rel α β) (s : Rel β γ) (t : Set γ)
Goal: (r.comp s).preimage t = r.preimage (s.preimage t)
-- Rel.preimage_univ
theorem preimage_univ : r.preimage Set.univ = r.dom 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.preimage Set.univ = r.dom
-- Rel.preimage_empty
@[simp]
theorem preimage_empty : r.preimage ∅ = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β)
Goal: r.preimage ∅ = ∅
-- Rel.preimage_inv
@[simp]
theorem preimage_inv (s : Set α) : r.inv.preimage s = r.image s 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) (s : Set α)
Goal: r.inv.preimage s = r.image s
-- Rel.preimage_bot
@[simp]
theorem preimage_bot (s : Set β) : (⊥ : Rel α β).preimage s = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set β)
Goal: ⊥.preimage s = ∅
-- Rel.preimage_top
@[simp]
theorem preimage_top {s : Set β} (h : Set.Nonempty s) :
    (⊤ : Rel α β).preimage s = Set.univ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set β} (h : s.Nonempty)
Goal: ⊤.preimage s = Set.univ
-- Rel.image_eq_dom_of_codomain_subset
theorem image_eq_dom_of_codomain_subset {s : Set β} (h : r.codom ⊆ s) : r.preimage s = r.dom 
Arguments: {α : Type u_1} {β : Type u_2} (r : Rel α β) {s : Set β} (h : r.codom ⊆ s)
Goal: r.preimage s = r.dom