File: Mathlib/Data/Finsupp/NeLocus.lean

full_name: Finsupp.neLocus
code: /-- Given two finitely supported functions `f g : α →₀ N`, `Finsupp.neLocus f g` is the `Finset`
where `f` and `g` differ. This generalizes `(f - g).support` to situations without subtraction. -/
def neLocus (f g : α →₀ N) : Finset α 
goal: Finset α

full_name: Finsupp.mem_neLocus
code: @[simp]
theorem mem_neLocus {f g : α →₀ N} {a : α} : a ∈ f.neLocus g ↔ f a ≠ g a 
goal: a ∈ f.neLocus g ↔ f a ≠ g a

full_name: Finsupp.not_mem_neLocus
code: theorem not_mem_neLocus {f g : α →₀ N} {a : α} : a ∉ f.neLocus g ↔ f a = g a 
goal: a ∉ f.neLocus g ↔ f a = g a

full_name: Finsupp.coe_neLocus
code: @[simp]
theorem coe_neLocus : ↑(f.neLocus g) = { x | f x ≠ g x } 
goal: ↑(f.neLocus g) = {x | f x ≠ g x}

full_name: Finsupp.neLocus_eq_empty
code: @[simp]
theorem neLocus_eq_empty {f g : α →₀ N} : f.neLocus g = ∅ ↔ f = g 
goal: f.neLocus g = ∅ ↔ f = g

full_name: Finsupp.nonempty_neLocus_iff
code: @[simp]
theorem nonempty_neLocus_iff {f g : α →₀ N} : (f.neLocus g).Nonempty ↔ f ≠ g 
goal: (f.neLocus g).Nonempty ↔ f ≠ g

full_name: Finsupp.neLocus_comm
code: theorem neLocus_comm : f.neLocus g = g.neLocus f 
goal: f.neLocus g = g.neLocus f

full_name: Finsupp.neLocus_zero_right
code: @[simp]
theorem neLocus_zero_right : f.neLocus 0 = f.support 
goal: f.neLocus 0 = f.support

full_name: Finsupp.neLocus_zero_left
code: @[simp]
theorem neLocus_zero_left : (0 : α →₀ N).neLocus f = f.support 
goal: Finsupp.neLocus 0 f = f.support

full_name: Finsupp.subset_mapRange_neLocus
code: theorem subset_mapRange_neLocus [DecidableEq N] [Zero N] [DecidableEq M] [Zero M] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) : (f.mapRange F F0).neLocus (g.mapRange F F0) ⊆ f.neLocus g 
goal: (Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) ⊆ f.neLocus g

full_name: Finsupp.zipWith_neLocus_eq_left
code: theorem zipWith_neLocus_eq_left [DecidableEq N] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f : α →₀ M) (g₁ g₂ : α →₀ N)
    (hF : ∀ f, Function.Injective fun g => F f g) :
    (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂ 
goal: (Finsupp.zipWith F F0 f g₁).neLocus (Finsupp.zipWith F F0 f g₂) = g₁.neLocus g₂

full_name: Finsupp.zipWith_neLocus_eq_right
code: theorem zipWith_neLocus_eq_right [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N)
    (hF : ∀ g, Function.Injective fun f => F f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂ 
goal: (Finsupp.zipWith F F0 f₁ g).neLocus (Finsupp.zipWith F F0 f₂ g) = f₁.neLocus f₂

full_name: Finsupp.mapRange_neLocus_eq
code: theorem mapRange_neLocus_eq [DecidableEq N] [DecidableEq M] [Zero M] [Zero N] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) (hF : Function.Injective F) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) = f.neLocus g 
goal: (Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) = f.neLocus g

full_name: Finsupp.neLocus_add_left
code: @[simp]
theorem neLocus_add_left [AddLeftCancelMonoid N] (f g h : α →₀ N) :
    (f + g).neLocus (f + h) = g.neLocus h 
goal: (f + g).neLocus (f + h) = g.neLocus h

full_name: Finsupp.neLocus_add_right
code: @[simp]
theorem neLocus_add_right [AddRightCancelMonoid N] (f g h : α →₀ N) :
    (f + h).neLocus (g + h) = f.neLocus g 
goal: (f + h).neLocus (g + h) = f.neLocus g

full_name: Finsupp.neLocus_neg_neg
code: @[simp]
theorem neLocus_neg_neg : neLocus (-f) (-g) = f.neLocus g 
goal: (-f).neLocus (-g) = f.neLocus g

full_name: Finsupp.neLocus_neg
code: theorem neLocus_neg : neLocus (-f) g = f.neLocus (-g) 
goal: (-f).neLocus g = f.neLocus (-g)

full_name: Finsupp.neLocus_eq_support_sub
code: theorem neLocus_eq_support_sub : f.neLocus g = (f - g).support 
goal: f.neLocus g = (f - g).support

full_name: Finsupp.neLocus_sub_left
code: @[simp]
theorem neLocus_sub_left : neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂ 
goal: (f - g₁).neLocus (f - g₂) = g₁.neLocus g₂

full_name: Finsupp.neLocus_sub_right
code: @[simp]
theorem neLocus_sub_right : neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂ 
goal: (f₁ - g).neLocus (f₂ - g) = f₁.neLocus f₂

full_name: Finsupp.neLocus_self_add_right
code: @[simp]
theorem neLocus_self_add_right : neLocus f (f + g) = g.support 
goal: f.neLocus (f + g) = g.support

full_name: Finsupp.neLocus_self_add_left
code: @[simp]
theorem neLocus_self_add_left : neLocus (f + g) f = g.support 
goal: (f + g).neLocus f = g.support

full_name: Finsupp.neLocus_self_sub_right
code: @[simp]
theorem neLocus_self_sub_right : neLocus f (f - g) = g.support 
goal: f.neLocus (f - g) = g.support

full_name: Finsupp.neLocus_self_sub_left
code: @[simp]
theorem neLocus_self_sub_left : neLocus (f - g) f = g.support 
goal: (f - g).neLocus f = g.support