File: Mathlib/Order/RelClasses.lean

full_name: of_eq
code: theorem of_eq [IsRefl α r] : ∀ {a b}, a = b → r a b
  
goal: a = b → r a b

full_name: comm
code: theorem comm [IsSymm α r] {a b : α} : r a b ↔ r b a 
goal: r a b ↔ r b a

full_name: antisymm'
code: theorem antisymm' [IsAntisymm α r] {a b : α} : r a b → r b a → b = a 
goal: r a b → r b a → b = a

full_name: antisymm_iff
code: theorem antisymm_iff [IsRefl α r] [IsAntisymm α r] {a b : α} : r a b ∧ r b a ↔ a = b 
goal: r a b ∧ r b a ↔ a = b

full_name: antisymm_of
code: /-- A version of `antisymm` with `r` explicit.

This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there.  -/
@[elab_without_expected_type]
theorem antisymm_of (r : α → α → Prop) [IsAntisymm α r] {a b : α} : r a b → r b a → a = b 
goal: r a b → r b a → a = b

full_name: antisymm_of'
code: /-- A version of `antisymm'` with `r` explicit.

This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there.  -/
@[elab_without_expected_type]
theorem antisymm_of' (r : α → α → Prop) [IsAntisymm α r] {a b : α} : r a b → r b a → b = a 
goal: r a b → r b a → b = a

full_name: comm_of
code: /-- A version of `comm` with `r` explicit.

This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there.  -/
theorem comm_of (r : α → α → Prop) [IsSymm α r] {a b : α} : r a b ↔ r b a 
goal: r a b ↔ r b a

full_name: IsRefl.swap
code: theorem IsRefl.swap (r) [IsRefl α r] : IsRefl α (swap r) 
goal: IsRefl α (Function.swap r)

full_name: IsIrrefl.swap
code: theorem IsIrrefl.swap (r) [IsIrrefl α r] : IsIrrefl α (swap r) 
goal: IsIrrefl α (Function.swap r)

full_name: IsTrans.swap
code: theorem IsTrans.swap (r) [IsTrans α r] : IsTrans α (swap r) 
goal: IsTrans α (Function.swap r)

full_name: IsAntisymm.swap
code: theorem IsAntisymm.swap (r) [IsAntisymm α r] : IsAntisymm α (swap r) 
goal: IsAntisymm α (Function.swap r)

full_name: IsAsymm.swap
code: theorem IsAsymm.swap (r) [IsAsymm α r] : IsAsymm α (swap r) 
goal: IsAsymm α (Function.swap r)

full_name: IsTotal.swap
code: theorem IsTotal.swap (r) [IsTotal α r] : IsTotal α (swap r) 
goal: IsTotal α (Function.swap r)

full_name: IsTrichotomous.swap
code: theorem IsTrichotomous.swap (r) [IsTrichotomous α r] : IsTrichotomous α (swap r) 
goal: IsTrichotomous α (Function.swap r)

full_name: IsPreorder.swap
code: theorem IsPreorder.swap (r) [IsPreorder α r] : IsPreorder α (swap r) 
goal: IsPreorder α (Function.swap r)

full_name: IsStrictOrder.swap
code: theorem IsStrictOrder.swap (r) [IsStrictOrder α r] : IsStrictOrder α (swap r) 
goal: IsStrictOrder α (Function.swap r)

full_name: IsPartialOrder.swap
code: theorem IsPartialOrder.swap (r) [IsPartialOrder α r] : IsPartialOrder α (swap r) 
goal: IsPartialOrder α (Function.swap r)

full_name: IsTotalPreorder.swap
code: theorem IsTotalPreorder.swap (r) [IsTotalPreorder α r] : IsTotalPreorder α (swap r) 
goal: IsTotalPreorder α (Function.swap r)

full_name: IsLinearOrder.swap
code: theorem IsLinearOrder.swap (r) [IsLinearOrder α r] : IsLinearOrder α (swap r) 
goal: IsLinearOrder α (Function.swap r)

full_name: IsAsymm.isAntisymm
code: protected theorem IsAsymm.isAntisymm (r) [IsAsymm α r] : IsAntisymm α r 
goal: IsAntisymm α r

full_name: IsAsymm.isIrrefl
code: protected theorem IsAsymm.isIrrefl [IsAsymm α r] : IsIrrefl α r 
goal: IsIrrefl α r

full_name: IsTotal.isTrichotomous
code: protected theorem IsTotal.isTrichotomous (r) [IsTotal α r] : IsTrichotomous α r 
goal: IsTrichotomous α r

full_name: IsTotal.to_isRefl
code: instance (priority := 100) IsTotal.to_isRefl (r) [IsTotal α r] : IsRefl α r 
goal: IsRefl α r

full_name: ne_of_irrefl
code: theorem ne_of_irrefl {r} [IsIrrefl α r] : ∀ {x y : α}, r x y → x ≠ y
  
goal: r x y → x ≠ y

full_name: ne_of_irrefl'
code: theorem ne_of_irrefl' {r} [IsIrrefl α r] : ∀ {x y : α}, r x y → y ≠ x
  
goal: r x y → y ≠ x

full_name: not_rel_of_subsingleton
code: theorem not_rel_of_subsingleton (r) [IsIrrefl α r] [Subsingleton α] (x y) : ¬r x y 
goal: ¬r x y

full_name: rel_of_subsingleton
code: theorem rel_of_subsingleton (r) [IsRefl α r] [Subsingleton α] (x y) : r x y 
goal: r x y

