File: Mathlib/Data/DFinsupp/Lex.lean

full_name: DFinsupp.Lex
code: /-- `DFinsupp.Lex r s` is the lexicographic relation on `Π₀ i, α i`, where `ι` is ordered by `r`,
and `α i` is ordered by `s i`.
The type synonym `Lex (Π₀ i, α i)` has an order given by `DFinsupp.Lex (· < ·) (· < ·)`.
-/
protected def Lex (r : ι → ι → Prop) (s : ∀ i, α i → α i → Prop) (x y : Π₀ i, α i) : Prop 
goal: Prop

full_name: Pi.lex_eq_dfinsupp_lex
code: theorem _root_.Pi.lex_eq_dfinsupp_lex {r : ι → ι → Prop} {s : ∀ i, α i → α i → Prop}
    (a b : Π₀ i, α i) : Pi.Lex r (s _) (a : ∀ i, α i) b = DFinsupp.Lex r s a b 
goal: Pi.Lex r (fun {i} => s i) ⇑a ⇑b = DFinsupp.Lex r s a b

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

full_name: DFinsupp.instLTLex
code: instance [LT ι] [∀ i, LT (α i)] : LT (Lex (Π₀ i, α i)) 
goal: LT (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.lex_lt_of_lt_of_preorder
code: theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (α i)] (r) [IsStrictOrder ι r] {x y : Π₀ i, α i}
    (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: DFinsupp.lex_lt_of_lt
code: theorem lex_lt_of_lt [∀ i, PartialOrder (α i)] (r) [IsStrictOrder ι r] {x y : Π₀ i, α i}
    (hlt : x < y) : Pi.Lex r (· < ·) x y 
goal: Pi.Lex r (fun {i} x x_1 => x < x_1) ⇑x ⇑y

full_name: DFinsupp.Lex.isStrictOrder
code: instance Lex.isStrictOrder [∀ i, PartialOrder (α i)] :
    IsStrictOrder (Lex (Π₀ i, α i)) (· < ·) 
goal: IsStrictOrder (Lex (Π₀ (i : ι), α i)) fun x x_1 => x < x_1

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

full_name: _private.Mathlib.Data.DFinsupp.Lex.0.DFinsupp.lt_trichotomy_rec
code: /-- Auxiliary helper to case split computably. There is no need for this to be public, as it
can be written with `Or.by_cases` on `lt_trichotomy` once the instances below are constructed. -/
private def lt_trichotomy_rec {P : Lex (Π₀ i, α i) → Lex (Π₀ i, α i) → Sort*}
    (h_lt : ∀ {f g}, toLex f < toLex g → P (toLex f) (toLex g))
    (h_eq : ∀ {f g}, toLex f = toLex g → P (toLex f) (toLex g))
    (h_gt : ∀ {f g}, toLex g < toLex f → P (toLex f) (toLex g)) : ∀ f g, P f g 
goal: P f g

full_name: DFinsupp.Lex.decidableLE
code: /-- The less-or-equal relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·) 
goal: DecidableRel fun x x_1 => x ≤ x_1

full_name: DFinsupp.wrapped._@.Mathlib.Data.DFinsupp.Lex._hyg.1404
code: /-- The less-or-equal relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·) 
goal: Subtype (Eq @DFinsupp.definition✝)

full_name: DFinsupp.definition._@.Mathlib.Data.DFinsupp.Lex._hyg.1404
code: /-- The less-or-equal relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·) 
goal: DecidableRel fun x x_1 => x ≤ x_1

full_name: DFinsupp.Lex.decidableLE_def
code: /-- The less-or-equal relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·) 
goal: DFinsupp.Lex.decidableLE =
  DFinsupp.lt_trichotomy_rec (fun {f g} h => isTrue ⋯) (fun {f g} h => isTrue ⋯) fun {f g} h => isFalse ⋯

full_name: DFinsupp.Lex.decidableLT_def
code: /-- The less-than relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·) 
goal: DFinsupp.Lex.decidableLT =
  DFinsupp.lt_trichotomy_rec (fun {f g} h => isTrue h) (fun {f g} h => isFalse ⋯) fun {f g} h => isFalse ⋯

