File: Mathlib/Order/Cover.lean

full_name: WCovBy
code: /-- `WCovBy a b` means that `a = b` or `b` covers `a`.
This means that `a ≤ b` and there is no element in between.
-/
def WCovBy (a b : α) : Prop 
goal: Prop

full_name: _aux_Mathlib_Order_Cover___unexpand_WCovBy_1
code: /-- Notation for `WCovBy a b`. -/
infixl:50 " ⩿ " => WCovBy
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Order_Cover___macroRules_term_⩿__1»
code: /-- Notation for `WCovBy a b`. -/
infixl:50 " ⩿ " => WCovBy
goal: Lean.Macro

full_name: WCovBy.le
code: theorem WCovBy.le (h : a ⩿ b) : a ≤ b 
goal: a ≤ b

full_name: WCovBy.refl
code: theorem WCovBy.refl (a : α) : a ⩿ a 
goal: a ⩿ a

full_name: WCovBy.rfl
code: @[simp] lemma WCovBy.rfl : a ⩿ a 
goal: a ⩿ a

full_name: Eq.wcovBy
code: protected theorem Eq.wcovBy (h : a = b) : a ⩿ b 
goal: a ⩿ b

full_name: wcovBy_of_le_of_le
code: theorem wcovBy_of_le_of_le (h1 : a ≤ b) (h2 : b ≤ a) : a ⩿ b 
goal: a ⩿ b

full_name: AntisymmRel.wcovBy
code: theorem AntisymmRel.wcovBy (h : AntisymmRel (· ≤ ·) a b) : a ⩿ b 
goal: a ⩿ b

full_name: WCovBy.wcovBy_iff_le
code: theorem WCovBy.wcovBy_iff_le (hab : a ⩿ b) : b ⩿ a ↔ b ≤ a 
goal: b ⩿ a ↔ b ≤ a

full_name: wcovBy_of_eq_or_eq
code: theorem wcovBy_of_eq_or_eq (hab : a ≤ b) (h : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b) : a ⩿ b 
goal: a ⩿ b

full_name: AntisymmRel.trans_wcovBy
code: theorem AntisymmRel.trans_wcovBy (hab : AntisymmRel (· ≤ ·) a b) (hbc : b ⩿ c) : a ⩿ c 
goal: a ⩿ c

full_name: wcovBy_congr_left
code: theorem wcovBy_congr_left (hab : AntisymmRel (· ≤ ·) a b) : a ⩿ c ↔ b ⩿ c 
goal: a ⩿ c ↔ b ⩿ c

full_name: WCovBy.trans_antisymm_rel
code: theorem WCovBy.trans_antisymm_rel (hab : a ⩿ b) (hbc : AntisymmRel (· ≤ ·) b c) : a ⩿ c 
goal: a ⩿ c

full_name: wcovBy_congr_right
code: theorem wcovBy_congr_right (hab : AntisymmRel (· ≤ ·) a b) : c ⩿ a ↔ c ⩿ b 
goal: c ⩿ a ↔ c ⩿ b

full_name: not_wcovBy_iff
code: /-- If `a ≤ b`, then `b` does not cover `a` iff there's an element in between. -/
theorem not_wcovBy_iff (h : a ≤ b) : ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b 
goal: ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b

full_name: WCovBy.isRefl
code: instance WCovBy.isRefl : IsRefl α (· ⩿ ·) 
goal: IsRefl α fun x x_1 => x ⩿ x_1

full_name: WCovBy.Ioo_eq
code: theorem WCovBy.Ioo_eq (h : a ⩿ b) : Ioo a b = ∅ 
goal: Set.Ioo a b = ∅

full_name: wcovBy_iff_Ioo_eq
code: theorem wcovBy_iff_Ioo_eq : a ⩿ b ↔ a ≤ b ∧ Ioo a b = ∅ 
goal: a ⩿ b ↔ a ≤ b ∧ Set.Ioo a b = ∅

full_name: WCovBy.of_le_of_le
code: lemma WCovBy.of_le_of_le (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c) : b ⩿ c 
goal: b ⩿ c

full_name: WCovBy.of_le_of_le'
code: lemma WCovBy.of_le_of_le' (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c) : a ⩿ b 
goal: a ⩿ b

full_name: WCovBy.of_image
code: theorem WCovBy.of_image (f : α ↪o β) (h : f a ⩿ f b) : a ⩿ b 
goal: a ⩿ b