full_name: empty_relation_apply
code: @[simp]
theorem empty_relation_apply (a b : α) : EmptyRelation a b ↔ False 
goal: EmptyRelation a b ↔ False

full_name: eq_empty_relation
code: theorem eq_empty_relation (r) [IsIrrefl α r] [Subsingleton α] : r = EmptyRelation 
goal: r = EmptyRelation

full_name: instIsIrreflEmptyRelation
code: instance : IsIrrefl α EmptyRelation 
goal: IsIrrefl α EmptyRelation

full_name: trans_trichotomous_left
code: theorem trans_trichotomous_left [IsTrans α r] [IsTrichotomous α r] {a b c : α} :
    ¬r b a → r b c → r a c 
goal: ¬r b a → r b c → r a c

full_name: trans_trichotomous_right
code: theorem trans_trichotomous_right [IsTrans α r] [IsTrichotomous α r] {a b c : α} :
    r a b → ¬r c b → r a c 
goal: r a b → ¬r c b → r a c

full_name: transitive_of_trans
code: theorem transitive_of_trans (r : α → α → Prop) [IsTrans α r] : Transitive r 
goal: Transitive r

full_name: extensional_of_trichotomous_of_irrefl
code: /-- In a trichotomous irreflexive order, every element is determined by the set of predecessors. -/
theorem extensional_of_trichotomous_of_irrefl (r : α → α → Prop) [IsTrichotomous α r] [IsIrrefl α r]
    {a b : α} (H : ∀ x, r x a ↔ r x b) : a = b 
goal: a = b

full_name: partialOrderOfSO
code: /-- Construct a partial order from an `isStrictOrder` relation.

See note [reducible non-instances]. -/
abbrev partialOrderOfSO (r) [IsStrictOrder α r] : PartialOrder α 
goal: PartialOrder α

full_name: linearOrderOfSTO
code: /-- Construct a linear order from an `IsStrictTotalOrder` relation.

See note [reducible non-instances]. -/
abbrev linearOrderOfSTO (r) [IsStrictTotalOrder α r] [∀ x y, Decidable ¬r x y] : LinearOrder α 
goal: LinearOrder α

full_name: IsStrictTotalOrder.swap
code: theorem IsStrictTotalOrder.swap (r) [IsStrictTotalOrder α r] : IsStrictTotalOrder α (swap r) 
goal: IsStrictTotalOrder α (Function.swap r)

full_name: IsOrderConnected.conn
code: /-- A connected order is one satisfying the condition `a < c → a < b ∨ b < c`.
  This is recognizable as an intuitionistic substitute for `a ≤ b ∨ b ≤ a` on
  the constructive reals, and is also known as negative transitivity,
  since the contrapositive asserts transitivity of the relation `¬ a < b`.  -/
class IsOrderConnected (α : Type u) (lt : α → α → Prop) : Prop where
  /-- A connected order is one satisfying the condition `a < c → a < b ∨ b < c`. -/
  conn : ∀ a b c, lt a c → lt a b ∨ lt b c
goal: lt a c → lt a b ∨ lt b c

full_name: IsOrderConnected
code: /-- A connected order is one satisfying the condition `a < c → a < b ∨ b < c`.
  This is recognizable as an intuitionistic substitute for `a ≤ b ∨ b ≤ a` on
  the constructive reals, and is also known as negative transitivity,
  since the contrapositive asserts transitivity of the relation `¬ a < b`.  -/
class IsOrderConnected (α : Type u) (lt : α → α → Prop) : Prop where
  /-- A connected order is one satisfying the condition `a < c → a < b ∨ b < c`. -/
  conn : ∀ a b c, lt a c → lt a b ∨ lt b c
goal: Prop

full_name: IsOrderConnected.neg_trans
code: theorem IsOrderConnected.neg_trans {r : α → α → Prop} [IsOrderConnected α r] {a b c}
    (h₁ : ¬r a b) (h₂ : ¬r b c) : ¬r a c 
goal: ¬r a c

full_name: isStrictWeakOrder_of_isOrderConnected
code: theorem isStrictWeakOrder_of_isOrderConnected [IsAsymm α r] [IsOrderConnected α r] :
    IsStrictWeakOrder α r 
goal: IsStrictWeakOrder α r

full_name: isStrictOrderConnected_of_isStrictTotalOrder
code: instance (priority := 100) isStrictOrderConnected_of_isStrictTotalOrder [IsStrictTotalOrder α r] :
    IsOrderConnected α r 
goal: IsOrderConnected α r

full_name: isStrictTotalOrder_of_isStrictTotalOrder
code: instance (priority := 100) isStrictTotalOrder_of_isStrictTotalOrder [IsStrictTotalOrder α r] :
    IsStrictWeakOrder α r 
goal: IsStrictWeakOrder α r

full_name: IsWellFounded.wf
code: /-- A well-founded relation. Not to be confused with `IsWellOrder`. -/
@[mk_iff] class IsWellFounded (α : Type u) (r : α → α → Prop) : Prop where
  /-- The relation is `WellFounded`, as a proposition. -/
  wf : WellFounded r
goal: WellFounded r

full_name: isWellFounded_iff
code: /-- A well-founded relation. Not to be confused with `IsWellOrder`. -/
@[mk_iff] class IsWellFounded (α : Type u) (r : α → α → Prop) : Prop where
  /-- The relation is `WellFounded`, as a proposition. -/
  wf : WellFounded r
