File: Mathlib/Logic/Relation.lean

full_name: IsRefl.reflexive
code: theorem IsRefl.reflexive [IsRefl α r] : Reflexive r 
goal: Reflexive r

full_name: Reflexive.rel_of_ne_imp
code: /-- To show a reflexive relation `r : α → α → Prop` holds over `x y : α`,
it suffices to show it holds when `x ≠ y`. -/
theorem Reflexive.rel_of_ne_imp (h : Reflexive r) {x y : α} (hr : x ≠ y → r x y) : r x y 
goal: r x y

full_name: Reflexive.ne_imp_iff
code: /-- If a reflexive relation `r : α → α → Prop` holds over `x y : α`,
then it holds whether or not `x ≠ y`. -/
theorem Reflexive.ne_imp_iff (h : Reflexive r) {x y : α} : x ≠ y → r x y ↔ r x y 
goal: x ≠ y → r x y ↔ r x y

full_name: reflexive_ne_imp_iff
code: /-- If a reflexive relation `r : α → α → Prop` holds over `x y : α`,
then it holds whether or not `x ≠ y`. Unlike `Reflexive.ne_imp_iff`, this uses `[IsRefl α r]`. -/
theorem reflexive_ne_imp_iff [IsRefl α r] {x y : α} : x ≠ y → r x y ↔ r x y 
goal: x ≠ y → r x y ↔ r x y

full_name: Symmetric.iff
code: protected theorem Symmetric.iff (H : Symmetric r) (x y : α) : r x y ↔ r y x 
goal: r x y ↔ r y x

full_name: Symmetric.flip_eq
code: theorem Symmetric.flip_eq (h : Symmetric r) : flip r = r 
goal: flip r = r

full_name: Symmetric.swap_eq
code: theorem Symmetric.swap_eq : Symmetric r → swap r = r 
goal: Symmetric r → Function.swap r = r

full_name: flip_eq_iff
code: theorem flip_eq_iff : flip r = r ↔ Symmetric r 
goal: flip r = r ↔ Symmetric r

full_name: swap_eq_iff
code: theorem swap_eq_iff : swap r = r ↔ Symmetric r 
goal: Function.swap r = r ↔ Symmetric r

full_name: Reflexive.comap
code: theorem Reflexive.comap (h : Reflexive r) (f : α → β) : Reflexive (r on f) 
goal: Reflexive (r on f)

full_name: Symmetric.comap
code: theorem Symmetric.comap (h : Symmetric r) (f : α → β) : Symmetric (r on f) 
goal: Symmetric (r on f)

full_name: Transitive.comap
code: theorem Transitive.comap (h : Transitive r) (f : α → β) : Transitive (r on f) 
goal: Transitive (r on f)

full_name: Equivalence.comap
code: theorem Equivalence.comap (h : Equivalence r) (f : α → β) : Equivalence (r on f) 
goal: Equivalence (r on f)

full_name: Relation.Comp
code: /-- The composition of two relations, yielding a new relation.  The result
relates a term of `α` and a term of `γ` if there is an intermediate
term of `β` related to both.
-/
def Comp (r : α → β → Prop) (p : β → γ → Prop) (a : α) (c : γ) : Prop 
goal: Prop

full_name: Relation._aux_Mathlib_Logic_Relation___unexpand_Relation_Comp_1
code: @[inherit_doc]
local infixr:80 " ∘r " => Relation.Comp
goal: Lean.PrettyPrinter.Unexpander

full_name: Relation.«_aux_Mathlib_Logic_Relation___macroRules_Relation_term_∘r__1»
code: @[inherit_doc]
local infixr:80 " ∘r " => Relation.Comp
goal: Lean.Macro

full_name: Relation.comp_eq
code: theorem comp_eq : r ∘r (· = ·) = r 
goal: (Relation.Comp r fun x x_1 => x = x_1) = r