full_name: WCovBy.image
code: theorem WCovBy.image (f : α ↪o β) (hab : a ⩿ b) (h : (range f).OrdConnected) : f a ⩿ f b 
goal: f a ⩿ f b

full_name: Set.OrdConnected.apply_wcovBy_apply_iff
code: theorem Set.OrdConnected.apply_wcovBy_apply_iff (f : α ↪o β) (h : (range f).OrdConnected) :
    f a ⩿ f b ↔ a ⩿ b 
goal: f a ⩿ f b ↔ a ⩿ b

full_name: apply_wcovBy_apply_iff
code: @[simp]
theorem apply_wcovBy_apply_iff {E : Type*} [EquivLike E α β] [OrderIsoClass E α β] (e : E) :
    e a ⩿ e b ↔ a ⩿ b 
goal: e a ⩿ e b ↔ a ⩿ b

full_name: toDual_wcovBy_toDual_iff
code: @[simp]
theorem toDual_wcovBy_toDual_iff : toDual b ⩿ toDual a ↔ a ⩿ b 
goal: OrderDual.toDual b ⩿ OrderDual.toDual a ↔ a ⩿ b

full_name: ofDual_wcovBy_ofDual_iff
code: @[simp]
theorem ofDual_wcovBy_ofDual_iff {a b : αᵒᵈ} : ofDual a ⩿ ofDual b ↔ b ⩿ a 
goal: OrderDual.ofDual a ⩿ OrderDual.ofDual b ↔ b ⩿ a

full_name: WCovBy.eq_or_eq
code: theorem WCovBy.eq_or_eq (h : a ⩿ b) (h2 : a ≤ c) (h3 : c ≤ b) : c = a ∨ c = b 
goal: c = a ∨ c = b

full_name: wcovBy_iff_le_and_eq_or_eq
code: /-- An `iff` version of `WCovBy.eq_or_eq` and `wcovBy_of_eq_or_eq`. -/
theorem wcovBy_iff_le_and_eq_or_eq : a ⩿ b ↔ a ≤ b ∧ ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b 
goal: a ⩿ b ↔ a ≤ b ∧ ∀ (c : α), a ≤ c → c ≤ b → c = a ∨ c = b

full_name: WCovBy.le_and_le_iff
code: theorem WCovBy.le_and_le_iff (h : a ⩿ b) : a ≤ c ∧ c ≤ b ↔ c = a ∨ c = b 
goal: a ≤ c ∧ c ≤ b ↔ c = a ∨ c = b

full_name: WCovBy.Icc_eq
code: theorem WCovBy.Icc_eq (h : a ⩿ b) : Icc a b = {a, b} 
goal: Set.Icc a b = {a, b}

full_name: WCovBy.Ico_subset
code: theorem WCovBy.Ico_subset (h : a ⩿ b) : Ico a b ⊆ {a} 
goal: Set.Ico a b ⊆ {a}

full_name: WCovBy.Ioc_subset
code: theorem WCovBy.Ioc_subset (h : a ⩿ b) : Ioc a b ⊆ {b} 
goal: Set.Ioc a b ⊆ {b}

full_name: WCovBy.sup_eq
code: theorem WCovBy.sup_eq (hac : a ⩿ c) (hbc : b ⩿ c) (hab : a ≠ b) : a ⊔ b = c 
goal: a ⊔ b = c

full_name: WCovBy.inf_eq
code: theorem WCovBy.inf_eq (hca : c ⩿ a) (hcb : c ⩿ b) (hab : a ≠ b) : a ⊓ b = c 
goal: a ⊓ b = c

full_name: CovBy
code: /-- `CovBy a b` means that `b` covers `a`: `a < b` and there is no element in between. -/
def CovBy (a b : α) : Prop 
goal: Prop

full_name: _aux_Mathlib_Order_Cover___unexpand_CovBy_1
code: /-- Notation for `CovBy a b`. -/
infixl:50 " ⋖ " => CovBy
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Order_Cover___macroRules_term_⋖__1»
code: /-- Notation for `CovBy a b`. -/
infixl:50 " ⋖ " => CovBy
goal: Lean.Macro

full_name: CovBy.lt
code: theorem CovBy.lt (h : a ⋖ b) : a < b 
goal: a < b

full_name: not_covBy_iff
code: /-- If `a < b`, then `b` does not cover `a` iff there's an element in between. -/
theorem not_covBy_iff (h : a < b) : ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b 
goal: ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b