goal: IsWellFounded α r ↔ WellFounded r

full_name: IsWellFounded
code: /-- A well-founded relation. Not to be confused with `IsWellOrder`. -/
@[mk_iff] class IsWellFounded (α : Type u) (r : α → α → Prop) : Prop where
  /-- The relation is `WellFounded`, as a proposition. -/
  wf : WellFounded r
goal: Prop

full_name: WellFoundedRelation.isWellFounded
code: instance WellFoundedRelation.isWellFounded [h : WellFoundedRelation α] :
    IsWellFounded α WellFoundedRelation.rel 
goal: IsWellFounded α WellFoundedRelation.rel

full_name: WellFoundedRelation.asymmetric
code: theorem WellFoundedRelation.asymmetric {α : Sort*} [WellFoundedRelation α] {a b : α} :
    WellFoundedRelation.rel a b → ¬ WellFoundedRelation.rel b a 
goal: WellFoundedRelation.rel a b → ¬WellFoundedRelation.rel b a

full_name: WellFounded.prod_lex
code: lemma WellFounded.prod_lex {ra : α → α → Prop} {rb : β → β → Prop} (ha : WellFounded ra)
    (hb : WellFounded rb) : WellFounded (Prod.Lex ra rb) 
goal: WellFounded (Prod.Lex ra rb)

full_name: IsWellFounded.induction
code: /-- Induction on a well-founded relation. -/
theorem induction {C : α → Prop} : ∀ a, (∀ x, (∀ y, r y x → C y) → C x) → C a 
goal: (∀ (x : α), (∀ (y : α), r y x → C y) → C x) → C a

full_name: IsWellFounded.apply
code: /-- All values are accessible under the well-founded relation. -/
theorem apply : ∀ a, Acc r a 
goal: Acc r a

full_name: IsWellFounded.fix
code: /-- Creates data, given a way to generate a value from all that compare as less under a well-founded
relation. See also `IsWellFounded.fix_eq`. -/
def fix {C : α → Sort*} : (∀ x : α, (∀ y : α, r y x → C y) → C x) → ∀ x : α, C x 
goal: ((x : α) → ((y : α) → r y x → C y) → C x) → (x : α) → C x

full_name: IsWellFounded.fix_eq
code: /-- The value from `IsWellFounded.fix` is built from the previous ones as specified. -/
theorem fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, r y x → C y) → C x) :
    ∀ x, fix r F x = F x fun y _ => fix r F y 
goal: IsWellFounded.fix r F x = F x fun y x => IsWellFounded.fix r F y

full_name: IsWellFounded.toWellFoundedRelation
code: /-- Derive a `WellFoundedRelation` instance from an `isWellFounded` instance. -/
def toWellFoundedRelation : WellFoundedRelation α 
goal: WellFoundedRelation α

full_name: WellFounded.asymmetric
code: theorem WellFounded.asymmetric {α : Sort*} {r : α → α → Prop} (h : WellFounded r) (a b) :
    r a b → ¬r b a 
goal: r a b → ¬r b a

full_name: instIsAsymmOfIsWellFounded
code: instance (priority := 100) (r : α → α → Prop) [IsWellFounded α r] : IsAsymm α r 
goal: IsAsymm α r

full_name: instIsIrreflOfIsWellFounded
code: instance (priority := 100) (r : α → α → Prop) [IsWellFounded α r] : IsIrrefl α r 
goal: IsIrrefl α r

full_name: instIsWellFoundedTransGen
code: instance (r : α → α → Prop) [i : IsWellFounded α r] : IsWellFounded α (Relation.TransGen r) 
goal: IsWellFounded α (Relation.TransGen r)

full_name: WellFoundedLT
code: /-- A class for a well founded relation `<`. -/
abbrev WellFoundedLT (α : Type*) [LT α] : Prop 
goal: Prop

full_name: WellFoundedGT
code: /-- A class for a well founded relation `>`. -/
abbrev WellFoundedGT (α : Type*) [LT α] : Prop 
goal: Prop

full_name: wellFounded_lt
code: lemma wellFounded_lt [LT α] [WellFoundedLT α] : @WellFounded α (· < ·) 
goal: WellFounded fun x x_1 => x < x_1

full_name: wellFounded_gt
code: lemma wellFounded_gt [LT α] [WellFoundedGT α] : @WellFounded α (· > ·) 
goal: WellFounded fun x x_1 => x > x_1

full_name: instWellFoundedGTOrderDualOfWellFoundedLT
code: instance (priority := 100) (α : Type*) [LT α] [h : WellFoundedLT α] : WellFoundedGT αᵒᵈ 
goal: WellFoundedGT αᵒᵈ

full_name: instWellFoundedLTOrderDualOfWellFoundedGT
code: instance (priority := 100) (α : Type*) [LT α] [h : WellFoundedGT α] : WellFoundedLT αᵒᵈ 
goal: WellFoundedLT αᵒᵈ

full_name: wellFoundedGT_dual_iff
code: theorem wellFoundedGT_dual_iff (α : Type*) [LT α] : WellFoundedGT αᵒᵈ ↔ WellFoundedLT α 
goal: WellFoundedGT αᵒᵈ ↔ WellFoundedLT α

full_name: wellFoundedLT_dual_iff
code: theorem wellFoundedLT_dual_iff (α : Type*) [LT α] : WellFoundedLT αᵒᵈ ↔ WellFoundedGT α 
goal: WellFoundedLT αᵒᵈ ↔ WellFoundedGT α