full_name: Relation.eq_comp
code: theorem eq_comp : (· = ·) ∘r r = r 
goal: Relation.Comp (fun x x_1 => x = x_1) r = r

full_name: Relation.iff_comp
code: theorem iff_comp {r : Prop → α → Prop} : (· ↔ ·) ∘r r = r 
goal: Relation.Comp (fun x x_1 => x ↔ x_1) r = r

full_name: Relation.comp_iff
code: theorem comp_iff {r : α → Prop → Prop} : r ∘r (· ↔ ·) = r 
goal: (Relation.Comp r fun x x_1 => x ↔ x_1) = r

full_name: Relation.comp_assoc
code: theorem comp_assoc : (r ∘r p) ∘r q = r ∘r p ∘r q 
goal: Relation.Comp (Relation.Comp r p) q = Relation.Comp r (Relation.Comp p q)

full_name: Relation.flip_comp
code: theorem flip_comp : flip (r ∘r p) = flip p ∘r flip r 
goal: flip (Relation.Comp r p) = Relation.Comp (flip p) (flip r)

full_name: Relation.Fibration
code: /-- A function `f : α → β` is a fibration between the relation `rα` and `rβ` if for all
  `a : α` and `b : β`, whenever `b : β` and `f a` are related by `rβ`, `b` is the image
  of some `a' : α` under `f`, and `a'` and `a` are related by `rα`. -/
def Fibration 
goal: Prop

full_name: Acc.of_fibration
code: /-- If `f : α → β` is a fibration between relations `rα` and `rβ`, and `a : α` is
  accessible under `rα`, then `f a` is accessible under `rβ`. -/
theorem _root_.Acc.of_fibration (fib : Fibration rα rβ f) {a} (ha : Acc rα a) : Acc rβ (f a) 
goal: Acc rβ (f a)

full_name: Acc.of_downward_closed
code: theorem _root_.Acc.of_downward_closed (dc : ∀ {a b}, rβ b (f a) → ∃ c, f c = b) (a : α)
    (ha : Acc (InvImage rβ f) a) : Acc rβ (f a) 
goal: Acc rβ (f a)

full_name: Relation.Map
code: /-- The map of a relation `r` through a pair of functions pushes the
relation to the codomains of the functions.  The resulting relation is
defined by having pairs of terms related if they have preimages
related by `r`.
-/
protected def Map (r : α → β → Prop) (f : α → γ) (g : β → δ) : γ → δ → Prop 
goal: γ → δ → Prop

full_name: Relation.map_apply
code: lemma map_apply : Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d 
goal: Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d

full_name: Relation.map_map
code: @[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) 
goal: Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁)

full_name: Relation.map_apply_apply
code: @[simp]
lemma map_apply_apply (hf : Injective f) (hg : Injective g) (r : α → β → Prop) (a : α) (b : β) :
    Relation.Map r f g (f a) (g b) ↔ r a b 
goal: Relation.Map r f g (f a) (g b) ↔ r a b

full_name: Relation.map_id_id
code: @[simp] lemma map_id_id (r : α → β → Prop) : Relation.Map r id id = r 
goal: Relation.Map r id id = r

full_name: Relation.instDecidableMapOfExistsAndEq
code: instance [Decidable (∃ a b, r a b ∧ f a = c ∧ g b = d)] : Decidable (Relation.Map r f g c d) 
goal: Decidable (Relation.Map r f g c d)

full_name: Relation.ReflTransGen.cases_tail_iff
code: /-- `ReflTransGen r`: reflexive transitive closure of `r` -/
@[mk_iff ReflTransGen.cases_tail_iff]
inductive ReflTransGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflTransGen r a a
  | tail {b c} : ReflTransGen r a b → r b c → ReflTransGen r a c
goal: ∀ (a_1 : α), Relation.ReflTransGen r a a_1 ↔ a_1 = a ∨ ∃ b, Relation.ReflTransGen r a b ∧ r b a_1