full_name: not_covBy
code: /-- In a dense order, nothing covers anything. -/
theorem not_covBy [DenselyOrdered α] : ¬a ⋖ b 
goal: ¬a ⋖ b

full_name: denselyOrdered_iff_forall_not_covBy
code: theorem denselyOrdered_iff_forall_not_covBy : DenselyOrdered α ↔ ∀ a b : α, ¬a ⋖ b 
goal: DenselyOrdered α ↔ ∀ (a b : α), ¬a ⋖ b

full_name: toDual_covBy_toDual_iff
code: @[simp]
theorem toDual_covBy_toDual_iff : toDual b ⋖ toDual a ↔ a ⋖ b 
goal: OrderDual.toDual b ⋖ OrderDual.toDual a ↔ a ⋖ b

full_name: ofDual_covBy_ofDual_iff
code: @[simp]
theorem ofDual_covBy_ofDual_iff {a b : αᵒᵈ} : ofDual a ⋖ ofDual b ↔ b ⋖ a 
goal: OrderDual.ofDual a ⋖ OrderDual.ofDual b ↔ b ⋖ a

full_name: CovBy.le
code: theorem CovBy.le (h : a ⋖ b) : a ≤ b 
goal: a ≤ b

full_name: CovBy.ne
code: protected theorem CovBy.ne (h : a ⋖ b) : a ≠ b 
goal: a ≠ b

full_name: CovBy.ne'
code: theorem CovBy.ne' (h : a ⋖ b) : b ≠ a 
goal: b ≠ a

full_name: CovBy.wcovBy
code: protected theorem CovBy.wcovBy (h : a ⋖ b) : a ⩿ b 
goal: a ⩿ b

full_name: WCovBy.covBy_of_not_le
code: theorem WCovBy.covBy_of_not_le (h : a ⩿ b) (h2 : ¬b ≤ a) : a ⋖ b 
goal: a ⋖ b

full_name: WCovBy.covBy_of_lt
code: theorem WCovBy.covBy_of_lt (h : a ⩿ b) (h2 : a < b) : a ⋖ b 
goal: a ⋖ b

full_name: CovBy.of_le_of_lt
code: lemma CovBy.of_le_of_lt (hac : a ⋖ c) (hab : a ≤ b) (hbc : b < c) : b ⋖ c 
goal: b ⋖ c

full_name: CovBy.of_lt_of_le
code: lemma CovBy.of_lt_of_le (hac : a ⋖ c) (hab : a < b) (hbc : b ≤ c) : a ⋖ b 
goal: a ⋖ b

full_name: not_covBy_of_lt_of_lt
code: theorem not_covBy_of_lt_of_lt (h₁ : a < b) (h₂ : b < c) : ¬a ⋖ c 
goal: ¬a ⋖ c

full_name: covBy_iff_wcovBy_and_lt
code: theorem covBy_iff_wcovBy_and_lt : a ⋖ b ↔ a ⩿ b ∧ a < b 
goal: a ⋖ b ↔ a ⩿ b ∧ a < b

full_name: covBy_iff_wcovBy_and_not_le
code: theorem covBy_iff_wcovBy_and_not_le : a ⋖ b ↔ a ⩿ b ∧ ¬b ≤ a 
goal: a ⋖ b ↔ a ⩿ b ∧ ¬b ≤ a

full_name: wcovBy_iff_covBy_or_le_and_le
code: theorem wcovBy_iff_covBy_or_le_and_le : a ⩿ b ↔ a ⋖ b ∨ a ≤ b ∧ b ≤ a 
goal: a ⩿ b ↔ a ⋖ b ∨ a ≤ b ∧ b ≤ a

full_name: AntisymmRel.trans_covBy
code: theorem AntisymmRel.trans_covBy (hab : AntisymmRel (· ≤ ·) a b) (hbc : b ⋖ c) : a ⋖ c 
goal: a ⋖ c

full_name: covBy_congr_left
code: theorem covBy_congr_left (hab : AntisymmRel (· ≤ ·) a b) : a ⋖ c ↔ b ⋖ c 
goal: a ⋖ c ↔ b ⋖ c

full_name: CovBy.trans_antisymmRel
code: theorem CovBy.trans_antisymmRel (hab : a ⋖ b) (hbc : AntisymmRel (· ≤ ·) b c) : a ⋖ c 
goal: a ⋖ c

full_name: covBy_congr_right
code: theorem covBy_congr_right (hab : AntisymmRel (· ≤ ·) a b) : c ⋖ a ↔ c ⋖ b 
goal: c ⋖ a ↔ c ⋖ b

