name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Order.IsPredLimit.mk | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, ¬IsMax a → Order.IsPredPrelimit a → Order.IsPredLimit a | null | true |
List.bidirectionalRec._proof_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (b : α) (l : List α), (b :: l).dropLast ++ [(b :: l).getLast ⋯] = b :: l | null | false |
_private.Batteries.Data.HashMap.Basic.0.Std.HashMap.ofListWith.match_1 | Batteries.Data.HashMap.Basic | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((v : β) → motive (some v)) → motive x | null | false |
Topology.WithLower.toLower_lt_toLower | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] {x y : α}, Topology.WithLower.toLower x < Topology.WithLower.toLower y ↔ x < y | null | true |
ImportGraph.Lake.Glob.Modules.noConfusion | ImportGraph.Util.Modules | {P : Sort u} → {t t' : ImportGraph.Lake.Glob.Modules} → t = t' → ImportGraph.Lake.Glob.Modules.noConfusionType P t t' | null | false |
Set.instDistribLattice._proof_3 | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} (a b : α → Prop), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
AlgEquiv.mk.injEq | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (toEquiv : A ≃ B)
(map_mul' : ∀ (x y : A), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y)
(map_add' : ∀ (x y : A), toEquiv.toFun (x + y) = toEquiv.... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
MeasureTheory.AEEqFun.coeFn_compMeasurable | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] [inst_3 : MeasurableSpace β]
[inst_4 : TopologicalSpace.PseudoMetrizableSpace β] [inst_5 : BorelSpace β] [inst_6 : MeasurableSpace γ]
[inst_7 : Topolo... | null | true |
ofUnits_units_gc | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], GaloisConnection Subgroup.ofUnits Submonoid.units | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State.Inv_append | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf1 cnf2 : Std.Sat.CNF ℕ},
Std.Sat.AIG.toCNF.State.Inv✝ aig cnf1 →
Std.Sat.AIG.toCNF.State.Inv✝ aig cnf2 → Std.Sat.AIG.toCNF.State.Inv✝ aig (cnf1 ++ cnf2) | Combining two CNFs for which `State.Inv` holds preserves `State.Inv`.
| true |
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.isCyclic_units_iff_of_odd._simp_1_1 | Mathlib.RingTheory.ZMod.UnitsCyclic | IsCyclic (ZMod 1)ˣ = True | null | false |
Module.DirectLimit.lift_injective | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] {P : Type u_4} [inst_5 : AddCommMonoid P] [inst_6 : Module R P] (g : (i : ι) → G ... | null | true |
NonUnitalStarAlgHom.prod_fst_snd | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : Star B],
(NonUnitalStarAlgHom.fst R A B).prod (NonUnitalStarAlgHom.snd R A B) =... | null | true |
mul_le_mul_iff_left₀._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosMono α] [MulPosReflectLE α],
0 < a → (b * a ≤ c * a) = (b ≤ c) | null | false |
CategoryTheory.CardinalFilteredPoset.PropSet | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | {κ : Cardinal.{u}} → [inst : Fact κ.IsRegular] → (J : CategoryTheory.CardinalDirectedPoset κ) → Set ↑J.obj → Prop | **Alias** of `CategoryTheory.CardinalDirectedPoset.PropSet`.
---
Given `J : CardinalDirectedPoset κ`, this is the predicate
on `Set J.obj` that is satisfied by subsets that are of
cardinality `< κ` and have a terminal object. | true |
AddAction.IsTrivialBlock.vadd_iff | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {M : Type u_3} {α : Type u_4} [inst : AddGroup M] [inst_1 : AddAction M α] {B : Set α} (g : M),
AddAction.IsTrivialBlock (g +ᵥ B) ↔ AddAction.IsTrivialBlock B | null | true |
Std.Do.Spec.IterM.foldM_filterWithPostcondition | Std.Do.Triple.SpecLemmas | ∀ {α β δ : Type w} {ps : Std.Do.PostShape} {m : Type w → Type w'} {n : Type w → Type w''} {o : Type w → Type w'''}
[inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m] [inst_3 : Monad n] [inst_4 : Monad o]
[LawfulMonad m] [LawfulMonad n] [LawfulMonad o] [inst_8 : Std.Do.WPMonad o ps] [inst_9 : ... | null | true |
CategoryTheory.coeComonad | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → Coe (CategoryTheory.Comonad C) (CategoryTheory.Functor C C) | null | true |
Lean.Meta.Grind.UnitLike.State | Lean.Meta.Tactic.Grind.Types | Type | Cache for `Unit`-like types. It maps the type to its element.
We say a type is `Unit`-like if it is a subsingleton and is inhabited.
| true |
CategoryTheory.NatTrans.CommShift₂.commShift_app | Mathlib.CategoryTheory.Shift.CommShiftTwo | ∀ {C₁ : Type u_1} {C₂ : Type u_3} {D : Type u_5} {inst : CategoryTheory.Category.{v_1, u_1} C₁}
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} {inst_2 : CategoryTheory.Category.{v_5, u_5} D} {M : Type u_6}
{inst_3 : AddCommMonoid M} {inst_4 : CategoryTheory.HasShift C₁ M} {inst_5 : CategoryTheory.HasShift C₂ M}
... | null | true |
OmegaCompletePartialOrder.ContinuousHom.bind._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : OmegaCompletePartialOrder α] {β γ : Type u_1} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ)
(c : OmegaCompletePartialOrder.Chain α),
((↑f).partBind g.toOrderHom).toFun (OmegaCompletePartialOrder.ωSup c) =
OmegaCompletePartialOrder.ωSup (c.map ((↑f).partBind g.toOrderHom)) | null | false |
Std.DTreeMap.self_le_maxKeyD_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β k}
{fallback : α}, (cmp k ((t.insert k v).maxKeyD fallback)).isLE = true | null | true |
Multiset.inter_le_ndinter | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∩ t ≤ s.ndinter t | null | true |
_private.ImportGraph.WorkspaceModel.Build.0.ImportGraph.Lake.WorkspaceSummary.toWorkspaceModel.match_3 | ImportGraph.WorkspaceModel.Build | (motive : ImportGraph.WorkspaceModel.Library → Sort u_1) →
(x : ImportGraph.WorkspaceModel.Library) →
((name : Lean.Name) →
(srcDir : System.FilePath) →
(roots : Array Lean.Name) →
(globs : Array Lake.Glob) →
(revealedDeps : ImportGraph.LibraryBitset) →
... | null | false |
Std.IterM.fold_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {f : γ → β → γ} {init : γ}
{it : Std.IterM m β},
Std.IterM.fold f init it = do
let __do_lift ← it.step
match ... | null | true |
Finset.min'_subset | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s t : Finset α} (H : s.Nonempty) (hst : s ⊆ t), t.min' ⋯ ≤ s.min' H | null | true |
Multiset.prod_toList | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_2} [inst : CommMonoid M] (s : Multiset M), s.toList.prod = s.prod | null | true |
Associates.exists_non_zero_rep | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : MonoidWithZero M] {a : Associates M}, a ≠ 0 → ∃ a0, a0 ≠ 0 ∧ Associates.mk a0 = a | null | true |
CategoryTheory.BasedFunctor._aux_Mathlib_CategoryTheory_FiberedCategory_BasedCategory___unexpand_CategoryTheory_BasedFunctor_id_1 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | Lean.PrettyPrinter.Unexpander | null | false |
Orientation.definition._@.Mathlib.Analysis.InnerProductSpace.TwoDim.2712757639._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : InnerProductSpace ℝ E] → [Fact (Module.finrank ℝ E = 2)] → Orientation ℝ E (Fin 2) → E ≃ₗᵢ[ℝ] E | null | false |
Std.HashSet.Raw.size | Std.Data.HashSet.Raw | {α : Type u} → Std.HashSet.Raw α → ℕ | The number of elements present in the set | true |
CategoryTheory.Functor.essImage.counit_isIso | Mathlib.CategoryTheory.Adjunction.Reflective | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{j : CategoryTheory.Functor C D} [inst_2 : CategoryTheory.Coreflective j] {A : D},
j.essImage A → CategoryTheory.IsIso ((CategoryTheory.coreflectorAdjunction j).counit.app A) | null | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.Recv.bodyInterest.injEq | Std.Http.Server.Connection | ∀ {β : Type} (x x_1 : Bool),
(Std.Http.Server.Connection.Recv.bodyInterest✝ x = Std.Http.Server.Connection.Recv.bodyInterest✝ x_1) = (x = x_1) | null | true |
AddEquiv.mapAddSubgroup._proof_4 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (f : G ≃+ H) {sg1 sg2 : AddSubgroup G},
{ toFun := AddSubgroup.map ↑f, invFun := AddSubgroup.map ↑f.symm, left_inv := ⋯, right_inv := ⋯ } sg1 ≤
{ toFun := AddSubgroup.map ↑f, invFun := AddSubgroup.map ↑f.symm, left_inv := ⋯, right_inv := ... | null | false |
Lean.Data.Trie.find? | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α → String → Option α | Looks up a value at the given key `s`. | true |
Topology.IsInducing.isNowhereDense_image | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Topology.IsInducing f → ∀ {s : Set X}, IsNowhereDense s → IsNowhereDense (f '' s) | The image of a nowhere dense set through an inducing map is nowhere dense. | true |
Array.erase_comm | Init.Data.Array.Erase | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] (a b : α) {xs : Array α}, (xs.erase a).erase b = (xs.erase b).erase a | null | true |
_private.Mathlib.Algebra.QuadraticDiscriminant.0.quadratic_eq_zero_iff._simp_1_5 | Mathlib.Algebra.QuadraticDiscriminant | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Real.tendsto_pow_mul_exp_neg_atTop_nhds_zero | Mathlib.Analysis.SpecialFunctions.Exp | ∀ (n : ℕ), Filter.Tendsto (fun x => x ^ n * Real.exp (-x)) Filter.atTop (nhds 0) | The function `x^n * exp(-x)` tends to `0` at `+∞`, for any natural number `n`. | true |
Std.Http.Body.Replayable.mk.noConfusion | Std.Http.Data.Body.Replayable | {α : Type} →
{P : Sort u} →
{resetInPlace resetInPlace' : α → Std.Async.Async Unit} →
{ resetInPlace := resetInPlace } = { resetInPlace := resetInPlace' } → (resetInPlace ≍ resetInPlace' → P) → P | null | false |
AlgebraicGeometry.Scheme.ProEt.equivOfIsEmpty | Mathlib.AlgebraicGeometry.Sites.Proetale | (S : AlgebraicGeometry.Scheme) → [IsEmpty ↥S] → S.ProEt ≌ CategoryTheory.Discrete PUnit.{u_1 + 1} | If `S` is the empty scheme, the pro-étale site over `S` is a point. | true |
Std.LinearPreorderPackage.ofOrd._proof_4 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (args : Std.Packages.LinearPreorderOfOrdArgs α), Std.IsPreorder α | null | false |
Std.ExtDTreeMap.mem_keys | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.LawfulEqCmp cmp]
[inst : Std.TransCmp cmp] {k : α}, k ∈ t.keys ↔ k ∈ t | null | true |
uniformity_lift_le_comp | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {f : SetRel α α → Filter β},
Monotone f → ((uniformity α).lift fun s => f (SetRel.comp s s)) ≤ (uniformity α).lift f | null | true |
CategoryTheory.Presheaf.isLimitOfIsSheaf._proof_1 | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} A] (J : CategoryTheory.GrothendieckTopology C)
(P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : J.Cover X) (hP : CategoryTheory.Presheaf.IsSheaf J P)
(s : CategoryTheory.Limits.Cone (S.index P... | null | false |
ContinuousLinearMap.piEquivL._proof_13 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ (𝕜 : Type u_4) [inst : NormedField 𝕜] (E : Type u_1) {ι : Type u_2} (F : ι → Type u_3) [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : (i : ι) → AddCommGroup (F i)]
[inst_5 : (i : ι) → Module 𝕜 (F i)] [inst_6 : (i : ι) → TopologicalSpace (F i)]
[inst_7 : ∀ (i : ι), Is... | null | false |
Std.DHashMap.Raw.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β],
m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → Std.DHashMap.Raw.Const.get! (m₁ ∪ m₂) k = Std.DHashMap.Raw.Const.get! m₁ k | null | true |
GrpWithZero | Mathlib.Algebra.Category.GrpWithZero | Type (u_1 + 1) | The category of groups with zero. | true |
_private.Init.Data.List.ToArray.0.List.filter.match_1.splitter | Init.Data.List.ToArray | (motive : Bool → Sort u_1) → (x : Bool) → (Unit → motive true) → (Unit → motive false) → motive x | null | true |
TwoSidedIdeal.matrix_jacobson_bot | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} [inst : Ring R] {n : Type u_2} [inst_1 : Fintype n] [inst_2 : DecidableEq n],
TwoSidedIdeal.matrix n ⊥.jacobson = ⊥.jacobson | null | true |
_private.Mathlib.NumberTheory.Padics.Measure.AmiceTransform.0.AbstractMeasure.invTransformₗ._proof_4 | Mathlib.NumberTheory.Padics.Measure.AmiceTransform | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)], ContinuousAdd ℤ_[p] | null | false |
PProd.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Sort u} →
{β : Sort v} →
{t : α ×' β} →
{α' : Sort u} → {β' : Sort v} → {t' : α' ×' β'} → α = α' → β = β' → t ≍ t' → PProd.noConfusionType P t t' | null | false |
_private.Mathlib.Topology.TietzeExtension.0.BoundedContinuousFunction.exists_extension_forall_mem_Icc_of_isClosedEmbedding._simp_1_1 | Mathlib.Topology.TietzeExtension | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] {a b : E} {r : ℝ}, (a + b ∈ Metric.closedBall a r) = (‖b‖ ≤ r) | null | false |
Polynomial.ofFinsupp.inj | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u_1} {inst : Semiring R} {toFinsupp toFinsupp_1 : AddMonoidAlgebra R ℕ},
{ toFinsupp := toFinsupp } = { toFinsupp := toFinsupp_1 } → toFinsupp = toFinsupp_1 | null | true |
FirstOrder.Language.BoundedFormula.realize_foldr_sup._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {n : ℕ} (l : List (L.BoundedFormula α n))
(v : α → M) (xs : Fin n → M), (List.foldr (fun x1 x2 => x1 ⊔ x2) ⊥ l).Realize v xs = ∃ φ ∈ l, φ.Realize v xs | null | false |
MonoidAlgebra.distribMulAction._proof_2 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_1} {S : Type u_3} {M : Type u_2} [inst : Monoid S] [inst_1 : Semiring R] [inst_2 : DistribMulAction S R]
(b : MonoidAlgebra R M), 1 • b = b | null | false |
RealNormedSpace.cobounded_neBot | Mathlib.Analysis.Normed.Module.Basic | ∀ (E : Type u_3) [inst : NormedAddCommGroup E] [Nontrivial E] [NormedSpace ℝ E], (Bornology.cobounded E).NeBot | null | true |
LocalizedModule.divBy._proof_10 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (s : ↥S) (x y : LocalizedModule S M),
(x + y).liftOn (fun p => LocalizedModule.mk p.1 (p.2 * s)) ⋯ =
x.liftOn (fun p => LocalizedModule.mk p.1 (p.2 * s)) ⋯ + y.liftOn (fun p => LocalizedMod... | null | false |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.auxContinuousLinearEquiv._simp_1 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Ordnode.Sized.node3R | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α},
l.Sized → m.Sized → r.Sized → (l.node3R x m y r).Sized | null | true |
_private.Init.Data.Nat.Fold.0.Nat.fold._proof_1 | Init.Data.Nat.Fold | ∀ (n : ℕ), n < n.succ | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.finMulAntidiag_one._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] {f : ι → M} [Subsingleton Mˣ],
(∏ i ∈ s, f i = 1) = ∀ i ∈ s, f i = 1 | null | false |
CategoryTheory.MorphismProperty.Arrow.mk | Mathlib.CategoryTheory.MorphismProperty.Comma | {T : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} T] →
{P Q W : CategoryTheory.MorphismProperty T} → {A B : T} → (f : A ⟶ B) → P f → P.Arrow Q W | Make an object of `P.Arrow Q X` from a morphism `f : A ⟶ B` and a proof of `P f`. | true |
MulActionHom.End.equivMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} [inst : Monoid M],
MulActionHom.End.equivMulOpposite =
{ toFun := fun f => MulOpposite.op (f 1),
invFun := fun m => { toFun := fun x => x * MulOpposite.unop m, map_smul' := ⋯ }, left_inv := ⋯, right_inv := ⋯,
map_mul' := ⋯ } | null | true |
CategoryTheory.Bicategory.yoneda₀._proof_6 | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (x : B) {a b c d : Bᵒᵖ} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
(CategoryTheory.PrelaxFunctor.mkOfHomFunctors (fun y => ↧(Opposite.unop y ⟶ x)) fun a b =>
(Bicategory.Opposite.unopFunctor a b).comp
(CategoryTheory.Bicategory.precomposingCat (Opp... | null | false |
DirectSum.lof_apply | Mathlib.Algebra.DirectSum.Module | ∀ (R : Type u) [inst : Semiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] [inst_3 : DecidableEq ι] (i : ι) (b : M i), ((DirectSum.lof R ι M i) b) i = b | null | true |
Vector.Perm.symm | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, xs.Perm ys → ys.Perm xs | null | true |
_private.Mathlib.Order.Cover.0.Set.Ico_eq_singleton_iff._simp_1_5 | Mathlib.Order.Cover | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_27 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {u' v' : V}, 2 ≤ [u', v'].length → 0 < [v'].length | null | false |
_private.Mathlib.GroupTheory.SemidirectProduct.0.SemidirectProduct.range_inl_eq_ker_rightHom._simp_1_2 | Mathlib.GroupTheory.SemidirectProduct | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
AddConGen.Rel.symm | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {x y : M}, AddConGen.Rel r x y → AddConGen.Rel r y x | null | true |
Lean.Level.param.elim | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → t.ctorIdx = 4 → ((a : Lean.Name) → motive (Lean.Level.param a)) → motive t | null | false |
QuotientAddGroup.mk_nsmul | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [nN : N.Normal] (a : G) (n : ℕ), ↑(n • a) = n • ↑a | null | true |
UpperHalfPlane.σ_sq | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : GL (Fin 2) ℝ) (z : ℂ), (UpperHalfPlane.σ g) ((UpperHalfPlane.σ g) z) = z | null | true |
AddSubsemigroup.unop_eq_top | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] {S : AddSubsemigroup Mᵃᵒᵖ}, S.unop = ⊤ ↔ S = ⊤ | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalTerm.0.Lean.Elab.ConfigEval.ensureEvalTerm.getIndType.match_1 | Lean.Elab.ConfigEval.DeriveEvalTerm | (motive : Lean.ConstantInfo → Sort u_1) →
(__x : Lean.ConstantInfo) →
((ival : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo ival)) →
((x : Lean.ConstantInfo) → motive x) → motive __x | null | false |
Lean.EnvironmentHeader.ctorIdx | Lean.Environment | Lean.EnvironmentHeader → ℕ | null | false |
String.Slice.Pos.prev_next | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} {h : p ≠ s.endPos}, (p.next h).prev ⋯ = p | null | true |
RootPairing.RootPositiveForm.zero_lt_posForm_iff | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing S]
[inst_1 : LinearOrder S] [inst_2 : CommRing R] [inst_3 : Algebra S R] [inst_4 : AddCommGroup M] [inst_5 : Module R M]
[inst_6 : AddCommGroup N] [inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsValuedIn S]
... | null | true |
_private.Mathlib.Algebra.Lie.Derivation.Basic.0.LieDerivation.instBracket._abel_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(D1 D2 : LieDerivation R L L) (a b : L),
⁅a, D1 (D2 b)⁆ + ⁅D1 a, D2 b⁆ + (⁅D2 a, D1 b⁆ + ⁅D1 (D2 a), b⁆) -
(⁅a, D2 (D1 b)⁆ + ⁅D2 a, D1 b⁆ + (⁅D1 a, D2 b⁆ + ⁅D2 (D1 a), b⁆)) =
⁅a, D1 (D2 b)⁆ - ⁅a, D2 (D1 b)⁆ ... | null | false |
Std.ExtDHashMap.contains_insert_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {v : β k}, (m.insert k v).contains k = true | null | true |
Std.DTreeMap.Internal.Impl.Const.get_insertMany!_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
[inst_1 : BEq α] [inst_2 : Std.LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α}
{h' : Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertMany! t l) = true},
Std.DTre... | null | true |
List.Palindrome.cons_concat | Mathlib.Data.List.Palindrome | ∀ {α : Type u_1} (x : α) {l : List α}, l.Palindrome → (x :: (l ++ [x])).Palindrome | null | true |
Max.oppositeMin_def | Init.Data.Order.Opposite | ∀ {α : Type u_1} {min : Max α}, min.oppositeMin = { min := max } | null | true |
MeasureTheory.lpMeasToLpTrimLie | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | {α : Type u_1} →
(F : Type u_2) →
(𝕜 : Type u_3) →
(p : ENNReal) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace 𝕜 F] →
{m m0 : MeasurableSpace α} →
(μ : MeasureTheory.Measure α) →
[inst_3 : Fact (... | `lpMeas` and `Lp F p (μ.trim hm)` are isometric, with a linear equivalence. | true |
PreQuasiregular.instMonoid._proof_2 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (x y z : PreQuasiregular R),
PreQuasiregular.equiv.symm (x * y * z) = PreQuasiregular.equiv.symm (x * (y * z)) | null | false |
EuclideanDomain.mod_eq_zero | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {a b : R}, a % b = 0 ↔ b ∣ a | null | true |
Submodule.addSubgroupClass | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
AddSubgroupClass (Submodule R M) M | null | true |
mem_upperBounds_univ | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ upperBounds Set.univ ↔ IsTop a | null | true |
Equiv.pnatEquivNat_apply | Mathlib.Data.PNat.Equiv | ⇑Equiv.pnatEquivNat = PNat.natPred | null | true |
ValuationSubring.instLinearOrderedCommGroupWithZeroValueGroup._proof_56 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K), Nontrivial A.ValueGroup | null | false |
Fin.instLocallyFiniteOrderBot._proof_1 | Mathlib.Order.Interval.Finset.Fin | ∀ (n : ℕ), NeZero (n + 1) | null | false |
Lean.Lsp.instToJsonCallHierarchyItem.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CallHierarchyItem → Lean.Json | null | true |
CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.section_ | Mathlib.CategoryTheory.Sites.CoversTop.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{I : Type u_1} →
{Y : I → C} →
{x : CategoryTheory.Presheaf.FamilyOfElementsOnObjects F Y} →
x.IsCompatible → J.Cov... | The section of a sheaf of types which lifts a compatible family of elements indexed
by objects which cover the terminal object. | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_top_top._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {m : α → EReal} {f : Filter α}, Filter.Tendsto m f (nhds ⊤) = ∀ (x : ℝ), ∀ᶠ (a : α) in f, ↑x < m a | null | false |
GaloisConnection.l_comm_iff_u_comm | Mathlib.Order.GaloisConnection.Defs | ∀ {X : Type u_1} [inst : PartialOrder X] {Y : Type u_2} [inst_1 : Preorder Y] {Z : Type u_3} [inst_2 : Preorder Z]
{W : Type u_4} [inst_3 : PartialOrder W] {lYX : X → Y} {uXY : Y → X},
GaloisConnection lYX uXY →
∀ {lWZ : Z → W} {uZW : W → Z},
GaloisConnection lWZ uZW →
∀ {lWY : Y → W} {uYW : W → Y... | null | true |
Algebra.formallySmooth_iff | Mathlib.RingTheory.Smooth.Basic | ∀ (R : Type u) (A : Type v) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.FormallySmooth R A ↔ Module.Projective A Ω[A⁄R] ∧ Subsingleton (Algebra.H1Cotangent R A) | null | true |
CategoryTheory.Pseudofunctor.DescentData'.instIsIsoαCategoryObjLocallyDiscreteOppositeCatMkOpPullHom'Hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Li... | null | true |
CategoryTheory.Limits.Cocone.functorialityEquivalence._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
(F : CategoryTheory.Functor J C) (e : C ≌ D) (c : CategoryTheory.Limits.Cocone F) (j : J),
((CategoryTheory.Functor.id (Categ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.