full_name: IsWellOrder
code: /-- A well order is a well-founded linear order. -/
class IsWellOrder (α : Type u) (r : α → α → Prop) extends
  IsTrichotomous α r, IsTrans α r, IsWellFounded α r : Prop
goal: Prop

full_name: instIsStrictTotalOrderOfIsWellOrder
code: instance (priority := 100) {α} (r : α → α → Prop) [IsWellOrder α r] :
    IsStrictTotalOrder α r 
goal: IsStrictTotalOrder α r

full_name: instIsTrichotomousOfIsWellOrder
code: instance (priority := 100) {α} (r : α → α → Prop) [IsWellOrder α r] : IsTrichotomous α r 
goal: IsTrichotomous α r

full_name: instIsTransOfIsWellOrder
code: instance (priority := 100) {α} (r : α → α → Prop) [IsWellOrder α r] : IsTrans α r 
goal: IsTrans α r

full_name: instIsIrreflOfIsWellOrder
code: instance (priority := 100) {α} (r : α → α → Prop) [IsWellOrder α r] : IsIrrefl α r 
goal: IsIrrefl α r

full_name: instIsAsymmOfIsWellOrder
code: instance (priority := 100) {α} (r : α → α → Prop) [IsWellOrder α r] : IsAsymm α r 
goal: IsAsymm α r

full_name: WellFoundedLT.induction
code: /-- Inducts on a well-founded `<` relation. -/
theorem induction {C : α → Prop} : ∀ a, (∀ x, (∀ y, y < x → C y) → C x) → C a 
goal: (∀ (x : α), (∀ (y : α), y < x → C y) → C x) → C a

full_name: WellFoundedLT.apply
code: /-- All values are accessible under the well-founded `<`. -/
theorem apply : ∀ a : α, Acc (· < ·) a 
goal: Acc (fun x x_1 => x < x_1) a

full_name: WellFoundedLT.fix
code: /-- Creates data, given a way to generate a value from all that compare as lesser. See also
`WellFoundedLT.fix_eq`. -/
def fix {C : α → Sort*} : (∀ x : α, (∀ y : α, y < x → C y) → C x) → ∀ x : α, C x 
goal: ((x : α) → ((y : α) → y < x → C y) → C x) → (x : α) → C x

full_name: WellFoundedLT.fix_eq
code: /-- The value from `WellFoundedLT.fix` is built from the previous ones as specified. -/
theorem fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, y < x → C y) → C x) :
    ∀ x, fix F x = F x fun y _ => fix F y 
goal: WellFoundedLT.fix F x = F x fun y x => WellFoundedLT.fix F y

full_name: WellFoundedLT.toWellFoundedRelation
code: /-- Derive a `WellFoundedRelation` instance from a `WellFoundedLT` instance. -/
def toWellFoundedRelation : WellFoundedRelation α 
goal: WellFoundedRelation α

full_name: WellFoundedGT.induction
code: /-- Inducts on a well-founded `>` relation. -/
theorem induction {C : α → Prop} : ∀ a, (∀ x, (∀ y, x < y → C y) → C x) → C a 
goal: (∀ (x : α), (∀ (y : α), x < y → C y) → C x) → C a

full_name: WellFoundedGT.apply
code: /-- All values are accessible under the well-founded `>`. -/
theorem apply : ∀ a : α, Acc (· > ·) a 
goal: Acc (fun x x_1 => x > x_1) a

full_name: WellFoundedGT.fix
code: /-- Creates data, given a way to generate a value from all that compare as greater. See also
`WellFoundedGT.fix_eq`. -/
def fix {C : α → Sort*} : (∀ x : α, (∀ y : α, x < y → C y) → C x) → ∀ x : α, C x 
goal: ((x : α) → ((y : α) → x < y → C y) → C x) → (x : α) → C x

full_name: WellFoundedGT.fix_eq
code: /-- The value from `WellFoundedGT.fix` is built from the successive ones as specified. -/
theorem fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, x < y → C y) → C x) :
    ∀ x, fix F x = F x fun y _ => fix F y 
goal: WellFoundedGT.fix F x = F x fun y x => WellFoundedGT.fix F y

full_name: WellFoundedGT.toWellFoundedRelation
code: /-- Derive a `WellFoundedRelation` instance from a `WellFoundedGT` instance. -/
def toWellFoundedRelation : WellFoundedRelation α 
goal: WellFoundedRelation α

full_name: IsWellOrder.linearOrder
code: /-- Construct a decidable linear order from a well-founded linear order. -/
noncomputable def IsWellOrder.linearOrder (r : α → α → Prop) [IsWellOrder α r] : LinearOrder α 
goal: LinearOrder α

full_name: IsWellOrder.toHasWellFounded
code: /-- Derive a `WellFoundedRelation` instance from an `IsWellOrder` instance. -/
def IsWellOrder.toHasWellFounded [LT α] [hwo : IsWellOrder α (· < ·)] : WellFoundedRelation α 
goal: WellFoundedRelation α

full_name: Subsingleton.isWellOrder
code: theorem Subsingleton.isWellOrder [Subsingleton α] (r : α → α → Prop) [hr : IsIrrefl α r] :
    IsWellOrder α r 
goal: IsWellOrder α r

full_name: instIsWellOrderEmptyRelationOfSubsingleton
code: instance [Subsingleton α] : IsWellOrder α EmptyRelation 
goal: IsWellOrder α EmptyRelation