full_name: instIsNonstrictStrictOrderWCovByCovBy
code: instance : IsNonstrictStrictOrder α (· ⩿ ·) (· ⋖ ·) 
goal: IsNonstrictStrictOrder α (fun x x_1 => x ⩿ x_1) fun x x_1 => x ⋖ x_1

full_name: CovBy.isIrrefl
code: instance CovBy.isIrrefl : IsIrrefl α (· ⋖ ·) 
goal: IsIrrefl α fun x x_1 => x ⋖ x_1

full_name: CovBy.Ioo_eq
code: theorem CovBy.Ioo_eq (h : a ⋖ b) : Ioo a b = ∅ 
goal: Set.Ioo a b = ∅

full_name: covBy_iff_Ioo_eq
code: theorem covBy_iff_Ioo_eq : a ⋖ b ↔ a < b ∧ Ioo a b = ∅ 
goal: a ⋖ b ↔ a < b ∧ Set.Ioo a b = ∅

full_name: CovBy.of_image
code: theorem CovBy.of_image (f : α ↪o β) (h : f a ⋖ f b) : a ⋖ b 
goal: a ⋖ b

full_name: CovBy.image
code: theorem CovBy.image (f : α ↪o β) (hab : a ⋖ b) (h : (range f).OrdConnected) : f a ⋖ f b 
goal: f a ⋖ f b

full_name: Set.OrdConnected.apply_covBy_apply_iff
code: theorem Set.OrdConnected.apply_covBy_apply_iff (f : α ↪o β) (h : (range f).OrdConnected) :
    f a ⋖ f b ↔ a ⋖ b 
goal: f a ⋖ f b ↔ a ⋖ b

full_name: apply_covBy_apply_iff
code: @[simp]
theorem apply_covBy_apply_iff {E : Type*} [EquivLike E α β] [OrderIsoClass E α β] (e : E) :
    e a ⋖ e b ↔ a ⋖ b 
goal: e a ⋖ e b ↔ a ⋖ b

full_name: covBy_of_eq_or_eq
code: theorem covBy_of_eq_or_eq (hab : a < b) (h : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b) : a ⋖ b 
goal: a ⋖ b

full_name: WCovBy.covBy_of_ne
code: theorem WCovBy.covBy_of_ne (h : a ⩿ b) (h2 : a ≠ b) : a ⋖ b 
goal: a ⋖ b

full_name: covBy_iff_wcovBy_and_ne
code: theorem covBy_iff_wcovBy_and_ne : a ⋖ b ↔ a ⩿ b ∧ a ≠ b 
goal: a ⋖ b ↔ a ⩿ b ∧ a ≠ b

full_name: wcovBy_iff_covBy_or_eq
code: theorem wcovBy_iff_covBy_or_eq : a ⩿ b ↔ a ⋖ b ∨ a = b 
goal: a ⩿ b ↔ a ⋖ b ∨ a = b

full_name: wcovBy_iff_eq_or_covBy
code: theorem wcovBy_iff_eq_or_covBy : a ⩿ b ↔ a = b ∨ a ⋖ b 
goal: a ⩿ b ↔ a = b ∨ a ⋖ b

full_name: CovBy.eq_or_eq
code: theorem CovBy.eq_or_eq (h : a ⋖ b) (h2 : a ≤ c) (h3 : c ≤ b) : c = a ∨ c = b 
goal: c = a ∨ c = b

full_name: covBy_iff_lt_and_eq_or_eq
code: /-- An `iff` version of `CovBy.eq_or_eq` and `covBy_of_eq_or_eq`. -/
theorem covBy_iff_lt_and_eq_or_eq : a ⋖ b ↔ a < b ∧ ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b 
goal: a ⋖ b ↔ a < b ∧ ∀ (c : α), a ≤ c → c ≤ b → c = a ∨ c = b

full_name: CovBy.Ico_eq
code: theorem CovBy.Ico_eq (h : a ⋖ b) : Ico a b = {a} 
goal: Set.Ico a b = {a}

full_name: CovBy.Ioc_eq
code: theorem CovBy.Ioc_eq (h : a ⋖ b) : Ioc a b = {b} 
goal: Set.Ioc a b = {b}

full_name: CovBy.Icc_eq
code: theorem CovBy.Icc_eq (h : a ⋖ b) : Icc a b = {a, b} 
goal: Set.Icc a b = {a, b}