full_name: Relation.ReflTransGen.tail
code: /-- `ReflTransGen r`: reflexive transitive closure of `r` -/
@[mk_iff ReflTransGen.cases_tail_iff]
inductive ReflTransGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflTransGen r a a
  | tail {b c} : ReflTransGen r a b → r b c → ReflTransGen r a c
goal: Relation.ReflTransGen r a b → r b c → Relation.ReflTransGen r a c

full_name: Relation.ReflTransGen
code: /-- `ReflTransGen r`: reflexive transitive closure of `r` -/
@[mk_iff ReflTransGen.cases_tail_iff]
inductive ReflTransGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflTransGen r a a
  | tail {b c} : ReflTransGen r a b → r b c → ReflTransGen r a c
goal: α → Prop

full_name: Relation.ReflTransGen.refl
code: /-- `ReflTransGen r`: reflexive transitive closure of `r` -/
@[mk_iff ReflTransGen.cases_tail_iff]
inductive ReflTransGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflTransGen r a a
  | tail {b c} : ReflTransGen r a b → r b c → ReflTransGen r a c
goal: Relation.ReflTransGen r a a

full_name: Relation.ReflGen.single
code: /-- `ReflGen r`: reflexive closure of `r` -/
@[mk_iff]
inductive ReflGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflGen r a a
  | single {b} : r a b → ReflGen r a b
goal: r a b → Relation.ReflGen r a b

full_name: Relation.reflGen_iff
code: /-- `ReflGen r`: reflexive closure of `r` -/
@[mk_iff]
inductive ReflGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflGen r a a
  | single {b} : r a b → ReflGen r a b
goal: ∀ (a_1 : α), Relation.ReflGen r a a_1 ↔ a_1 = a ∨ r a a_1

full_name: Relation.ReflGen.refl
code: /-- `ReflGen r`: reflexive closure of `r` -/
@[mk_iff]
inductive ReflGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflGen r a a
  | single {b} : r a b → ReflGen r a b
goal: Relation.ReflGen r a a

full_name: Relation.ReflGen
code: /-- `ReflGen r`: reflexive closure of `r` -/
@[mk_iff]
inductive ReflGen (r : α → α → Prop) (a : α) : α → Prop
  | refl : ReflGen r a a
  | single {b} : r a b → ReflGen r a b
goal: α → Prop

full_name: Relation.TransGen
code: /-- `TransGen r`: transitive closure of `r` -/
@[mk_iff]
inductive TransGen (r : α → α → Prop) (a : α) : α → Prop
  | single {b} : r a b → TransGen r a b
  | tail {b c} : TransGen r a b → r b c → TransGen r a c
goal: α → Prop

full_name: Relation.TransGen.single
code: /-- `TransGen r`: transitive closure of `r` -/
@[mk_iff]
inductive TransGen (r : α → α → Prop) (a : α) : α → Prop
  | single {b} : r a b → TransGen r a b
  | tail {b c} : TransGen r a b → r b c → TransGen r a c
goal: r a b → Relation.TransGen r a b

full_name: Relation.TransGen.tail
code: /-- `TransGen r`: transitive closure of `r` -/
@[mk_iff]
inductive TransGen (r : α → α → Prop) (a : α) : α → Prop
  | single {b} : r a b → TransGen r a b
  | tail {b c} : TransGen r a b → r b c → TransGen r a c
goal: Relation.TransGen r a b → r b c → Relation.TransGen r a c

full_name: Relation.transGen_iff
code: /-- `TransGen r`: transitive closure of `r` -/
@[mk_iff]
inductive TransGen (r : α → α → Prop) (a : α) : α → Prop
  | single {b} : r a b → TransGen r a b
  | tail {b c} : TransGen r a b → r b c → TransGen r a c
goal: ∀ (a_1 : α), Relation.TransGen r a a_1 ↔ r a a_1 ∨ ∃ b, Relation.TransGen r a b ∧ r b a_1

