name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ISize.toNatClampNeg_ofIntClamp_of_lt | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, n < 2 ^ 31 → (ISize.ofIntClamp n).toNatClampNeg = n.toNat | null | true |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x : ZFSet.{u}), (∅ ⊆ x) = True | null | false |
Polynomial.degree_wronskian_lt_add | Mathlib.RingTheory.Polynomial.Wronskian | ∀ {R : Type u_1} [inst : CommRing R] {a b : Polynomial R}, a ≠ 0 → b ≠ 0 → (a.wronskian b).degree < a.degree + b.degree | Degree of `W(a,b)` is strictly less than the sum of degrees of `a` and `b` (both nonzero). | true |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 = ↑lo → ↑lo + 1 ≤ as.size | null | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toArray_rcc_succ_right_eq_append_map._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...=n).toArray = (m...=n).toList.toArray | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot | null | false |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] (F : CategoryTheory.Functor C AddCommGrpCat)
[inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F] (X : C),
CategoryTheory.CategoryStruct.comp CategoryTh... | null | false |
RingCon.mk.injEq | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (toCon : Con R)
(add' : ∀ {w x y z : R}, toCon.toSetoid w x → toCon.toSetoid y z → toCon.toSetoid (w + y) (x + z)) (toCon_1 : Con R)
(add'_1 : ∀ {w x y z : R}, toCon_1.toSetoid w x → toCon_1.toSetoid y z → toCon_1.toSetoid (w + y) (x + z)),
({ toCon := toCon, add' ... | null | true |
AddSubsemigroup.instCompleteLattice._proof_8 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] (a b c : AddSubsemigroup M), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} →
[inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → AddCommSemigroup (UpperSet α) | null | true |
tendsto_norm_inv_mul_self_nhdsNE | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : NormedGroup E] (a : E),
Filter.Tendsto (fun x => ‖x⁻¹ * a‖) (nhdsWithin a {a}ᶜ) (nhdsWithin 0 (Set.Ioi 0)) | null | true |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | null | false |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.inter m₂).getD k fallback = if m₂.contains k = true then m₁.getD k fallback else fallback | null | true |
CategoryTheory.Limits.coneOfIsSplitMono_π_app | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f : X ⟶ Y) [inst_1 : CategoryTheory.IsSplitMono f]
(X_1 : CategoryTheory.Limits.WalkingParallelPair),
(CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
X_1 = t →
... | null | true |
NonemptyInterval.toDualProdHom | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → NonemptyInterval α ↪o αᵒᵈ × α | `toDualProd` as an order embedding. | true |
CategoryTheory.leftAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y] {f : X ⟶ Y} {g : ᘁX ⟶ Z},
CategoryTheory.CategoryStruct.comp (ᘁf) g =
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (Φ : CategoryTheory.SmallObject.SuccStruct C)
(J : Type u_3) [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] (x x_1 : J) (f : x ⟶ x_1),
CategoryT... | null | false |
HomologicalComplex.instHasFilteredColimitsOfSize | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C],
CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', max t v, max (max t u) v} (HomologicalComplex C c) | null | true |
CategoryTheory.Limits.IsColimit.ofCoconeUncurry._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | null | false |
CategoryTheory.constantCommuteCompose_hom_app_val | Mathlib.CategoryTheory.Sites.ConstantSheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{B : Type u_3} [inst_3 : CategoryTheory.Category.{v_3, u_3} B] (U : CategoryTheory.Functor D B)
[i... | **Alias** of `CategoryTheory.constantCommuteCompose_hom_app_hom`. | true |
Lean.Lsp.DependencyBuildMode.never.sizeOf_spec | Lean.Data.Lsp.Extra | sizeOf Lean.Lsp.DependencyBuildMode.never = 1 | null | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.BisimO.match_1.splitter._sparseCasesOn_5 | Mathlib.Data.Seq.Computation | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
LinearMap.tensorProduct._proof_5 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid N]
[inst_6 : Module R N], IsScalarTower R A (TensorProduct R A M →ₗ[A] TensorProduct R A N) | null | false |
Std.Broadcast.noConfusion | Std.Sync.Broadcast | {P : Sort u} →
{α : Type} →
{t : Std.Broadcast α} →
{α' : Type} → {t' : Std.Broadcast α'} → α = α' → t ≍ t' → Std.Broadcast.noConfusionType P t t' | null | false |
UInt64.sub_eq_add_neg | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a - b = a + -b | null | true |
Mathlib.Meta.FunProp.MorApplication.ctorIdx | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.MorApplication → ℕ | null | false |
CategoryTheory.Functor.mapProjectiveResolution._proof_4 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.Limits.HasZeroObject D] [inst_5 : CategoryTheory.Preadditive D]
[inst_6 : ... | null | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ}
[inst_4 : n.AtLeastTwo], (0 < OfNat.ofNat n) = True | null | false |
Submodule._aux_Mathlib_Analysis_InnerProductSpace_Orthogonal___unexpand_Submodule_IsOrtho_1 | Mathlib.Analysis.InnerProductSpace.Orthogonal | Lean.PrettyPrinter.Unexpander | null | false |
Plausible.Random.randBool | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {g : Type} → [RandomGen g] → Plausible.RandGT g m Bool | Generate a random `Bool`.
| true |
Finsupp.mapRange.addEquiv_toEquiv | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (e : M ≃+ N),
↑(Finsupp.mapRange.addEquiv e) = Finsupp.mapRange.equiv ↑e ⋯ | null | true |
Lean.Meta.Sym.State.inferType._default | Lean.Meta.Sym.SymM | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Expr | null | false |
Matroid.cRk_closure_congr | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {X Y : Set α} [M.InvariantCardinalRank], M.closure X = M.closure Y → M.cRk X = M.cRk Y | null | true |
Nat.dfold_add._auto_5 | Init.Data.Nat.Fold | Lean.Syntax | null | false |
Lean.Json.json_ | Lean.Data.Json.Elab | Lean.ParserDescr | Json string syntax. | true |
Projectivization.Subspace.mem_submodule_iff | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s : Projectivization.Subspace K V) {v : V} (hv : v ≠ 0),
v ∈ Projectivization.Subspace.submodule s ↔ Projectivization.mk K v hv ∈ s | null | true |
_private.Batteries.Data.Array.Scan.0.Array.take_scanl._proof_1_3 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {f : β → α → β} (init : β) (as : Array α),
-1 * ↑as.size + 1 ≤ 0 →
i + 1 = (Array.scanl f init as).size - 1 →
i = as.size - 1 →
∀ (w : ℕ),
w + 1 ≤ ((Array.scanl f init as).extract 0 (i + 1)).size → w < (Array.scanl f init (as.extract 0 i)).size | null | false |
Fintype.toOrderBot._proof_1 | Mathlib.Data.Fintype.Order | ∀ (α : Type u_1) [inst : Fintype α] (a : α), ∃ x, x ∈ Finset.univ | null | false |
CategoryTheory.Functor.lanCompColimIso._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
[CategoryTheory.Limit... | null | false |
mem_const_vsub_affineSegment | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P),
p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y | null | true |
IO.CancelToken.noConfusion | Init.System.CancelToken | {P : Sort u} → {t t' : IO.CancelToken} → t = t' → IO.CancelToken.noConfusionType P t t' | null | false |
TopologicalSpace.OpenNhdsOf.instDistribLattice._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} (a b : TopologicalSpace.OpenNhdsOf x),
a ≤ { toOpens := a.toOpens ⊔ b.toOpens, mem' := ⋯ } | null | false |
QuadraticMap.linMulLin.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A]
[inst_6 : IsScalarTower R A A] (f f_1 : M →ₗ[R] A),
f = f_1 → ∀ (g g_1 : M →ₗ[R] A), g = g_1 → Quadrat... | null | true |
Finset.singletonAddHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : Add α] → α →ₙ+ Finset α | The singleton operation as an `AddHom`. | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (lowerBound : α),
Std.DTreeMap.Internal.Impl.pruneLE✝ Std.DTreeMap.Internal.Impl.leaf lowerBound = Std.DTreeMap.Internal.Impl.leaf | null | true |
SimpleGraph.Walk.darts_dropUntil_suffix_darts | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v w u : V} [inst : DecidableEq V] (p : G.Walk v w) (h : u ∈ p.support),
(p.dropUntil u h).darts <:+ p.darts | null | true |
Std.DTreeMap.Const.contains_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{f : Option β → Option β},
(Std.DTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).isSome else t.contains k' | null | true |
HomotopyCategory.shift_quotient_obj | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex C (ComplexShape.up ℤ)) (n : ℤ),
(CategoryTheory.shiftFunctor (HomotopyCategory C (ComplexShape.up ℤ)) n).obj
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj K) =
(HomotopyCategor... | null | true |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_whiskerLeft_δ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
CategoryTheor... | null | true |
CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful | null | true |
PiNat.self_mem_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ), x ∈ PiNat.cylinder x n | null | true |
SetRel.IsCover.anti | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {U : SetRel X X} {s t N : Set X}, s ⊆ t → U.IsCover t N → U.IsCover s N | null | true |
_private.Mathlib.RingTheory.Etale.Field.0.Algebra.FormallyEtale.of_isSeparable._simp_1_1 | Mathlib.RingTheory.Etale.Field | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
Filter.Eventually.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∀ᶠ (x : α) in f, q x | null | true |
PiTensorProduct.definition._proof_2._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.2741663271._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (G : Type (max u_3 u_1 u_2)) (x : SeminormedAddCommGroup G)
(x_1 : NormedSpace 𝕜 G), ContinuousConstSMul 𝕜 G | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_inter!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
NonarchAddGroupSeminorm.coe_lt_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupSeminorm E}, ⇑p < ⇑q ↔ p < q | null | true |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_6 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ | null | false |
Std.Http.Protocol.H1.Error.unsupportedVersion | Std.Http.Protocol.H1.Error | Std.Http.Protocol.H1.Error | Unsupported HTTP version.
| true |
Submodule.map | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
... | The pushforward of a submodule `p ⊆ M` by `f : M → M₂` | true |
real_inner_div_norm_mul_norm_eq_neg_one_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
inner ℝ x y / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x | The inner product of two vectors, divided by the product of their
norms, has value -1 if and only if they are nonzero and one is
a negative multiple of the other. | true |
concaveOn_univ_piecewise_Iic_of_monotoneOn_Iic_antitoneOn_Ici | Mathlib.Analysis.Convex.Piecewise | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : Module 𝕜 E] [PosSMulMono 𝕜 E] [inst_7 : AddCommGroup β]
[inst_8 : PartialOrder β] [IsOrderedAddMonoid β] [inst_10 : Module 𝕜 β] [Pos... | The piecewise function `(Set.Iic e).piecewise f g` of a function `f` increasing and concave on
`Set.Iic e` and a function `g` decreasing and concave on `Set.Ici e`, such that `f e = g e`, is
concave on the universal set. | true |
PFunctor.M.dest_mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : ↑F F.M), (PFunctor.M.mk x).dest = x | null | true |
Lean.SubExpr.Pos.pushNthBindingDomain | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof? | Lean.Meta.Tactic.Grind.Split | Lean.MVarId → Lean.MetaM (Option Lean.Expr) | Given a `mvarId` associated with a subgoal created by `splitCore`, inspects the
proof term assigned to `mvarId` and tries to extract the proof of `False` that does not
depend on hypotheses introduced in the subgoal.
For example: suppose the subgoal is of the form `p → q → False` where `p` and `q` are new
hypotheses int... | true |
CategoryTheory.Discrete.sumEquiv.match_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} →
(motive : J ⊕ K → Sort u_3) →
(t : J ⊕ K) → ((j : J) → motive (Sum.inl j)) → ((k : K) → motive (Sum.inr k)) → motive t | null | false |
Std.ExtTreeMap.maxKey_eq_iff_mem_and_forall | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {he : t ≠ ∅} {km : α}, t.maxKey he = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | null | true |
AlgebraNorm.algebraNormClass | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} [inst : SeminormedCommRing R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S],
AlgebraNormClass (AlgebraNorm R S) R S | null | true |
_private.Mathlib.Data.Set.Accumulate.0.Set.iUnion_accumulate._simp_1_1 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
TopologicalSpace.ext_isClosed | Mathlib.Topology.Basic | ∀ {X : Type u_2} {t₁ t₂ : TopologicalSpace X}, (∀ (s : Set X), IsClosed s ↔ IsClosed s) → t₁ = t₂ | **Alias** of the reverse direction of `TopologicalSpace.ext_iff_isClosed`. | true |
CategoryTheory.Subfunctor.Subpresheaf.equalizer.ι | Mathlib.CategoryTheory.Subfunctor.Equalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F₁ F₂ : CategoryTheory.Functor C (Type w)} →
{A : CategoryTheory.Subfunctor F₁} →
(f g : A.toFunctor ⟶ F₂) → (CategoryTheory.Subfunctor.equalizer f g).toFunctor ⟶ A.toFunctor | **Alias** of `CategoryTheory.Subfunctor.equalizer.ι`.
---
Given two morphisms `f` and `g` in `A.toFunctor ⟶ F₂`, this is the monomorphism
of functors corresponding to the inclusion `Subfunctor.equalizer f g ≤ A`. | true |
LieAlgebra.hasTrivialRadical_iff | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.HasTrivialRadical R L ↔ LieAlgebra.radical R L = ⊥ | null | true |
IsSelfAdjoint.cfc_arg | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u : A), IsSelfAdjoint (cfc (Complex.ofReal ∘ Complex.arg) u) | null | true |
nonneg_of_mul_nonneg_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [PosMulStrictMono R], 0 ≤ a * b → 0 < a → 0 ≤ b | null | true |
ContinuousMap.id._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ (α : Type u_1) [inst : TopologicalSpace α], Continuous id | null | false |
CategoryTheory.Functor.LaxMonoidal.comp._proof_1 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
instAssociativeInt8HAdd | Init.Data.SInt.Lemmas | Std.Associative fun x1 x2 => x1 + x2 | null | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___macroRules_CategoryTheory_rfl_cat_1 | Mathlib.CategoryTheory.Category.Basic | Lean.Macro | `rfl_cat` is a macro for `intros; rfl` which is attempted in `aesop_cat` before
doing the more expensive `aesop` tactic.
This gives a speedup because `simp` (called by `aesop`) can be very slow.
https://github.com/leanprover-community/mathlib4/pull/25475 contains measurements from June 2025.
Implementation notes:
* `... | false |
Fin.tail_vecCons | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} (x : α) (t : Fin n → α), Fin.tail (Matrix.vecCons x t) = t | null | true |
WittVector.IsocrystalHom.mk.inj | Mathlib.RingTheory.WittVector.Isocrystal | ∀ {p : ℕ} {inst : Fact (Nat.Prime p)} {k : Type u_1} {inst_1 : CommRing k} {inst_2 : CharP k p}
{inst_3 : PerfectRing k p} {V : Type u_2} {inst_4 : AddCommGroup V} {inst_5 : WittVector.Isocrystal p k V}
{V₂ : Type u_3} {inst_6 : AddCommGroup V₂} {inst_7 : WittVector.Isocrystal p k V₂}
{toLinearMap : V →ₗ[Fraction... | null | true |
DirectLimit.instGroupWithZero._proof_16 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → GroupWithZero (G i)] [∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (n : ℕ)
(x ... | null | false |
Finsupp.coe_smul._simp_1 | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
b • ⇑v = ⇑(b • v) | null | false |
Lean.Meta.LazyDiscrTree.MatchResult.push | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.MatchResult α → ℕ → Array α → Lean.Meta.LazyDiscrTree.MatchResult α | null | true |
SSet.Subcomplex.Pairing.II | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | the set of type (II) simplices | true |
Std.DHashMap.Internal.Raw₀.getKey_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : (a : α) → β a → Bool} {k : α} (h : (↑m).WF)
{h' : (Std.DHashMap.Internal.Raw₀.filter f m).contains k = true},
(Std.DHashMap.Internal.Raw₀.filter f m).get... | null | true |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rintroContinue.loop._unsafe_rec | Lean.Elab.Tactic.RCases | {α : Type} →
Lean.Syntax →
Lean.TSyntaxArray `rintroPat →
Option Lean.Term →
(Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α) →
ℕ → Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.upShadow) = ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t | null | false |
CentroidHom.toEndRingHom_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ (α : Type u_5) [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), (CentroidHom.toEndRingHom α) f = f.toEnd | null | true |
IntermediateField.eq_of_le_of_finrank_eq | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
[FiniteDimensional K ↥E], F ≤ E → Module.finrank K ↥F = Module.finrank K ↥E → F = E | If `F ≤ E` are two intermediate fields of `L / K` such that `[F : K] = [E : K]` are finite,
then `F = E`. | true |
Mathlib.Tactic.Order.AtomicFact.isTop.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (idx : ℕ), sizeOf (Mathlib.Tactic.Order.AtomicFact.isTop idx) = 1 + sizeOf idx | null | true |
Std.TreeMap.Raw.instForMProdOfMonad | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} → {m : Type w → Type w₂} → [Monad m] → ForM m (Std.TreeMap.Raw α β cmp) (α × β) | null | true |
HomotopicalAlgebra.instHasTwoOutOfThreePropertyFullSubcategoryWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{P : CategoryTheory.ObjectProperty C} [(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences P.FullSubcategory).HasTwoOutOfThreeProperty | null | true |
Lean.Grind.ISize.natCast | Init.GrindInstances.Ring.SInt | NatCast ISize | null | true |
CategoryTheory.SingleFunctors.shiftIso_zero_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (a : A) (X : C),
(F.shiftIso 0 a a ⋯).hom.app X = (CategoryTheory.shi... | null | true |
LieModule.maxTrivEquiv._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} {N : Type u_4} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[ins... | null | false |
Finsupp.comapDomain_inl_sumElim | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Zero γ] (f : α →₀ γ) (g : β →₀ γ),
Finsupp.comapDomain Sum.inl (f.sumElim g) ⋯ = f | null | true |
Std.TreeMap.le_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.minKey!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_eq_getKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
IsChain.succ | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain r (SuccChain r s) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.