full_name: CovBy.Ioi_eq
code: theorem CovBy.Ioi_eq (h : a ⋖ b) : Ioi a = Ici b 
goal: Set.Ioi a = Set.Ici b

full_name: CovBy.Iio_eq
code: theorem CovBy.Iio_eq (h : a ⋖ b) : Iio b = Iic a 
goal: Set.Iio b = Set.Iic a

full_name: WCovBy.le_of_lt
code: theorem WCovBy.le_of_lt (hab : a ⩿ b) (hcb : c < b) : c ≤ a 
goal: c ≤ a

full_name: WCovBy.ge_of_gt
code: theorem WCovBy.ge_of_gt (hab : a ⩿ b) (hac : a < c) : b ≤ c 
goal: b ≤ c

full_name: CovBy.le_of_lt
code: theorem CovBy.le_of_lt (hab : a ⋖ b) : c < b → c ≤ a 
goal: c < b → c ≤ a

full_name: CovBy.ge_of_gt
code: theorem CovBy.ge_of_gt (hab : a ⋖ b) : a < c → b ≤ c 
goal: a < c → b ≤ c

full_name: CovBy.unique_left
code: theorem CovBy.unique_left (ha : a ⋖ c) (hb : b ⋖ c) : a = b 
goal: a = b

full_name: CovBy.unique_right
code: theorem CovBy.unique_right (hb : a ⋖ b) (hc : a ⋖ c) : b = c 
goal: b = c

full_name: CovBy.eq_of_between
code: /-- If `a`, `b`, `c` are consecutive and `a < x < c` then `x = b`. -/
theorem CovBy.eq_of_between {x : α} (hab : a ⋖ b) (hbc : b ⋖ c) (hax : a < x) (hxc : x < c) :
    x = b 
goal: x = b

full_name: LT.lt.exists_disjoint_Iio_Ioi
code: /-- If `a < b` then there exist `a' > a` and `b' < b` such that `Set.Iio a'` is strictly to the left
of `Set.Ioi b'`. -/
lemma LT.lt.exists_disjoint_Iio_Ioi (h : a < b) :
    ∃ a' > a, ∃ b' < b, ∀ x < a', ∀ y > b', x < y 
goal: ∃ a' > a, ∃ b' < b, ∀ x < a', ∀ y > b', x < y

full_name: Set.wcovBy_insert
code: @[simp] lemma wcovBy_insert (x : α) (s : Set α) : s ⩿ insert x s 
goal: s ⩿ insert x s

full_name: Set.sdiff_singleton_wcovBy
code: @[simp] lemma sdiff_singleton_wcovBy (s : Set α) (a : α) : s \ {a} ⩿ s 
goal: s \ {a} ⩿ s

full_name: Set.covBy_insert
code: @[simp] lemma covBy_insert (ha : a ∉ s) : s ⋖ insert a s 
goal: s ⋖ insert a s

full_name: Set.sdiff_singleton_covBy
code: @[simp] lemma sdiff_singleton_covBy (ha : a ∈ s) : s \ {a} ⋖ s 
goal: s \ {a} ⋖ s

full_name: CovBy.exists_set_insert
code: lemma _root_.CovBy.exists_set_insert (h : s ⋖ t) : ∃ a ∉ s, insert a s = t 
goal: ∃ a ∉ s, insert a s = t

full_name: CovBy.exists_set_sdiff_singleton
code: lemma _root_.CovBy.exists_set_sdiff_singleton (h : s ⋖ t) : ∃ a ∈ t, t \ {a} =  s 
goal: ∃ a ∈ t, t \ {a} = s

full_name: Set.covBy_iff_exists_insert
code: lemma covBy_iff_exists_insert : s ⋖ t ↔ ∃ a ∉ s, insert a s = t 
goal: s ⋖ t ↔ ∃ a ∉ s, insert a s = t

full_name: Set.covBy_iff_exists_sdiff_singleton
code: lemma covBy_iff_exists_sdiff_singleton : s ⋖ t ↔ ∃ a ∈ t, t \ {a} = s 
goal: s ⋖ t ↔ ∃ a ∈ t, t \ {a} = s

full_name: wcovBy_eq_reflGen_covBy
code: lemma wcovBy_eq_reflGen_covBy [PartialOrder α] : ((· : α) ⩿ ·) = ReflGen (· ⋖ ·) 
goal: (fun x x_1 => x ⩿ x_1) = Relation.ReflGen fun x x_1 => x ⋖ x_1

