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 ⌀ |
|---|---|---|---|---|---|---|
map_eq_map {α β} (f : α → β) (o : Part α) : f <$> o = map f o :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | map_eq_map | null |
bind_eq_bind {α β} (f : Part α) (g : α → Part β) : f >>= g = f.bind g :=
rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | bind_eq_bind | null |
bind_le {α} (x : Part α) (f : α → Part β) (y : Part β) :
x >>= f ≤ y ↔ ∀ a, a ∈ x → f a ≤ y := by
constructor <;> intro h
· intro a h' b
have h := h b
simp only [and_imp, bind_eq_bind, mem_bind_iff, exists_imp] at h
apply h _ h'
· intro b h'
simp only [bind_eq_bind, mem_bind_iff] at h'
rcases h' with ⟨a, h₀, h₁⟩
apply h _ h₀ _ h₁ | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | bind_le | null |
restrict (p : Prop) (o : Part α) (H : p → o.Dom) : Part α :=
⟨p, fun h => o.get (H h)⟩
@[simp] | def | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | restrict | `restrict p o h` replaces the domain of `o` with `p`, and is well defined when
`p` implies `o` is defined. |
mem_restrict (p : Prop) (o : Part α) (h : p → o.Dom) (a : α) :
a ∈ restrict p o h ↔ p ∧ a ∈ o := by
dsimp [restrict, mem_eq]; constructor
· rintro ⟨h₀, h₁⟩
exact ⟨h₀, ⟨_, h₁⟩⟩
rintro ⟨h₀, _, h₂⟩; exact ⟨h₀, h₂⟩ | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mem_restrict | null |
unsafe unwrap (o : Part α) : α :=
o.get lcProof | def | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | unwrap | `unwrap o` gets the value at `o`, ignoring the condition. This function is unsound. |
assert_defined {p : Prop} {f : p → Part α} : ∀ h : p, (f h).Dom → (assert p f).Dom :=
Exists.intro | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | assert_defined | null |
bind_defined {f : Part α} {g : α → Part β} :
∀ h : f.Dom, (g (f.get h)).Dom → (f.bind g).Dom :=
assert_defined
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | bind_defined | null |
bind_dom {f : Part α} {g : α → Part β} : (f.bind g).Dom ↔ ∃ h : f.Dom, (g (f.get h)).Dom :=
Iff.rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | bind_dom | null |
@[to_additive]
mul_def [Mul α] (a b : Part α) : a * b = bind a fun y ↦ map (y * ·) b := rfl
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mul_def | null |
one_def [One α] : (1 : Part α) = some 1 := rfl
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | one_def | null |
inv_def [Inv α] (a : Part α) : a⁻¹ = Part.map (· ⁻¹) a := rfl
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inv_def | null |
div_def [Div α] (a b : Part α) : a / b = bind a fun y => map (y / ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | div_def | null |
mod_def [Mod α] (a b : Part α) : a % b = bind a fun y => map (y % ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mod_def | null |
append_def [Append α] (a b : Part α) : a ++ b = bind a fun y => map (y ++ ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | append_def | null |
inter_def [Inter α] (a b : Part α) : a ∩ b = bind a fun y => map (y ∩ ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inter_def | null |
union_def [Union α] (a b : Part α) : a ∪ b = bind a fun y => map (y ∪ ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | union_def | null |
sdiff_def [SDiff α] (a b : Part α) : a \ b = bind a fun y => map (y \ ·) b := rfl | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | sdiff_def | null |
@[to_additive]
one_mem_one [One α] : (1 : α) ∈ (1 : Part α) :=
⟨trivial, rfl⟩
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | one_mem_one | null |
mul_mem_mul [Mul α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma * mb ∈ a * b := ⟨⟨ha.1, hb.1⟩, by simp only [← ha.2, ← hb.2]; rfl⟩
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mul_mem_mul | null |
left_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : a.Dom := hab.1
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_mul_dom | null |
right_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : b.Dom := hab.2
@[to_additive (attr := simp)] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_mul_dom | null |
mul_get_eq [Mul α] (a b : Part α) (hab : Dom (a * b)) :
(a * b).get hab = a.get (left_dom_of_mul_dom hab) * b.get (right_dom_of_mul_dom hab) := rfl
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mul_get_eq | null |
some_mul_some [Mul α] (a b : α) : some a * some b = some (a * b) := by simp [mul_def]
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_mul_some | null |
inv_mem_inv [Inv α] (a : Part α) (ma : α) (ha : ma ∈ a) : ma⁻¹ ∈ a⁻¹ := by
simp [inv_def]; aesop
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inv_mem_inv | null |
inv_some [Inv α] (a : α) : (some a)⁻¹ = some a⁻¹ :=
rfl
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inv_some | null |
div_mem_div [Div α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma / mb ∈ a / b := by simp [div_def]; aesop
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | div_mem_div | null |
left_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : a.Dom := hab.1
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_div_dom | null |
right_dom_of_div_dom [Div α] {a b : Part α} (hab : Dom (a / b)) : b.Dom := hab.2
@[to_additive (attr := simp)] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_div_dom | null |
div_get_eq [Div α] (a b : Part α) (hab : Dom (a / b)) :
(a / b).get hab = a.get (left_dom_of_div_dom hab) / b.get (right_dom_of_div_dom hab) := by
simp [div_def]; aesop
@[to_additive] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | div_get_eq | null |
some_div_some [Div α] (a b : α) : some a / some b = some (a / b) := by simp [div_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_div_some | null |
mod_mem_mod [Mod α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma % mb ∈ a % b := by simp [mod_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mod_mem_mod | null |
left_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : a.Dom := hab.1 | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_mod_dom | null |
right_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : b.Dom := hab.2
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_mod_dom | null |
mod_get_eq [Mod α] (a b : Part α) (hab : Dom (a % b)) :
(a % b).get hab = a.get (left_dom_of_mod_dom hab) % b.get (right_dom_of_mod_dom hab) := by
simp [mod_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | mod_get_eq | null |
some_mod_some [Mod α] (a b : α) : some a % some b = some (a % b) := by simp [mod_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_mod_some | null |
append_mem_append [Append α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma ++ mb ∈ a ++ b := by simp [append_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | append_mem_append | null |
left_dom_of_append_dom [Append α] {a b : Part α} (hab : Dom (a ++ b)) : a.Dom := hab.1 | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_append_dom | null |
right_dom_of_append_dom [Append α] {a b : Part α} (hab : Dom (a ++ b)) : b.Dom := hab.2
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_append_dom | null |
append_get_eq [Append α] (a b : Part α) (hab : Dom (a ++ b)) : (a ++ b).get hab =
a.get (left_dom_of_append_dom hab) ++ b.get (right_dom_of_append_dom hab) := by
simp [append_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | append_get_eq | null |
some_append_some [Append α] (a b : α) : some a ++ some b = some (a ++ b) := by
simp [append_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_append_some | null |
inter_mem_inter [Inter α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma ∩ mb ∈ a ∩ b := by simp [inter_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inter_mem_inter | null |
left_dom_of_inter_dom [Inter α] {a b : Part α} (hab : Dom (a ∩ b)) : a.Dom := hab.1 | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_inter_dom | null |
right_dom_of_inter_dom [Inter α] {a b : Part α} (hab : Dom (a ∩ b)) : b.Dom := hab.2
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_inter_dom | null |
inter_get_eq [Inter α] (a b : Part α) (hab : Dom (a ∩ b)) :
(a ∩ b).get hab = a.get (left_dom_of_inter_dom hab) ∩ b.get (right_dom_of_inter_dom hab) := by
simp [inter_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | inter_get_eq | null |
some_inter_some [Inter α] (a b : α) : some a ∩ some b = some (a ∩ b) := by
simp [inter_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_inter_some | null |
union_mem_union [Union α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma ∪ mb ∈ a ∪ b := by simp [union_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | union_mem_union | null |
left_dom_of_union_dom [Union α] {a b : Part α} (hab : Dom (a ∪ b)) : a.Dom := hab.1 | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_union_dom | null |
right_dom_of_union_dom [Union α] {a b : Part α} (hab : Dom (a ∪ b)) : b.Dom := hab.2
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_union_dom | null |
union_get_eq [Union α] (a b : Part α) (hab : Dom (a ∪ b)) :
(a ∪ b).get hab = a.get (left_dom_of_union_dom hab) ∪ b.get (right_dom_of_union_dom hab) := by
simp [union_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | union_get_eq | null |
some_union_some [Union α] (a b : α) : some a ∪ some b = some (a ∪ b) := by simp [union_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_union_some | null |
sdiff_mem_sdiff [SDiff α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
ma \ mb ∈ a \ b := by simp [sdiff_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | sdiff_mem_sdiff | null |
left_dom_of_sdiff_dom [SDiff α] {a b : Part α} (hab : Dom (a \ b)) : a.Dom := hab.1 | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | left_dom_of_sdiff_dom | null |
right_dom_of_sdiff_dom [SDiff α] {a b : Part α} (hab : Dom (a \ b)) : b.Dom := hab.2
@[simp] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | right_dom_of_sdiff_dom | null |
sdiff_get_eq [SDiff α] (a b : Part α) (hab : Dom (a \ b)) :
(a \ b).get hab = a.get (left_dom_of_sdiff_dom hab) \ b.get (right_dom_of_sdiff_dom hab) := by
simp [sdiff_def]; aesop | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | sdiff_get_eq | null |
some_sdiff_some [SDiff α] (a b : α) : some a \ some b = some (a \ b) := by simp [sdiff_def] | theorem | Data | [
"Mathlib.Algebra.Notation.Defs",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Part.lean | some_sdiff_some | null |
PEquiv (α : Type u) (β : Type v) where
/-- The underlying partial function of a `PEquiv` -/
toFun : α → Option β
/-- The partial inverse of `toFun` -/
invFun : β → Option α
/-- `invFun` is the partial inverse of `toFun` -/
inv : ∀ (a : α) (b : β), invFun b = some a ↔ toFun a = some b | structure | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | PEquiv | A `PEquiv` is a partial equivalence, a representation of a bijection between a subset
of `α` and a subset of `β`. See also `PartialEquiv` for a version that requires `toFun` and
`invFun` to be globally defined functions and has `source` and `target` sets as extra fields. |
@[refl]
protected refl (α : Type*) : α ≃. α where
toFun := some
invFun := some
inv _ _ := eq_comm | def | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | refl | A `PEquiv` is a partial equivalence, a representation of a bijection between a subset
of `α` and a subset of `β`. See also `PartialEquiv` for a version that requires `toFun` and
`invFun` to be globally defined functions and has `source` and `target` sets as extra fields. -/
infixr:25 " ≃. " => PEquiv
namespace PEquiv
variable {α : Type u} {β : Type v} {γ : Type w} {δ : Type x}
open Function Option
instance : FunLike (α ≃. β) α (Option β) :=
{ coe := toFun
coe_injective' := by
rintro ⟨f₁, f₂, hf⟩ ⟨g₁, g₂, hg⟩ (rfl : f₁ = g₁)
congr with y x
simp only [hf, hg] }
@[simp] theorem coe_mk (f₁ : α → Option β) (f₂ h) : (mk f₁ f₂ h : α → Option β) = f₁ :=
rfl
theorem coe_mk_apply (f₁ : α → Option β) (f₂ : β → Option α) (h) (x : α) :
(PEquiv.mk f₁ f₂ h : α → Option β) x = f₁ x :=
rfl
@[ext] theorem ext {f g : α ≃. β} (h : ∀ x, f x = g x) : f = g :=
DFunLike.ext f g h
/-- The identity map as a partial equivalence. |
@[symm]
protected symm (f : α ≃. β) : β ≃. α where
toFun := f.2
invFun := f.1
inv _ _ := (f.inv _ _).symm | def | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm | The inverse partial equivalence. |
mem_iff_mem (f : α ≃. β) : ∀ {a : α} {b : β}, a ∈ f.symm b ↔ b ∈ f a :=
f.3 _ _ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_iff_mem | null |
eq_some_iff (f : α ≃. β) : ∀ {a : α} {b : β}, f.symm b = some a ↔ f a = some b :=
f.3 _ _ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | eq_some_iff | null |
@[trans]
protected trans (f : α ≃. β) (g : β ≃. γ) :
α ≃. γ where
toFun a := (f a).bind g
invFun a := (g.symm a).bind f.symm
inv a b := by simp_all [and_comm, eq_some_iff f, eq_some_iff g, bind_eq_some_iff]
@[simp] | def | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans | Composition of partial equivalences `f : α ≃. β` and `g : β ≃. γ`. |
refl_apply (a : α) : PEquiv.refl α a = some a :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | refl_apply | null |
symm_refl : (PEquiv.refl α).symm = PEquiv.refl α :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_refl | null |
symm_symm (f : α ≃. β) : f.symm.symm = f := rfl | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_symm | null |
symm_bijective : Function.Bijective (PEquiv.symm : (α ≃. β) → β ≃. α) :=
Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_bijective | null |
symm_injective : Function.Injective (@PEquiv.symm α β) :=
symm_bijective.injective | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_injective | null |
trans_assoc (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ) :
(f.trans g).trans h = f.trans (g.trans h) :=
ext fun _ => Option.bind_assoc _ _ _ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_assoc | null |
mem_trans (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ) :
c ∈ f.trans g a ↔ ∃ b, b ∈ f a ∧ c ∈ g b :=
Option.bind_eq_some_iff | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_trans | null |
trans_eq_some (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ) :
f.trans g a = some c ↔ ∃ b, f a = some b ∧ g b = some c :=
Option.bind_eq_some_iff | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_eq_some | null |
trans_eq_none (f : α ≃. β) (g : β ≃. γ) (a : α) :
f.trans g a = none ↔ ∀ b c, b ∉ f a ∨ c ∉ g b := by
simp only [eq_none_iff_forall_not_mem, mem_trans, imp_iff_not_or.symm]
push_neg
exact forall_swap
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_eq_none | null |
refl_trans (f : α ≃. β) : (PEquiv.refl α).trans f = f := by
ext; dsimp [PEquiv.trans]; rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | refl_trans | null |
trans_refl (f : α ≃. β) : f.trans (PEquiv.refl β) = f := by
ext; dsimp [PEquiv.trans]; simp | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_refl | null |
protected inj (f : α ≃. β) {a₁ a₂ : α} {b : β} (h₁ : b ∈ f a₁) (h₂ : b ∈ f a₂) :
a₁ = a₂ := by rw [← mem_iff_mem] at *; cases h : f.symm b <;> simp_all | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | inj | null |
injective_of_forall_ne_isSome (f : α ≃. β) (a₂ : α)
(h : ∀ a₁ : α, a₁ ≠ a₂ → isSome (f a₁)) : Injective f :=
HasLeftInverse.injective
⟨fun b => Option.recOn b a₂ fun b' => Option.recOn (f.symm b') a₂ id, fun x => by
classical
cases hfx : f x
· have : x = a₂ := not_imp_comm.1 (h x) (hfx.symm ▸ by simp)
simp [this]
· dsimp only
rw [(eq_some_iff f).2 hfx]
rfl⟩ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | injective_of_forall_ne_isSome | If the domain of a `PEquiv` is `α` except a point, its forward direction is injective. |
injective_of_forall_isSome {f : α ≃. β} (h : ∀ a : α, isSome (f a)) : Injective f :=
(Classical.em (Nonempty α)).elim
(fun hn => injective_of_forall_ne_isSome f (Classical.choice hn) fun a _ => h a) fun hn x =>
(hn ⟨x⟩).elim | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | injective_of_forall_isSome | If the domain of a `PEquiv` is all of `α`, its forward direction is injective. |
ofSet (s : Set α) [DecidablePred (· ∈ s)] :
α ≃. α where
toFun a := if a ∈ s then some a else none
invFun a := if a ∈ s then some a else none
inv a b := by
split_ifs with hb ha ha
· simp [eq_comm]
· simp [ne_of_mem_of_not_mem hb ha]
· simp [ne_of_mem_of_not_mem ha hb]
· simp | def | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet | Creates a `PEquiv` that is the identity on `s`, and `none` outside of it. |
mem_ofSet_self_iff {s : Set α} [DecidablePred (· ∈ s)] {a : α} : a ∈ ofSet s a ↔ a ∈ s := by
dsimp [ofSet]; split_ifs <;> simp [*] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_ofSet_self_iff | null |
mem_ofSet_iff {s : Set α} [DecidablePred (· ∈ s)] {a b : α} :
a ∈ ofSet s b ↔ a = b ∧ a ∈ s := by
dsimp [ofSet]
grind
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_ofSet_iff | null |
ofSet_eq_some_iff {s : Set α} {_ : DecidablePred (· ∈ s)} {a b : α} :
ofSet s b = some a ↔ a = b ∧ a ∈ s :=
mem_ofSet_iff | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet_eq_some_iff | null |
ofSet_eq_some_self_iff {s : Set α} {_ : DecidablePred (· ∈ s)} {a : α} :
ofSet s a = some a ↔ a ∈ s :=
mem_ofSet_self_iff
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet_eq_some_self_iff | null |
ofSet_symm : (ofSet s).symm = ofSet s :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet_symm | null |
ofSet_univ : ofSet Set.univ = PEquiv.refl α :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet_univ | null |
ofSet_eq_refl {s : Set α} [DecidablePred (· ∈ s)] :
ofSet s = PEquiv.refl α ↔ s = Set.univ :=
⟨fun h => by
rw [Set.eq_univ_iff_forall]
intro
rw [← mem_ofSet_self_iff, h]
exact rfl, fun h => by simp only [← ofSet_univ, h]⟩ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | ofSet_eq_refl | null |
symm_trans_rev (f : α ≃. β) (g : β ≃. γ) : (f.trans g).symm = g.symm.trans f.symm :=
rfl | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_trans_rev | null |
self_trans_symm (f : α ≃. β) : f.trans f.symm = ofSet { a | (f a).isSome } := by
ext
dsimp [PEquiv.trans]
simp only [eq_some_iff f, Option.isSome_iff_exists, bind_eq_some_iff,
ofSet_eq_some_iff]
constructor
· rintro ⟨b, hb₁, hb₂⟩
exact ⟨PEquiv.inj _ hb₂ hb₁, b, hb₂⟩
· simp +contextual | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | self_trans_symm | null |
symm_trans_self (f : α ≃. β) : f.symm.trans f = ofSet { b | (f.symm b).isSome } :=
symm_injective <| by simp [symm_trans_rev, self_trans_symm, -symm_symm] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_trans_self | null |
trans_symm_eq_iff_forall_isSome {f : α ≃. β} :
f.trans f.symm = PEquiv.refl α ↔ ∀ a, isSome (f a) := by
rw [self_trans_symm, ofSet_eq_refl, Set.eq_univ_iff_forall]; rfl | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_symm_eq_iff_forall_isSome | null |
instBotPEquiv : Bot (α ≃. β) :=
⟨{ toFun := fun _ => none
invFun := fun _ => none
inv := by simp }⟩ | instance | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | instBotPEquiv | null |
@[simp]
bot_apply (a : α) : (⊥ : α ≃. β) a = none :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | bot_apply | null |
symm_bot : (⊥ : α ≃. β).symm = ⊥ :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_bot | null |
trans_bot (f : α ≃. β) : f.trans (⊥ : β ≃. γ) = ⊥ := by
ext; dsimp [PEquiv.trans]; simp
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | trans_bot | null |
bot_trans (f : β ≃. γ) : (⊥ : α ≃. β).trans f = ⊥ := by
ext; dsimp [PEquiv.trans]; simp | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | bot_trans | null |
isSome_symm_get (f : α ≃. β) {a : α} (h : isSome (f a)) :
isSome (f.symm (Option.get _ h)) :=
isSome_iff_exists.2 ⟨a, by rw [f.eq_some_iff, some_get]⟩ | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | isSome_symm_get | null |
single (a : α) (b : β) :
α ≃. β where
toFun x := if x = a then some b else none
invFun x := if x = b then some a else none
inv x y := by
split_ifs with h1 h2
· simp [*]
· simp only [some.injEq, iff_false] at *
exact Ne.symm h2
· simp only [some.injEq, false_iff] at *
exact Ne.symm h1
· simp | def | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | single | Create a `PEquiv` which sends `a` to `b` and `b` to `a`, but is otherwise `none`. |
mem_single (a : α) (b : β) : b ∈ single a b a :=
if_pos rfl | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_single | null |
mem_single_iff (a₁ a₂ : α) (b₁ b₂ : β) : b₁ ∈ single a₂ b₂ a₁ ↔ a₁ = a₂ ∧ b₁ = b₂ := by
dsimp [single]; split_ifs <;> simp [*, eq_comm]
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | mem_single_iff | null |
symm_single (a : α) (b : β) : (single a b).symm = single b a :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | symm_single | null |
single_apply (a : α) (b : β) : single a b a = some b :=
if_pos rfl | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | single_apply | null |
single_apply_of_ne {a₁ a₂ : α} (h : a₁ ≠ a₂) (b : β) : single a₁ b a₂ = none :=
if_neg h.symm | theorem | Data | [
"Mathlib.Data.Option.Basic",
"Batteries.Tactic.Congr",
"Mathlib.Data.Set.Basic",
"Mathlib.Tactic.Contrapose"
] | Mathlib/Data/PEquiv.lean | single_apply_of_ne | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.