full_name: instIsWellOrderOfIsEmpty
code: instance (priority := 100) [IsEmpty α] (r : α → α → Prop) : IsWellOrder α r 
goal: IsWellOrder α r

full_name: instIsWellFoundedProdLex
code: instance [IsWellFounded α r] [IsWellFounded β s] : IsWellFounded (α × β) (Prod.Lex r s) 
goal: IsWellFounded (α × β) (Prod.Lex r s)

full_name: instIsWellOrderProdLex
code: instance [IsWellOrder α r] [IsWellOrder β s] : IsWellOrder (α × β) (Prod.Lex r s) 
goal: IsWellOrder (α × β) (Prod.Lex r s)

full_name: instIsWellFoundedInvImage
code: instance (r : α → α → Prop) [IsWellFounded α r] (f : β → α) : IsWellFounded _ (InvImage r f) 
goal: IsWellFounded β (InvImage r f)

full_name: instIsWellFoundedInvImageNatLt
code: instance (f : α → ℕ) : IsWellFounded _ (InvImage (· < ·) f) 
goal: IsWellFounded α (InvImage (fun x x_1 => x < x_1) f)

full_name: Subrelation.isWellFounded
code: theorem Subrelation.isWellFounded (r : α → α → Prop) [IsWellFounded α r] {s : α → α → Prop}
    (h : Subrelation s r) : IsWellFounded α s 
goal: IsWellFounded α s

full_name: Prod.wellFoundedLT
code: instance Prod.wellFoundedLT [PartialOrder α] [WellFoundedLT α] [Preorder β] [WellFoundedLT β] :
    WellFoundedLT (α × β) 
goal: WellFoundedLT (α × β)

full_name: Prod.wellFoundedGT
code: instance Prod.wellFoundedGT [PartialOrder α] [WellFoundedGT α] [Preorder β] [WellFoundedGT β] :
    WellFoundedGT (α × β) 
goal: WellFoundedGT (α × β)

full_name: Set.Unbounded
code: /-- An unbounded or cofinal set. -/
def Unbounded (r : α → α → Prop) (s : Set α) : Prop 
goal: Prop

full_name: Set.Bounded
code: /-- A bounded or final set. Not to be confused with `Bornology.IsBounded`. -/
def Bounded (r : α → α → Prop) (s : Set α) : Prop 
goal: Prop

full_name: Set.not_bounded_iff
code: @[simp]
theorem not_bounded_iff {r : α → α → Prop} (s : Set α) : ¬Bounded r s ↔ Unbounded r s 
goal: ¬Set.Bounded r s ↔ Set.Unbounded r s

full_name: Set.not_unbounded_iff
code: @[simp]
theorem not_unbounded_iff {r : α → α → Prop} (s : Set α) : ¬Unbounded r s ↔ Bounded r s 
goal: ¬Set.Unbounded r s ↔ Set.Bounded r s

full_name: Set.unbounded_of_isEmpty
code: theorem unbounded_of_isEmpty [IsEmpty α] {r : α → α → Prop} (s : Set α) : Unbounded r s 
goal: Set.Unbounded r s