full_name: transGen_wcovBy_eq_reflTransGen_covBy
code: lemma transGen_wcovBy_eq_reflTransGen_covBy [PartialOrder α] :
    TransGen ((· : α) ⩿ ·) = ReflTransGen (· ⋖ ·) 
goal: (Relation.TransGen fun x x_1 => x ⩿ x_1) = Relation.ReflTransGen fun x x_1 => x ⋖ x_1

full_name: reflTransGen_wcovBy_eq_reflTransGen_covBy
code: lemma reflTransGen_wcovBy_eq_reflTransGen_covBy [PartialOrder α] :
    ReflTransGen ((· : α) ⩿ ·) = ReflTransGen (· ⋖ ·) 
goal: (Relation.ReflTransGen fun x x_1 => x ⩿ x_1) = Relation.ReflTransGen fun x x_1 => x ⋖ x_1

full_name: Prod.swap_wcovBy_swap
code: @[simp]
theorem swap_wcovBy_swap : x.swap ⩿ y.swap ↔ x ⩿ y 
goal: x.swap ⩿ y.swap ↔ x ⩿ y

full_name: Prod.swap_covBy_swap
code: @[simp]
theorem swap_covBy_swap : x.swap ⋖ y.swap ↔ x ⋖ y 
goal: x.swap ⋖ y.swap ↔ x ⋖ y

full_name: Prod.fst_eq_or_snd_eq_of_wcovBy
code: theorem fst_eq_or_snd_eq_of_wcovBy : x ⩿ y → x.1 = y.1 ∨ x.2 = y.2 
goal: x ⩿ y → x.1 = y.1 ∨ x.2 = y.2

full_name: WCovBy.fst
code: theorem _root_.WCovBy.fst (h : x ⩿ y) : x.1 ⩿ y.1 
goal: x.1 ⩿ y.1

full_name: WCovBy.snd
code: theorem _root_.WCovBy.snd (h : x ⩿ y) : x.2 ⩿ y.2 
goal: x.2 ⩿ y.2

full_name: Prod.mk_wcovBy_mk_iff_left
code: theorem mk_wcovBy_mk_iff_left : (a₁, b) ⩿ (a₂, b) ↔ a₁ ⩿ a₂ 
goal: (a₁, b) ⩿ (a₂, b) ↔ a₁ ⩿ a₂

full_name: Prod.mk_wcovBy_mk_iff_right
code: theorem mk_wcovBy_mk_iff_right : (a, b₁) ⩿ (a, b₂) ↔ b₁ ⩿ b₂ 
goal: (a, b₁) ⩿ (a, b₂) ↔ b₁ ⩿ b₂

full_name: Prod.mk_covBy_mk_iff_left
code: theorem mk_covBy_mk_iff_left : (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂ 
goal: (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂

full_name: Prod.mk_covBy_mk_iff_right
code: theorem mk_covBy_mk_iff_right : (a, b₁) ⋖ (a, b₂) ↔ b₁ ⋖ b₂ 
goal: (a, b₁) ⋖ (a, b₂) ↔ b₁ ⋖ b₂

full_name: Prod.mk_wcovBy_mk_iff
code: theorem mk_wcovBy_mk_iff : (a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂ 
goal: (a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂

full_name: Prod.mk_covBy_mk_iff
code: theorem mk_covBy_mk_iff : (a₁, b₁) ⋖ (a₂, b₂) ↔ a₁ ⋖ a₂ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₂ 
goal: (a₁, b₁) ⋖ (a₂, b₂) ↔ a₁ ⋖ a₂ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₂

full_name: Prod.wcovBy_iff
code: theorem wcovBy_iff : x ⩿ y ↔ x.1 ⩿ y.1 ∧ x.2 = y.2 ∨ x.2 ⩿ y.2 ∧ x.1 = y.1 
goal: x ⩿ y ↔ x.1 ⩿ y.1 ∧ x.2 = y.2 ∨ x.2 ⩿ y.2 ∧ x.1 = y.1

full_name: Prod.covBy_iff
code: theorem covBy_iff : x ⋖ y ↔ x.1 ⋖ y.1 ∧ x.2 = y.2 ∨ x.2 ⋖ y.2 ∧ x.1 = y.1 
goal: x ⋖ y ↔ x.1 ⋖ y.1 ∧ x.2 = y.2 ∨ x.2 ⋖ y.2 ∧ x.1 = y.1