statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
discrim_eq_sq_of_quadratic_eq_zero {x : R} (h : a * x * x + b * x + c = 0) :
discrim a b c = (2 * a * x + b) ^ 2 | begin
rw [discrim],
linear_combination -4 * a * h
end | lemma | discrim_eq_sq_of_quadratic_eq_zero | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
quadratic_eq_zero_iff_discrim_eq_sq [ne_zero (2 : R)] [no_zero_divisors R]
(ha : a ≠ 0) {x : R} :
a * x * x + b * x + c = 0 ↔ discrim a b c = (2 * a * x + b) ^ 2 | begin
refine ⟨discrim_eq_sq_of_quadratic_eq_zero, λ h, _⟩,
rw [discrim] at h,
have ha : 2 * 2 * a ≠ 0 := mul_ne_zero (mul_ne_zero (ne_zero.ne _) (ne_zero.ne _)) ha,
apply mul_left_cancel₀ ha,
linear_combination -h
end | lemma | quadratic_eq_zero_iff_discrim_eq_sq | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"mul_left_cancel₀",
"mul_ne_zero",
"ne_zero",
"ne_zero.ne",
"no_zero_divisors"
] | A quadratic has roots if and only if its discriminant equals some square. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
quadratic_ne_zero_of_discrim_ne_sq (h : ∀ s : R, discrim a b c ≠ s^2) (x : R) :
a * x * x + b * x + c ≠ 0 | mt discrim_eq_sq_of_quadratic_eq_zero $ h _ | lemma | quadratic_ne_zero_of_discrim_ne_sq | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"discrim_eq_sq_of_quadratic_eq_zero"
] | A quadratic has no root if its discriminant has no square root. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
quadratic_eq_zero_iff (ha : a ≠ 0) {s : K} (h : discrim a b c = s * s) (x : K) :
a * x * x + b * x + c = 0 ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a) | begin
rw [quadratic_eq_zero_iff_discrim_eq_sq ha, h, sq, mul_self_eq_mul_self_iff],
field_simp,
apply or_congr,
{ split; intro h'; linear_combination -h' },
{ split; intro h'; linear_combination h' },
end | lemma | quadratic_eq_zero_iff | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"mul_self_eq_mul_self_iff",
"quadratic_eq_zero_iff_discrim_eq_sq"
] | Roots of a quadratic equation. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
exists_quadratic_eq_zero (ha : a ≠ 0) (h : ∃ s, discrim a b c = s * s) :
∃ x, a * x * x + b * x + c = 0 | begin
rcases h with ⟨s, hs⟩,
use (-b + s) / (2 * a),
rw quadratic_eq_zero_iff ha hs,
simp
end | lemma | exists_quadratic_eq_zero | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"quadratic_eq_zero_iff"
] | A quadratic has roots if its discriminant has square roots | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
quadratic_eq_zero_iff_of_discrim_eq_zero (ha : a ≠ 0) (h : discrim a b c = 0) (x : K) :
a * x * x + b * x + c = 0 ↔ x = -b / (2 * a) | begin
have : discrim a b c = 0 * 0, by rw [h, mul_zero],
rw [quadratic_eq_zero_iff ha this, add_zero, sub_zero, or_self]
end | lemma | quadratic_eq_zero_iff_of_discrim_eq_zero | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"mul_zero",
"quadratic_eq_zero_iff"
] | Root of a quadratic when its discriminant equals zero | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
discrim_le_zero (h : ∀ x : K, 0 ≤ a * x * x + b * x + c) : discrim a b c ≤ 0 | begin
rw [discrim, sq],
obtain ha|rfl|ha : a < 0 ∨ a = 0 ∨ 0 < a := lt_trichotomy a 0,
-- if a < 0
{ have : tendsto (λ x, (a * x + b) * x + c) at_top at_bot :=
tendsto_at_bot_add_const_right _ c ((tendsto_at_bot_add_const_right _ b
(tendsto_id.neg_const_mul_at_top ha)).at_bot_mul_at_top tendsto_id),... | lemma | discrim_le_zero | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"eq_or_ne",
"mul_div_cancel'",
"ring",
"zero_le_four"
] | If a polynomial of degree 2 is always nonnegative, then its discriminant is nonpositive. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
discrim_le_zero_of_nonpos (h : ∀ x : K, a * x * x + b * x + c ≤ 0) : discrim a b c ≤ 0 | discrim_neg a b c ▸ discrim_le_zero (by simpa only [neg_mul, ← neg_add, neg_nonneg]) | lemma | discrim_le_zero_of_nonpos | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"discrim_le_zero",
"discrim_neg",
"neg_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
discrim_lt_zero (ha : a ≠ 0) (h : ∀ x : K, 0 < a * x * x + b * x + c) : discrim a b c < 0 | begin
have : ∀ x : K, 0 ≤ a*x*x + b*x + c := assume x, le_of_lt (h x),
refine lt_of_le_of_ne (discrim_le_zero this) _,
assume h',
have := h (-b / (2 * a)),
have : a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c = 0,
{ rw [quadratic_eq_zero_iff_of_discrim_eq_zero ha h' (-b / (2 * a))] },
linar... | lemma | discrim_lt_zero | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"discrim_le_zero",
"quadratic_eq_zero_iff_of_discrim_eq_zero"
] | If a polynomial of degree 2 is always positive, then its discriminant is negative,
at least when the coefficient of the quadratic term is nonzero. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
discrim_lt_zero_of_neg (ha : a ≠ 0) (h : ∀ x : K, a * x * x + b * x + c < 0) :
discrim a b c < 0 | discrim_neg a b c ▸ discrim_lt_zero (neg_ne_zero.2 ha) (by simpa only [neg_mul, ← neg_add, neg_pos]) | lemma | discrim_lt_zero_of_neg | algebra | src/algebra/quadratic_discriminant.lean | [
"algebra.char_p.invertible",
"order.filter.at_top_bot",
"tactic.linarith",
"tactic.field_simp",
"tactic.linear_combination"
] | [
"discrim",
"discrim_lt_zero",
"discrim_neg",
"neg_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
shelf (α : Type u) | (act : α → α → α)
(self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z)) | class | shelf | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | A *shelf* is a structure with a self-distributive binary operation.
The binary operation is regarded as a left action of the type on itself. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
unital_shelf (α : Type u) extends shelf α, has_one α | (one_act : ∀ a : α, act 1 a = a)
(act_one : ∀ a : α, act a 1 = a) | class | unital_shelf | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"shelf"
] | A *unital shelf* is a shelf equipped with an element `1` such that, for all elements `x`,
we have both `x ◃ 1` and `1 ◃ x` equal `x`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
shelf_hom (S₁ : Type*) (S₂ : Type*) [shelf S₁] [shelf S₂] | (to_fun : S₁ → S₂)
(map_act' : ∀ {x y : S₁}, to_fun (shelf.act x y) = shelf.act (to_fun x) (to_fun y)) | structure | shelf_hom | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"shelf"
] | The type of homomorphisms between shelves.
This is also the notion of rack and quandle homomorphisms. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
rack (α : Type u) extends shelf α | (inv_act : α → α → α)
(left_inv : ∀ x, function.left_inverse (inv_act x) (act x))
(right_inv : ∀ x, function.right_inverse (inv_act x) (act x)) | class | rack | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"shelf"
] | A *rack* is an automorphic set (a set with an action on itself by
bijections) that is self-distributive. It is a shelf such that each
element's action is invertible.
The notations `x ◃ y` and `x ◃⁻¹ y` denote the action and the
inverse action, respectively, and they are right associative. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y | begin
have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw act_one,
rw [h, ←shelf.self_distrib, act_one],
end | lemma | unital_shelf.act_act_self_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | A monoid is *graphic* if, for all `x` and `y`, the *graphic identity*
`(x * y) * x = x * y` holds. For a unital shelf, this graphic
identity holds. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
act_idem (x : S) : (x ◃ x) = x | by rw [←act_one x, ←shelf.self_distrib, act_one, act_one] | lemma | unital_shelf.act_idem | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y | begin
have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw act_one,
rw [h, ←shelf.self_distrib, one_act],
end | lemma | unital_shelf.act_self_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z | by rw [self_distrib, self_distrib, act_act_self_eq, act_self_act_eq] | lemma | unital_shelf.assoc | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | The associativity of a unital shelf comes for free. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
self_distrib {x y z : R} : x ◃ (y ◃ z) = (x ◃ y) ◃ (x ◃ z) | shelf.self_distrib | lemma | rack.self_distrib | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
act (x : R) : R ≃ R | { to_fun := shelf.act x,
inv_fun := inv_act x,
left_inv := left_inv x,
right_inv := right_inv x } | def | rack.act | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"inv_fun"
] | A rack acts on itself by equivalences. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
act_apply (x y : R) : act x y = x ◃ y | rfl | lemma | rack.act_apply | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
act_symm_apply (x y : R) : (act x).symm y = x ◃⁻¹ y | rfl | lemma | rack.act_symm_apply | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inv_act_apply (x y : R) : (act x)⁻¹ y = x ◃⁻¹ y | rfl | lemma | rack.inv_act_apply | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inv_act_act_eq (x y : R) : x ◃⁻¹ x ◃ y = y | left_inv x y | lemma | rack.inv_act_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
act_inv_act_eq (x y : R) : x ◃ x ◃⁻¹ y = y | right_inv x y | lemma | rack.act_inv_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' | by { split, apply (act x).injective, rintro rfl, refl } | lemma | rack.left_cancel | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' | by { split, apply (act x).symm.injective, rintro rfl, refl } | lemma | rack.left_cancel_inv | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_distrib_inv {x y z : R} : x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ (x ◃⁻¹ z) | begin
rw [←left_cancel (x ◃⁻¹ y), right_inv, ←left_cancel x, right_inv, self_distrib],
repeat {rw right_inv },
end | lemma | rack.self_distrib_inv | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ad_conj {R : Type*} [rack R] (x y : R) :
act (x ◃ y) = act x * act y * (act x)⁻¹ | begin
rw [eq_mul_inv_iff_mul_eq], ext z,
apply self_distrib.symm,
end | lemma | rack.ad_conj | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"eq_mul_inv_iff_mul_eq",
"rack"
] | The *adjoint action* of a rack on itself is `op'`, and the adjoint
action of `x ◃ y` is the conjugate of the action of `y` by the action
of `x`. It is another way to understand the self-distributivity axiom.
This is used in the natural rack homomorphism `to_conj` from `R` to
`conj (R ≃ R)` defined by `op'`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
opposite_rack : rack Rᵐᵒᵖ | { act := λ x y, op (inv_act (unop x) (unop y)),
self_distrib := mul_opposite.rec $ λ x, mul_opposite.rec $ λ y, mul_opposite.rec $ λ z, begin
simp only [unop_op, op_inj],
exact self_distrib_inv,
end,
inv_act := λ x y, op (shelf.act (unop x) (unop y)),
left_inv := mul_opposite.rec $ λ x, mul_opposite.rec... | instance | rack.opposite_rack | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"mul_opposite.rec",
"rack"
] | The opposite rack, swapping the roles of `◃` and `◃⁻¹`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
op_act_op_eq {x y : R} : (op x) ◃ (op y) = op (x ◃⁻¹ y) | rfl | lemma | rack.op_act_op_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_inv_act_op_eq {x y : R} : (op x) ◃⁻¹ (op y) = op (x ◃ y) | rfl | lemma | rack.op_inv_act_op_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_act_act_eq {x y : R} : (x ◃ x) ◃ y = x ◃ y | by { rw [←right_inv x y, ←self_distrib] } | lemma | rack.self_act_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_inv_act_inv_act_eq {x y : R} : (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y | by { have h := @self_act_act_eq _ _ (op x) (op y), simpa using h } | lemma | rack.self_inv_act_inv_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_act_inv_act_eq {x y : R} : (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y | by { rw ←left_cancel (x ◃ x), rw right_inv, rw self_act_act_eq, rw right_inv } | lemma | rack.self_act_inv_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_inv_act_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y | by { have h := @self_act_inv_act_eq _ _ (op x) (op y), simpa using h } | lemma | rack.self_inv_act_act_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_act_eq_iff_eq {x y : R} : x ◃ x = y ◃ y ↔ x = y | begin
split, swap, rintro rfl, refl,
intro h,
transitivity (x ◃ x) ◃⁻¹ (x ◃ x),
rw [←left_cancel (x ◃ x), right_inv, self_act_act_eq],
rw [h, ←left_cancel (y ◃ y), right_inv, self_act_act_eq],
end | lemma | rack.self_act_eq_iff_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_inv_act_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y | by { have h := @self_act_eq_iff_eq _ _ (op x) (op y), simpa using h } | lemma | rack.self_inv_act_eq_iff_eq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_apply_equiv (R : Type*) [rack R] : R ≃ R | { to_fun := λ x, x ◃ x,
inv_fun := λ x, x ◃⁻¹ x,
left_inv := λ x, by simp,
right_inv := λ x, by simp } | def | rack.self_apply_equiv | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"inv_fun",
"rack"
] | The map `x ↦ x ◃ x` is a bijection. (This has applications for the
regular isotopy version of the Reidemeister I move for knot diagrams.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_involutory (R : Type*) [rack R] : Prop | ∀ x : R, function.involutive (shelf.act x) | def | rack.is_involutory | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | An involutory rack is one for which `rack.op R x` is an involution for every x. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
involutory_inv_act_eq_act {R : Type*} [rack R] (h : is_involutory R) (x y : R) :
x ◃⁻¹ y = x ◃ y | begin
rw [←left_cancel x, right_inv],
exact ((h x).left_inverse y).symm,
end | lemma | rack.involutory_inv_act_eq_act | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_abelian (R : Type*) [rack R] : Prop | ∀ (x y z w : R), (x ◃ y) ◃ (z ◃ w) = (x ◃ z) ◃ (y ◃ w) | def | rack.is_abelian | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | An abelian rack is one for which the mediality axiom holds. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
assoc_iff_id {R : Type*} [rack R] {x y z : R} :
x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z | by { rw self_distrib, rw left_cancel } | lemma | rack.assoc_iff_id | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | Associative racks are uninteresting. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_fun_eq_coe (f : S₁ →◃ S₂) : f.to_fun = f | rfl | lemma | shelf_hom.to_fun_eq_coe | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y | map_act' f | lemma | shelf_hom.map_act | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
id (S : Type*) [shelf S] : S →◃ S | { to_fun := id,
map_act' := by simp } | def | shelf_hom.id | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"shelf"
] | The identity homomorphism | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inhabited (S : Type*) [shelf S] : inhabited (S →◃ S) | ⟨id S⟩ | instance | shelf_hom.inhabited | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"shelf"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comp (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) : S₁ →◃ S₃ | { to_fun := g.to_fun ∘ f.to_fun,
map_act' := by simp } | def | shelf_hom.comp | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | The composition of shelf homomorphisms | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
comp_apply (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) (x : S₁) :
(g.comp f) x = g (f x) | rfl | lemma | shelf_hom.comp_apply | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
quandle (α : Type*) extends rack α | (fix : ∀ {x : α}, act x x = x) | class | quandle | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | A quandle is a rack such that each automorphism fixes its corresponding element. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
fix_inv {x : Q} : x ◃⁻¹ x = x | by { rw ←left_cancel x, simp } | lemma | quandle.fix_inv | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
opposite_quandle : quandle Qᵐᵒᵖ | { fix := λ x, by { induction x using mul_opposite.rec, simp } } | instance | quandle.opposite_quandle | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"mul_opposite.rec",
"quandle"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
conj (G : Type*) | G | def | quandle.conj | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | The conjugation quandle of a group. Each element of the group acts by
the corresponding inner automorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
conj.quandle (G : Type*) [group G] : quandle (conj G) | { act := (λ x, @mul_aut.conj G _ x),
self_distrib := λ x y z, begin
dsimp only [mul_equiv.coe_to_equiv, mul_aut.conj_apply, conj],
group,
end,
inv_act := (λ x, (@mul_aut.conj G _ x).symm),
left_inv := λ x y, by { dsimp [act, conj], group },
right_inv := λ x y, by { dsimp [act, conj], group },
fix :=... | instance | quandle.conj.quandle | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"mul_aut.conj",
"mul_aut.conj_apply",
"mul_equiv.coe_to_equiv",
"quandle"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
conj_act_eq_conj {G : Type*} [group G] (x y : conj G) :
x ◃ y = ((x : G) * (y : G) * (x : G)⁻¹ : G) | rfl | lemma | quandle.conj_act_eq_conj | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
conj_swap {G : Type*} [group G] (x y : conj G) :
x ◃ y = y ↔ y ◃ x = x | begin
dsimp [conj] at *, split,
repeat { intro h, conv_rhs { rw eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h) }, simp, },
end | lemma | quandle.conj_swap | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"eq_mul_inv_of_mul_eq",
"group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
conj.map {G : Type*} {H : Type*} [group G] [group H] (f : G →* H) : conj G →◃ conj H | { to_fun := f,
map_act' := by simp } | def | quandle.conj.map | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group"
] | `conj` is functorial | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
dihedral (n : ℕ) | zmod n | def | quandle.dihedral | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"zmod"
] | The dihedral quandle. This is the conjugation quandle of the dihedral group restrict to flips.
Used for Fox n-colorings of knots. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
dihedral_act (n : ℕ) (a : zmod n) : zmod n → zmod n | λ b, 2 * a - b | def | quandle.dihedral_act | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"zmod"
] | The operation for the dihedral quandle. It does not need to be an equivalence
because it is an involution (see `dihedral_act.inv`). | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
dihedral_act.inv (n : ℕ) (a : zmod n) : function.involutive (dihedral_act n a) | by { intro b, dsimp [dihedral_act], ring } | lemma | quandle.dihedral_act.inv | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"ring",
"zmod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_conj (R : Type*) [rack R] : R →◃ quandle.conj (R ≃ R) | { to_fun := act,
map_act' := ad_conj } | def | rack.to_conj | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"quandle.conj",
"rack"
] | This is the natural rack homomorphism to the conjugation quandle of the group `R ≃ R`
that acts on the rack. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pre_envel_group (R : Type u) : Type u
| unit : pre_envel_group
| incl (x : R) : pre_envel_group
| mul (a b : pre_envel_group) : pre_envel_group
| inv (a : pre_envel_group) : pre_envel_group | inductive | rack.pre_envel_group | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | Free generators of the enveloping group. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group.inhabited (R : Type u) : inhabited (pre_envel_group R) | ⟨pre_envel_group.unit⟩ | instance | rack.pre_envel_group.inhabited | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel' (R : Type u) [rack R] :
pre_envel_group R → pre_envel_group R → Type u
| refl {a : pre_envel_group R} : pre_envel_group_rel' a a
| symm {a b : pre_envel_group R} (hab : pre_envel_group_rel' a b) : pre_envel_group_rel' b a
| trans {a b c : pre_envel_group R}
(hab : pre_envel_group_rel' a b) (hbc... | inductive | rack.pre_envel_group_rel' | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"mul_left_inv",
"mul_one",
"one_mul",
"rack"
] | Relations for the enveloping group. This is a type-valued relation because
`to_envel_group.map_aux.well_def` inducts on it to show `to_envel_group.map`
is well-defined. The relation `pre_envel_group_rel` is the `Prop`-valued version,
which is used to define `envel_group` itself. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel'.inhabited (R : Type u) [rack R] :
inhabited (pre_envel_group_rel' R unit unit) | ⟨pre_envel_group_rel'.refl⟩ | instance | rack.pre_envel_group_rel'.inhabited | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel (R : Type u) [rack R] : pre_envel_group R → pre_envel_group R → Prop
| rel {a b : pre_envel_group R} (r : pre_envel_group_rel' R a b) : pre_envel_group_rel a b | inductive | rack.pre_envel_group_rel | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack",
"rel"
] | The `pre_envel_group_rel` relation as a `Prop`. Used as the relation for `pre_envel_group.setoid`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel'.rel {R : Type u} [rack R] {a b : pre_envel_group R} :
pre_envel_group_rel' R a b → pre_envel_group_rel R a b | pre_envel_group_rel.rel | lemma | rack.pre_envel_group_rel'.rel | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | A quick way to convert a `pre_envel_group_rel'` to a `pre_envel_group_rel`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pre_envel_group_rel.refl {R : Type u} [rack R] {a : pre_envel_group R} :
pre_envel_group_rel R a a | pre_envel_group_rel.rel pre_envel_group_rel'.refl | lemma | rack.pre_envel_group_rel.refl | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel.symm {R : Type u} [rack R] {a b : pre_envel_group R} :
pre_envel_group_rel R a b → pre_envel_group_rel R b a | | ⟨r⟩ := r.symm.rel | lemma | rack.pre_envel_group_rel.symm | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group_rel.trans {R : Type u} [rack R] {a b c : pre_envel_group R} :
pre_envel_group_rel R a b → pre_envel_group_rel R b c → pre_envel_group_rel R a c | | ⟨rab⟩ ⟨rbc⟩ := (rab.trans rbc).rel | lemma | rack.pre_envel_group_rel.trans | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack",
"rel"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pre_envel_group.setoid (R : Type*) [rack R] : setoid (pre_envel_group R) | { r := pre_envel_group_rel R,
iseqv := begin
split, apply pre_envel_group_rel.refl,
split, apply pre_envel_group_rel.symm,
apply pre_envel_group_rel.trans
end } | instance | rack.pre_envel_group.setoid | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
envel_group (R : Type*) [rack R] | quotient (pre_envel_group.setoid R) | def | rack.envel_group | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | The universal enveloping group for the rack R. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
envel_group.inhabited (R : Type*) [rack R] : inhabited (envel_group R) | ⟨1⟩ | instance | rack.envel_group.inhabited | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_envel_group (R : Type*) [rack R] : R →◃ quandle.conj (envel_group R) | { to_fun := λ x, ⟦incl x⟧,
map_act' := λ x y, quotient.sound (pre_envel_group_rel'.act_incl x y).symm.rel } | def | rack.to_envel_group | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"quandle.conj",
"rack"
] | The canonical homomorphism from a rack to its enveloping group.
Satisfies universal properties given by `to_envel_group.map` and `to_envel_group.univ`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_envel_group.map_aux {R : Type*} [rack R] {G : Type*} [group G]
(f : R →◃ quandle.conj G) : pre_envel_group R → G | | unit := 1
| (incl x) := f x
| (mul a b) := to_envel_group.map_aux a * to_envel_group.map_aux b
| (inv a) := (to_envel_group.map_aux a)⁻¹ | def | rack.to_envel_group.map_aux | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"quandle.conj",
"rack"
] | The preliminary definition of the induced map from the enveloping group.
See `to_envel_group.map`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
well_def {R : Type*} [rack R] {G : Type*} [group G] (f : R →◃ quandle.conj G) :
Π {a b : pre_envel_group R}, pre_envel_group_rel' R a b →
to_envel_group.map_aux f a = to_envel_group.map_aux f b | | a b refl := rfl
| a b (symm h) := (well_def h).symm
| a b (trans hac hcb) := eq.trans (well_def hac) (well_def hcb)
| _ _ (congr_mul ha hb) := by { simp [to_envel_group.map_aux, well_def ha, well_def hb] }
| _ _ (congr_inv ha) := by { simp [to_envel_group.map_aux, well_def ha] }
| _ _ (assoc a b c) := by { apply mul_... | lemma | rack.to_envel_group.map_aux.well_def | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"mul_assoc",
"mul_left_inv",
"mul_one",
"one_mul",
"quandle.conj",
"rack"
] | Show that `to_envel_group.map_aux` sends equivalent expressions to equal terms. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_envel_group.map {R : Type*} [rack R] {G : Type*} [group G] :
(R →◃ quandle.conj G) ≃ (envel_group R →* G) | { to_fun := λ f,
{ to_fun := λ x, quotient.lift_on x (to_envel_group.map_aux f)
(λ a b ⟨hab⟩, to_envel_group.map_aux.well_def f hab),
map_one' := begin
change quotient.lift_on ⟦rack.pre_envel_group.unit⟧ (to_envel_group.map_aux f) _ = 1,
simp [to_envel_group.map_aux],
end,
... | def | rack.to_envel_group.map | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"inv_fun",
"monoid_hom.ext",
"monoid_hom.map_inv",
"monoid_hom.map_mul",
"quandle.conj",
"quandle.conj.map",
"rack"
] | Given a map from a rack to a group, lift it to being a map from the enveloping group.
More precisely, the `envel_group` functor is left adjoint to `quandle.conj`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_envel_group.univ (R : Type*) [rack R] (G : Type*) [group G]
(f : R →◃ quandle.conj G) :
(quandle.conj.map (to_envel_group.map f)).comp (to_envel_group R) = f | to_envel_group.map.symm_apply_apply f | lemma | rack.to_envel_group.univ | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"quandle.conj",
"quandle.conj.map",
"rack"
] | Given a homomorphism from a rack to a group, it factors through the enveloping group. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_envel_group.univ_uniq (R : Type*) [rack R] (G : Type*) [group G]
(f : R →◃ quandle.conj G)
(g : envel_group R →* G) (h : f = (quandle.conj.map g).comp (to_envel_group R)) :
g = to_envel_group.map f | h.symm ▸ (to_envel_group.map.apply_symm_apply g).symm | lemma | rack.to_envel_group.univ_uniq | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"group",
"quandle.conj",
"quandle.conj.map",
"rack"
] | The homomorphism `to_envel_group.map f` is the unique map that fits into the commutative
triangle in `to_envel_group.univ`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
envel_action {R : Type*} [rack R] : envel_group R →* (R ≃ R) | to_envel_group.map (to_conj R) | def | rack.envel_action | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | The induced group homomorphism from the enveloping group into bijections of the rack,
using `rack.to_conj`. Satisfies the property `envel_action_prop`.
This gives the rack `R` the structure of an augmented rack over `envel_group R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
envel_action_prop {R : Type*} [rack R] (x y : R) :
envel_action (to_envel_group R x) y = x ◃ y | rfl | lemma | rack.envel_action_prop | algebra | src/algebra/quandle.lean | [
"algebra.hom.equiv.basic",
"algebra.hom.aut",
"data.zmod.defs",
"tactic.group"
] | [
"rack"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
quaternion_algebra (R : Type*) (a b : R) | mk {} :: (re : R) (im_i : R) (im_j : R) (im_k : R) | structure | quaternion_algebra | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | Quaternion algebra over a type with fixed coefficients $a=i^2$ and $b=j^2$.
Implemented as a structure with four fields: `re`, `im_i`, `im_j`, and `im_k`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
equiv_prod {R : Type*} (c₁ c₂ : R) : ℍ[R, c₁, c₂] ≃ R × R × R × R | { to_fun := λ a, ⟨a.1, a.2, a.3, a.4⟩,
inv_fun := λ a, ⟨a.1, a.2.1, a.2.2.1, a.2.2.2⟩,
left_inv := λ ⟨a₁, a₂, a₃, a₄⟩, rfl,
right_inv := λ ⟨a₁, a₂, a₃, a₄⟩, rfl } | def | quaternion_algebra.equiv_prod | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [
"inv_fun"
] | The equivalence between a quaternion algebra over R and R × R × R × R. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
equiv_tuple {R : Type*} (c₁ c₂ : R) : ℍ[R, c₁, c₂] ≃ (fin 4 → R) | { to_fun := λ a, ![a.1, a.2, a.3, a.4],
inv_fun := λ a, ⟨a 0, a 1, a 2, a 3⟩,
left_inv := λ ⟨a₁, a₂, a₃, a₄⟩, rfl,
right_inv := λ f, by ext ⟨_, _|_|_|_|_|⟨⟩⟩; refl } | def | quaternion_algebra.equiv_tuple | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [
"inv_fun"
] | The equivalence between a quaternion algebra over `R` and `fin 4 → R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
equiv_tuple_apply {R : Type*} (c₁ c₂ : R) (x : ℍ[R, c₁, c₂]) :
equiv_tuple c₁ c₂ x = ![x.re, x.im_i, x.im_j, x.im_k] | rfl | lemma | quaternion_algebra.equiv_tuple_apply | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mk.eta {R : Type*} {c₁ c₂} : ∀ a : ℍ[R, c₁, c₂], mk a.1 a.2 a.3 a.4 = a | | ⟨a₁, a₂, a₃, a₄⟩ := rfl | lemma | quaternion_algebra.mk.eta | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
im (x : ℍ[R, c₁, c₂]) : ℍ[R, c₁, c₂] | ⟨0, x.im_i, x.im_j, x.im_k⟩ | def | quaternion_algebra.im | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | The imaginary part of a quaternion. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
im_re : a.im.re = 0 | rfl | lemma | quaternion_algebra.im_re | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
im_im_i : a.im.im_i = a.im_i | rfl | lemma | quaternion_algebra.im_im_i | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
im_im_j : a.im.im_j = a.im_j | rfl | lemma | quaternion_algebra.im_im_j | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
im_im_k : a.im.im_k = a.im_k | rfl | lemma | quaternion_algebra.im_im_k | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
im_idem : a.im.im = a.im | rfl | lemma | quaternion_algebra.im_idem | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_re : (x : ℍ[R, c₁, c₂]).re = x | rfl | lemma | quaternion_algebra.coe_re | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_im_i : (x : ℍ[R, c₁, c₂]).im_i = 0 | rfl | lemma | quaternion_algebra.coe_im_i | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_im_j : (x : ℍ[R, c₁, c₂]).im_j = 0 | rfl | lemma | quaternion_algebra.coe_im_j | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_im_k : (x : ℍ[R, c₁, c₂]).im_k = 0 | rfl | lemma | quaternion_algebra.coe_im_k | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_injective : function.injective (coe : R → ℍ[R, c₁, c₂]) | λ x y h, congr_arg re h | lemma | quaternion_algebra.coe_injective | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_inj {x y : R} : (x : ℍ[R, c₁, c₂]) = y ↔ x = y | coe_injective.eq_iff | lemma | quaternion_algebra.coe_inj | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_zero : ((0 : R) : ℍ[R, c₁, c₂]) = 0 | rfl | lemma | quaternion_algebra.coe_zero | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_one : ((1 : R) : ℍ[R, c₁, c₂]) = 1 | rfl | lemma | quaternion_algebra.coe_one | algebra | src/algebra/quaternion.lean | [
"algebra.algebra.equiv",
"linear_algebra.finrank",
"linear_algebra.free_module.basic",
"linear_algebra.free_module.finite.basic",
"set_theory.cardinal.ordinal",
"tactic.ring_exp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.