full_name: DFinsupp.wrapped._@.Mathlib.Data.DFinsupp.Lex._hyg.1707
code: /-- The less-than relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·) 
goal: Subtype (Eq @DFinsupp.definition✝)

full_name: DFinsupp.Lex.decidableLT
code: /-- The less-than relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·) 
goal: DecidableRel fun x x_1 => x < x_1

full_name: DFinsupp.definition._@.Mathlib.Data.DFinsupp.Lex._hyg.1707
code: /-- The less-than relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·) 
goal: DecidableRel fun x x_1 => x < x_1

full_name: DFinsupp.instDecidableEqLex
code: instance : DecidableEq (Lex (Π₀ i, α i)) 
goal: DecidableEq (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.Lex.linearOrder
code: /-- The linear order on `DFinsupp`s obtained by the lexicographic ordering. -/
instance Lex.linearOrder : LinearOrder (Lex (Π₀ i, α i)) 
goal: LinearOrder (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.toLex_monotone
code: theorem toLex_monotone : Monotone (@toLex (Π₀ i, α i)) 
goal: Monotone ⇑toLex

full_name: DFinsupp.lt_of_forall_lt_of_lt
code: theorem lt_of_forall_lt_of_lt (a b : Lex (Π₀ i, α i)) (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: DFinsupp.Lex.covariantClass_lt_left
code: instance Lex.covariantClass_lt_left :
    CovariantClass (Lex (Π₀ i, α i)) (Lex (Π₀ i, α i)) (· + ·) (· < ·) 
goal: CovariantClass (Lex (Π₀ (i : ι), α i)) (Lex (Π₀ (i : ι), α i)) (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: DFinsupp.Lex.covariantClass_le_left
code: instance Lex.covariantClass_le_left :
    CovariantClass (Lex (Π₀ i, α i)) (Lex (Π₀ i, α i)) (· + ·) (· ≤ ·) 
goal: CovariantClass (Lex (Π₀ (i : ι), α i)) (Lex (Π₀ (i : ι), α i)) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: DFinsupp.Lex.covariantClass_lt_right
code: instance Lex.covariantClass_lt_right :
    CovariantClass (Lex (Π₀ i, α i)) (Lex (Π₀ i, α i)) (Function.swap (· + ·)) (· < ·) 
goal: CovariantClass (Lex (Π₀ (i : ι), α i)) (Lex (Π₀ (i : ι), α i)) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: DFinsupp.Lex.covariantClass_le_right
code: instance Lex.covariantClass_le_right :
    CovariantClass (Lex (Π₀ i, α i)) (Lex (Π₀ i, α i)) (Function.swap (· + ·)) (· ≤ ·) 
goal: CovariantClass (Lex (Π₀ (i : ι), α i)) (Lex (Π₀ (i : ι), α i)) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: DFinsupp.Lex.orderBot
code: instance Lex.orderBot [∀ i, CanonicallyOrderedAddCommMonoid (α i)] :
    OrderBot (Lex (Π₀ i, α i)) 
goal: OrderBot (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.Lex.orderedAddCancelCommMonoid
code: instance Lex.orderedAddCancelCommMonoid [∀ i, OrderedCancelAddCommMonoid (α i)] :
    OrderedCancelAddCommMonoid (Lex (Π₀ i, α i)) 
goal: OrderedCancelAddCommMonoid (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.Lex.orderedAddCommGroup
code: instance Lex.orderedAddCommGroup [∀ i, OrderedAddCommGroup (α i)] :
    OrderedAddCommGroup (Lex (Π₀ i, α i)) 
goal: OrderedAddCommGroup (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.Lex.linearOrderedCancelAddCommMonoid
code: instance Lex.linearOrderedCancelAddCommMonoid
    [∀ i, LinearOrderedCancelAddCommMonoid (α i)] :
    LinearOrderedCancelAddCommMonoid (Lex (Π₀ i, α i)) 
goal: LinearOrderedCancelAddCommMonoid (Lex (Π₀ (i : ι), α i))

full_name: DFinsupp.Lex.linearOrderedAddCommGroup
code: instance Lex.linearOrderedAddCommGroup [∀ i, LinearOrderedAddCommGroup (α i)] :
    LinearOrderedAddCommGroup (Lex (Π₀ i, α i)) 
goal: LinearOrderedAddCommGroup (Lex (Π₀ (i : ι), α i))