File: Mathlib/Data/Finsupp/Order.lean

full_name: Finsupp.instLEFinsupp
code: instance instLEFinsupp : LE (ι →₀ α) 
goal: LE (ι →₀ α)

full_name: Finsupp.le_def
code: lemma le_def : f ≤ g ↔ ∀ i, f i ≤ g i 
goal: f ≤ g ↔ ∀ (i : ι), f i ≤ g i

full_name: Finsupp.coe_le_coe
code: @[simp, norm_cast] lemma coe_le_coe : ⇑f ≤ g ↔ f ≤ g 
goal: ⇑f ≤ ⇑g ↔ f ≤ g

full_name: Finsupp.orderEmbeddingToFun
code: /-- The order on `Finsupp`s over a partial order embeds into the order on functions -/
def orderEmbeddingToFun : (ι →₀ α) ↪o (ι → α) 
goal: (ι →₀ α) ↪o (ι → α)

full_name: Finsupp.orderEmbeddingToFun_apply
code: @[simp]
theorem orderEmbeddingToFun_apply {f : ι →₀ α} {i : ι} : orderEmbeddingToFun f i = f i 
goal: Finsupp.orderEmbeddingToFun f i = f i

full_name: Finsupp.preorder
code: instance preorder : Preorder (ι →₀ α) 
goal: Preorder (ι →₀ α)

full_name: Finsupp.lt_def
code: lemma lt_def : f < g ↔ f ≤ g ∧ ∃ i, f i < g i 
goal: f < g ↔ f ≤ g ∧ ∃ i, f i < g i

full_name: Finsupp.coe_lt_coe
code: @[simp, norm_cast] lemma coe_lt_coe : ⇑f < g ↔ f < g 
goal: ⇑f < ⇑g ↔ f < g

full_name: Finsupp.coe_mono
code: lemma coe_mono : Monotone (Finsupp.toFun : (ι →₀ α) → ι → α) 
goal: Monotone Finsupp.toFun

full_name: Finsupp.coe_strictMono
code: lemma coe_strictMono : Monotone (Finsupp.toFun : (ι →₀ α) → ι → α) 
goal: Monotone Finsupp.toFun

full_name: Finsupp.partialorder
code: instance partialorder [PartialOrder α] : PartialOrder (ι →₀ α) 
goal: PartialOrder (ι →₀ α)

full_name: Finsupp.semilatticeInf
code: instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (ι →₀ α) 
goal: SemilatticeInf (ι →₀ α)

full_name: Finsupp.inf_apply
code: @[simp]
theorem inf_apply [SemilatticeInf α] {i : ι} {f g : ι →₀ α} : (f ⊓ g) i = f i ⊓ g i 
goal: (f ⊓ g) i = f i ⊓ g i

full_name: Finsupp.semilatticeSup
code: instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (ι →₀ α) 
goal: SemilatticeSup (ι →₀ α)

full_name: Finsupp.sup_apply
code: @[simp]
theorem sup_apply [SemilatticeSup α] {i : ι} {f g : ι →₀ α} : (f ⊔ g) i = f i ⊔ g i 
goal: (f ⊔ g) i = f i ⊔ g i

full_name: Finsupp.lattice
code: instance lattice [Lattice α] : Lattice (ι →₀ α) 
goal: Lattice (ι →₀ α)

full_name: Finsupp.support_inf_union_support_sup
code: theorem support_inf_union_support_sup : (f ⊓ g).support ∪ (f ⊔ g).support = f.support ∪ g.support 
goal: (f ⊓ g).support ∪ (f ⊔ g).support = f.support ∪ g.support

full_name: Finsupp.support_sup_union_support_inf
code: theorem support_sup_union_support_inf : (f ⊔ g).support ∪ (f ⊓ g).support = f.support ∪ g.support 
goal: (f ⊔ g).support ∪ (f ⊓ g).support = f.support ∪ g.support

full_name: Finsupp.orderedAddCommMonoid
code: instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (ι →₀ α) 
goal: OrderedAddCommMonoid (ι →₀ α)

full_name: Finsupp.orderedCancelAddCommMonoid
code: instance orderedCancelAddCommMonoid [OrderedCancelAddCommMonoid α] :
    OrderedCancelAddCommMonoid (ι →₀ α) 
goal: OrderedCancelAddCommMonoid (ι →₀ α)

