File: Mathlib/Data/Finsupp/Lex.lean

full_name: Finsupp.Lex
code: /-- `Finsupp.Lex r s` is the lexicographic relation on `α →₀ N`, where `α` is ordered by `r`,
and `N` is ordered by `s`.

The type synonym `Lex (α →₀ N)` has an order given by `Finsupp.Lex (· < ·) (· < ·)`.
-/
protected def Lex (r : α → α → Prop) (s : N → N → Prop) (x y : α →₀ N) : Prop 
goal: Prop

full_name: Pi.lex_eq_finsupp_lex
code: theorem _root_.Pi.lex_eq_finsupp_lex {r : α → α → Prop} {s : N → N → Prop} (a b : α →₀ N) :
    Pi.Lex r s a b = Finsupp.Lex r s a b 
goal: Pi.Lex r (fun {i} => s) ⇑a ⇑b = Finsupp.Lex r s a b

full_name: Finsupp.lex_def
code: theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N} :
    Finsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s (a j) (b j) 
goal: Finsupp.Lex r s a b ↔ ∃ j, (∀ (d : α), r d j → a d = b d) ∧ s (a j) (b j)

full_name: Finsupp.lex_eq_invImage_dfinsupp_lex
code: theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
    Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun _ ↦ s) toDFinsupp 
goal: Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun x => s) Finsupp.toDFinsupp

full_name: Finsupp.instLTLex
code: instance [LT α] [LT N] : LT (Lex (α →₀ N)) 
goal: LT (Lex (α →₀ N))

full_name: Finsupp.lex_lt_of_lt_of_preorder
code: theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
    ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i 
goal: ∃ i, (∀ (j : α), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i

full_name: Finsupp.lex_lt_of_lt
code: theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
    Pi.Lex r (· < ·) x y 
goal: Pi.Lex r (fun {i} x x_1 => x < x_1) ⇑x ⇑y

full_name: Finsupp.Lex.isStrictOrder
code: instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
    IsStrictOrder (Lex (α →₀ N)) (· < ·) 
goal: IsStrictOrder (Lex (α →₀ N)) fun x x_1 => x < x_1

full_name: Finsupp.Lex.partialOrder
code: /-- The partial order on `Finsupp`s obtained by the lexicographic ordering.
See `Finsupp.Lex.linearOrder` for a proof that this partial order is in fact linear. -/
instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) 
goal: PartialOrder (Lex (α →₀ N))

full_name: Finsupp.Lex.linearOrder
code: /-- The linear order on `Finsupp`s obtained by the lexicographic ordering. -/
instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) 
goal: LinearOrder (Lex (α →₀ N))

full_name: Finsupp.toLex_monotone
code: theorem toLex_monotone : Monotone (@toLex (α →₀ N)) 
goal: Monotone ⇑toLex

full_name: Finsupp.lt_of_forall_lt_of_lt
code: theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
    (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b 
goal: (∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b

full_name: Finsupp.Lex.covariantClass_lt_left
code: instance Lex.covariantClass_lt_left :
    CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) 
goal: CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Finsupp.Lex.covariantClass_le_left
code: instance Lex.covariantClass_le_left :
    CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) 
goal: CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Finsupp.Lex.covariantClass_lt_right
code: instance Lex.covariantClass_lt_right :
    CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) 
goal: CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Finsupp.Lex.covariantClass_le_right
code: instance Lex.covariantClass_le_right :
    CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) 
goal: CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Finsupp.Lex.orderBot
code: instance Lex.orderBot [CanonicallyOrderedAddCommMonoid N] : OrderBot (Lex (α →₀ N)) 
goal: OrderBot (Lex (α →₀ N))

full_name: Finsupp.Lex.orderedAddCancelCommMonoid
code: noncomputable instance Lex.orderedAddCancelCommMonoid [OrderedCancelAddCommMonoid N] :
    OrderedCancelAddCommMonoid (Lex (α →₀ N)) 
goal: OrderedCancelAddCommMonoid (Lex (α →₀ N))

full_name: Finsupp.Lex.orderedAddCommGroup
code: noncomputable instance Lex.orderedAddCommGroup [OrderedAddCommGroup N] :
    OrderedAddCommGroup (Lex (α →₀ N)) 
goal: OrderedAddCommGroup (Lex (α →₀ N))

full_name: Finsupp.Lex.linearOrderedCancelAddCommMonoid
code: noncomputable instance Lex.linearOrderedCancelAddCommMonoid [LinearOrderedCancelAddCommMonoid N] :
    LinearOrderedCancelAddCommMonoid (Lex (α →₀ N)) 
goal: LinearOrderedCancelAddCommMonoid (Lex (α →₀ N))

full_name: Finsupp.Lex.linearOrderedAddCommGroup
code: noncomputable instance Lex.linearOrderedAddCommGroup [LinearOrderedAddCommGroup N] :
    LinearOrderedAddCommGroup (Lex (α →₀ N)) 
goal: LinearOrderedAddCommGroup (Lex (α →₀ N))