full_name: Order.Preimage.instIsRefl
code: instance instIsRefl {r : α → α → Prop} [IsRefl α r] {f : β → α} : IsRefl β (f ⁻¹'o r) 
goal: IsRefl β (f ⁻¹'o r)

full_name: Order.Preimage.instIsTrans
code: instance instIsTrans {r : α → α → Prop} [IsTrans α r] {f : β → α} : IsTrans β (f ⁻¹'o r) 
goal: IsTrans β (f ⁻¹'o r)

full_name: IsNonstrictStrictOrder
code: /-- An unbundled relation class stating that `r` is the nonstrict relation corresponding to the
strict relation `s`. Compare `Preorder.lt_iff_le_not_le`. This is mostly meant to provide dot
notation on `(⊆)` and `(⊂)`. -/
class IsNonstrictStrictOrder (α : Type*) (r : semiOutParam (α → α → Prop)) (s : α → α → Prop) :
    Prop where
  /-- The relation `r` is the nonstrict relation corresponding to the strict relation `s`. -/
  right_iff_left_not_left (a b : α) : s a b ↔ r a b ∧ ¬r b a
goal: Prop

full_name: IsNonstrictStrictOrder.right_iff_left_not_left
code: /-- An unbundled relation class stating that `r` is the nonstrict relation corresponding to the
strict relation `s`. Compare `Preorder.lt_iff_le_not_le`. This is mostly meant to provide dot
notation on `(⊆)` and `(⊂)`. -/
class IsNonstrictStrictOrder (α : Type*) (r : semiOutParam (α → α → Prop)) (s : α → α → Prop) :
    Prop where
  /-- The relation `r` is the nonstrict relation corresponding to the strict relation `s`. -/
  right_iff_left_not_left (a b : α) : s a b ↔ r a b ∧ ¬r b a
goal: s a b ↔ r a b ∧ ¬r b a

full_name: right_iff_left_not_left
code: theorem right_iff_left_not_left {r s : α → α → Prop} [IsNonstrictStrictOrder α r s] {a b : α} :
    s a b ↔ r a b ∧ ¬r b a 
goal: s a b ↔ r a b ∧ ¬r b a

full_name: right_iff_left_not_left_of
code: /-- A version of `right_iff_left_not_left` with explicit `r` and `s`. -/
theorem right_iff_left_not_left_of (r s : α → α → Prop) [IsNonstrictStrictOrder α r s] {a b : α} :
    s a b ↔ r a b ∧ ¬r b a 
goal: s a b ↔ r a b ∧ ¬r b a

full_name: instIsIrreflOfIsNonstrictStrictOrder
code: instance {s : α → α → Prop} [IsNonstrictStrictOrder α r s] : IsIrrefl α s 
goal: IsIrrefl α s

full_name: subset_of_eq_of_subset
code: lemma subset_of_eq_of_subset (hab : a = b) (hbc : b ⊆ c) : a ⊆ c 
goal: a ⊆ c

full_name: subset_of_subset_of_eq
code: lemma subset_of_subset_of_eq (hab : a ⊆ b) (hbc : b = c) : a ⊆ c 
goal: a ⊆ c

full_name: subset_refl
code: @[refl, simp]
lemma subset_refl [IsRefl α (· ⊆ ·)] (a : α) : a ⊆ a 
goal: a ⊆ a

full_name: subset_rfl
code: lemma subset_rfl [IsRefl α (· ⊆ ·)] : a ⊆ a 
goal: a ⊆ a

full_name: subset_of_eq
code: lemma subset_of_eq [IsRefl α (· ⊆ ·)] : a = b → a ⊆ b 
goal: a = b → a ⊆ b

full_name: superset_of_eq
code: lemma superset_of_eq [IsRefl α (· ⊆ ·)] : a = b → b ⊆ a 
goal: a = b → b ⊆ a

full_name: ne_of_not_subset
code: lemma ne_of_not_subset [IsRefl α (· ⊆ ·)] : ¬a ⊆ b → a ≠ b 
goal: ¬a ⊆ b → a ≠ b

full_name: ne_of_not_superset
code: lemma ne_of_not_superset [IsRefl α (· ⊆ ·)] : ¬a ⊆ b → b ≠ a 
goal: ¬a ⊆ b → b ≠ a

full_name: subset_trans
code: @[trans]
lemma subset_trans [IsTrans α (· ⊆ ·)] {a b c : α} : a ⊆ b → b ⊆ c → a ⊆ c 
goal: a ⊆ b → b ⊆ c → a ⊆ c

full_name: subset_antisymm
code: lemma subset_antisymm [IsAntisymm α (· ⊆ ·)] : a ⊆ b → b ⊆ a → a = b 
goal: a ⊆ b → b ⊆ a → a = b

full_name: superset_antisymm
code: lemma superset_antisymm [IsAntisymm α (· ⊆ ·)] : a ⊆ b → b ⊆ a → b = a 
goal: a ⊆ b → b ⊆ a → b = a

full_name: subset_antisymm_iff
code: theorem subset_antisymm_iff [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] : a = b ↔ a ⊆ b ∧ b ⊆ a 
goal: a = b ↔ a ⊆ b ∧ b ⊆ a

full_name: superset_antisymm_iff
code: theorem superset_antisymm_iff [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] : a = b ↔ b ⊆ a ∧ a ⊆ b 
goal: a = b ↔ b ⊆ a ∧ a ⊆ b

full_name: ssubset_of_eq_of_ssubset
code: lemma ssubset_of_eq_of_ssubset (hab : a = b) (hbc : b ⊂ c) : a ⊂ c 
goal: a ⊂ c

full_name: ssubset_of_ssubset_of_eq
code: lemma ssubset_of_ssubset_of_eq (hab : a ⊂ b) (hbc : b = c) : a ⊂ c 
goal: a ⊂ c

full_name: ssubset_irrefl
code: lemma ssubset_irrefl [IsIrrefl α (· ⊂ ·)] (a : α) : ¬a ⊂ a 
goal: ¬a ⊂ a

full_name: ssubset_irrfl
code: lemma ssubset_irrfl [IsIrrefl α (· ⊂ ·)] {a : α} : ¬a ⊂ a 
goal: ¬a ⊂ a

full_name: ne_of_ssubset
code: lemma ne_of_ssubset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → a ≠ b 
goal: a ⊂ b → a ≠ b

full_name: ne_of_ssuperset
code: lemma ne_of_ssuperset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → b ≠ a 
goal: a ⊂ b → b ≠ a

full_name: ssubset_trans
code: @[trans]
lemma ssubset_trans [IsTrans α (· ⊂ ·)] {a b c : α} : a ⊂ b → b ⊂ c → a ⊂ c 
goal: a ⊂ b → b ⊂ c → a ⊂ c

full_name: ssubset_asymm
code: lemma ssubset_asymm [IsAsymm α (· ⊂ ·)] {a b : α} : a ⊂ b → ¬b ⊂ a 
goal: a ⊂ b → ¬b ⊂ a

full_name: ssubset_iff_subset_not_subset
code: theorem ssubset_iff_subset_not_subset : a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a 
goal: a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a

full_name: subset_of_ssubset
code: theorem subset_of_ssubset (h : a ⊂ b) : a ⊆ b 
goal: a ⊆ b

full_name: not_subset_of_ssubset
code: theorem not_subset_of_ssubset (h : a ⊂ b) : ¬b ⊆ a 
goal: ¬b ⊆ a

full_name: not_ssubset_of_subset
code: theorem not_ssubset_of_subset (h : a ⊆ b) : ¬b ⊂ a 
goal: ¬b ⊂ a

full_name: ssubset_of_subset_not_subset
code: theorem ssubset_of_subset_not_subset (h₁ : a ⊆ b) (h₂ : ¬b ⊆ a) : a ⊂ b 
goal: a ⊂ b

full_name: ssubset_of_subset_of_ssubset
code: theorem ssubset_of_subset_of_ssubset [IsTrans α (· ⊆ ·)] (h₁ : a ⊆ b) (h₂ : b ⊂ c) : a ⊂ c 
goal: a ⊂ c

full_name: ssubset_of_ssubset_of_subset
code: theorem ssubset_of_ssubset_of_subset [IsTrans α (· ⊆ ·)] (h₁ : a ⊂ b) (h₂ : b ⊆ c) : a ⊂ c 
goal: a ⊂ c

full_name: ssubset_of_subset_of_ne
code: theorem ssubset_of_subset_of_ne [IsAntisymm α (· ⊆ ·)] (h₁ : a ⊆ b) (h₂ : a ≠ b) : a ⊂ b 
goal: a ⊂ b

full_name: ssubset_of_ne_of_subset
code: theorem ssubset_of_ne_of_subset [IsAntisymm α (· ⊆ ·)] (h₁ : a ≠ b) (h₂ : a ⊆ b) : a ⊂ b 
goal: a ⊂ b

full_name: eq_or_ssubset_of_subset
code: theorem eq_or_ssubset_of_subset [IsAntisymm α (· ⊆ ·)] (h : a ⊆ b) : a = b ∨ a ⊂ b 
goal: a = b ∨ a ⊂ b

full_name: ssubset_or_eq_of_subset
code: theorem ssubset_or_eq_of_subset [IsAntisymm α (· ⊆ ·)] (h : a ⊆ b) : a ⊂ b ∨ a = b 
goal: a ⊂ b ∨ a = b

full_name: eq_of_subset_of_not_ssubset
code: lemma eq_of_subset_of_not_ssubset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) : a = b 
goal: a = b

full_name: eq_of_superset_of_not_ssuperset
code: lemma eq_of_superset_of_not_ssuperset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) :
    b = a 
goal: b = a

full_name: ssubset_iff_subset_ne
code: theorem ssubset_iff_subset_ne [IsAntisymm α (· ⊆ ·)] : a ⊂ b ↔ a ⊆ b ∧ a ≠ b 
goal: a ⊂ b ↔ a ⊆ b ∧ a ≠ b

full_name: subset_iff_ssubset_or_eq
code: theorem subset_iff_ssubset_or_eq [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] :
    a ⊆ b ↔ a ⊂ b ∨ a = b 
goal: a ⊆ b ↔ a ⊂ b ∨ a = b

full_name: instIsReflLe
code: instance [Preorder α] : IsRefl α (· ≤ ·) 
goal: IsRefl α fun x x_1 => x ≤ x_1

full_name: instIsReflGe
code: instance [Preorder α] : IsRefl α (· ≥ ·) 
goal: IsRefl α fun x x_1 => x ≥ x_1

full_name: instIsTransLe
code: instance [Preorder α] : IsTrans α (· ≤ ·) 
goal: IsTrans α fun x x_1 => x ≤ x_1

full_name: instIsTransGe
code: instance [Preorder α] : IsTrans α (· ≥ ·) 
goal: IsTrans α fun x x_1 => x ≥ x_1

full_name: instIsPreorderLe
code: instance [Preorder α] : IsPreorder α (· ≤ ·) 
goal: IsPreorder α fun x x_1 => x ≤ x_1

full_name: instIsPreorderGe
code: instance [Preorder α] : IsPreorder α (· ≥ ·) 
goal: IsPreorder α fun x x_1 => x ≥ x_1

full_name: instIsIrreflLt
code: instance [Preorder α] : IsIrrefl α (· < ·) 
goal: IsIrrefl α fun x x_1 => x < x_1

full_name: instIsIrreflGt
code: instance [Preorder α] : IsIrrefl α (· > ·) 
goal: IsIrrefl α fun x x_1 => x > x_1

full_name: instIsTransLt
code: instance [Preorder α] : IsTrans α (· < ·) 
goal: IsTrans α fun x x_1 => x < x_1

full_name: instIsTransGt
code: instance [Preorder α] : IsTrans α (· > ·) 
goal: IsTrans α fun x x_1 => x > x_1

full_name: instIsAsymmLt
code: instance [Preorder α] : IsAsymm α (· < ·) 
goal: IsAsymm α fun x x_1 => x < x_1

full_name: instIsAsymmGt
code: instance [Preorder α] : IsAsymm α (· > ·) 
goal: IsAsymm α fun x x_1 => x > x_1

full_name: instIsAntisymmLt
code: instance [Preorder α] : IsAntisymm α (· < ·) 
goal: IsAntisymm α fun x x_1 => x < x_1

full_name: instIsAntisymmGt
code: instance [Preorder α] : IsAntisymm α (· > ·) 
goal: IsAntisymm α fun x x_1 => x > x_1

full_name: instIsStrictOrderLt
code: instance [Preorder α] : IsStrictOrder α (· < ·) 
goal: IsStrictOrder α fun x x_1 => x < x_1

full_name: instIsStrictOrderGt
code: instance [Preorder α] : IsStrictOrder α (· > ·) 
goal: IsStrictOrder α fun x x_1 => x > x_1

full_name: instIsNonstrictStrictOrderLeLt
code: instance [Preorder α] : IsNonstrictStrictOrder α (· ≤ ·) (· < ·) 
goal: IsNonstrictStrictOrder α (fun x x_1 => x ≤ x_1) fun x x_1 => x < x_1

full_name: instIsAntisymmLe
code: instance [PartialOrder α] : IsAntisymm α (· ≤ ·) 
goal: IsAntisymm α fun x x_1 => x ≤ x_1

full_name: instIsAntisymmGe
code: instance [PartialOrder α] : IsAntisymm α (· ≥ ·) 
goal: IsAntisymm α fun x x_1 => x ≥ x_1

full_name: instIsPartialOrderLe
code: instance [PartialOrder α] : IsPartialOrder α (· ≤ ·) 
goal: IsPartialOrder α fun x x_1 => x ≤ x_1

full_name: instIsPartialOrderGe
code: instance [PartialOrder α] : IsPartialOrder α (· ≥ ·) 
goal: IsPartialOrder α fun x x_1 => x ≥ x_1

full_name: LE.isTotal
code: instance LE.isTotal [LinearOrder α] : IsTotal α (· ≤ ·) 
goal: IsTotal α fun x x_1 => x ≤ x_1

full_name: instIsTotalGe
code: instance [LinearOrder α] : IsTotal α (· ≥ ·) 
goal: IsTotal α fun x x_1 => x ≥ x_1

full_name: instIsTotalPreorderLe_1
code: instance [LinearOrder α] : IsTotalPreorder α (· ≤ ·) 
goal: IsTotalPreorder α fun x x_1 => x ≤ x_1

full_name: instIsTotalPreorderGe
code: instance [LinearOrder α] : IsTotalPreorder α (· ≥ ·) 
goal: IsTotalPreorder α fun x x_1 => x ≥ x_1

full_name: instIsLinearOrderLe
code: instance [LinearOrder α] : IsLinearOrder α (· ≤ ·) 
goal: IsLinearOrder α fun x x_1 => x ≤ x_1

full_name: instIsLinearOrderGe
code: instance [LinearOrder α] : IsLinearOrder α (· ≥ ·) 
goal: IsLinearOrder α fun x x_1 => x ≥ x_1

full_name: instIsTrichotomousLt
code: instance [LinearOrder α] : IsTrichotomous α (· < ·) 
goal: IsTrichotomous α fun x x_1 => x < x_1

full_name: instIsTrichotomousGt
code: instance [LinearOrder α] : IsTrichotomous α (· > ·) 
goal: IsTrichotomous α fun x x_1 => x > x_1

full_name: instIsTrichotomousLe
code: instance [LinearOrder α] : IsTrichotomous α (· ≤ ·) 
goal: IsTrichotomous α fun x x_1 => x ≤ x_1

full_name: instIsTrichotomousGe
code: instance [LinearOrder α] : IsTrichotomous α (· ≥ ·) 
goal: IsTrichotomous α fun x x_1 => x ≥ x_1

full_name: instIsStrictTotalOrderLt
code: instance [LinearOrder α] : IsStrictTotalOrder α (· < ·) 
goal: IsStrictTotalOrder α fun x x_1 => x < x_1

full_name: instIsOrderConnectedLt
code: instance [LinearOrder α] : IsOrderConnected α (· < ·) 
goal: IsOrderConnected α fun x x_1 => x < x_1

full_name: instIsIncompTransLt
code: instance [LinearOrder α] : IsIncompTrans α (· < ·) 
goal: IsIncompTrans α fun x x_1 => x < x_1

full_name: instIsStrictWeakOrderLt
code: instance [LinearOrder α] : IsStrictWeakOrder α (· < ·) 
goal: IsStrictWeakOrder α fun x x_1 => x < x_1

full_name: transitive_le
code: theorem transitive_le [Preorder α] : Transitive (@LE.le α _) 
goal: Transitive LE.le

full_name: transitive_lt
code: theorem transitive_lt [Preorder α] : Transitive (@LT.lt α _) 
goal: Transitive LT.lt

full_name: transitive_ge
code: theorem transitive_ge [Preorder α] : Transitive (@GE.ge α _) 
goal: Transitive GE.ge

full_name: transitive_gt
code: theorem transitive_gt [Preorder α] : Transitive (@GT.gt α _) 
goal: Transitive GT.gt

full_name: OrderDual.isTotal_le
code: instance OrderDual.isTotal_le [LE α] [h : IsTotal α (· ≤ ·)] : IsTotal αᵒᵈ (· ≤ ·) 
goal: IsTotal αᵒᵈ fun x x_1 => x ≤ x_1

full_name: instWellFoundedLTNat
code: instance : WellFoundedLT ℕ 
goal: WellFoundedLT ℕ

full_name: Nat.lt.isWellOrder
code: instance Nat.lt.isWellOrder : IsWellOrder ℕ (· < ·) 
goal: IsWellOrder ℕ fun x x_1 => x < x_1

full_name: instIsWellOrderOrderDualGtOfLt
code: instance [LinearOrder α] [h : IsWellOrder α (· < ·)] : IsWellOrder αᵒᵈ (· > ·) 
goal: IsWellOrder αᵒᵈ fun x x_1 => x > x_1

full_name: instIsWellOrderOrderDualLtOfGt
code: instance [LinearOrder α] [h : IsWellOrder α (· > ·)] : IsWellOrder αᵒᵈ (· < ·) 
goal: IsWellOrder αᵒᵈ fun x x_1 => x < x_1