File: Mathlib/Data/DFinsupp/Order.lean

full_name: DFinsupp.instLE
code: instance : LE (Π₀ i, α i) 
goal: LE (Π₀ (i : ι), α i)

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

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

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

full_name: DFinsupp.coe_orderEmbeddingToFun
code: @[simp, norm_cast]
lemma coe_orderEmbeddingToFun : ⇑(orderEmbeddingToFun (α := α)) = DFunLike.coe 
goal: ⇑DFinsupp.orderEmbeddingToFun = DFunLike.coe

full_name: DFinsupp.orderEmbeddingToFun_apply
code: theorem orderEmbeddingToFun_apply {f : Π₀ i, α i} {i : ι} :
    (@orderEmbeddingToFun ι α _ _ f) i = f i 
goal: DFinsupp.orderEmbeddingToFun f i = f i

full_name: DFinsupp.instPreorder
code: instance : Preorder (Π₀ i, α i) 
goal: Preorder (Π₀ (i : ι), α i)

full_name: DFinsupp.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: DFinsupp.coe_lt_coe
code: @[simp, norm_cast] lemma coe_lt_coe : ⇑f < g ↔ f < g 
goal: ⇑f < ⇑g ↔ f < g

full_name: DFinsupp.coe_mono
code: lemma coe_mono : Monotone ((⇑) : (Π₀ i, α i) → ∀ i, α i) 
goal: Monotone DFunLike.coe

full_name: DFinsupp.coe_strictMono
code: lemma coe_strictMono : Monotone ((⇑) : (Π₀ i, α i) → ∀ i, α i) 
goal: Monotone DFunLike.coe

full_name: DFinsupp.instPartialOrder
code: instance [∀ i, PartialOrder (α i)] : PartialOrder (Π₀ i, α i) 
goal: PartialOrder (Π₀ (i : ι), α i)

full_name: DFinsupp.instSemilatticeInf
code: instance [∀ i, SemilatticeInf (α i)] : SemilatticeInf (Π₀ i, α i) 
goal: SemilatticeInf (Π₀ (i : ι), α i)

full_name: DFinsupp.coe_inf
code: @[simp, norm_cast]
lemma coe_inf [∀ i, SemilatticeInf (α i)] (f g : Π₀ i, α i) : f ⊓ g = ⇑f ⊓ g 
goal: ⇑(f ⊓ g) = ⇑f ⊓ ⇑g

full_name: DFinsupp.inf_apply
code: theorem inf_apply [∀ i, SemilatticeInf (α i)] (f g : Π₀ i, α i) (i : ι) : (f ⊓ g) i = f i ⊓ g i 
goal: (f ⊓ g) i = f i ⊓ g i

full_name: DFinsupp.instSemilatticeSup
code: instance [∀ i, SemilatticeSup (α i)] : SemilatticeSup (Π₀ i, α i) 
goal: SemilatticeSup (Π₀ (i : ι), α i)

full_name: DFinsupp.coe_sup
code: @[simp, norm_cast]
lemma coe_sup [∀ i, SemilatticeSup (α i)] (f g : Π₀ i, α i) : f ⊔ g = ⇑f ⊔ g 
goal: ⇑(f ⊔ g) = ⇑f ⊔ ⇑g

full_name: DFinsupp.sup_apply
code: theorem sup_apply [∀ i, SemilatticeSup (α i)] (f g : Π₀ i, α i) (i : ι) : (f ⊔ g) i = f i ⊔ g i 
goal: (f ⊔ g) i = f i ⊔ g i

full_name: DFinsupp.lattice
code: instance lattice : Lattice (Π₀ i, α i) 
goal: Lattice (Π₀ (i : ι), α i)

full_name: DFinsupp.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: DFinsupp.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: DFinsupp.instOrderedAddCommMonoid
code: instance (α : ι → Type*) [∀ i, OrderedAddCommMonoid (α i)] : OrderedAddCommMonoid (Π₀ i, α i) 
goal: OrderedAddCommMonoid (Π₀ (i : ι), α i)

full_name: DFinsupp.instOrderedCancelAddCommMonoid
code: instance (α : ι → Type*) [∀ i, OrderedCancelAddCommMonoid (α i)] :
    OrderedCancelAddCommMonoid (Π₀ i, α i) 
goal: OrderedCancelAddCommMonoid (Π₀ (i : ι), α i)

full_name: DFinsupp.instContravariantClassHAddLe
code: instance [∀ i, OrderedAddCommMonoid (α i)] [∀ i, ContravariantClass (α i) (α i) (· + ·) (· ≤ ·)] :
    ContravariantClass (Π₀ i, α i) (Π₀ i, α i) (· + ·) (· ≤ ·) 
goal: ContravariantClass (Π₀ (i : ι), α i) (Π₀ (i : ι), α i) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: DFinsupp.instPosSMulMono
code: instance instPosSMulMono [∀ i, PosSMulMono α (β i)] : PosSMulMono α (Π₀ i, β i) 
goal: PosSMulMono α (Π₀ (i : ι), β i)

