File: Mathlib/Order/Synonym.lean

full_name: OrderDual.instNontrivial
code: instance [h : Nontrivial α] : Nontrivial αᵒᵈ 
goal: Nontrivial αᵒᵈ

full_name: OrderDual.toDual
code: /-- `toDual` is the identity function to the `OrderDual` of a linear order.  -/
def toDual : α ≃ αᵒᵈ 
goal: α ≃ αᵒᵈ

full_name: OrderDual.ofDual
code: /-- `ofDual` is the identity function from the `OrderDual` of a linear order.  -/
def ofDual : αᵒᵈ ≃ α 
goal: αᵒᵈ ≃ α

full_name: OrderDual.toDual_symm_eq
code: @[simp]
theorem toDual_symm_eq : (@toDual α).symm = ofDual 
goal: OrderDual.toDual.symm = OrderDual.ofDual

full_name: OrderDual.ofDual_symm_eq
code: @[simp]
theorem ofDual_symm_eq : (@ofDual α).symm = toDual 
goal: OrderDual.ofDual.symm = OrderDual.toDual

full_name: OrderDual.toDual_ofDual
code: @[simp]
theorem toDual_ofDual (a : αᵒᵈ) : toDual (ofDual a) = a 
goal: OrderDual.toDual (OrderDual.ofDual a) = a

full_name: OrderDual.ofDual_toDual
code: @[simp]
theorem ofDual_toDual (a : α) : ofDual (toDual a) = a 
goal: OrderDual.ofDual (OrderDual.toDual a) = a

full_name: OrderDual.toDual_inj
code: theorem toDual_inj {a b : α} : toDual a = toDual b ↔ a = b 
goal: OrderDual.toDual a = OrderDual.toDual b ↔ a = b

full_name: OrderDual.ofDual_inj
code: theorem ofDual_inj {a b : αᵒᵈ} : ofDual a = ofDual b ↔ a = b 
goal: OrderDual.ofDual a = OrderDual.ofDual b ↔ a = b

full_name: OrderDual.toDual_le_toDual
code: @[simp]
theorem toDual_le_toDual [LE α] {a b : α} : toDual a ≤ toDual b ↔ b ≤ a 
goal: OrderDual.toDual a ≤ OrderDual.toDual b ↔ b ≤ a

full_name: OrderDual.toDual_lt_toDual
code: @[simp]
theorem toDual_lt_toDual [LT α] {a b : α} : toDual a < toDual b ↔ b < a 
goal: OrderDual.toDual a < OrderDual.toDual b ↔ b < a

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

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

full_name: OrderDual.le_toDual
code: theorem le_toDual [LE α] {a : αᵒᵈ} {b : α} : a ≤ toDual b ↔ b ≤ ofDual a 
goal: a ≤ OrderDual.toDual b ↔ b ≤ OrderDual.ofDual a

full_name: OrderDual.lt_toDual
code: theorem lt_toDual [LT α] {a : αᵒᵈ} {b : α} : a < toDual b ↔ b < ofDual a 
goal: a < OrderDual.toDual b ↔ b < OrderDual.ofDual a

full_name: OrderDual.toDual_le
code: theorem toDual_le [LE α] {a : α} {b : αᵒᵈ} : toDual a ≤ b ↔ ofDual b ≤ a 
goal: OrderDual.toDual a ≤ b ↔ OrderDual.ofDual b ≤ a

full_name: OrderDual.toDual_lt
code: theorem toDual_lt [LT α] {a : α} {b : αᵒᵈ} : toDual a < b ↔ ofDual b < a 
goal: OrderDual.toDual a < b ↔ OrderDual.ofDual b < a

full_name: OrderDual.rec
code: /-- Recursor for `αᵒᵈ`. -/
@[elab_as_elim]
protected def rec {C : αᵒᵈ → Sort*} (h₂ : ∀ a : α, C (toDual a)) : ∀ a : αᵒᵈ, C a 
goal: C a

full_name: OrderDual.forall
code: @[simp]
protected theorem «forall» {p : αᵒᵈ → Prop} : (∀ a, p a) ↔ ∀ a, p (toDual a) 
goal: (∀ (a : αᵒᵈ), p a) ↔ ∀ (a : α), p (OrderDual.toDual a)

full_name: OrderDual.exists
code: @[simp]
protected theorem «exists» {p : αᵒᵈ → Prop} : (∃ a, p a) ↔ ∃ a, p (toDual a) 
goal: (∃ a, p a) ↔ ∃ a, p (OrderDual.toDual a)

full_name: Lex
code: /-- A type synonym to equip a type with its lexicographic order. -/
def Lex (α : Type*) 
goal: Type u_4

full_name: toLex
code: /-- `toLex` is the identity function to the `Lex` of a type.  -/
@[match_pattern]
def toLex : α ≃ Lex α 
goal: α ≃ Lex α

full_name: ofLex
code: /-- `ofLex` is the identity function from the `Lex` of a type.  -/
@[match_pattern]
def ofLex : Lex α ≃ α 
goal: Lex α ≃ α

full_name: toLex_symm_eq
code: @[simp]
theorem toLex_symm_eq : (@toLex α).symm = ofLex 
goal: toLex.symm = ofLex

full_name: ofLex_symm_eq
code: @[simp]
theorem ofLex_symm_eq : (@ofLex α).symm = toLex 
goal: ofLex.symm = toLex

full_name: toLex_ofLex
code: @[simp]
theorem toLex_ofLex (a : Lex α) : toLex (ofLex a) = a 
goal: toLex (ofLex a) = a

full_name: ofLex_toLex
code: @[simp]
theorem ofLex_toLex (a : α) : ofLex (toLex a) = a 
goal: ofLex (toLex a) = a

full_name: toLex_inj
code: theorem toLex_inj {a b : α} : toLex a = toLex b ↔ a = b 
goal: toLex a = toLex b ↔ a = b

full_name: ofLex_inj
code: theorem ofLex_inj {a b : Lex α} : ofLex a = ofLex b ↔ a = b 
goal: ofLex a = ofLex b ↔ a = b

full_name: Lex.rec
code: /-- A recursor for `Lex`. Use as `induction x`. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
protected def Lex.rec {β : Lex α → Sort*} (h : ∀ a, β (toLex a)) : ∀ a, β a 
goal: β a

full_name: Lex.forall
code: @[simp] lemma Lex.forall {p : Lex α → Prop} : (∀ a, p a) ↔ ∀ a, p (toLex a) 
goal: (∀ (a : Lex α), p a) ↔ ∀ (a : α), p (toLex a)

full_name: Lex.exists
code: @[simp] lemma Lex.exists {p : Lex α → Prop} : (∃ a, p a) ↔ ∃ a, p (toLex a) 
goal: (∃ a, p a) ↔ ∃ a, p (toLex a)