fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
protected nonempty (q : Trunc α) : Nonempty α :=
q.exists_rep.nonempty | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | nonempty | null |
protected mk'' (a : α) : Quotient s₁ :=
⟦a⟧ | abbrev | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | mk'' | A version of `Quotient.mk` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. |
mk''_surjective : Function.Surjective (Quotient.mk'' : α → Quotient s₁) :=
Quot.exists_rep | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | mk''_surjective | `Quotient.mk''` is a surjective function. |
protected liftOn' (q : Quotient s₁) (f : α → φ) (h : ∀ a b, s₁ a b → f a = f b) :
φ :=
Quotient.liftOn q f h
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn' | A version of `Quotient.liftOn` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. |
protected liftOn'_mk'' (f : α → φ) (h) (x : α) :
Quotient.liftOn' (@Quotient.mk'' _ s₁ x) f h = f x :=
rfl
@[simp] lemma surjective_liftOn' {f : α → φ} (h) :
Function.Surjective (fun x : Quotient s₁ ↦ x.liftOn' f h) ↔ Function.Surjective f :=
Quot.surjective_lift _ | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn'_mk'' | null |
protected liftOn₂' (q₁ : Quotient s₁) (q₂ : Quotient s₂) (f : α → β → γ)
(h : ∀ a₁ a₂ b₁ b₂, s₁ a₁ b₁ → s₂ a₂ b₂ → f a₁ a₂ = f b₁ b₂) : γ :=
Quotient.liftOn₂ q₁ q₂ f h
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn₂' | A version of `Quotient.liftOn₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments. |
protected liftOn₂'_mk'' (f : α → β → γ) (h) (a : α) (b : β) :
Quotient.liftOn₂' (@Quotient.mk'' _ s₁ a) (@Quotient.mk'' _ s₂ b) f h = f a b :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn₂'_mk'' | null |
@[elab_as_elim]
protected ind' {p : Quotient s₁ → Prop} (h : ∀ a, p (Quotient.mk'' a)) (q : Quotient s₁) :
p q :=
Quotient.ind h q | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | ind' | A version of `Quotient.ind` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. |
@[elab_as_elim]
protected ind₂' {p : Quotient s₁ → Quotient s₂ → Prop}
(h : ∀ a₁ a₂, p (Quotient.mk'' a₁) (Quotient.mk'' a₂))
(q₁ : Quotient s₁) (q₂ : Quotient s₂) : p q₁ q₂ :=
Quotient.ind₂ h q₁ q₂ | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | ind₂' | A version of `Quotient.ind₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments. |
@[elab_as_elim]
protected inductionOn' {p : Quotient s₁ → Prop} (q : Quotient s₁)
(h : ∀ a, p (Quotient.mk'' a)) : p q :=
Quotient.inductionOn q h | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | inductionOn' | A version of `Quotient.inductionOn` taking `{s : Setoid α}` as an implicit argument instead
of an instance argument. |
@[elab_as_elim]
protected inductionOn₂' {p : Quotient s₁ → Quotient s₂ → Prop} (q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(h : ∀ a₁ a₂, p (Quotient.mk'' a₁) (Quotient.mk'' a₂)) : p q₁ q₂ :=
Quotient.inductionOn₂ q₁ q₂ h | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | inductionOn₂' | A version of `Quotient.inductionOn₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit
arguments instead of instance arguments. |
@[elab_as_elim]
protected inductionOn₃' {p : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
(q₁ : Quotient s₁) (q₂ : Quotient s₂) (q₃ : Quotient s₃)
(h : ∀ a₁ a₂ a₃, p (Quotient.mk'' a₁) (Quotient.mk'' a₂) (Quotient.mk'' a₃)) :
p q₁ q₂ q₃ :=
Quotient.inductionOn₃ q₁ q₂ q₃ h | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | inductionOn₃' | A version of `Quotient.inductionOn₃` taking `{s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ}`
as implicit arguments instead of instance arguments. |
@[elab_as_elim]
protected recOnSubsingleton' {φ : Quotient s₁ → Sort*} [∀ a, Subsingleton (φ ⟦a⟧)]
(q : Quotient s₁)
(f : ∀ a, φ (Quotient.mk'' a)) : φ q :=
Quotient.recOnSubsingleton q f | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | recOnSubsingleton' | A version of `Quotient.recOnSubsingleton` taking `{s₁ : Setoid α}` as an implicit argument
instead of an instance argument. |
@[elab_as_elim]
protected recOnSubsingleton₂' {φ : Quotient s₁ → Quotient s₂ → Sort*}
[∀ a b, Subsingleton (φ ⟦a⟧ ⟦b⟧)]
(q₁ : Quotient s₁) (q₂ : Quotient s₂) (f : ∀ a₁ a₂, φ (Quotient.mk'' a₁) (Quotient.mk'' a₂)) :
φ q₁ q₂ :=
Quotient.recOnSubsingleton₂ q₁ q₂ f | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | recOnSubsingleton₂' | A version of `Quotient.recOnSubsingleton₂` taking `{s₁ : Setoid α} {s₂ : Setoid α}`
as implicit arguments instead of instance arguments. |
protected hrecOn' {φ : Quotient s₁ → Sort*} (qa : Quotient s₁) (f : ∀ a, φ (Quotient.mk'' a))
(c : ∀ a₁ a₂, a₁ ≈ a₂ → f a₁ ≍ f a₂) : φ qa :=
Quot.hrecOn qa f c
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | hrecOn' | Recursion on a `Quotient` argument `a`, result type depends on `⟦a⟧`. |
hrecOn'_mk'' {φ : Quotient s₁ → Sort*} (f : ∀ a, φ (Quotient.mk'' a))
(c : ∀ a₁ a₂, a₁ ≈ a₂ → f a₁ ≍ f a₂)
(x : α) : (Quotient.mk'' x).hrecOn' f c = f x :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | hrecOn'_mk'' | null |
protected hrecOn₂' {φ : Quotient s₁ → Quotient s₂ → Sort*} (qa : Quotient s₁)
(qb : Quotient s₂) (f : ∀ a b, φ (Quotient.mk'' a) (Quotient.mk'' b))
(c : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ ≍ f a₂ b₂) :
φ qa qb :=
Quotient.hrecOn₂ qa qb f c
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | hrecOn₂' | Recursion on two `Quotient` arguments `a` and `b`, result type depends on `⟦a⟧` and `⟦b⟧`. |
hrecOn₂'_mk'' {φ : Quotient s₁ → Quotient s₂ → Sort*}
(f : ∀ a b, φ (Quotient.mk'' a) (Quotient.mk'' b))
(c : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ ≍ f a₂ b₂) (x : α) (qb : Quotient s₂) :
(Quotient.mk'' x).hrecOn₂' qb f c = qb.hrecOn' (f x) fun _ _ ↦ c _ _ _ _ (Setoid.refl _) :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | hrecOn₂'_mk'' | null |
protected map' (f : α → β) (h : ∀ a b, s₁.r a b → s₂.r (f a) (f b)) :
Quotient s₁ → Quotient s₂ :=
Quot.map f h
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | map' | Map a function `f : α → β` that sends equivalent elements to equivalent elements
to a function `Quotient sa → Quotient sb`. Useful to define unary operations on quotients.
This is a version of `Quotient.map` using `Setoid.r` instead of `≈`. |
map'_mk'' (f : α → β) (h) (x : α) :
(Quotient.mk'' x : Quotient s₁).map' f h = (Quotient.mk'' (f x) : Quotient s₂) :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | map'_mk'' | null |
protected map₂' (f : α → β → γ)
(h : ∀ ⦃a₁ a₂ : α⦄, s₁.r a₁ a₂ → ∀ ⦃b₁ b₂ : β⦄, s₂.r b₁ b₂ → s₃.r (f a₁ b₁) (f a₂ b₂)) :
Quotient s₁ → Quotient s₂ → Quotient s₃ :=
Quotient.map₂ f h
@[simp] | def | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | map₂' | Map a function `f : α → β → γ` that sends equivalent elements to equivalent elements
to a function `f : Quotient sa → Quotient sb → Quotient sc`. Useful to define binary operations
on quotients. This is a version of `Quotient.map₂` using `Setoid.r` instead of `≈`. |
map₂'_mk'' (f : α → β → γ) (h) (x : α) :
(Quotient.mk'' x : Quotient s₁).map₂' f h =
(Quotient.map' (f x) (h (Setoid.refl x)) : Quotient s₂ → Quotient s₃) :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | map₂'_mk'' | null |
exact' {a b : α} :
(Quotient.mk'' a : Quotient s₁) = Quotient.mk'' b → s₁ a b :=
Quotient.exact | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | exact' | null |
sound' {a b : α} : s₁ a b → @Quotient.mk'' α s₁ a = Quotient.mk'' b :=
Quotient.sound
@[simp] | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | sound' | null |
protected eq' {s₁ : Setoid α} {a b : α} :
@Quotient.mk' α s₁ a = @Quotient.mk' α s₁ b ↔ s₁ a b :=
Quotient.eq | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | eq' | null |
protected eq'' {a b : α} : @Quotient.mk'' α s₁ a = Quotient.mk'' b ↔ s₁ a b :=
Quotient.eq | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | eq'' | null |
out_eq' (q : Quotient s₁) : Quotient.mk'' q.out = q :=
q.out_eq | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | out_eq' | null |
mk_out' (a : α) : s₁ (Quotient.mk'' a : Quotient s₁).out a :=
Quotient.exact (Quotient.out_eq _) | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | mk_out' | null |
protected mk''_eq_mk : Quotient.mk'' = Quotient.mk s :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | mk''_eq_mk | null |
protected liftOn'_mk (x : α) (f : α → β) (h) : (Quotient.mk s x).liftOn' f h = f x :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn'_mk | null |
protected liftOn₂'_mk {t : Setoid β} (f : α → β → γ) (h) (a : α) (b : β) :
Quotient.liftOn₂' (Quotient.mk s a) (Quotient.mk t b) f h = f a b :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | liftOn₂'_mk | null |
map'_mk {t : Setoid β} (f : α → β) (h) (x : α) :
(Quotient.mk s x).map' f h = (Quotient.mk t (f x)) :=
rfl | theorem | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | map'_mk | null |
@[simp]
Equivalence.quot_mk_eq_iff {α : Type*} {r : α → α → Prop} (h : Equivalence r) (x y : α) :
Quot.mk r x = Quot.mk r y ↔ r x y := by
constructor
· rw [Quot.eq]
intro hxy
induction hxy with
| rel _ _ H => exact H
| refl _ => exact h.refl _
| symm _ _ _ H => exact h.symm H
| trans _ _ _ _ _ h₁₂ h₂₃ => exact h.trans h₁₂ h₂₃
· exact Quot.sound | lemma | Data | [
"Mathlib.Logic.Relation",
"Mathlib.Logic.Unique",
"Mathlib.Util.Notation3"
] | Mathlib/Data/Quot.lean | Equivalence.quot_mk_eq_iff | null |
SetRel (α β : Type*) := α → β → Prop
```
The fact that `SetRel` wasn't an `abbrev` confuses automation.
But simply making it an `abbrev` would
have killed the point of having a separate less see-through type to perform relation operations on,
so we instead redefined
``` | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | SetRel | null |
SetRel (α β : Type*) := Set (α × β) → Prop
```
This extra level of indirection guides automation correctly and prevents (some kinds of) leakage.
Simultaneously, uniform spaces need a theory of relations on a type `α` as elements of
`Set (α × α)`, and the new definition of `SetRel` fulfills this role quite well.
-/
variable {α β γ δ : Type*} {ι : Sort*} | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | SetRel | null |
SetRel (α β : Type*) := Set (α × β) | abbrev | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | SetRel | A relation on `α` and `β`, aka a set-valued function, aka a partial multifunction.
We represent them as sets due to how relations are used in the context of uniform spaces. |
inv (R : SetRel α β) : SetRel β α := Prod.swap ⁻¹' R
@[simp] lemma mem_inv : b ~[R.inv] a ↔ a ~[R] b := .rfl
@[deprecated (since := "2025-07-06")] alias inv_def := mem_inv
@[simp] lemma inv_inv : R.inv.inv = R := rfl
@[gcongr] lemma inv_mono (h : R₁ ⊆ R₂) : R₁.inv ⊆ R₂.inv := fun (_a, _b) hab ↦ h hab
@[simp] lemma inv_empty : (∅ : SetRel α β).inv = ∅ := rfl
@[simp] lemma inv_univ : inv (.univ : SetRel α β) = .univ := rfl
@[deprecated (since := "2025-07-06")] alias inv_bot := inv_empty
variable (R) in | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | inv | Notation for apply a relation `R : SetRel α β` to `a : α`, `b : β`,
scoped to the `SetRel` namespace.
Since `SetRel α β := Set (α × β)`, `a ~[R] b` is simply notation for `(a, b) ∈ R`, but this should
be considered an implementation detail. -/
scoped notation:50 a:50 " ~[" R "] " b:50 => (a, b) ∈ R
variable (R) in
/-- The inverse relation : `R.inv x y ↔ R y x`. Note that this is *not* a groupoid inverse. |
dom : Set α := {a | ∃ b, a ~[R] b}
variable (R) in | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | dom | Domain of a relation. |
cod : Set β := {b | ∃ a, a ~[R] b}
@[deprecated (since := "2025-07-06")] alias codom := cod
@[simp] lemma mem_dom : a ∈ R.dom ↔ ∃ b, a ~[R] b := .rfl
@[simp] lemma mem_cod : b ∈ R.cod ↔ ∃ a, a ~[R] b := .rfl
@[gcongr] lemma dom_mono (h : R₁ ≤ R₂) : R₁.dom ⊆ R₂.dom := fun _a ⟨b, hab⟩ ↦ ⟨b, h hab⟩
@[gcongr] lemma cod_mono (h : R₁ ≤ R₂) : R₁.cod ⊆ R₂.cod := fun _b ⟨a, hab⟩ ↦ ⟨a, h hab⟩
@[simp] lemma dom_empty : (∅ : SetRel α β).dom = ∅ := by aesop
@[simp] lemma cod_empty : (∅ : SetRel α β).cod = ∅ := by aesop
@[simp] lemma dom_univ [Nonempty β] : dom (.univ : SetRel α β) = .univ := by aesop
@[simp] lemma cod_univ [Nonempty α] : cod (.univ : SetRel α β) = .univ := by aesop
@[simp] lemma cod_inv : R.inv.cod = R.dom := rfl
@[simp] lemma dom_inv : R.inv.dom = R.cod := rfl
@[deprecated (since := "2025-07-06")] alias codom_inv := cod_inv | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | cod | Codomain of a relation, aka range. |
protected id : SetRel α α := {(a₁, a₂) | a₁ = a₂}
@[simp] lemma mem_id : a₁ ~[SetRel.id] a₂ ↔ a₁ = a₂ := .rfl | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | id | The identity relation. |
inv_id : (.id : SetRel α α).inv = .id := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | inv_id | null |
comp (R : SetRel α β) (S : SetRel β γ) : SetRel α γ := {(a, c) | ∃ b, a ~[R] b ∧ b ~[S] c}
@[inherit_doc] scoped infixl:62 " ○ " => comp
@[simp] lemma mem_comp : a ~[R ○ S] c ↔ ∃ b, a ~[R] b ∧ b ~[S] c := .rfl | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp | Composition of relation.
Note that this follows the `CategoryTheory` order of arguments. |
prodMk_mem_comp (hab : a ~[R] b) (hbc : b ~[S] c) : a ~[R ○ S] c := ⟨b, hab, hbc⟩ | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | prodMk_mem_comp | null |
comp_assoc (R : SetRel α β) (S : SetRel β γ) (t : SetRel γ δ) :
(R ○ S) ○ t = R ○ (S ○ t) := by aesop
@[simp] lemma comp_id (R : SetRel α β) : R ○ .id = R := by aesop
@[simp] lemma id_comp (R : SetRel α β) : .id ○ R = R := by aesop
@[simp] lemma inv_comp (R : SetRel α β) (S : SetRel β γ) : (R ○ S).inv = S.inv ○ R.inv := by aesop
@[simp] lemma comp_empty (R : SetRel α β) : R ○ (∅ : SetRel β γ) = ∅ := by aesop
@[simp] lemma empty_comp (S : SetRel β γ) : (∅ : SetRel α β) ○ S = ∅ := by aesop
@[simp] lemma comp_univ (R : SetRel α β) :
R ○ (.univ : SetRel β γ) = {(a, _c) : α × γ | a ∈ R.dom} := by
aesop
@[simp] lemma univ_comp (S : SetRel β γ) :
(.univ : SetRel α β) ○ S = {(_b, c) : α × γ | c ∈ S.cod} := by
aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_assoc | null |
comp_iUnion (R : SetRel α β) (S : ι → SetRel β γ) : R ○ ⋃ i, S i = ⋃ i, R ○ S i := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_iUnion | null |
iUnion_comp (R : ι → SetRel α β) (S : SetRel β γ) : (⋃ i, R i) ○ S = ⋃ i, R i ○ S := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | iUnion_comp | null |
comp_sUnion (R : SetRel α β) (𝒮 : Set (SetRel β γ)) : R ○ ⋃₀ 𝒮 = ⋃ S ∈ 𝒮, R ○ S := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_sUnion | null |
sUnion_comp (ℛ : Set (SetRel α β)) (S : SetRel β γ) : ⋃₀ ℛ ○ S = ⋃ R ∈ ℛ, R ○ S := by aesop
@[gcongr] | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | sUnion_comp | null |
comp_subset_comp {S₁ S₂ : SetRel β γ} (hR : R₁ ⊆ R₂) (hS : S₁ ⊆ S₂) : R₁ ○ S₁ ⊆ R₂ ○ S₂ :=
fun _ ↦ .imp fun _ ↦ .imp (@hR _) (@hS _)
@[gcongr] | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_subset_comp | null |
comp_subset_comp_left {S : SetRel β γ} (hR : R₁ ⊆ R₂) : R₁ ○ S ⊆ R₂ ○ S :=
comp_subset_comp hR .rfl
@[gcongr] | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_subset_comp_left | null |
comp_subset_comp_right {S₁ S₂ : SetRel β γ} (hS : S₁ ⊆ S₂) : R ○ S₁ ⊆ R ○ S₂ :=
comp_subset_comp .rfl hS | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comp_subset_comp_right | null |
protected _root_.Monotone.relComp {ι : Type*} [Preorder ι] {f : ι → SetRel α β}
{g : ι → SetRel β γ} (hf : Monotone f) (hg : Monotone g) : Monotone fun x ↦ f x ○ g x :=
fun _i _j hij ⟨_a, _c⟩ ⟨b, hab, hbc⟩ ↦ ⟨b, hf hij hab, hg hij hbc⟩ | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | _root_.Monotone.relComp | null |
prod_comp_prod_of_inter_nonempty (ht : (t₁ ∩ t₂).Nonempty) (s : Set α) (u : Set γ) :
s ×ˢ t₁ ○ t₂ ×ˢ u = s ×ˢ u := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | prod_comp_prod_of_inter_nonempty | null |
prod_comp_prod_of_disjoint (ht : Disjoint t₁ t₂) (s : Set α) (u : Set γ) :
s ×ˢ t₁ ○ t₂ ×ˢ u = ∅ :=
Set.eq_empty_of_forall_notMem fun _ ⟨_z, ⟨_, hzs⟩, hzu, _⟩ ↦ Set.disjoint_left.1 ht hzs hzu | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | prod_comp_prod_of_disjoint | null |
prod_comp_prod (s : Set α) (t₁ t₂ : Set β) (u : Set γ) [Decidable (Disjoint t₁ t₂)] :
s ×ˢ t₁ ○ t₂ ×ˢ u = if Disjoint t₁ t₂ then ∅ else s ×ˢ u := by
split_ifs with hst
· exact prod_comp_prod_of_disjoint hst ..
· rw [prod_comp_prod_of_inter_nonempty <| Set.not_disjoint_iff_nonempty_inter.1 hst]
@[deprecated (since := "2025-07-06")] alias comp_right_top := comp_univ
@[deprecated (since := "2025-07-06")] alias comp_left_top := univ_comp
variable (R s) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | prod_comp_prod | null |
image : Set β := {b | ∃ a ∈ s, a ~[R] b}
variable (R t) in | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image | Image of a set under a relation. |
preimage : Set α := {a | ∃ b ∈ t, a ~[R] b}
@[simp] lemma mem_image : b ∈ image R s ↔ ∃ a ∈ s, a ~[R] b := .rfl
@[simp] lemma mem_preimage : a ∈ preimage R t ↔ ∃ b ∈ t, a ~[R] b := .rfl
@[gcongr] lemma image_subset_image (hs : s₁ ⊆ s₂) : image R s₁ ⊆ image R s₂ :=
fun _ ⟨a, ha, hab⟩ ↦ ⟨a, hs ha, hab⟩
@[gcongr] lemma preimage_subset_preimage (ht : t₁ ⊆ t₂) : preimage R t₁ ⊆ preimage R t₂ :=
fun _ ⟨a, ha, hab⟩ ↦ ⟨a, ht ha, hab⟩
variable (R t) in
@[simp] lemma image_inv : R.inv.image t = preimage R t := rfl
variable (R s) in
@[simp] lemma preimage_inv : R.inv.preimage s = image R s := rfl | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage | Preimage of a set `t` under a relation `R`. Same as the image of `t` under `R.inv`. |
image_mono : Monotone R.image := fun _ _ ↦ image_subset_image | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_mono | null |
preimage_mono : Monotone R.preimage := fun _ _ ↦ preimage_subset_preimage
@[simp] lemma image_empty_right : image R ∅ = ∅ := by aesop
@[simp] lemma preimage_empty_right : preimage R ∅ = ∅ := by aesop
@[simp] lemma image_univ_right : image R .univ = R.cod := by aesop
@[simp] lemma preimage_univ_right : preimage R .univ = R.dom := by aesop
variable (R) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage_mono | null |
image_inter_subset : image R (s₁ ∩ s₂) ⊆ image R s₁ ∩ image R s₂ := image_mono.map_inf_le ..
@[deprecated (since := "2025-07-06")] alias preimage_top := image_inter_subset
variable (R) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_inter_subset | null |
preimage_inter_subset : preimage R (t₁ ∩ t₂) ⊆ preimage R t₁ ∩ preimage R t₂ :=
preimage_mono.map_inf_le ..
@[deprecated (since := "2025-07-06")] alias image_eq_dom_of_codomain_subset := preimage_inter_subset
variable (R s₁ s₂) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage_inter_subset | null |
image_union : image R (s₁ ∪ s₂) = image R s₁ ∪ image R s₂ := by aesop
@[deprecated (since := "2025-07-06")] alias preimage_eq_codom_of_domain_subset := image_union
variable (R t₁ t₂) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_union | null |
preimage_union : preimage R (t₁ ∪ t₂) = preimage R t₁ ∪ preimage R t₂ := by aesop
variable (s) in
@[simp] lemma image_id : image .id s = s := by aesop
variable (s) in
@[simp] lemma preimage_id : preimage .id s = s := by aesop
variable (R S s) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage_union | null |
image_comp : image (R ○ S) s = image S (image R s) := by aesop
variable (R S u) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_comp | null |
preimage_comp : preimage (R ○ S) u = preimage R (preimage S u) := by aesop
variable (s) in
@[simp] lemma image_empty_left : image (∅ : SetRel α β) s = ∅ := by aesop
variable (t) in
@[simp] lemma preimage_empty_left : preimage (∅ : SetRel α β) t = ∅ := by aesop
@[deprecated (since := "2025-07-06")] alias preimage_bot := preimage_empty_left
@[simp] lemma image_univ_left (hs : s.Nonempty) : image (.univ : SetRel α β) s = .univ := by aesop
@[simp] lemma preimage_univ_left (ht : t.Nonempty) : preimage (.univ : SetRel α β) t = .univ := by
aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage_comp | null |
image_eq_cod_of_dom_subset (h : R.cod ⊆ t) : R.preimage t = R.dom := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_eq_cod_of_dom_subset | null |
preimage_eq_dom_of_cod_subset (h : R.cod ⊆ t) : R.preimage t = R.dom := by aesop
variable (R s) in
@[simp] lemma image_inter_dom : image R (s ∩ R.dom) = image R s := by aesop
variable (R t) in
@[simp] lemma preimage_inter_cod : preimage R (t ∩ R.cod) = preimage R t := by aesop
@[deprecated (since := "2025-07-06")] alias preimage_inter_codom_eq := preimage_inter_cod | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | preimage_eq_dom_of_cod_subset | null |
inter_dom_subset_preimage_image : s ∩ R.dom ⊆ R.preimage (image R s) := by
aesop (add simp [Set.subset_def]) | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | inter_dom_subset_preimage_image | null |
inter_cod_subset_image_preimage : t ∩ R.cod ⊆ image R (R.preimage t) := by
aesop (add simp [Set.subset_def])
@[deprecated (since := "2025-07-06")]
alias image_preimage_subset_inter_codom := inter_cod_subset_image_preimage
variable (R t) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | inter_cod_subset_image_preimage | null |
core : Set α := {a | ∀ ⦃b⦄, a ~[R] b → b ∈ t}
@[simp] lemma mem_core : a ∈ R.core t ↔ ∀ ⦃b⦄, a ~[R] b → b ∈ t := .rfl
@[gcongr] | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core | Core of a set `S : Set β` w.R.t `R : SetRel α β` is the set of `x : α` that are related *only*
to elements of `S`. Other generalization of `Function.preimage`. |
core_subset_core (ht : t₁ ⊆ t₂) : R.core t₁ ⊆ R.core t₂ := fun _a ha _b hab ↦ ht <| ha hab | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core_subset_core | null |
core_mono : Monotone R.core := fun _ _ ↦ core_subset_core
variable (R t₁ t₂) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core_mono | null |
core_inter : R.core (t₁ ∩ t₂) = R.core t₁ ∩ R.core t₂ := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core_inter | null |
core_union_subset : R.core t₁ ∪ R.core t₂ ⊆ R.core (t₁ ∪ t₂) := core_mono.le_map_sup ..
@[simp] lemma core_univ : R.core Set.univ = Set.univ := by aesop
variable (t) in
@[simp] lemma core_id : core .id t = t := by aesop
variable (R S u) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core_union_subset | null |
core_comp : core (R ○ S) u = core R (core S u) := by aesop | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | core_comp | null |
image_subset_iff : image R s ⊆ t ↔ s ⊆ core R t := by aesop (add simp [Set.subset_def]) | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_subset_iff | null |
image_core_gc : GaloisConnection R.image R.core := fun _ _ ↦ image_subset_iff
variable (R s) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | image_core_gc | null |
restrictDomain : SetRel s β := {(a, b) | ↑a ~[R] b}
variable {R R₁ R₂ : SetRel α α} {S : SetRel β β} {a b c : α}
/-! ### Reflexive relations -/
variable (R) in | def | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | restrictDomain | Restrict the domain of a relation to a subtype. |
protected IsRefl : Prop := IsRefl α (· ~[R] ·)
variable (R) in | abbrev | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | IsRefl | A relation `R` is reflexive if `a ~[R] a`. |
protected refl [R.IsRefl] (a : α) : a ~[R] a := refl_of (· ~[R] ·) a
variable (R) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | refl | null |
protected rfl [R.IsRefl] : a ~[R] a := R.refl a | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | rfl | null |
id_subset [R.IsRefl] : .id ⊆ R := by rintro ⟨_, _⟩ rfl; exact R.rfl | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | id_subset | null |
id_subset_iff : .id ⊆ R ↔ R.IsRefl where
mp h := ⟨fun _ ↦ h rfl⟩
mpr _ := id_subset | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | id_subset_iff | null |
isRefl_univ : SetRel.IsRefl (.univ : SetRel α α) where
refl _ := trivial | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isRefl_univ | null |
isRefl_inter [R₁.IsRefl] [R₂.IsRefl] : (R₁ ∩ R₂).IsRefl where
refl _ := ⟨R₁.rfl, R₂.rfl⟩ | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isRefl_inter | null |
protected IsRefl.sInter {ℛ : Set <| SetRel α α} (hℛ : ∀ R ∈ ℛ, R.IsRefl) :
SetRel.IsRefl (⋂₀ ℛ) where
refl _a R hR := (hℛ R hR).refl _ | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | IsRefl.sInter | null |
isRefl_iInter {R : ι → SetRel α α} [∀ i, (R i).IsRefl] :
SetRel.IsRefl (⋂ i, R i) := .sInter <| by simpa | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isRefl_iInter | null |
isRefl_preimage {f : β → α} [R.IsRefl] : SetRel.IsRefl (Prod.map f f ⁻¹' R) where
refl _ := R.rfl | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isRefl_preimage | null |
isRefl_mono [R₁.IsRefl] (hR : R₁ ⊆ R₂) : R₂.IsRefl where refl _ := hR R₁.rfl | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isRefl_mono | null |
left_subset_comp {R : SetRel α β} [S.IsRefl] : R ⊆ R ○ S := by
simpa using comp_subset_comp_right id_subset | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | left_subset_comp | null |
right_subset_comp [R.IsRefl] {S : SetRel α β} : S ⊆ R ○ S := by
simpa using comp_subset_comp_left id_subset | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | right_subset_comp | null |
subset_iterate_comp [R.IsRefl] {S : SetRel α β} : ∀ {n}, S ⊆ (R ○ ·)^[n] S
| 0 => .rfl
| _n + 1 => right_subset_comp.trans subset_iterate_comp | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | subset_iterate_comp | null |
exists_eq_singleton_of_prod_subset_id {s t : Set α} (hs : s.Nonempty) (ht : t.Nonempty)
(hst : s ×ˢ t ⊆ SetRel.id) : ∃ x, s = {x} ∧ t = {x} := by
obtain ⟨a, ha⟩ := hs
obtain ⟨b, hb⟩ := ht
simp only [Set.prod_subset_iff, mem_id] at hst
obtain rfl := hst _ ha _ hb
simp only [Set.eq_singleton_iff_unique_mem, and_assoc]
exact ⟨a, ha, (hst · · _ hb), hb, (hst _ ha · · |>.symm)⟩
/-! ### Symmetric relations -/
variable (R) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | exists_eq_singleton_of_prod_subset_id | null |
protected IsSymm : Prop := IsSymm α (· ~[R] ·)
variable (R) in | abbrev | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | IsSymm | A relation `R` is symmetric if `a ~[R] b ↔ b ~[R] a`. |
protected symm [R.IsSymm] (hab : a ~[R] b) : b ~[R] a := symm_of (· ~[R] ·) hab
variable (R) in | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | symm | null |
protected comm [R.IsSymm] : a ~[R] b ↔ b ~[R] a := comm_of (· ~[R] ·)
variable (R) in
@[simp] lemma inv_eq_self [R.IsSymm] : R.inv = R := by ext; exact R.comm | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | comm | null |
inv_eq_self_iff : R.inv = R ↔ R.IsSymm where
mp hR := ⟨fun a b hab ↦ by rwa [← hR]⟩
mpr _ := inv_eq_self _ | lemma | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | inv_eq_self_iff | null |
isSymm_empty : (∅ : SetRel α α).IsSymm where symm _ _ := by simp | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isSymm_empty | null |
isSymm_univ : SetRel.IsSymm (Set.univ : SetRel α α) where symm _ _ := by simp | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isSymm_univ | null |
isSymm_inter [R₁.IsSymm] [R₂.IsSymm] : (R₁ ∩ R₂).IsSymm where
symm _ _ := .imp R₁.symm R₂.symm | instance | Data | [
"Mathlib.Data.Set.Prod",
"Mathlib.Order.RelIso.Basic",
"Mathlib.Order.SetNotation"
] | Mathlib/Data/Rel.lean | isSymm_inter | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.