name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.Linear.Expr.var.injEq | Init.Data.Int.Linear | ∀ (i i_1 : Int.Linear.Var), (Int.Linear.Expr.var i = Int.Linear.Expr.var i_1) = (i = i_1) | null | true |
_private.Mathlib.RingTheory.Regular.ProjectiveDimension.0.ModuleCat.projectiveDimension_quotSMulTop_eq_succ_of_isSMulRegular._simp_1_9 | Mathlib.RingTheory.Regular.ProjectiveDimension | ∀ {R : Type u_1} {M : Type u_3} [inst : MonoidWithZero R] [inst_1 : Zero M] [inst_2 : MulActionWithZero R M],
IsSMulRegular M 0 = Subsingleton M | null | false |
PUnit.commGroup.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.commGroup =
{ mul := fun x x_1 => PUnit.unit, mul_assoc := PUnit.commGroup._proof_5, one := PUnit.unit,
one_mul := PUnit.commGroup._proof_6, mul_one := PUnit.commGroup._proof_7, npow_zero := PUnit.commGroup._proof_1,
npow_succ := PUnit.commGroup._proof_2, inv := fun x => PUnit.unit, div_eq_mul_inv := PU... | null | true |
CategoryTheory.Abelian.comp_epiDesc | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[inst_2 : CategoryTheory.Epi f] {T : C} (g : X ⟶ T)
(hg : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) g = 0),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Abelian.ep... | null | true |
Vector.mapFinIdxM._proof_7 | Init.Data.Vector.Basic | ∀ {n : ℕ}, 0 = n - n | null | false |
Algebra.intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | (A : Type u_1) →
(K : Type u_2) →
(L : Type u_3) →
(B : Type u_6) →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Field K] →
[inst_4 : Field L] →
[inst_5 : Algebra A K] →
[IsF... | The restriction of the trace on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intTrace` instead. | true |
LinearEquiv.isUnit_det' | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f : M ≃ₗ[A] M),
IsUnit (LinearMap.det ↑f) | Specialization of `LinearEquiv.isUnit_det` | true |
Nat.div2_bit1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), (2 * n + 1).div2 = n | null | true |
BoxIntegral.Prepartition.filter | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → BoxIntegral.Prepartition I → (BoxIntegral.Box ι → Prop) → BoxIntegral.Prepartition I | The prepartition with boxes `{J ∈ π | p J}`. | true |
TotalComplexShape.symm.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_2} →
{I₂ : Type u_1} → (motive : I₂ × I₁ → Sort u_3) → (x : I₂ × I₁) → ((i₂ : I₂) → (i₁ : I₁) → motive (i₂, i₁)) → motive x | null | false |
Batteries.PairingHeap.deleteMin | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → Batteries.PairingHeap α le → Option (α × Batteries.PairingHeap α le) | Amortized `O(log n)`. Remove and return the minimum element from the heap. | true |
PProd | Init.Prelude | Sort u → Sort v → Sort (max (max 1 u) v) | A product type in which the types may be propositions, usually written `α ×' β`.
This type is primarily used internally and as an implementation detail of proof automation. It is
rarely useful in hand-written code.
Conventions for notations in identifiers:
* The recommended spelling of `×'` in identifiers is `PPro... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
↑(2 ^ w) ≤ x.toInt - y.toInt → ¬-(↑(2 ^ (w + 1)) / 2) ≤ x.toInt - y.toInt - ↑(2 ^ (w + 1)) → False | null | false |
bddAbove_iff_exists_ge | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeSup γ] {s : Set γ} (x₀ : γ), BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x | null | true |
TrivSqZeroExt.addGroup | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → [AddGroup R] → [AddGroup M] → AddGroup (TrivSqZeroExt R M) | null | true |
PowerSeries.derivativeFun | Mathlib.RingTheory.PowerSeries.Derivative | {R : Type u_1} → [CommSemiring R] → PowerSeries R → PowerSeries R | The formal derivative of a power series in one variable.
This is defined here as a function, but will be packaged as a
derivation `derivative` on `R⟦X⟧`.
| true |
Std.LinearOrderPackage.ctorIdx | Init.Data.Order.PackageFactories | {α : Type u} → Std.LinearOrderPackage α → ℕ | null | false |
CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g] {Z_1 : C}
(h : Opposite.unop (CategoryTheory.Limits.pullback f.op g.op) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g)
(Category... | null | true |
EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_3} {P : Type u_4} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → p₂ ∈ s → p₁ ≠ p₂ → dist p₁ p₂ /... | Given two points on a circle, twice the radius of that circle may be expressed explicitly as
the distance between those two points divided by the cosine of the angle between the chord and
the radius at one of those points. | true |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C (CategoryTheory.Mon D)} (α : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one { app := fun ... | null | false |
GroupAlgebra.mul_average_left | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : Invertible ↑(Fintype.card G)] (g : G), (fun₀ | g => 1) * GroupAlgebra.average k G = GroupAlgebra.average k G | `average k G` is invariant under left multiplication by elements of `G`. | true |
FreeAddMagma | Mathlib.Algebra.Free | Type u → Type u | If `α` is a type, then `FreeAddMagma α` is the free additive magma generated by `α`.
This is an additive magma equipped with a function `FreeAddMagma.of : α → FreeAddMagma α` which has
the following universal property: if `M` is any magma, and `f : α → M` is any function,
then this function is the composite of `FreeAdd... | true |
CategoryTheory.PreOneHypercover.sieve₁_inter | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] {i j : E.I₀ × F.I₀} {W : C}
{p₁ : W ⟶ CategoryTheory.Limits.pullback (E.f i.1) (F.f i.2)}
{p₂ : W ⟶ CategoryTheory.Limits... | null | true |
Lean.Widget.eraseWidgetSpec | Lean.Widget.Commands | Lean.ParserDescr | null | true |
Module.Basis.mk._proof_1 | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
_private.Lean.Meta.Tactic.Grind.Ctor.0.Lean.Meta.Grind.propagateCtorHetero._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Ctor | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
iInf_ite | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (p : ι → Prop) [inst_1 : DecidablePred p] (f g : ι → α),
(⨅ i, if p i then f i else g i) = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), g i | null | true |
CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R), CategoryTheory.IsCofilteredOrEmpty D | If `C` is cofiltered or empty, and we have a functor `L : C ⥤ D` with a right adjoint,
then `D` is cofiltered or empty.
| true |
Quaternion.instDivisionRing._proof_8 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (a : Quaternion R),
GroupWithZero.zpow (Int.negSucc n) a = (GroupWithZero.zpow (↑n.succ) a)⁻¹ | null | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | null | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore_length._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True | null | false |
Semiring.toGrindSemiring._proof_12 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (n : ℕ), OfNat.ofNat (n + 2 + 1) = OfNat.ofNat (n + 2) + 1 | null | false |
HomologicalComplex.homologyπ_extendHomologyIso_inv_assoc | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (K : HomologicalComplex C c) (e : c.Embedding c') {j : ι} {j' : ι'}
(hj' : ... | null | true |
ProbabilityTheory.geometricPMFReal | Mathlib.Probability.Distributions.Geometric | ℝ → ℕ → ℝ | The pmf of the geometric distribution depending on its success probability. | true |
continuousAt_jacobiTheta₂ | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z : ℂ) {τ : ℂ}, 0 < τ.im → ContinuousAt (fun p => jacobiTheta₂ p.1 p.2) (z, τ) | null | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (x x_1 : (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ)
(x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.PreGaloisCategory.Poi... | null | false |
Bundle.TotalSpace.mk' | Mathlib.Data.Bundle | {B : Type u_1} → {E : B → Type u_3} → (F : Type u_4) → (x : B) → E x → Bundle.TotalSpace F E | null | true |
String.instLinearOrder._proof_9 | Mathlib.Data.String.Basic | ∀ (a b : String), (if a ≤ b then a else b) = if a ≤ b then a else b | null | false |
ComplexShape.down.congr_simp | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : Add α] [inst_1 : IsRightCancelAdd α] [inst_2 : One α],
ComplexShape.down α = ComplexShape.down α | null | true |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.iterate_toEnd_mem_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True | null | false |
IsBaseChange.equiv._proof_2 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S | null | false |
ImplicitFunctionData.hasStrictFDerivAt_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | null | true |
Array.back_scanl? | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {f : β → α → β} {as : Array α},
(Array.scanl f init as).back? = some (Array.foldl f init as) | **Alias** of `Array.back?_scanl`. | true |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.exists_basis_of_pairing_eq_zero._simp_1_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M} {s : Set M},
(x ∈ Submodule.span R (insert y s)) = ∃ a, x + a • y ∈ Submodule.span R s | null | false |
LieDerivation.mk.injEq | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [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]
(toLinearMap : L →ₗ[R] M) (leibniz' : ∀ (a b : L), toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, t... | null | true |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | null | false |
Unitization.instNeg | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Neg R] → [Neg A] → Neg (Unitization R A) | null | true |
List.SortedGE.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → List.IsChain (fun x1 x2 => x1 ≥ x2) l | **Alias** of the forward direction of `List.sortedGE_iff_isChain`. | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Mathlib.Tactic.BicategoryLike.MonadMor₁.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{id₁M : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{id₁M' : Mathlib.Tactic.BicategoryL... | null | false |
Lean.Meta.LazyDiscrTree.Key.fvar.injEq | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.FVarId) (a_1 : ℕ) (a_2 : Lean.FVarId) (a_3 : ℕ),
(Lean.Meta.LazyDiscrTree.Key.fvar a a_1 = Lean.Meta.LazyDiscrTree.Key.fvar a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
HomologicalComplex.instHasColimitDiscreteWalkingPairCompPairEval | Mathlib.Algebra.Homology.HomologicalComplexBiprod | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K L : HomologicalComplex C c)
[∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (L.X i)] (i : ι),
CategoryTheory.Limits.HasColimit ((CategoryTheory.Limits.pair K L... | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferConstType | Lean.Meta.InferType | Lean.Name → List Lean.Level → Lean.MetaM Lean.Expr | null | true |
CategoryTheory.Endofunctor.Coalgebra.ctorIdx | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C C} → CategoryTheory.Endofunctor.Coalgebra F → ℕ | null | false |
convexHull.eq_1 | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], convexHull 𝕜 = ClosureOperator.ofCompletePred (Convex 𝕜) ⋯ | null | true |
_private.Lean.Meta.TryThis.0.Lean.Meta.Tactic.TryThis.Suggestion.processEdit.match_1 | Lean.Meta.TryThis | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((indent column : ℕ) → motive (indent, column)) → motive x | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_eq_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ},
(∃ k',
k ≤ k' ∧
k' ≤ stackPos ∧ String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1)) →
∀ (k' : ℕ), k ≤ k' → ¬k < k' → ¬k = k' → False | null | false |
CategoryTheory.Over.fst_left | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
{R S : CategoryTheory.Over X},
CategoryTheory.Over.Hom.left (CategoryTheory.SemiCartesianMonoidalCategory.fst R S) =
CategoryTheory.Limits.pullback.fst R.hom S.hom | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_motive._simp_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.fold.match_1.splitter | BatteriesRecycling.RBTree.Lemmas | {α : Type u_1} →
(motive : RBTree.RBNode α → Sort u_2) →
(x : RBTree.RBNode α) →
(Unit → motive RBTree.RBNode.nil) →
((c : RBTree.RBColor) →
(l : RBTree.RBNode α) → (v : α) → (r : RBTree.RBNode α) → motive (RBTree.RBNode.node c l v r)) →
motive x | null | true |
CategoryTheory.Limits.Fork.IsLimit.lift' | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
{X Y : C} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : X ⟶ Y} →
{s : CategoryTheory.Limits.Fork f g} →
CategoryTheory.Limits.IsLimit s →
{W : C} →
(k : W ⟶ X) →
CategoryTheory.CategoryStruct.comp k f = CategoryTheory.Category... | If `s` is a limit fork over `f` and `g`, then a morphism `k : W ⟶ X` satisfying
`k ≫ f = k ≫ g` induces a morphism `l : W ⟶ s.pt` such that `l ≫ fork.ι s = k`. | true |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.Finset.aemeasurable_sum.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {ι : Type u_1} {α : Type u_3} {f : ι → α → M} (s : Finset ι) (_g : α → M)
(motive : (∃ a ∈ s.val, f a = _g) → Prop) (x : ∃ a ∈ s.val, f a = _g),
(∀ (_i : ι) (hi : _i ∈ s.val) (hg : f _i = _g), motive ⋯) → motive x | null | false |
Polynomial.eval_mul_X_pow | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R} {k : ℕ},
Polynomial.eval x (p * Polynomial.X ^ k) = Polynomial.eval x p * x ^ k | null | true |
CategoryTheory.Limits.inr_comp_pushoutComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : X ⟶ Y) (g : X ⟶ Z)
[inst_2 : CategoryTheory.Limits.HasPushout f g] [inst_3 : CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
{Z_1 : D} (h : G... | null | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.hasDerivAt_taylorWithinEval_succ._simp_1_6 | Mathlib.Analysis.Calculus.Taylor | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.HashMap.get?_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, k ∉ m₁ → (m₁ ∪ m₂).get? k = m₂.get? k | null | true |
WeierstrassCurve.Projective.Nonsingular | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → Prop | The proposition that a projective point representative `(x, y, z)` on a Weierstrass curve `W` is
nonsingular.
In other words, either `W_X(x, y, z) ≠ 0`, `W_Y(x, y, z) ≠ 0`, or `W_Z(x, y, z) ≠ 0`.
Note that this definition is only mathematically accurate for fields. | true |
CommRingCat.Under.tensorProductFan' | Mathlib.Algebra.Category.Ring.Under.Limits | {R : CommRingCat} →
(S : CommRingCat) →
[inst : Algebra ↑R ↑S] →
{ι : Type u} →
(P : ι → CategoryTheory.Under R) →
CategoryTheory.Limits.Fan fun i => S.mkUnder (TensorProduct ↑R ↑S ↑(P i).right) | The fan on `i ↦ S ⊗[R] P i` given by `∀ i, S ⊗[R] P i` | true |
Std.TreeMap.contains_iff_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α}, t.contains k = true ↔ k ∈ t | null | true |
Pi.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
MeasurableSpace.DynkinSystem.mk.sizeOf_spec | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_4} [inst : SizeOf α] (Has : Set α → Prop) (has_empty : Has ∅) (has_compl : ∀ {a : Set α}, Has a → Has aᶜ)
(has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Function.onFun Disjoint f) → (∀ (i : ℕ), Has (f i)) → Has (⋃ i, f i)),
sizeOf { Has := Has, has_empty := has_empty, has_compl := has_compl, has_iUnio... | null | true |
Mathlib.Tactic.LinearCombination.expandLinearCombo._unsafe_rec | Mathlib.Tactic.LinearCombination | Option Lean.Expr → Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.LinearCombination.Expanded | null | false |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.A_c_eq_zero | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} {A : FixedDetMatrix (Fin 2) ℤ m}, ↑A 1 0 = 0 → ↑A 0 0 * ↑A 1 1 = m | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift_self | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (h : D.IsTerminal e),
h.lift ⋯ = CategoryTheory.CategoryStruct.id e | null | true |
RCLike.I_to_real | Mathlib.Analysis.RCLike.Basic | RCLike.I = 0 | null | true |
Lean.Elab.ConfigEval.EvalConfigItem.evalSetOptions | Lean.Elab.ConfigEval.Extra | Lean.Name → Lean.Options → Lean.Elab.ConfigEval.ConfigItem → Lean.Elab.TermElabM Lean.Options | Uses global option declarations with the prefix `optionPrefix` when setting `Options`.
Assumes that `item` is shifted, with the rest of the item being the option name suffix to use.
| true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_34 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n),
(Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ofArray_fold_fn acc (some c)).size = n →
∀ (l : Std.Tactic.BVDecide.LRAT.Internal.PosFi... | null | false |
IsAddRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsCancelAdd R] (g : R), IsAddRegular g | If all additions cancel then every element is add-regular. | true |
Int64.toISize_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int64.ofNat n).toISize = ISize.ofNat n | null | true |
Lean.Meta.Simp.Methods.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {pre post : Lean.Meta.Simp.Simproc} {dpre dpost : Lean.Meta.Simp.DSimproc}
{discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge : Bool}
{pre_1 post_1 : Lean.Meta.Simp.Simproc} {dpre_1 dpost_1 : Lean.Meta.Simp.DSimproc}
{discharge?_1 : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)... | null | true |
Lean.ReducibilityHints.opaque.sizeOf_spec | Lean.Declaration | sizeOf Lean.ReducibilityHints.opaque = 1 | null | true |
Std.Time.Modifier.z.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.ZoneName} →
Std.Time.Modifier.z presentation = Std.Time.Modifier.z presentation' → (presentation = presentation' → P) → P | null | false |
AffineMap.instAddCommGroup._proof_4 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] (x : P1 →ᵃ[k] V2)
(x_1 : ℕ), ⇑(x_1 • x) = x_1 • ⇑x | null | false |
MeasureTheory.AEEqFun.instMonoid | Mathlib.MeasureTheory.Function.AEEqFun | {α : Type u_1} →
{γ : Type u_3} →
[inst : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_1 : TopologicalSpace γ] → [inst_2 : Monoid γ] → [ContinuousMul γ] → Monoid (α →ₘ[μ] γ) | null | true |
CategoryTheory.equivSmallModel._proof_1 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.EssentiallySmall.{u_1, u_3, u_2} C], Nonempty (C ≌ Classical.choose ⋯) | null | false |
CommRingCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(s : CategoryTheory.Limits.Cocone F) → CommRingCat.Colimits.Prequotient F → ↑s.pt | null | false |
IsSolvableByRad.rec | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
{motive : (a : E) → IsSolvableByRad F a → Prop},
(∀ (α : F), motive ((algebraMap F E) α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β), motive α a → motive β a_1 → motive (α + β) ⋯) →
(∀ (α... | null | false |
Polynomial.revAt_le | Mathlib.Algebra.Polynomial.Reverse | ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
l'.size ≤ d.size → d.size ≤ l'.size + 1 → ¬d.size + 1 + r'.size ≤ l'.size + 1 + r'.size + 1 → False | null | false |
ENat.iInf_toNat | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} {f : ι → ℕ}, (⨅ i, ↑(f i)).toNat = ⨅ i, f i | null | true |
Int.ModEq.mul_left | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (c : ℤ), a ≡ b [ZMOD n] → c * a ≡ c * b [ZMOD n] | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termY₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | null | true |
MvPowerSeries.truncTotalAlgHom._proof_4 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ (σ : Type u_1) (R : Type u_2) [inst : Finite σ] [inst_1 : CommRing R] (n : ℕ) (x x_1 : MvPowerSeries σ R),
(Ideal.Quotient.mk (MvPolynomial.idealOfVars σ R ^ n)) ((MvPowerSeries.truncTotal n) (x + x_1)) =
(Ideal.Quotient.mk (MvPolynomial.idealOfVars σ R ^ n)) ((MvPowerSeries.truncTotal n) x) +
(Ideal.Quot... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.glueData._proof_14 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (i : ↑X.affineOpens),
CategoryTheory.IsIso (CategoryTheory.Limits.pullback.fst (I.glueDataObjι (i, i).1) (X.homOfLE ⋯)) | null | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_three._simp_1_3 | Init.Data.ByteArray.Lemmas | ∀ {l l' : List UInt8}, l.toByteArray ++ l'.toByteArray = (l ++ l').toByteArray | null | false |
AddEquiv.strictMono_subsemigroupCongr | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddCommMonoid G] [inst_1 : Preorder G] {S T : AddSubsemigroup G} (h : S = T),
StrictMono ⇑(AddEquiv.subsemigroupCongr h) | null | true |
IsEmpty.oriented._proof_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], 1 ≠ 0 | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
CategoryTheory.TwoSquare.mk | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | Constructor for `TwoSquare`. | true |
Kronecker.«_aux_Mathlib_LinearAlgebra_Matrix_Kronecker___macroRules_Kronecker_term_⊗ₖₜ[_]__1» | Mathlib.LinearAlgebra.Matrix.Kronecker | Lean.Macro | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.