File: Mathlib/Data/DFinsupp/NeLocus.lean

full_name: DFinsupp.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 : Π₀ a, N a) : Finset α 
goal: Finset α

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

full_name: DFinsupp.not_mem_neLocus
code: theorem not_mem_neLocus {f g : Π₀ a, N a} {a : α} : a ∉ f.neLocus g ↔ f a = g a 
goal: a ∉ f.neLocus g ↔ f a = g a

full_name: DFinsupp.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: DFinsupp.neLocus_eq_empty
code: @[simp]
theorem neLocus_eq_empty {f g : Π₀ a, N a} : f.neLocus g = ∅ ↔ f = g 
goal: f.neLocus g = ∅ ↔ f = g

full_name: DFinsupp.nonempty_neLocus_iff
code: @[simp]
theorem nonempty_neLocus_iff {f g : Π₀ a, N a} : (f.neLocus g).Nonempty ↔ f ≠ g 
goal: (f.neLocus g).Nonempty ↔ f ≠ g

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

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

full_name: DFinsupp.neLocus_zero_left
code: @[simp]
theorem neLocus_zero_left : (0 : Π₀ a, N a).neLocus f = f.support 
goal: DFinsupp.neLocus 0 f = f.support

full_name: DFinsupp.subset_mapRange_neLocus
code: 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 
goal: (DFinsupp.mapRange F F0 f).neLocus (DFinsupp.mapRange F F0 g) ⊆ f.neLocus g

full_name: DFinsupp.zipWith_neLocus_eq_left
code: 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₂ 
goal: (DFinsupp.zipWith F F0 f g₁).neLocus (DFinsupp.zipWith F F0 f g₂) = g₁.neLocus g₂

full_name: DFinsupp.zipWith_neLocus_eq_right
code: 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₂ 
goal: (DFinsupp.zipWith F F0 f₁ g).neLocus (DFinsupp.zipWith F F0 f₂ g) = f₁.neLocus f₂

full_name: DFinsupp.mapRange_neLocus_eq
code: 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 
goal: (DFinsupp.mapRange F F0 f).neLocus (DFinsupp.mapRange F F0 g) = f.neLocus g

full_name: DFinsupp.neLocus_add_left
code: @[simp]
theorem neLocus_add_left [∀ a, AddLeftCancelMonoid (N a)] (f g h : Π₀ a, N a) :
    (f + g).neLocus (f + h) = g.neLocus h 
goal: (f + g).neLocus (f + h) = g.neLocus h

full_name: DFinsupp.neLocus_add_right
code: @[simp]
theorem neLocus_add_right [∀ a, AddRightCancelMonoid (N a)] (f g h : Π₀ a, N a) :
    (f + h).neLocus (g + h) = f.neLocus g 
goal: (f + h).neLocus (g + h) = f.neLocus g

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

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

full_name: DFinsupp.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: DFinsupp.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: DFinsupp.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: DFinsupp.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: DFinsupp.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: DFinsupp.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: DFinsupp.neLocus_self_sub_left
code: @[simp]
theorem neLocus_self_sub_left : neLocus (f - g) f = g.support 
goal: (f - g).neLocus f = g.support