full_name: DFinsupp.instSMulPosMono
code: instance instSMulPosMono [∀ i, SMulPosMono α (β i)] : SMulPosMono α (Π₀ i, β i) 
goal: SMulPosMono α (Π₀ (i : ι), β i)

full_name: DFinsupp.instPosSMulReflectLE
code: instance instPosSMulReflectLE [∀ i, PosSMulReflectLE α (β i)] : PosSMulReflectLE α (Π₀ i, β i) 
goal: PosSMulReflectLE α (Π₀ (i : ι), β i)

full_name: DFinsupp.instSMulPosReflectLE
code: instance instSMulPosReflectLE [∀ i, SMulPosReflectLE α (β i)] : SMulPosReflectLE α (Π₀ i, β i) 
goal: SMulPosReflectLE α (Π₀ (i : ι), β i)

full_name: DFinsupp.instPosSMulStrictMono
code: instance instPosSMulStrictMono [∀ i, PosSMulStrictMono α (β i)] : PosSMulStrictMono α (Π₀ i, β i) 
goal: PosSMulStrictMono α (Π₀ (i : ι), β i)

full_name: DFinsupp.instSMulPosStrictMono
code: instance instSMulPosStrictMono [∀ i, SMulPosStrictMono α (β i)] : SMulPosStrictMono α (Π₀ i, β i) 
goal: SMulPosStrictMono α (Π₀ (i : ι), β i)

full_name: DFinsupp.instSMulPosReflectLT
code: instance instSMulPosReflectLT [∀ i, SMulPosReflectLT α (β i)] : SMulPosReflectLT α (Π₀ i, β i) 
goal: SMulPosReflectLT α (Π₀ (i : ι), β i)

full_name: DFinsupp.instOrderBot
code: instance : OrderBot (Π₀ i, α i) 
goal: OrderBot (Π₀ (i : ι), α i)

full_name: DFinsupp.bot_eq_zero
code: protected theorem bot_eq_zero : (⊥ : Π₀ i, α i) = 0 
goal: ⊥ = 0

full_name: DFinsupp.add_eq_zero_iff
code: @[simp]
theorem add_eq_zero_iff (f g : Π₀ i, α i) : f + g = 0 ↔ f = 0 ∧ g = 0 
goal: f + g = 0 ↔ f = 0 ∧ g = 0

full_name: DFinsupp.le_iff'
code: theorem le_iff' (hf : f.support ⊆ s) : f ≤ g ↔ ∀ i ∈ s, f i ≤ g i 
goal: f ≤ g ↔ ∀ i ∈ s, f i ≤ g i

full_name: DFinsupp.le_iff
code: theorem le_iff : f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i 
goal: f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i

full_name: DFinsupp.support_monotone
code: lemma support_monotone : Monotone (support (ι := ι) (β := α)) 
goal: Monotone DFinsupp.support

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

full_name: DFinsupp.decidableLE
code: instance decidableLE [∀ i, DecidableRel (@LE.le (α i) _)] : DecidableRel (@LE.le (Π₀ i, α i) _) 
goal: DecidableRel LE.le

full_name: DFinsupp.single_le_iff
code: @[simp]
theorem single_le_iff {f : Π₀ i, α i} {i : ι} {a : α i} : single i a ≤ f ↔ a ≤ f i 
goal: DFinsupp.single i a ≤ f ↔ a ≤ f i

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

full_name: DFinsupp.tsub_apply
code: theorem tsub_apply (f g : Π₀ i, α i) (i : ι) : (f - g) i = f i - g i 
goal: (f - g) i = f i - g i

full_name: DFinsupp.coe_tsub
code: @[simp, norm_cast]
theorem coe_tsub (f g : Π₀ i, α i) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: DFinsupp.instOrderedSub
code: instance : OrderedSub (Π₀ i, α i) 
goal: OrderedSub (Π₀ (i : ι), α i)

full_name: DFinsupp.instCanonicallyOrderedAddCommMonoid
code: instance : CanonicallyOrderedAddCommMonoid (Π₀ i, α i) 
goal: CanonicallyOrderedAddCommMonoid (Π₀ (i : ι), α i)

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

full_name: DFinsupp.support_tsub
code: theorem support_tsub : (f - g).support ⊆ f.support 
goal: (f - g).support ⊆ f.support

full_name: DFinsupp.subset_support_tsub
code: theorem subset_support_tsub : f.support \ g.support ⊆ (f - g).support 
goal: f.support \ g.support ⊆ (f - g).support

full_name: DFinsupp.support_inf
code: @[simp]
theorem support_inf : (f ⊓ g).support = f.support ∩ g.support 
goal: (f ⊓ g).support = f.support ∩ g.support

full_name: DFinsupp.support_sup
code: @[simp]
theorem support_sup : (f ⊔ g).support = f.support ∪ g.support 
goal: (f ⊔ g).support = f.support ∪ g.support

full_name: DFinsupp.disjoint_iff
code: nonrec theorem disjoint_iff : Disjoint f g ↔ Disjoint f.support g.support 
goal: Disjoint f g ↔ Disjoint f.support g.support