full_name: Finsupp.contravariantClass
code: instance contravariantClass [OrderedAddCommMonoid α] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    ContravariantClass (ι →₀ α) (ι →₀ α) (· + ·) (· ≤ ·) 
goal: ContravariantClass (ι →₀ α) (ι →₀ α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Finsupp.instPosSMulMono
code: instance instPosSMulMono [PosSMulMono α β] : PosSMulMono α (ι →₀ β) 
goal: PosSMulMono α (ι →₀ β)

full_name: Finsupp.instSMulPosMono
code: instance instSMulPosMono [SMulPosMono α β] : SMulPosMono α (ι →₀ β) 
goal: SMulPosMono α (ι →₀ β)

full_name: Finsupp.instPosSMulReflectLE
code: instance instPosSMulReflectLE [PosSMulReflectLE α β] : PosSMulReflectLE α (ι →₀ β) 
goal: PosSMulReflectLE α (ι →₀ β)

full_name: Finsupp.instSMulPosReflectLE
code: instance instSMulPosReflectLE [SMulPosReflectLE α β] : SMulPosReflectLE α (ι →₀ β) 
goal: SMulPosReflectLE α (ι →₀ β)

full_name: Finsupp.instPosSMulStrictMono
code: instance instPosSMulStrictMono [PosSMulStrictMono α β] : PosSMulStrictMono α (ι →₀ β) 
goal: PosSMulStrictMono α (ι →₀ β)

full_name: Finsupp.instSMulPosStrictMono
code: instance instSMulPosStrictMono [SMulPosStrictMono α β] : SMulPosStrictMono α (ι →₀ β) 
goal: SMulPosStrictMono α (ι →₀ β)

full_name: Finsupp.instSMulPosReflectLT
code: instance instSMulPosReflectLT [SMulPosReflectLT α β] : SMulPosReflectLT α (ι →₀ β) 
goal: SMulPosReflectLT α (ι →₀ β)

full_name: Finsupp.orderBot
code: instance orderBot : OrderBot (ι →₀ α) 
goal: OrderBot (ι →₀ α)

full_name: Finsupp.bot_eq_zero
code: protected theorem bot_eq_zero : (⊥ : ι →₀ α) = 0 
goal: ⊥ = 0

full_name: Finsupp.add_eq_zero_iff
code: @[simp]
theorem add_eq_zero_iff (f g : ι →₀ α) : f + g = 0 ↔ f = 0 ∧ g = 0 
goal: f + g = 0 ↔ f = 0 ∧ g = 0

full_name: Finsupp.le_iff'
code: theorem le_iff' (f g : ι →₀ α) {s : Finset ι} (hf : f.support ⊆ s) : f ≤ g ↔ ∀ i ∈ s, f i ≤ g i 
goal: f ≤ g ↔ ∀ i ∈ s, f i ≤ g i

full_name: Finsupp.le_iff
code: theorem le_iff (f g : ι →₀ α) : f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i 
goal: f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i

full_name: Finsupp.support_monotone
code: lemma support_monotone : Monotone (support (α := ι) (M := α)) 
goal: Monotone Finsupp.support

full_name: Finsupp.support_mono
code: lemma support_mono (hfg : f ≤ g) : f.support ⊆ g.support 
goal: f.support ⊆ g.support

full_name: Finsupp.decidableLE
code: instance decidableLE [DecidableRel (@LE.le α _)] : DecidableRel (@LE.le (ι →₀ α) _) 
goal: DecidableRel LE.le

full_name: Finsupp.decidableLT
code: instance decidableLT [DecidableRel (@LE.le α _)] : DecidableRel (@LT.lt (ι →₀ α) _) 
goal: DecidableRel LT.lt

full_name: Finsupp.single_le_iff
code: @[simp]
theorem single_le_iff {i : ι} {x : α} {f : ι →₀ α} : single i x ≤ f ↔ x ≤ f i 
goal: Finsupp.single i x ≤ f ↔ x ≤ f i

full_name: Finsupp.tsub
code: /-- This is called `tsub` for truncated subtraction, to distinguish it with subtraction in an
additive group. -/
instance tsub : Sub (ι →₀ α) 
goal: Sub (ι →₀ α)

full_name: Finsupp.orderedSub
code: instance orderedSub : OrderedSub (ι →₀ α) 
goal: OrderedSub (ι →₀ α)

full_name: Finsupp.instCanonicallyOrderedAddCommMonoid
code: instance : CanonicallyOrderedAddCommMonoid (ι →₀ α) 
goal: CanonicallyOrderedAddCommMonoid (ι →₀ α)

full_name: Finsupp.coe_tsub
code: @[simp, norm_cast] lemma coe_tsub (f g : ι →₀ α) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: Finsupp.tsub_apply
code: theorem tsub_apply (f g : ι →₀ α) (a : ι) : (f - g) a = f a - g a 
goal: (f - g) a = f a - g a

full_name: Finsupp.single_tsub
code: @[simp]
theorem single_tsub : single i (a - b) = single i a - single i b 
goal: Finsupp.single i (a - b) = Finsupp.single i a - Finsupp.single i b

full_name: Finsupp.support_tsub
code: theorem support_tsub {f1 f2 : ι →₀ α} : (f1 - f2).support ⊆ f1.support 
goal: (f1 - f2).support ⊆ f1.support

full_name: Finsupp.subset_support_tsub
code: theorem subset_support_tsub [DecidableEq ι] {f1 f2 : ι →₀ α} :
    f1.support \ f2.support ⊆ (f1 - f2).support 
goal: f1.support \ f2.support ⊆ (f1 - f2).support

full_name: Finsupp.support_inf
code: @[simp]
theorem support_inf [DecidableEq ι] (f g : ι →₀ α) : (f ⊓ g).support = f.support ∩ g.support 
goal: (f ⊓ g).support = f.support ∩ g.support

full_name: Finsupp.support_sup
code: @[simp]
theorem support_sup [DecidableEq ι] (f g : ι →₀ α) : (f ⊔ g).support = f.support ∪ g.support 
goal: (f ⊔ g).support = f.support ∪ g.support

full_name: Finsupp.disjoint_iff
code: nonrec theorem disjoint_iff {f g : ι →₀ α} : Disjoint f g ↔ Disjoint f.support g.support 
goal: Disjoint f g ↔ Disjoint f.support g.support

full_name: Finsupp.sub_single_one_add
code: theorem sub_single_one_add {a : ι} {u u' : ι →₀ ℕ} (h : u a ≠ 0) :
    u - single a 1 + u' = u + u' - single a 1 
goal: u - Finsupp.single a 1 + u' = u + u' - Finsupp.single a 1

full_name: Finsupp.add_sub_single_one
code: theorem add_sub_single_one {a : ι} {u u' : ι →₀ ℕ} (h : u' a ≠ 0) :
    u + (u' - single a 1) = u + u' - single a 1 
goal: u + (u' - Finsupp.single a 1) = u + u' - Finsupp.single a 1