name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.ProjectionFunctionInfo | Lean.ProjFns | Type | Given a structure `S`, Lean automatically creates an auxiliary definition (projection function)
for each field. This structure caches information about these auxiliary definitions.
| true |
CategoryTheory.Functor.constComp | Mathlib.CategoryTheory.Functor.Const | (J : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} D] →
(X : C) →
(F : CategoryTheory.Functor C D) →
((CategoryThe... | These are actually equal, of course, but not definitionally equal
(the equality requires `F.map (𝟙 _) = 𝟙 _`). A natural isomorphism is
more convenient than an equality between functors (compare id_to_iso). | true |
IncidenceAlgebra.moduleRight._proof_4 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_3} {𝕝 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Semiring 𝕜] [inst_2 : AddCommMonoid 𝕝]
[inst_3 : Module 𝕜 𝕝] (c : 𝕜) (f : IncidenceAlgebra 𝕝 α), ⇑(c • f) = c • ⇑f | null | false |
PreInnerProductSpace.Core.conj_inner_symm | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_4} {F : Type u_5} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
(self : PreInnerProductSpace.Core 𝕜 F) (x y : F), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | The inner product is *Hermitian*, taking the `conj` swaps the arguments. | true |
LinearMap.vecEmpty_apply | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₃]
[inst_3 : Module R M] [inst_4 : Module R M₃] (m : M), LinearMap.vecEmpty m = ![] | null | true |
CategoryTheory.Cat.chosenTerminalIsTerminal._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Cat | ∀ (x : CategoryTheory.Cat) (x_1 : x ⟶ CategoryTheory.Cat.chosenTerminal), x_1 = x_1 | null | false |
Quiver.arborescenceMk._proof_1 | Mathlib.Combinatorics.Quiver.Arborescence | ∀ {V : Type u_1} [inst : Quiver V] (r : V) (height : V → ℕ),
(∀ ⦃a b : V⦄ (a_1 : a ⟶ b), height a < height b) →
(∀ (b : V), b = r ∨ ∃ a, Nonempty (a ⟶ b)) → ∀ (b : V), Nonempty (Quiver.Path r b) | null | false |
AddHom.noConfusionType | Mathlib.Algebra.Group.Hom.Defs | Sort u →
{M : Type u_10} →
{N : Type u_11} →
[inst : Add M] →
[inst_1 : Add N] →
(M →ₙ+ N) → {M' : Type u_10} → {N' : Type u_11} → [inst' : Add M'] → [inst'_1 : Add N'] → (M' →ₙ+ N') → Sort u | null | false |
Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKey! k = default | null | true |
PMF.toMeasure_ofMultiset_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} {s : Multiset α} (hs : s ≠ 0) (t : Set α) [inst : MeasurableSpace α],
MeasurableSet t →
(PMF.ofMultiset s hs).toMeasure t = (∑' (x : α), ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s))) / ↑s.card | null | true |
WithBot.one | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [One α] → One (WithBot α) | null | true |
CategoryTheory.MonoidalCategory.Limits.preservesLimit_of_braided_and_preservesLimit_tensor_left | Mathlib.CategoryTheory.Monoidal.Limits.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{J : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.BraidedCategory C] (c : C)
[CategoryTheory.Limits.PreservesLimit F (CategoryTheory.MonoidalCat... | When `C` is braided and `tensorLeft c` preserves a limit, then so does `tensorRight k`. | true |
instMulActionElemFixedPointsSubtypeMemSubgroupOfNormal._aux_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | {G : Type u_2} →
[inst : Group G] →
{α : Type u_1} →
[inst_1 : MulAction G α] →
{H : Subgroup G} → [hH : H.Normal] → G → ↑(MulAction.fixedPoints (↥H) α) → ↑(MulAction.fixedPoints (↥H) α) | null | false |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.isLimit | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{H : J.OneHypercoverFamily} →
{P : CategoryTheory.Functor Cᵒᵖ A} →
(∀ ⦃X : C⦄ (E : J.OneHyperco... | Auxiliary definition for `OneHypercoverFamily.isSheaf_iff`. | true |
ChainComplex.prev | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : AddRightCancelSemigroup α] [inst_1 : One α] (i : α), (ComplexShape.down α).prev i = i + 1 | null | true |
AlgebraicGeometry.Scheme.coe_homeoOfIso | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y), ⇑(AlgebraicGeometry.Scheme.homeoOfIso e) = ⇑e.hom | null | true |
ZeroAtInftyContinuousMap.instNonUnitalNormedRing._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalNormedRing β]
(x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖ | null | false |
CategoryTheory.Limits.mapPair._proof_11 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
{F G : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C}
(f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left })
(g :
F.obj { as := CategoryTheory.Li... | null | false |
_private.Mathlib.MeasureTheory.Function.Piecewise.0.IndexedPartition.stronglyMeasurable_piecewise._simp_1_7 | Mathlib.MeasureTheory.Function.Piecewise | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
autEquivZmod._proof_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {n : ℕ} {a : K},
Irreducible (Polynomial.X ^ n - Polynomial.C a) → ∀ {ζ : K}, IsPrimitiveRoot ζ n → ∃ x, x ∈ primitiveRoots n K | null | false |
CategoryTheory.Presieve.hasPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X : C} {R : CategoryTheory.Presieve X} {Y : C} (f : Y ⟶ X)
[self : R.HasPullbacks f] {Z : C} {h : Z ⟶ X}, R h → CategoryTheory.Limits.HasPullback h f | **Alias** of `CategoryTheory.Presieve.HasPullbacks.hasPullback`. | true |
Module.Relations.Solution.casesOn | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] →
{motive : relations.Solution M → Sort u_1} →
(t : relations.Solution M) →
((var : relations.G → M) →
... | null | false |
Lean.Parser.TokenCacheEntry.startPos | Lean.Parser.Types | Lean.Parser.TokenCacheEntry → String.Pos.Raw | null | true |
Pi.rightCancelMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → RightCancelMonoid (f i)],
Pi.rightCancelMonoid =
{ toSemigroup := Pi.rightCancelSemigroup.toSemigroup, toOne := Pi.monoid.toOne, one_mul := ⋯, mul_one := ⋯,
npow := Monoid.npow, npow_zero := ⋯, npow_succ := ⋯, toIsRightCancelMul := ⋯ } | null | true |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_9 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x - y) = ↑x - ↑y | null | false |
Matroid.mem_closure_diff_singleton_iff_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X : Set α} {e : α},
e ∈ X →
autoParam (e ∈ M.E) Matroid.mem_closure_sdiff_singleton_iff_closure._auto_1 →
(e ∈ M.closure (X \ {e}) ↔ M.closure (X \ {e}) = M.closure X) | **Alias** of `Matroid.mem_closure_sdiff_singleton_iff_closure`. | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData._sizeOf_1 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.PendingSolverPropagationsData✝ → ℕ | null | false |
CategoryTheory.PullbackShift.functor.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
(F : CategoryTheory.F... | null | true |
Lean.Lsp.DeclarationParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams},
{ toTextDocumentPositionParams := toTextDocumentPositionParams } =
{ toTextDocumentPositionParams := toTextDocumentPositionParams_1 } →
toTextDocumentPositionParams = toTextDocumentPositionParams_1 | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Solve.0.Lean.Elab.Tactic.Do.Internal.VCGen.trySplit | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | Lean.MVarId →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Array Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Array Lean.E... | Split an `ite`/`dite`/match program head, or iota-reduce if the discriminant is
constructor-shaped. Returns `none` when the program isn't a split. | true |
NonAssocSemiring.natCast_succ | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonAssocSemiring α] (n : ℕ), ↑(n + 1) = ↑n + 1 | The canonical map `ℕ → R` is a homomorphism. | true |
FirstOrder.Language.LHom.onRelation | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → (L →ᴸ L') → ⦃n : ℕ⦄ → L.Relations n → L'.Relations n | The mapping of relations | true |
Vector.not_mem_range_self | Init.Data.Vector.Range | ∀ {n : ℕ}, n ∉ Vector.range n | null | true |
CategoryTheory.SingleFunctors.postcompPostcompIso_inv_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} {E' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Category.{v_4, u_4} E'] {A : Type u_5} [inst_4 : AddMonoid A]
[inst_5 : CategoryTheo... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftConcat_eq_of_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {k : ℕ}, x.toNat < 2 ^ k → 2 ^ k * 2 ≤ 2 ^ w → ¬x.toNat * 2 < 2 ^ w → False | null | false |
ContinuousWithinAt.insert | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → ContinuousWithinAt f (insert x s) x | **Alias** of the reverse direction of `continuousWithinAt_insert_self`. | true |
ArchimedeanClass.stdPart_add_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x y : K},
0 < ArchimedeanClass.mk y → ArchimedeanClass.stdPart (x + y) = ArchimedeanClass.stdPart x | null | true |
Con.comap | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
{N : Type u_2} →
[inst : Mul M] → [inst_1 : Mul N] → (f : M → N) → (∀ (x y : M), f (x * y) = f x * f y) → Con N → Con M | Given types with multiplications `M, N` and a congruence relation `c` on `N`, a
multiplication-preserving map `f : M → N` induces a congruence relation on `f`'s domain
defined by '`x ≈ y` iff `f(x)` is related to `f(y)` by `c`.' | true |
CategoryTheory.Limits.biprod.isKernelSndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biprod.sndKernelFork X Y) | The fork `biprod.sndKernelFork` is indeed a limit. | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.ArchimedeanClass.mk_le_mk_iff_lt.match_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M}
(motive : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → Prop) (x : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b),
(∀ (n : ℕ) (hn : |ArchimedeanOrder.val (ArchimedeanOrder.of b)| ≤ n • |ArchimedeanOrder.val... | null | false |
Std.DTreeMap.Internal.Impl.minKeyD.match_1.congr_eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → α → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α β) (x_1 : α)
(h_1 : (fallback : α) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Impl... | null | true |
Lean.Meta.Grind.CheckResult.ctorIdx | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult → ℕ | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.numbering.go._f | Lean.DocString.Parser | (x : List Lean.Doc.Parser.OrderedListType) → List.below x → Lean.Parser.ParserFn | null | false |
_private.Mathlib.Algebra.Order.Ring.GeomSum.0.geom_sum_alternating_of_lt_neg_one._simp_1_2 | Mathlib.Algebra.Order.Ring.GeomSum | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | null | false |
CategoryTheory.Lax.OplaxTrans.Hom.of.injEq | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (as as_1 : CategoryTheory.Lax.OplaxTrans.Modification η θ),
({ as := as } = { as := as_1 }) = (as = as_1) | null | true |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path.match_1_1 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} {σ : Type u_2} (M : εNFA α σ) {s₁ s₂ : σ}
(motive : (∃ n, M.IsPath s₁ s₂ (List.replicate n none)) → Prop) (h : ∃ n, M.IsPath s₁ s₂ (List.replicate n none)),
(∀ (n : ℕ) (h : M.IsPath s₁ s₂ (List.replicate n none)), motive ⋯) → motive h | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_7 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {l : ℕ} (k t : ℕ), k + 1 + t < l → t < l | null | false |
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.Subsemigroup.isMulCommutative_iSup._simp_1_2 | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
IsCoprime.mul_add_right_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → ∀ (z : R), IsCoprime x (z * x + y) | null | true |
Std.Time.Awareness.only.sizeOf_spec | Std.Time.Format.Basic | ∀ (a : Std.Time.TimeZone), sizeOf (Std.Time.Awareness.only a) = 1 + sizeOf a | null | true |
WithTopology.noConfusionType | Mathlib.Topology.Defs.Basic | Sort u →
{X : Type u_1} →
{t : TopologicalSpace X} →
WithTopology X t → {X' : Type u_1} → {t' : TopologicalSpace X'} → WithTopology X' t' → Sort u | null | false |
CategoryTheory.Limits.evaluationJointlyReflectsLimits._proof_2 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] {K : Type u_1} [inst_2 : CategoryTheory.Category.{u_4, u_1} K]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (c : CategoryTheory.Limits.Cone F)
(t : (k : K) → CategoryTheory.... | null | false |
AddEquiv.instUnique.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_16} {N : Type u_17} [inst : Unique M] [inst_1 : Unique N] [inst_2 : Add M] [inst_3 : Add N],
AddEquiv.instUnique = { default := AddEquiv.ofUnique, uniq := ⋯ } | null | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {i : ℕ} {a : α},
List.countPBefore p (a :: xs) (i + 1) = if p a = true then List.countPBefore p xs i + 1 else List.countPBefore p xs i | null | false |
instModuleFormalMultilinearSeriesOfContinuousConstSMulOfSMulCommClass._proof_7 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | null | false |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces | Init.Data.String.Extra | ℕ → String → String | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_limsup_le_one._simp_1_4 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_toNat_iff_getLsbD_eq_true._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {i : ℕ} (w : ℕ) {x : BitVec (w + 1)}, i < w + 1 → ¬w - i + (i + 1) = w + 1 → False | null | false |
AddGroupWithOne.noConfusion | Mathlib.Data.Int.Cast.Defs | {P : Sort u_1} →
{R : Type u} →
{t : AddGroupWithOne R} →
{R' : Type u} → {t' : AddGroupWithOne R'} → R = R' → t ≍ t' → AddGroupWithOne.noConfusionType P t t' | null | false |
_private.Mathlib.Data.List.Basic.0.List.eq_cons_of_length_one._proof_1_6 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} (h : l.length = 1) (n : ℕ), n + 1 ≤ [l.get ⟨0, ⋯⟩].length → ¬n = 0 → n - 1 < [].length | null | false |
RestrictedProduct.instGroupCoeOfSubgroupClass._proof_10 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Group (R i)] [inst_2 : ∀ (i : ι), SubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (x_1 : ℤ), ⇑(x ^ x_1) = ⇑(x ^ x_1) | null | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.explainStuckTypeclassProblem._sparseCasesOn_7 | Lean.Elab.SyntheticMVars | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
HomologicalComplex.HomologySequence.snakeInput._proof_15 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i : ι), (S.X₁.sc i).HasHomology | null | false |
Lean.Meta.UnificationHint.noConfusionType | Lean.Meta.UnificationHint | Sort u → Lean.Meta.UnificationHint → Lean.Meta.UnificationHint → Sort u | null | false |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β]
(a : MeasureTheory.SimpleFunc α β), a * 0 = 0 | null | false |
Equiv.image_symm_apply_coe | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (y : ↑(⇑e '' s)), ↑((e.image s).symm y) = e.symm ↑y | null | true |
Complex.tanh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tanh ↑x).im = 0 | null | true |
Std.TreeSet.get_get? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{h : (t.get? k).isSome = true}, (t.get? k).get h = t.get k ⋯ | null | true |
Field.FG.mk | Mathlib.Algebra.Field.Subfield.Basic | ∀ {L : Type v} [inst : DivisionRing L], (∃ S, Subfield.closure ↑S = ⊤) → Field.FG L | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_7 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y z : V},
0 ≤ Real.sin (InnerProductGeometry.angle x y) / ‖z‖ | null | false |
Mathlib.Tactic.Abel.abelConv | Mathlib.Tactic.Abel | Lean.ParserDescr | `abel` solves equations in the language of *additive*, commutative monoids and groups.
`abel` and its variants work as both tactics and conv tactics.
* `abel1` fails if the target is not an equality that is provable by the axioms of
commutative monoids/groups.
* `abel_nf` rewrites all group expressions into a norma... | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X}, E.sieve₀ ≤ S → ∀ (i : E.multicospanShape.L), S.arrows (E.f i) | null | false |
Lex.instDivisionRing._aux_9 | Mathlib.Algebra.Field.Basic | {K : Type u_1} → [DivisionRing K] → ℚ≥0 → Lex K → Lex K | null | false |
Std.Time.WallTime.instHSubDuration_1 | Std.Time.DateTime.WallTime | HSub Std.Time.WallTime Std.Time.WallTime Std.Time.Duration | null | true |
instCoeTailNatOfNatCast | Init.Data.Cast | {R : Type u_1} → [NatCast R] → CoeTail ℕ R | null | true |
_private.Mathlib.Analysis.Analytic.Constructions.0.Finset.analyticWithinAt_sum._simp_1_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
CategoryTheory.Limits.BinaryBicones.functoriality | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type uD} →
[inst_2 : CategoryTheory.Category.{uD', uD} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(P Q : C) →
(F : CategoryThe... | A functor `F : C ⥤ D` sends binary bicones for `P` and `Q`
to binary bicones for `G.obj P` and `G.obj Q` functorially. | true |
Lean.Elab.TerminationHints._sizeOf_inst | Lean.Elab.PreDefinition.TerminationHint | SizeOf Lean.Elab.TerminationHints | null | false |
Set.image_prod | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) {s : Set α} {t : Set β},
(fun x => f x.1 x.2) '' s ×ˢ t = Set.image2 f s t | null | true |
Aesop.RappData.metaState | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Lean.Meta.SavedState | null | true |
AddValuation.comap_id | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀]
(v : AddValuation R Γ₀), AddValuation.comap (RingHom.id R) v = v | null | true |
Associated.neg_neg | Mathlib.Algebra.Ring.Associated | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : HasDistribNeg M] {a b : M}, Associated a b → Associated (-a) (-b) | null | true |
FirstOrder.Language.ElementaryEmbedding.toEmbedding._proof_2 | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.ElementaryEmbedding M N) {x : ℕ} (R : L.Relations x) (x_1 : Fin x → M),
FirstOrder.Language.Structure.RelMap R (⇑f ∘ x_1) ↔ FirstOrder.Language.Structure.RelMap R x_1 | null | false |
LinearMap.BilinForm.toLinHomAux₁ | Mathlib.LinearAlgebra.BilinearForm.Hom | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → M → M →ₗ[R] R | Auxiliary definition to define `toLinHom`; see below. | true |
AEMeasurable.sum_measure | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
[Countable ι] {μ : ι → MeasureTheory.Measure α},
(∀ (i : ι), AEMeasurable f (μ i)) → AEMeasurable f (MeasureTheory.Measure.sum μ) | null | true |
Pi.single | Mathlib.Algebra.Notation.Pi.Basic | {ι : Type u_1} → {M : ι → Type u_6} → [(i : ι) → Zero (M i)] → [DecidableEq ι] → (i : ι) → M i → (j : ι) → M j | The function supported at `i`, with value `x` there, and `0` elsewhere. | true |
CovBySMul.of_subset._simp_2 | Mathlib.Combinatorics.Additive.CovBySMul | ∀ {M : Type u_1} {X : Type u_3} [inst : Monoid M] [inst_1 : MulAction M X] {A B : Set X},
A ⊆ B → CovBySMul M 1 A B = True | null | false |
mabs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a|ₘ ≤ b ↔ b⁻¹ ≤ a ∧ a ≤ b | null | true |
PresheafOfModules.Sheafify.map_smul_eq | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory._aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_termFrontFace__1 | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro | null | false |
CategoryTheory.IsEquivalenceRelation.casesOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.IsEquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.IsEquivalenceRelation p₁ p₂) →
((nonempty_equivalenceRelation : Nonempty (CategoryTheory.Equivalen... | null | false |
RingHom.eqLocus | Mathlib.Algebra.Ring.Subring.Basic | {R : Type u} → [inst : NonAssocRing R] → {S : Type v} → [inst_1 : Semiring S] → (R →+* S) → (R →+* S) → Subring R | The subring of elements `x : R` such that `f x = g x`, i.e.,
the equalizer of f and g as a subring of R | true |
IntermediateField.extendScalars._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → F.toSubfield ≤ E.toSubfield | null | false |
Equiv.piCongrFiberwise_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {β : Type u_10} {γ₁ : α → Type u_11} {γ₂ : β → Type u_12} {f : α → β}
(e : (b : β) → ((σ : { a // f a = b }) → γ₁ ↑σ) ≃ γ₂ b) (g : (a : α) → γ₁ a) (b : β),
(Equiv.piCongrFiberwise e) g b = (e b) fun σ => g ↑σ | null | true |
Turing.PartrecToTM2.K'.main.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | sizeOf Turing.PartrecToTM2.K'.main = 1 | null | true |
continuous_inf_dom_left₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
{tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z},
(Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 | A version of `continuous_inf_dom_left` for binary functions | true |
Int.fdiv_add_fmod' | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a | null | true |
connectedComponents_lift_unique' | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Sort u_3} {g₁ g₂ : ConnectedComponents α → β},
g₁ ∘ ConnectedComponents.mk = g₂ ∘ ConnectedComponents.mk → g₁ = g₂ | null | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff_left._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (sᶜ ∈ f) = Disjoint (Filter.principal s) f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.