full_name: Relation.ReflGen.to_reflTransGen
code: theorem to_reflTransGen : ∀ {a b}, ReflGen r a b → ReflTransGen r a b
  
goal: Relation.ReflGen r a b → Relation.ReflTransGen r a b

full_name: Relation.ReflGen.mono
code: theorem mono {p : α → α → Prop} (hp : ∀ a b, r a b → p a b) : ∀ {a b}, ReflGen r a b → ReflGen p a b
  
goal: Relation.ReflGen r a b → Relation.ReflGen p a b

full_name: Relation.ReflGen.instIsRefl
code: instance : IsRefl α (ReflGen r) 
goal: IsRefl α (Relation.ReflGen r)

full_name: Relation.ReflTransGen.trans
code: @[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c 
goal: Relation.ReflTransGen r a c

full_name: Relation.ReflTransGen.single
code: theorem single (hab : r a b) : ReflTransGen r a b 
goal: Relation.ReflTransGen r a b

full_name: Relation.ReflTransGen.head
code: theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c 
goal: Relation.ReflTransGen r a c

full_name: Relation.ReflTransGen.symmetric
code: theorem symmetric (h : Symmetric r) : Symmetric (ReflTransGen r) 
goal: Symmetric (Relation.ReflTransGen r)

full_name: Relation.ReflTransGen.cases_tail
code: theorem cases_tail : ReflTransGen r a b → b = a ∨ ∃ c, ReflTransGen r a c ∧ r c b 
goal: Relation.ReflTransGen r a b → b = a ∨ ∃ c, Relation.ReflTransGen r a c ∧ r c b

full_name: Relation.ReflTransGen.head_induction_on
code: @[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h 
goal: P a h

full_name: Relation.ReflTransGen.trans_induction_on
code: @[elab_as_elim]
theorem trans_induction_on {P : ∀ {a b : α}, ReflTransGen r a b → Prop} {a b : α}
    (h : ReflTransGen r a b) (ih₁ : ∀ a, @P a a refl) (ih₂ : ∀ {a b} (h : r a b), P (single h))
    (ih₃ : ∀ {a b c} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ →
     P (h₁.trans h₂)) : P h 
goal: P h

full_name: Relation.ReflTransGen.cases_head
code: theorem cases_head (h : ReflTransGen r a b) : a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b 
goal: a = b ∨ ∃ c, r a c ∧ Relation.ReflTransGen r c b

full_name: Relation.ReflTransGen.cases_head_iff
code: theorem cases_head_iff : ReflTransGen r a b ↔ a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b 
goal: Relation.ReflTransGen r a b ↔ a = b ∨ ∃ c, r a c ∧ Relation.ReflTransGen r c b

full_name: Relation.ReflTransGen.total_of_right_unique
code: theorem total_of_right_unique (U : Relator.RightUnique r) (ab : ReflTransGen r a b)
    (ac : ReflTransGen r a c) : ReflTransGen r b c ∨ ReflTransGen r c b 
goal: Relation.ReflTransGen r b c ∨ Relation.ReflTransGen r c b

full_name: Relation.TransGen.to_reflTransGen
code: theorem to_reflTransGen {a b} (h : TransGen r a b) : ReflTransGen r a b 
goal: Relation.ReflTransGen r a b

full_name: Relation.TransGen.trans_left
code: theorem trans_left (hab : TransGen r a b) (hbc : ReflTransGen r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.instTransReflTransGen
code: instance : Trans (TransGen r) (ReflTransGen r) (TransGen r) 
goal: Trans (Relation.TransGen r) (Relation.ReflTransGen r) (Relation.TransGen r)

full_name: Relation.TransGen.trans
code: @[trans]
theorem trans (hab : TransGen r a b) (hbc : TransGen r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.instTrans
code: instance : Trans (TransGen r) (TransGen r) (TransGen r) 
goal: Trans (Relation.TransGen r) (Relation.TransGen r) (Relation.TransGen r)

full_name: Relation.TransGen.head'
code: theorem head' (hab : r a b) (hbc : ReflTransGen r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.tail'
code: theorem tail' (hab : ReflTransGen r a b) (hbc : r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.head
code: theorem head (hab : r a b) (hbc : TransGen r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.head_induction_on
code: @[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, TransGen r a b → Prop} {a : α} (h : TransGen r a b)
    (base : ∀ {a} (h : r a b), P a (single h))
    (ih : ∀ {a c} (h' : r a c) (h : TransGen r c b), P c h → P a (h.head h')) : P a h 
goal: P a h

full_name: Relation.TransGen.trans_induction_on
code: @[elab_as_elim]
theorem trans_induction_on {P : ∀ {a b : α}, TransGen r a b → Prop} {a b : α} (h : TransGen r a b)
    (base : ∀ {a b} (h : r a b), P (single h))
    (ih : ∀ {a b c} (h₁ : TransGen r a b) (h₂ : TransGen r b c), P h₁ → P h₂ → P (h₁.trans h₂)) :
    P h 
goal: P h

full_name: Relation.TransGen.trans_right
code: theorem trans_right (hab : ReflTransGen r a b) (hbc : TransGen r b c) : TransGen r a c 
goal: Relation.TransGen r a c

full_name: Relation.TransGen.instTransReflTransGen_1
code: instance : Trans (ReflTransGen r) (TransGen r) (TransGen r) 
goal: Trans (Relation.ReflTransGen r) (Relation.TransGen r) (Relation.TransGen r)

full_name: Relation.TransGen.tail'_iff
code: theorem tail'_iff : TransGen r a c ↔ ∃ b, ReflTransGen r a b ∧ r b c 
goal: Relation.TransGen r a c ↔ ∃ b, Relation.ReflTransGen r a b ∧ r b c

full_name: Relation.TransGen.head'_iff
code: theorem head'_iff : TransGen r a c ↔ ∃ b, r a b ∧ ReflTransGen r b c 
goal: Relation.TransGen r a c ↔ ∃ b, r a b ∧ Relation.ReflTransGen r b c

full_name: Acc.TransGen
code: theorem _root_.Acc.TransGen (h : Acc r a) : Acc (TransGen r) a 
goal: Acc (Relation.TransGen r) a

full_name: acc_transGen_iff
code: theorem _root_.acc_transGen_iff : Acc (TransGen r) a ↔ Acc r a 
goal: Acc (Relation.TransGen r) a ↔ Acc r a

full_name: WellFounded.transGen
code: theorem _root_.WellFounded.transGen (h : WellFounded r) : WellFounded (TransGen r) 
goal: WellFounded (Relation.TransGen r)

full_name: Relation.reflGen_eq_self
code: lemma reflGen_eq_self (hr : Reflexive r) : ReflGen r = r 
goal: Relation.ReflGen r = r

full_name: Relation.reflexive_reflGen
code: lemma reflexive_reflGen : Reflexive (ReflGen r) 
goal: Reflexive (Relation.ReflGen r)

full_name: Relation.reflGen_minimal
code: lemma reflGen_minimal {r' : α → α → Prop} (hr' : Reflexive r') (h : ∀ x y, r x y → r' x y) {x y : α}
    (hxy : ReflGen r x y) : r' x y 
goal: r' x y

full_name: Relation.transGen_eq_self
code: theorem transGen_eq_self (trans : Transitive r) : TransGen r = r 
goal: Relation.TransGen r = r

full_name: Relation.transitive_transGen
code: theorem transitive_transGen : Transitive (TransGen r) 
goal: Transitive (Relation.TransGen r)

full_name: Relation.instIsTransTransGen
code: instance : IsTrans α (TransGen r) 
goal: IsTrans α (Relation.TransGen r)

full_name: Relation.transGen_idem
code: theorem transGen_idem : TransGen (TransGen r) = TransGen r 
goal: Relation.TransGen (Relation.TransGen r) = Relation.TransGen r

full_name: Relation.TransGen.lift
code: theorem TransGen.lift {p : β → β → Prop} {a b : α} (f : α → β) (h : ∀ a b, r a b → p (f a) (f b))
    (hab : TransGen r a b) : TransGen p (f a) (f b) 
goal: Relation.TransGen p (f a) (f b)

full_name: Relation.TransGen.lift'
code: theorem TransGen.lift' {p : β → β → Prop} {a b : α} (f : α → β)
    (h : ∀ a b, r a b → TransGen p (f a) (f b)) (hab : TransGen r a b) :
    TransGen p (f a) (f b) 
goal: Relation.TransGen p (f a) (f b)

full_name: Relation.TransGen.closed
code: theorem TransGen.closed {p : α → α → Prop} :
    (∀ a b, r a b → TransGen p a b) → TransGen r a b → TransGen p a b 
goal: (∀ (a b : α), r a b → Relation.TransGen p a b) → Relation.TransGen r a b → Relation.TransGen p a b

full_name: Relation.TransGen.closed'
code: lemma TransGen.closed' {P : α → Prop} (dc : ∀ {a b}, r a b → P b → P a)
    {a b : α} (h : TransGen r a b) : P b → P a 
goal: P b → P a

full_name: Relation.TransGen.mono
code: theorem TransGen.mono {p : α → α → Prop} :
    (∀ a b, r a b → p a b) → TransGen r a b → TransGen p a b 
goal: (∀ (a b : α), r a b → p a b) → Relation.TransGen r a b → Relation.TransGen p a b

full_name: Relation.transGen_minimal
code: lemma transGen_minimal {r' : α → α → Prop} (hr' : Transitive r') (h : ∀ x y, r x y → r' x y)
    {x y : α} (hxy : TransGen r x y) : r' x y 
goal: r' x y

full_name: Relation.TransGen.swap
code: theorem TransGen.swap (h : TransGen r b a) : TransGen (swap r) a b 
goal: Relation.TransGen (Function.swap r) a b

full_name: Relation.transGen_swap
code: theorem transGen_swap : TransGen (swap r) a b ↔ TransGen r b a 
goal: Relation.TransGen (Function.swap r) a b ↔ Relation.TransGen r b a

full_name: Relation.reflTransGen_iff_eq
code: theorem reflTransGen_iff_eq (h : ∀ b, ¬r a b) : ReflTransGen r a b ↔ b = a 
goal: Relation.ReflTransGen r a b ↔ b = a

full_name: Relation.reflTransGen_iff_eq_or_transGen
code: theorem reflTransGen_iff_eq_or_transGen : ReflTransGen r a b ↔ b = a ∨ TransGen r a b 
goal: Relation.ReflTransGen r a b ↔ b = a ∨ Relation.TransGen r a b

full_name: Relation.ReflTransGen.lift
code: theorem ReflTransGen.lift {p : β → β → Prop} {a b : α} (f : α → β)
    (h : ∀ a b, r a b → p (f a) (f b)) (hab : ReflTransGen r a b) : ReflTransGen p (f a) (f b) 
goal: Relation.ReflTransGen p (f a) (f b)

full_name: Relation.ReflTransGen.mono
code: theorem ReflTransGen.mono {p : α → α → Prop} : (∀ a b, r a b → p a b) →
    ReflTransGen r a b → ReflTransGen p a b 
goal: (∀ (a b : α), r a b → p a b) → Relation.ReflTransGen r a b → Relation.ReflTransGen p a b

full_name: Relation.reflTransGen_eq_self
code: theorem reflTransGen_eq_self (refl : Reflexive r) (trans : Transitive r) : ReflTransGen r = r 
goal: Relation.ReflTransGen r = r

full_name: Relation.reflTransGen_minimal
code: lemma reflTransGen_minimal {r' : α → α → Prop} (hr₁ : Reflexive r') (hr₂ : Transitive r')
    (h : ∀ x y, r x y → r' x y) {x y : α} (hxy : ReflTransGen r x y) : r' x y 
goal: r' x y

full_name: Relation.reflexive_reflTransGen
code: theorem reflexive_reflTransGen : Reflexive (ReflTransGen r) 
goal: Reflexive (Relation.ReflTransGen r)

full_name: Relation.transitive_reflTransGen
code: theorem transitive_reflTransGen : Transitive (ReflTransGen r) 
goal: Transitive (Relation.ReflTransGen r)

full_name: Relation.instIsReflReflTransGen
code: instance : IsRefl α (ReflTransGen r) 
goal: IsRefl α (Relation.ReflTransGen r)

full_name: Relation.instIsTransReflTransGen
code: instance : IsTrans α (ReflTransGen r) 
goal: IsTrans α (Relation.ReflTransGen r)

full_name: Relation.reflTransGen_idem
code: theorem reflTransGen_idem : ReflTransGen (ReflTransGen r) = ReflTransGen r 
goal: Relation.ReflTransGen (Relation.ReflTransGen r) = Relation.ReflTransGen r

full_name: Relation.ReflTransGen.lift'
code: theorem ReflTransGen.lift' {p : β → β → Prop} {a b : α} (f : α → β)
    (h : ∀ a b, r a b → ReflTransGen p (f a) (f b))
    (hab : ReflTransGen r a b) : ReflTransGen p (f a) (f b) 
goal: Relation.ReflTransGen p (f a) (f b)

full_name: Relation.reflTransGen_closed
code: theorem reflTransGen_closed {p : α → α → Prop} :
    (∀ a b, r a b → ReflTransGen p a b) → ReflTransGen r a b → ReflTransGen p a b 
goal: (∀ (a b : α), r a b → Relation.ReflTransGen p a b) → Relation.ReflTransGen r a b → Relation.ReflTransGen p a b

full_name: Relation.ReflTransGen.swap
code: theorem ReflTransGen.swap (h : ReflTransGen r b a) : ReflTransGen (swap r) a b 
goal: Relation.ReflTransGen (Function.swap r) a b

full_name: Relation.reflTransGen_swap
code: theorem reflTransGen_swap : ReflTransGen (swap r) a b ↔ ReflTransGen r b a 
goal: Relation.ReflTransGen (Function.swap r) a b ↔ Relation.ReflTransGen r b a

full_name: Relation.reflGen_transGen
code: @[simp] lemma reflGen_transGen : ReflGen (TransGen r) = ReflTransGen r 
goal: Relation.ReflGen (Relation.TransGen r) = Relation.ReflTransGen r

full_name: Relation.transGen_reflGen
code: @[simp] lemma transGen_reflGen : TransGen (ReflGen r) = ReflTransGen r 
goal: Relation.TransGen (Relation.ReflGen r) = Relation.ReflTransGen r

full_name: Relation.reflTransGen_reflGen
code: @[simp] lemma reflTransGen_reflGen : ReflTransGen (ReflGen r) = ReflTransGen r 
goal: Relation.ReflTransGen (Relation.ReflGen r) = Relation.ReflTransGen r

full_name: Relation.reflTransGen_transGen
code: @[simp] lemma reflTransGen_transGen : ReflTransGen (TransGen r) = ReflTransGen r 
goal: Relation.ReflTransGen (Relation.TransGen r) = Relation.ReflTransGen r

full_name: Relation.reflTransGen_eq_transGen
code: lemma reflTransGen_eq_transGen (hr : Reflexive r) :
    ReflTransGen r = TransGen r 
goal: Relation.ReflTransGen r = Relation.TransGen r

full_name: Relation.reflTransGen_eq_reflGen
code: lemma reflTransGen_eq_reflGen (hr : Transitive r) :
    ReflTransGen r = ReflGen r 
goal: Relation.ReflTransGen r = Relation.ReflGen r

full_name: Relation.Join
code: /-- The join of a relation on a single type is a new relation for which
pairs of terms are related if there is a third term they are both
related to.  For example, if `r` is a relation representing rewrites
in a term rewriting system, then *confluence* is the property that if
`a` rewrites to both `b` and `c`, then `join r` relates `b` and `c`
(see `Relation.church_rosser`).
-/
def Join (r : α → α → Prop) : α → α → Prop 
goal: α → α → Prop

full_name: Relation.church_rosser
code: /-- A sufficient condition for the Church-Rosser property. -/
theorem church_rosser (h : ∀ a b c, r a b → r a c → ∃ d, ReflGen r b d ∧ ReflTransGen r c d)
    (hab : ReflTransGen r a b) (hac : ReflTransGen r a c) : Join (ReflTransGen r) b c 
goal: Relation.Join (Relation.ReflTransGen r) b c

full_name: Relation.join_of_single
code: theorem join_of_single (h : Reflexive r) (hab : r a b) : Join r a b 
goal: Relation.Join r a b

full_name: Relation.symmetric_join
code: theorem symmetric_join : Symmetric (Join r) 
goal: Symmetric (Relation.Join r)

full_name: Relation.reflexive_join
code: theorem reflexive_join (h : Reflexive r) : Reflexive (Join r) 
goal: Reflexive (Relation.Join r)

full_name: Relation.transitive_join
code: theorem transitive_join (ht : Transitive r) (h : ∀ a b c, r a b → r a c → Join r b c) :
    Transitive (Join r) 
goal: Transitive (Relation.Join r)

full_name: Relation.equivalence_join
code: theorem equivalence_join (hr : Reflexive r) (ht : Transitive r)
    (h : ∀ a b c, r a b → r a c → Join r b c) : Equivalence (Join r) 
goal: Equivalence (Relation.Join r)

full_name: Relation.equivalence_join_reflTransGen
code: theorem equivalence_join_reflTransGen
    (h : ∀ a b c, r a b → r a c → ∃ d, ReflGen r b d ∧ ReflTransGen r c d) :
    Equivalence (Join (ReflTransGen r)) 
goal: Equivalence (Relation.Join (Relation.ReflTransGen r))

full_name: Relation.join_of_equivalence
code: theorem join_of_equivalence {r' : α → α → Prop} (hr : Equivalence r) (h : ∀ a b, r' a b → r a b) :
    Join r' a b → r a b
  
goal: Relation.Join r' a b → r a b

full_name: Relation.reflTransGen_of_transitive_reflexive
code: theorem reflTransGen_of_transitive_reflexive {r' : α → α → Prop} (hr : Reflexive r)
    (ht : Transitive r) (h : ∀ a b, r' a b → r a b) (h' : ReflTransGen r' a b) : r a b 
goal: r a b

full_name: Relation.reflTransGen_of_equivalence
code: theorem reflTransGen_of_equivalence {r' : α → α → Prop} (hr : Equivalence r) :
    (∀ a b, r' a b → r a b) → ReflTransGen r' a b → r a b 
goal: (∀ (a b : α), r' a b → r a b) → Relation.ReflTransGen r' a b → r a b

full_name: Equivalence.eqvGen_iff
code: theorem Equivalence.eqvGen_iff (h : Equivalence r) : EqvGen r a b ↔ r a b 
goal: EqvGen r a b ↔ r a b

full_name: Equivalence.eqvGen_eq
code: theorem Equivalence.eqvGen_eq (h : Equivalence r) : EqvGen r = r 
goal: EqvGen r = r

full_name: EqvGen.mono
code: theorem EqvGen.mono {r p : α → α → Prop} (hrp : ∀ a b, r a b → p a b) (h : EqvGen r a b) :
    EqvGen p a b 
goal: EqvGen p a b