name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.AtomM.Recurse.Context.noConfusionType | Mathlib.Util.AtomM.Recurse | Sort u → Mathlib.Tactic.AtomM.Recurse.Context → Mathlib.Tactic.AtomM.Recurse.Context → Sort u | null | false |
FiberBundleCore.mk.noConfusion | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_5} →
{B : Type u_6} →
{inst : TopologicalSpace B} →
{F : Type u_7} →
{inst_1 : TopologicalSpace F} →
{P : Sort u} →
{baseSet : ι → Set B} →
{isOpen_baseSet : ∀ (i : ι), IsOpen (baseSet i)} →
{indexAt : B → ι} →
{mem_ba... | null | false |
Matroid.instPartialOrderMatroidᵣ._proof_3 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} (M₁ M₂ : Matroid.Matroidᵣ α),
M₁.toMatroid.IsRestriction M₂.toMatroid → M₂.toMatroid.IsRestriction M₁.toMatroid → M₁ = M₂ | null | false |
Std.Http.Protocol.H1.Machine.rec | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Machine dir → Sort u} →
((reader : Std.Http.Protocol.H1.Reader dir) →
(writer : Std.Http.Protocol.H1.Writer dir) →
(config : Std.Http.Protocol.H1.Config) →
(events : Array (Std.Http.Protocol.H1.Event dir)) →
... | null | false |
_private.Std.Time.Time.HourMarker.0.Std.Time.HourMarker.toRelative.match_1 | Std.Time.Time.HourMarker | (motive : False → Sort u_1) → (x : False) → motive x | null | false |
Std.Sat.CNF.Clause.casesOn | Std.Sat.CNF.Basic | {α : Type u} →
{motive : Std.Sat.CNF.Clause α → Sort u_1} →
(t : Std.Sat.CNF.Clause α) →
((atoms : Array α) →
(polarities : ByteArray) →
(size_polarities : polarities.size = atoms.size) →
(isBool_polarities : ∀ (i : ℕ) (h : i < polarities.size), polarities[i] = 0 ∨ polari... | null | false |
same_sub_div | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {a b : K}, b ≠ 0 → (b - a) / b = 1 - a / b | null | true |
CategoryTheory.IsGroupoid.recOn | Mathlib.CategoryTheory.Groupoid | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsGroupoid C → Sort u_1} →
(t : CategoryTheory.IsGroupoid C) →
((all_isIso : ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso f) → motive ⋯) → motive t | null | false |
CategoryTheory.Limits.BinaryBicone.isBilimitOfKernelInl | Mathlib.CategoryTheory.Preadditive.Biproducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
(b : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.IsLimit b.sndKernelFork → b.IsBilimit | If `b` is a binary bicone such that `b.inl` is a kernel of `b.snd`, then `b` is a bilimit
bicone. | true |
List.prev_eq_getElem_idxOf_pred_of_ne_head._proof_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, a ∈ l → List.idxOf a l - 1 < l.length | null | false |
CategoryTheory.instIsCardinalAccessibleObjOppositeFunctorTypeUliftCoyonedaOpOfIsCardinalPresentable | Mathlib.CategoryTheory.Presentable.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) (κ : Cardinal.{w}) [inst_1 : Fact κ.IsRegular]
[CategoryTheory.IsCardinalPresentable X κ],
(CategoryTheory.uliftCoyoneda.{t, v₁, u₁}.obj (Opposite.op X)).IsCardinalAccessible κ | null | true |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Ico_eq_of_Icc_pred_eq | Mathlib.Tactic.Simproc.FinsetInterval | ∀ {m n : ℤ} {s : Finset ℤ}, Finset.Icc m (n - 1) = s → Finset.Ico m n = s | null | true |
List.insertIdx_subset_cons | Mathlib.Data.List.InsertIdx | ∀ {α : Type u} (n : ℕ) (a : α) (l : List α), l.insertIdx n a ⊆ a :: l | null | true |
IndexedPartition.measurable_piecewise | Mathlib.MeasureTheory.Function.Piecewise | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {s : ι → Set α} {f : ι → α → β}
[inst_1 : MeasurableSpace β] [Countable ι] (hs : IndexedPartition s),
(∀ (i : ι), MeasurableSet (s i)) → (∀ (i : ι), Measurable (f i)) → Measurable (hs.piecewise f) | null | true |
KaehlerDifferential.tensorKaehlerEquivBase._proof_7 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTow... | null | false |
Finset.Nonempty.mul_zero | Mathlib.Algebra.GroupWithZero.Pointwise.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {s : Finset α}, s.Nonempty → s * 0 = 0 | null | true |
AlgebraicTopology.DoldKan.Γ₀NondegComplexIso_hom_f | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (i : ℕ),
(AlgebraicTopology.DoldKan.Γ₀NondegComplexIso K).hom.f i =
CategoryTheory.CategoryStruct.id ((AlgebraicTopology.DoldKan.Γ₀... | null | true |
Function.Injective.cancelCommMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : CancelCommMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Injective.cancelCommMonoid f hf on... | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt8.lt_of_le_of_ne._simp_1_3 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = b) = (a.toNat = b.toNat) | null | false |
WithTop.instOrderBot.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] [inst_1 : OrderBot α], WithTop.instOrderBot = { toBot := WithTop.instBot, bot_le := ⋯ } | null | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_isNonloopAt._simp_1_1 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsNonloopAt e x = (G.Inc e x ∧ ¬G.IsLoopAt e x) | null | false |
QuadraticMap._sizeOf_inst | Mathlib.LinearAlgebra.QuadraticForm.Basic | (R : Type u) →
(M : Type v) →
(N : Type w) →
{inst : CommSemiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : Module R M} →
{inst_3 : AddCommMonoid N} →
{inst_4 : Module R N} → [SizeOf R] → [SizeOf M] → [SizeOf N] → SizeOf (QuadraticMap R M N) | null | false |
Lean.ofExceptKernelException | Lean.Exception | {m : Type → Type} →
{α : Type} → [Monad m] → [Lean.MonadError m] → [Lean.MonadOptions m] → Except Lean.Kernel.Exception α → m α | Lift from `Except KernelException` to `m` when `m` can throw kernel exceptions. | true |
Metric.instMetricSpaceInductiveLimit._aux_6 | Mathlib.Topology.MetricSpace.Gluing | {X : ℕ → Type u_1} →
[inst : (n : ℕ) → MetricSpace (X n)] →
{f : (n : ℕ) → X n → X (n + 1)} →
{I : ∀ (n : ℕ), Isometry (f n)} → Metric.InductiveLimit I → Metric.InductiveLimit I → ENNReal | null | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.pentagon | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{W X Y Z : CategoryTheory.FreeMonoidalCategory C}, CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ | null | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | SizeOf Lean.Meta.Grind.Arith.CommRing.PolyDerivation | null | false |
Prod.isRightRegular_mk._simp_2 | Mathlib.Algebra.Regular.Prod | ∀ {R : Type u_2} {S : Type u_3} [inst : Mul R] [inst_1 : Mul S] {a : R} {b : S},
IsRightRegular (a, b) = (IsRightRegular a ∧ IsRightRegular b) | null | false |
_private.Lean.Compiler.LCNF.ElimDead.0.Lean.Compiler.LCNF.Code.elimDead._unsafe_rec | Lean.Compiler.LCNF.ElimDead | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.M✝ (Lean.Compiler.LCNF.Code pu) | null | false |
Nat.pair_eq_pair._simp_1 | Mathlib.Data.Nat.Pairing | ∀ {a b c d : ℕ}, (Nat.pair a b = Nat.pair c d) = (a = c ∧ b = d) | null | false |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.collectLevelAux.match_1 | Lean.Meta.Closure | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
((u v : Lean.Level) → (h : u = v.succ) → motive (namedPattern u v.succ h)) →
((u v w : Lean.Level) → (h : u = v.max w) → motive (namedPattern u (v.max w) h)) →
((u v w : Lean.Level) → (h : u = v.imax w) → motive (namedPattern u (v.imax w) h)) →
... | null | false |
CategoryTheory.MonoidalCategory.tensorIso._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y X' Y' : C} (f : X ≅ Y) (g : X' ≅ Y'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f.hom g.hom)
(CategoryTheory.MonoidalCategoryStruct.tensorHom f.inv g.inv) ... | null | false |
orderEmbeddingOfInjective | Mathlib.Order.Hom.Lattice | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : SemilatticeInf α] →
[inst_2 : SemilatticeInf β] → (f : F) → [InfHomClass F α β] → Function.Injective ⇑f → α ↪o β | We can regard an injective map preserving binary infima as an order embedding. | true |
_private.Mathlib.Analysis.Convex.StrictConvexBetween.0.dist_add_dist_eq_iff._simp_1_1 | Mathlib.Analysis.Convex.StrictConvexBetween | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E}, (x ∈ segment 𝕜 y z) = SameRay 𝕜 (x - y) (z - x) | null | false |
RingHom.equivIntAlgHom_symm_apply | Mathlib.Algebra.Algebra.Hom | ∀ (R : Type u_1) (S : Type u_2) [inst : Ring R] [inst_1 : Ring S] (self : R →ₐ[ℤ] S),
(RingHom.equivIntAlgHom R S).symm self = self.toRingHom | null | true |
Std.ExtTreeMap.forM_eq_forM_keys | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} {m : Type w → Type w'}
[inst : Std.TransCmp cmp] [inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}},
(forM t fun a => f a.1) = t.keys.forM f | null | true |
Std.ExtHashSet.size_ofList | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α},
List.Pairwise (fun a b => (a == b) = false) l → (Std.ExtHashSet.ofList l).size = l.length | null | true |
AffineIndependent.range | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} {p : ι → P}, AffineIndependent k p → AffineIndependent k fun x => ↑x | If an indexed family of points is affinely independent, so is the
corresponding set of points. | true |
_private.Init.Data.Dyadic.Instances.0.Dyadic.instCommRing._simp_1 | Init.Data.Dyadic.Instances | ∀ {x y : Dyadic}, (x = y) = (x.toRat = y.toRat) | null | false |
Pi.smul'.eq_1 | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {α : ι → Type u_4} {β : ι → Type u_5} [inst : (i : ι) → SMul (α i) (β i)],
Pi.smul' = { smul := fun s x i => s i • x i } | null | true |
CategoryTheory.LiftsToColimit.ctorIdx | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | null | false |
Mathlib.Tactic.Zify._aux_Mathlib_Tactic_Zify___macroRules_Mathlib_Tactic_Zify_zify_1 | Mathlib.Tactic.Zify | Lean.Macro | null | false |
TypeVec.subtypeVal.eq_def | Mathlib.Data.TypeVec | ∀ (x : ℕ) (x_1 : TypeVec.{u} x) (x_2 : x_1.Arrow (TypeVec.repeat x Prop)) (x_3 : Fin2 x),
TypeVec.subtypeVal x_2 x_3 =
match (motive :=
(x : ℕ) →
(x_4 : TypeVec.{u} x) →
(x_5 : x_4.Arrow (TypeVec.repeat x Prop)) → (x_6 : Fin2 x) → TypeVec.Subtype_ x_5 x_6 → x_4 x_6)
x, x_1, x_2, x_3 ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_insertMany_list_le._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
MeasureTheory.measure_inv_smul_symmDiff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
(μ : MeasureTheory.Measure α) [MeasureTheory.SMulInvariantMeasure G α μ] (c : G) (s t : Set α),
μ (symmDiff (c⁻¹ • s) t) = μ (symmDiff s (c • t)) | null | true |
Lean.Server.ReferencedObject.mk.injEq | Lean.Server.Rpc.Basic | ∀ (obj : Dynamic) (id : USize) (rc : ℕ) (obj_1 : Dynamic) (id_1 : USize) (rc_1 : ℕ),
({ obj := obj, id := id, rc := rc } = { obj := obj_1, id := id_1, rc := rc_1 }) =
(obj = obj_1 ∧ id = id_1 ∧ rc = rc_1) | null | true |
Mathlib.Tactic.Matrix.ofList._unsafe_rec | Mathlib.Tactic.Matrix.OfLists | {α : Type u_1} → [Zero α] → (n : ℕ) → List α → Fin n → α | null | false |
Std.Http.Header.Name | Std.Http.Data.Headers.Name | Type | A validated HTTP header name that ensures all characters conform to HTTP standards. Header names are
case-insensitive according to HTTP specifications.
Reference: https://www.rfc-editor.org/rfc/rfc9110.html#name-field-names
| true |
PartialHomeomorph.homeomorphOfImageSubsetSource._proof_1 | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialHomeomorph X Y)
{s : Set X} {t : Set Y}, ↑e '' s = t → Set.MapsTo (↑e) s t | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.ofSubtype_eq_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, (f = g) = ∀ (x : α), f x = g x | null | false |
Lean.Meta.Config.noConfusion | Lean.Meta.Basic | {P : Sort u} → {t t' : Lean.Meta.Config} → t = t' → Lean.Meta.Config.noConfusionType P t t' | null | false |
GrpCat.FilteredColimits.G | Mathlib.Algebra.Category.Grp.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] → [CategoryTheory.IsFiltered J] → CategoryTheory.Functor J GrpCat → MonCat | The colimit of `F ⋙ forget₂ GrpCat MonCat` in the category `MonCat`.
In the following, we will show that this has the structure of a group.
| true |
CategoryTheory.SimplicialObject.δ_comp_σ_succ | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : ℕ}
{i : Fin (n + 1)},
CategoryTheory.CategoryStruct.comp (X.σ i) (X.δ i.succ) =
CategoryTheory.CategoryStruct.id (X.obj (Opposite.op { len := n })) | The second part of the third simplicial identity | true |
SSet.Subcomplex.image_inv | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (A : Y.Subcomplex) (f : X ⟶ Y) [inst : CategoryTheory.IsIso f],
A.image (CategoryTheory.inv f) = A.preimage f | null | true |
LieDerivation.mk.sizeOf_spec | 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]
[inst_7 : SizeOf R] [inst_8 : SizeOf L] [inst_9 : SizeOf M] (toLinearMap : L →ₗ[R] M)
(leibniz' ... | null | true |
CategoryTheory.Functor.Braided.copy._proof_1 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F : Categ... | null | false |
CategoryTheory.instIsIsoOverInferInstanceOverClass | Mathlib.CategoryTheory.Comma.Over.OverClass | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (S : C), CategoryTheory.IsIso (S ↘ S) | null | true |
LinearEquiv.instCoeLinearMap | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
... | null | true |
WithBot.preimage_coe_Ico | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, WithBot.some ⁻¹' Set.Ico ↑b ↑a = Set.Ico b a | null | true |
MeasureTheory.SimpleFunc.instNonAssocRing | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} →
{β : Type u_2} → [inst : MeasurableSpace α] → [NonAssocRing β] → NonAssocRing (MeasureTheory.SimpleFunc α β) | null | true |
_private.Init.Data.Order.LemmasExtra.0.Std.min_le_min | Init.Data.Order.LemmasExtra | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Min α] [Std.LawfulOrderLeftLeaningMin α] [Std.IsLinearOrder α] (a b : α),
a ⊓ b ≤ b ⊓ a | null | true |
CategoryTheory.objDown_objUp | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} (A : C), (CategoryTheory.ULiftHom.objUp A).objDown = A | null | true |
MulRingNorm.noConfusion | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {P : Sort u} →
{R : Type u_2} →
{inst : NonAssocRing R} →
{t : MulRingNorm R} →
{R' : Type u_2} →
{inst' : NonAssocRing R'} →
{t' : MulRingNorm R'} → R = R' → inst ≍ inst' → t ≍ t' → MulRingNorm.noConfusionType P t t' | null | false |
MvQPF.rec | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} →
{F : TypeVec.{u} n → Type u_1} →
{motive : MvQPF F → Sort u_2} →
([toMvFunctor : MvFunctor F] →
(P : MvPFunctor.{u} n) →
(abs : {α : TypeVec.{u} n} → ↑P α → F α) →
(repr : {α : TypeVec.{u} n} → F α → ↑P α) →
(abs_repr : ∀ {α : TypeVec.{u} n} (x :... | null | false |
WittVector.map_id | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)],
WittVector.map (RingHom.id R) = RingHom.id (WittVector p R) | null | true |
SimplexCategory.toTop_obj | Mathlib.AlgebraicTopology.TopologicalSimplex | ∀ (X : SimplexCategory),
SimplexCategory.toTop.{u}.obj X = TopCat.uliftFunctor.obj ↧(Convexity.StdSimplex ℝ (Fin (X.len + 1))) | null | true |
Real.tan_sub_int_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℤ), Real.tan (x - ↑n * Real.pi) = Real.tan x | null | true |
Lean.Syntax.getHeadInfo? | Init.Prelude | Lean.Syntax → Option Lean.SourceInfo | Retrieve the left-most node or leaf's info in the Syntax tree. | true |
Lean.Grind.AC.superpose_tail_idempotent_cert.eq_1 | Init.Grind.AC | ∀ (x : Lean.Grind.AC.Var) (lhs₁ rhs₁ rhs : Lean.Grind.AC.Seq),
Lean.Grind.AC.superpose_tail_idempotent_cert x lhs₁ rhs₁ rhs =
(lhs₁.endsWithVar_k x && rhs.beq' (rhs₁.concat (Lean.Grind.AC.Seq.var x))) | null | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.Complex.cderiv_sub._simp_1_2 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {M : Type u_1} {A : Type u_7} [inst : AddGroup A] [inst_1 : DistribSMul M A] (r : M) (x y : A),
r • x - r • y = r • (x - y) | null | false |
Std.Iter.noConfusion | Init.Data.Iterators.Basic | {P : Sort u} →
{α β : Type w} →
{t : Std.Iter β} →
{α' β' : Type w} → {t' : Std.Iter β'} → α = α' → β = β' → t ≍ t' → Std.Iter.noConfusionType P t t' | null | false |
CategoryTheory.Limits.HasPushouts | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A category `HasPushouts` if it has all colimits of shape `WalkingSpan`, i.e. if it has a
pushout for every pair of morphisms with the same domain. | true |
Multiset.mem_join | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {a : α} {S : Multiset (Multiset α)}, a ∈ S.join ↔ ∃ s ∈ S, a ∈ s | null | true |
Std.Sat.AIG.mkConst.eq_1 | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (val : Bool),
aig.mkConst val =
{
aig :=
{ decls := aig.decls.push Std.Sat.AIG.Decl.false, cache := aig.cache.noUpdate, hdag := ⋯, hzero := ⋯,
hconst := ⋯ },
ref := { gate := aig.decls.size, invert := val... | null | true |
Lean.Data.Trie._sizeOf_3 | Lean.Data.Trie | {α : Type} → [SizeOf α] → List (Lean.Data.Trie α) → ℕ | null | false |
DifferentiableWithinAt.fun_sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{s : Set E} {ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s... | Eta-expanded form of `DifferentiableWithinAt.sum` | true |
FunLike.coe_smul._simp_1 | Mathlib.Algebra.Group.IsApply | ∀ {M : Type u_1} {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : SMul M F]
[inst_2 : SMul M β] [IsSMulApply M F α β] (n : M) (f : F), n • ⇑f = ⇑(n • f) | null | false |
String.Slice.copy_dropSuffix?_copy | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat]
[inst_1 : String.Slice.Pattern.Model.PatternModel pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s : String.Slice},
Option.map String.Slice.copy (s.copy.dropSuffix? pat) = Option.map String.Slice.copy (s.dropSuffix? pat) | null | true |
Plausible.Gen.oneOf._auto_1 | Plausible.Gen | Lean.Syntax | null | false |
forall_or_of_or_forall | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_3} {p : α → Prop} {b : Prop}, (b ∨ ∀ (x : α), p x) → ∀ (x : α), b ∨ p x | null | true |
Mathlib.Meta.NormNum.evalNatSucc | Mathlib.Tactic.NormNum.Basic | Mathlib.Meta.NormNum.NormNumExt | The `norm_num` extension which identifies expressions of the form `Nat.succ a`,
such that `norm_num` successfully recognises `a`. | true |
OrderEmbedding.coe_subtype | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} [inst : Preorder α] (p : α → Prop), ⇑(OrderEmbedding.subtype p) = Subtype.val | null | true |
CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | null | false |
IsChain.empty._simp_1 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop}, IsChain r ∅ = True | null | false |
CategoryTheory.Regular.strongEpiMonoFactorisation._proof_4 | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Regular C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.StrongEpi
(CategoryTheory.Limits.coequalizer.π (CategoryTheory.Limits.pullback.fst f f)
(CategoryTheory.Limits.pullback.snd f f)) | null | false |
WeierstrassCurve.VariableChange.map._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} [inst_1 : CommRing A], MonoidHomClass (R →+* A) R A | null | false |
PowerSeries.trunc_trunc_mul_trunc | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_2} [inst : CommSemiring R] {n : ℕ} (f g : PowerSeries R),
(PowerSeries.trunc n) (↑((PowerSeries.trunc n) f) * ↑((PowerSeries.trunc n) g)) = (PowerSeries.trunc n) (f * g) | null | true |
String.Slice.Pattern.SearchStep.endPos_matched | Init.Data.String.Pattern.Basic | ∀ {s : String.Slice} {p q : s.Pos}, (String.Slice.Pattern.SearchStep.matched p q).endPos = q | null | true |
CategoryTheory.Functor.IsCoverDense.restrictHomEquivHom_naturality_left | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D} {A : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] {G : CategoryTheory.Functor C D} [inst_3 : G.IsCoverDense K]
[inst_4 : G.IsLocall... | null | true |
IsSumSq.rec'._proof_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : Add R] [inst_2 : Zero R] {x s : R}, IsSquare x → IsSumSq s → IsSumSq (x + s) | null | false |
DifferentiableAt.mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {𝔸 : Type u_4} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a b : E → 𝔸},
DifferentiableAt 𝕜 a x → DifferentiableAt 𝕜 b x → DifferentiableAt 𝕜 (a * b) x | null | true |
CategoryTheory.Comma.isoMk._proof_5 | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
{L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁}
(l : X.left ≅ Y.left) ... | null | false |
Lean.Meta.SynthInstance.State.resumeStack | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.State → Array (Lean.Meta.SynthInstance.ConsumerNode × Lean.Meta.SynthInstance.Answer) | null | true |
NonUnitalSubring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [inst_2 : IsSemitopologicalRing R]
(S : NonUnitalSubring R) {a b : R},
a ∈ S.toSubsemigroup.topologicalClosure.carrier →
b ∈ S.toSubsemigroup.topologicalClosure.carrier → a * b ∈ S.toSubsemigroup.topologicalClosure.carrier | null | false |
completelyRegularSpace_iff | Mathlib.Topology.Separation.CompletelyRegular | ∀ (X : Type u) [inst : TopologicalSpace X],
CompletelyRegularSpace X ↔ ∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K | null | true |
CategoryTheory.Limits.WidePullbackCone.reindex_π | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {X : C} {Y : ι → C} {f : (i : ι) → Y i ⟶ X}
(s : CategoryTheory.Limits.WidePullbackCone f) {ι' : Type u_3} (e : ι' ≃ ι) (i : ι'), (s.reindex e).π i = s.π (e i) | null | true |
measurable_setOfPred | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1}, Measurable fun p => {a | p a} | null | true |
bernoulli'.eq_1 | Mathlib.NumberTheory.Bernoulli | ∀ (n : ℕ), bernoulli' n = 1 - ∑ k, ↑(n.choose ↑k) / (↑n - ↑↑k + 1) * bernoulli' ↑k | null | true |
CategoryTheory.Limits.lim._proof_4 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] [inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C]
{X Y Z : CategoryTheory.Functor J C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.limMap (CategoryTheory.CategoryStruct.comp f g) =
... | null | false |
finsum_mem_finset_eq_sum | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) (s : Finset α),
∑ᶠ (i : α) (_ : i ∈ s), f i = ∑ i ∈ s, f i | null | true |
AlgebraicGeometry.Scheme.Opens.birationalOver_of_dense | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X S : AlgebraicGeometry.Scheme} (U : X.Opens) (sX : X ⟶ S),
Dense ↑U → AlgebraicGeometry.Scheme.BirationalOver (CategoryTheory.CategoryStruct.comp U.ι sX) sX | A dense open set `U : Opens X` of a scheme `X` over `S` is `S`-birational to `X`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.