name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
mem_lowerBounds_univ | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ lowerBounds Set.univ ↔ IsBot a | null | true |
Matroid.restrict_eq_self_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {R : Set α}, (M.restrict R = M) = (R = M.E) | null | false |
Std.DTreeMap.Internal.Impl.insertMany_cons | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} (h : t.WF)
{l : List ((a : α) × β a)} {k : α} {v : β k},
↑(t.insertMany (⟨k, v⟩ :: l) ⋯) = ↑((Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.insertMany l ⋯) | null | true |
Std.HashSet.Raw.ofArray | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → Array α → Std.HashSet.Raw α | Creates a hash set from an array of elements. Note that unlike repeatedly calling `insert`, if the
collection contains multiple elements that are equal (with regard to `==`), then the last element
in the collection will be present in the returned hash set.
| true |
Stream'.WSeq.get?_congr | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {s t : Stream'.WSeq α}, s ~ʷ t → ∀ (n : ℕ), (s.get? n).Equiv (t.get? n) | null | true |
IsBaseChange.of_lift_unique | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {M : Type v₁} {N : Type v₂} {S : Type v₃} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
[inst_2 : CommSemiring R] [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module R N]
[inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (f : M →ₗ[R] N),
(∀ (Q : Type (... | null | true |
FirstOrder.Language.IsFraisseLimit.recOn | Mathlib.ModelTheory.Fraisse | {L : FirstOrder.Language} →
{K : Set (CategoryTheory.Bundled L.Structure)} →
{M : Type w} →
[inst : L.Structure M] →
[inst_1 : Countable ((l : ℕ) × L.Functions l)] →
[inst_2 : Countable M] →
{motive : FirstOrder.Language.IsFraisseLimit K M → Sort u_1} →
(t : First... | null | false |
_private.Init.Data.Vector.Extract.0.Vector.extract_push._proof_3 | Init.Data.Vector.Extract | ∀ {n start stop : ℕ}, ¬stop ≤ n → start ≤ n → ¬min n n - start + 1 = min stop (n + 1) - start → False | null | false |
Ordinal.dvd_antisymm | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b : Ordinal.{u_4}}, a ∣ b → b ∣ a → a = b | null | true |
CategoryTheory.HasShift | Mathlib.CategoryTheory.Shift.Basic | (C : Type u) → (A : Type u_2) → [CategoryTheory.Category.{v, u} C] → [AddMonoid A] → Type (max (max u u_2) v) | A category has a shift indexed by an additive monoid `A`
if there is a monoidal functor from `A` to `C ⥤ C`. | true |
_private.Mathlib.Order.Zorn.0.zorn_le₀.match_1_5 | Mathlib.Order.Zorn | ∀ {α : Type u_1} [inst : Preorder α] (s : Set α) (c : Set ↑s)
(motive : (∃ ub ∈ s, ∀ z ∈ Subtype.val '' c, z ≤ ub) → Prop) (x : ∃ ub ∈ s, ∀ z ∈ Subtype.val '' c, z ≤ ub),
(∀ (ub : α) (hubs : ub ∈ s) (hub : ∀ z ∈ Subtype.val '' c, z ≤ ub), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Ring.Subring.Basic.0.Subring.top_prod._simp_1_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {s : Subring R} {t : Subring S}
{p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
uniformity_edist | Mathlib.Topology.EMetricSpace.Defs | ∀ {γ : Type u_3} [inst : EMetricSpace γ], uniformity γ = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | Reformulation of the uniform structure in terms of the extended distance | true |
_private.Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense.0.CategoryTheory.Functor.OneHypercoverDenseData.isSheaf_iff.liftAux | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type... | Auxiliary definition for `lift`. | true |
ProbabilityTheory.measurableSet_partitionFiltration_of_mem | Mathlib.Probability.Process.PartitionFiltration | ∀ {α : Type u_1} [m : MeasurableSpace α] {t : ℕ → Set α} (ht : ∀ (n : ℕ), MeasurableSet (t n)) (n : ℕ) {s : Set α},
s ∈ memPartition t n → MeasurableSet s | null | true |
List.min_map._proof_1 | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} {xs : List α} {f : α → β}, xs ≠ [] → List.map f xs ≠ [] | null | false |
Algebra.ker_algebraMap_isMaximal_of_isIntegral | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ (R : Type u_1) [inst : CommRing R] (k : Type u_6) [inst_1 : Field k] [inst_2 : Algebra R k] [Algebra.IsIntegral R k],
(RingHom.ker (algebraMap R k)).IsMaximal | null | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr.congr_simp | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} {T₁ T₂ : AlgebraicGeometry.Scheme.Pullback.Triplet f g}
(e : T₁ = T₂),
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e = AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_2 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size),
table[table.size - 1] ≤ table.size - 1 → ¬table[table.size - 1] < table.size → False | null | false |
Lean.Expr.forallName | Lean.Expr | (a : Lean.Expr) → a.isForall = true → Lean.Name | null | true |
Set.Icc_sdiff_Ioo_same._to_dual_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ≤ a → Set.Icc b a \ Set.Ioo b a = {a, b} | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.mor_eq._auto_3 | Mathlib.CategoryTheory.Sites.Descent.Precoverage | Lean.Syntax | null | false |
Std.Async.IO.AsyncStream.mk._flat_ctor | Std.Async.IO | {α : Type} → {β : outParam Type} → (α → Std.Async.Selector β) → (α → IO Unit) → Std.Async.IO.AsyncStream α β | null | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.moduleLintersRef._proof_1 | Lean.Elab.Command | Nonempty (ST.Ref IO.RealWorld (Array Lean.Elab.Command.ModuleLinter)) | null | false |
_private.Mathlib.Analysis.Calculus.SmoothSeries.0.contDiff_tsum_of_eventually._simp_1_5 | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Subgroup.instIsMulFGSubtypeProdMemProd | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {H : Subgroup G} {H' : Subgroup G'} [IsMulFG ↥H]
[IsMulFG ↥H'], IsMulFG ↥(H.prod H') | null | true |
Projectivization.Subspace.mem_span | 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 : Set (Projectivization K V)} (u : Projectivization K V),
u ∈ Projectivization.Subspace.span S ↔ ∀ (W : Projectivization.Subspace K V), S ⊆ ↑W → u ∈ W | A point in a projective space is contained in the span of a set of points if and only if the
point is contained in all subspaces of the projective space which contain the set of points. | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_475 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Batteries.Data.List.Basic.0.List.rotate'.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → ℕ → Sort u_2) (l : List α) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (l : List α) → motive l 0) (h_3 : (a : α) → (l : List α) → (n : ℕ) → motive (a :: l) n.succ),
(l = [] → False) →
(match l, 0 with
| [], x => h_1 x
| l, 0 => h_2 l
| a :: l, n.succ => h_3 a l n) ... | null | true |
_private.Std.Data.Iterators.Producers.Monadic.Array.0.Std.Iterators.Types.ArrayIterator.instFinitenessRelation | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} →
{m : Type w → Type w'} → [inst : Pure m] → Std.Iterators.FinitenessRelation (Std.Iterators.Types.ArrayIterator α) m | null | true |
_aux_Init_Notation___unexpand_HMul_hMul_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic.0.SimplexCategoryGenRel.δ_comp_δ_nat._proof_3 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ}, ∀ i < n + 2, i < n + 1 + 2 | null | false |
finprod_apply_ne_zero | Mathlib.Algebra.BigOperators.Finprod | ∀ {ι : Type u_7} {N₀ : Type u_8} {M₀ : Type u_9} [inst : CommMonoidWithZero M₀] [Nontrivial M₀] [NoZeroDivisors M₀]
{n : N₀} {f : ι → N₀ → M₀}, (∀ (i : ι), f i n ≠ 0) → (∏ᶠ (i : ι), f i) n ≠ 0 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_inter_right._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 |
MeasurableEmbedding.equivRange._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_2} {β : Type u_1} {f : α → β}, ↑(f '' Set.univ) = ↑(Set.range f) | null | false |
exists_lt_nsmul_of_neg | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {M : Type u_2} [inst : LinearOrder M] [DenselyOrdered M] {x : M} [inst_2 : AddCommGroup M]
[IsOrderedCancelAddMonoid M], x < 0 → ∀ (n : ℕ), ∃ y < 0, x < n • y | null | true |
MeasureTheory.ae_eq_dirac' | Mathlib.MeasureTheory.Measure.Dirac.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [MeasurableSingletonClass β]
{a : α} {f : α → β}, Measurable f → f =ᵐ[MeasureTheory.Measure.dirac a] Function.const α (f a) | null | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.arg.mkAnon | Lean.DocString.Parser | ℕ → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | null | true |
USize.ofInt_neg_one | Init.Data.UInt.Lemmas | USize.ofInt (-1) = -1 | null | true |
OpenPartialHomeomorph.map_nhdsWithin_eq | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {x : X},
x ∈ e.source → ∀ (s : Set X), Filter.map (↑e) (nhdsWithin x s) = nhdsWithin (↑e x) (↑e '' (e.source ∩ s)) | null | true |
infClosed_singleton._simp_1 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeInf α] {a : α}, InfClosed {a} = True | null | false |
Set.zero_mem_smul_set | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero β] [inst_1 : SMulZeroClass α β] {t : Set β} {a : α}, 0 ∈ t → 0 ∈ a • t | null | true |
Set.Subsingleton.denselyOrdered | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {s : Set α} [inst : LT α], s.Subsingleton → DenselyOrdered ↑s | null | true |
MeasureTheory.HasPDF.mk | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} {X : Ω → E}
{ℙ : MeasureTheory.Measure Ω} {μ : autoParam (MeasureTheory.Measure E) MeasureTheory.HasPDF._auto_1},
AEMeasurable X ℙ →
(MeasureTheory.Measure.map X ℙ).HaveLebesgueDecomposition μ →
(MeasureTheory.Measure.map X... | null | true |
Lean.Order.implication_order_monotone_exists | Init.Internal.Order.Basic | ∀ {α : Sort u_1} [inst : Lean.Order.PartialOrder α] {β : Sort u_2} (f : α → β → Lean.Order.ImplicationOrder),
Lean.Order.monotone f → Lean.Order.monotone fun x => Exists (f x) | null | true |
instIsAlgebraicPolynomialOfNoZeroDivisors_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[alg : Algebra.IsAlgebraic R S] [NoZeroDivisors S], Algebra.IsAlgebraic (Polynomial R) (Polynomial S) | null | true |
CategoryTheory.EnrichedNatTrans._sizeOf_1 | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
{inst : CategoryTheory.Category.{w, v} V} →
{inst_1 : CategoryTheory.MonoidalCategory V} →
{C : Type u₁} →
{inst_2 : CategoryTheory.EnrichedCategory V C} →
{D : Type u₂} →
{inst_3 : CategoryTheory.EnrichedCategory V D} →
{F G : CategoryTheory.Enrich... | null | false |
SimpleGraph.coe_recolorOfCardLE | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} (G : SimpleGraph V) {α : Type u_2} {β : Type u_3} [inst : Fintype α] [inst_1 : Fintype β]
(hαβ : Fintype.card α ≤ Fintype.card β),
⇑(G.recolorOfCardLE hαβ) = (SimpleGraph.Embedding.completeGraph ⋯.some).toHom.comp | null | true |
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.isMorApp?._sparseCasesOn_1 | Mathlib.Tactic.FunProp.Mor | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
NormedAddGroupHom.extension._proof_1 | Mathlib.Analysis.Normed.Group.HomCompletion | ∀ {G : Type u_1} [inst : SeminormedAddCommGroup G] {H : Type u_2} [inst_1 : SeminormedAddCommGroup H]
[inst_2 : T0Space H] [CompleteSpace H] (f : NormedAddGroupHom G H),
LipschitzWith ⟨‖f‖, ⋯⟩ (UniformSpace.Completion.extension ⇑f) | null | false |
NonUnitalSubsemiring.coe_equivMapOfInjective_apply | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(s : NonUnitalSubsemiring R) (f : R →ₙ+* S) (hf : Function.Injective ⇑f) (x : ↥s),
↑((s.equivMapOfInjective f hf) x) = f ↑x | null | true |
tangentSpaceCastModel | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
(I : ModelWithCorners 𝕜 E H) →
{M : Type u_4} →
... | Definitional identification between the tangent space of a manifold at a point and the
model space. *Do not use*, unless when setting up foundational properties of the tangent space:
this definition is a technical detail related to our specific implementation of tangent spaces,
but it has no mathematical meaning. The m... | true |
Lean.Elab.DefViewElabHeader.headerSnap?._inherited_default | Lean.Elab.MutualDef | Option (Lean.Language.SnapshotBundle (Option Lean.Elab.HeaderProcessedSnapshot)) | null | false |
SymAlg.instIsCommJordan | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Invertible 2], IsCommJordan αˢʸᵐ | null | true |
Rat.comap_cast_atTop | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {R : Type u_2} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [Archimedean R],
Filter.comap Rat.cast Filter.atTop = Filter.atTop | null | true |
ContMDiffWithinAt.nsmul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_3} [inst_1 : TopologicalSpace H]
{E : Type u_4} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_5}
[inst_4 : AddCommMonoid G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace ... | null | true |
FiberBundleCore.trivChange.eq_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i j : ι),
Z.trivChange i j =
{ toFun := fun p => (p.1, Z.coordChange i j p.1 p.2), invFun := fun p => (p.1, Z.coordChange j i p.1 p.2),
source := (Z.baseSet i ∩ Z.baseSet j... | null | true |
LT.lt.ssubset | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ⊂ t → s ⊂ t | **Alias** of the forward direction of `Set.lt_iff_ssubset`. | true |
_private.Mathlib.Data.Int.Init.0.Int.inductionOn'._proof_6 | Mathlib.Data.Int.Init | ∀ {motive : ℤ → Sort u_1} (b : ℤ) (n : ℕ), motive (b + Int.negSucc n - 1) = motive (b + Int.negSucc (n + 1)) | null | false |
IsIntegral.mem_range_ratCast_iff | Mathlib.RingTheory.Polynomial.RationalRoot | ∀ {α : Type u_1} [inst : DivisionRing α] [CharZero α] {x : α},
IsIntegral ℤ x → (x ∈ Set.range Rat.cast ↔ x ∈ Set.range Int.cast) | null | true |
IsSimpleOrder.mk._flat_ctor | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : LE α] [inst_1 : BoundedOrder α], (∃ x y, x ≠ y) → (∀ (a : α), a = ⊥ ∨ a = ⊤) → IsSimpleOrder α | null | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.meromorphicOrderAt_eq._simp_1_3 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {d : 𝕜 → ℤ} {x : 𝕜},
d x = 0 → ((∏ᶠ (u : 𝕜), (fun x => x - u) ^ d u) x = 0) = False | null | false |
ImportGraph.Lake.instReprBaseLibrary.repr | ImportGraph.WorkspaceModel.Base | ImportGraph.Lake.BaseLibrary → ℕ → Std.Format | null | true |
Aesop.PremiseIndex.mk.injEq | Aesop.Forward.PremiseIndex | ∀ (toNat toNat_1 : ℕ), ({ toNat := toNat } = { toNat := toNat_1 }) = (toNat = toNat_1) | null | true |
MulEquiv.mk.sizeOf_spec | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Mul M] [inst_1 : Mul N] [inst_2 : SizeOf M] [inst_3 : SizeOf N]
(toEquiv : M ≃ N) (map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y),
sizeOf { toEquiv := toEquiv, map_mul' := map_mul' } = 1 + sizeOf toEquiv | null | true |
_private.Mathlib.GroupTheory.GroupAction.Quotient.0.MulAction.finite_quotient_of_pretransitive_of_finite_quotient._simp_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | null | false |
Lean.Meta.Closure.process._unsafe_rec | Lean.Meta.Closure | Lean.Meta.Closure.ClosureM Unit | null | false |
_private.Lean.Linter.AmbiguousOpen.0.Lean.Linter.scopeCandidates._f | Lean.Linter.AmbiguousOpen | Lean.Environment → Lean.Name → (x : Lean.Name) → Lean.Name.below x → List Lean.Name | null | false |
Std.Http.URI.Builder.mk.inj | Std.Http.Data.URI.Basic | ∀ {scheme : Option Std.Http.URI.Scheme} {userInfo : Option Std.Http.URI.UserInfo} {host : Option Std.Http.URI.Host}
{port : Std.Http.URI.Port} {pathSegments : Array String} {query : Array (String × Option String)}
{fragment : Option String} {scheme_1 : Option Std.Http.URI.Scheme} {userInfo_1 : Option Std.Http.URI.U... | null | true |
CategoryTheory.Abelian.SpectralObject.liftE_ιE_fromOpcycles_assoc | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₂₃ : j ⟶ l)
(h₂₃ : CategoryTheory.CategoryStruct.... | null | true |
MulHom.coe_copy_eq | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {x : Mul M} {x_1 : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f | null | true |
Lean.Meta.Grind.CaseTrace.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{expr : Lean.Expr} →
{i num : ℕ} →
{source : Lean.Meta.Grind.SplitSource} →
{expr' : Lean.Expr} →
{i' num' : ℕ} →
{source' : Lean.Meta.Grind.SplitSource} →
{ expr := expr, i := i, num := num, source := source } =
{ expr := expr', i... | null | false |
LightDiagram'.diagram | Mathlib.Topology.Category.LightProfinite.Basic | LightDiagram' → CategoryTheory.Functor ℕᵒᵖ FintypeCat.Skeleton | The diagram takes values in a small category equivalent to `FintypeCat`. | true |
ContinuousMap.instNormedRing._proof_7 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_1} [inst_2 : NormedRing R] (n : ℕ),
↑(n + 1) = ↑n + 1 | null | false |
Lean.Meta.Occurrences.neg.noConfusion | Init.MetaTypes | {P : Sort u} →
{idxs idxs' : List ℕ} → Lean.Meta.Occurrences.neg idxs = Lean.Meta.Occurrences.neg idxs' → (idxs = idxs' → P) → P | null | false |
CategoryTheory.ComonadHom._sizeOf_1 | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{M N : CategoryTheory.Comonad C} → [SizeOf C] → CategoryTheory.ComonadHom M N → ℕ | null | false |
TensorProduct.piScalarRightHomBil | Mathlib.LinearAlgebra.TensorProduct.Pi | (R : Type u_1) →
[inst : CommSemiring R] →
(S : Type u_2) →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
(N : Type u_3) →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
[inst_5 : Module S N] → [inst_6 : IsScalarTower R S N] → (ι : Typ... | Internal implementation detail: we should make this `private`. | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.CyclotomicField.isCyclotomicExtension._simp_2 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
Lean.getPPInstantiateMVars | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → Bool | null | true |
Topology.IsEmbedding.subtypeVal | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop}, Topology.IsEmbedding Subtype.val | null | true |
_private.Init.Data.Array.Range.0.Array.range'.eq_1 | Init.Data.Array.Range | ∀ (start size step : ℕ), Array.range' start size step = Array.ofFn fun i => start + step * ↑i | null | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.UpperHalfPlane.norm_ρ._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
CategoryTheory.RelCat.graphFunctor._proof_1 | Mathlib.CategoryTheory.Category.RelCat | ∀ (X : Type u_1),
{ rel := Function.graph ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) } =
CategoryTheory.CategoryStruct.id X | null | false |
Lean.Meta.Cache.mk | Lean.Meta.Basic | Lean.Meta.InferTypeCache →
Lean.Meta.FunInfoCache →
Lean.Meta.SynthInstanceCache → Lean.Meta.WhnfCache → Lean.Meta.DefEqCache → Lean.Meta.DefEqCache → Lean.Meta.Cache | null | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxs_cons._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {xs : List α} {p : α → Bool} {s : ℕ},
List.findIdxs p (x :: xs) s = if p x = true then s :: List.findIdxs p xs (s + 1) else List.findIdxs p xs (s + 1) | null | false |
Ideal.IsLocal.casesOn | Mathlib.RingTheory.Jacobson.Ideal | {R : Type u} →
[inst : CommRing R] →
{I : Ideal R} →
{motive : I.IsLocal → Sort u_1} → (t : I.IsLocal) → ((out : I.jacobson.IsMaximal) → motive ⋯) → motive t | null | false |
Lake.BuildTrace | Lake.Build.Trace | Type | Trace used for common Lake targets. Combines `Hash` and `MTime`. | true |
FGModuleRepr.instAddCommGroupRepr._proof_20 | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | ∀ {R : Type u_1} [inst : Ring R] (x : FGModuleRepr R),
autoParam (∀ (n : ℕ) (a : x.repr), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Std.HashSet.forIn_eq_forIn | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} {δ : Type v} {m' : Type v → Type w} [inst : Monad m']
[LawfulMonad m'] {f : α → δ → m' (ForInStep δ)} {init : δ}, forIn m init f = forIn m init f | null | true |
MulAction.orbit | Mathlib.GroupTheory.GroupAction.Defs | (γ : Type u_2) → {α : Type u_3} → [SMul γ α] → α → Set α | The orbit of an element under an action. | true |
Nat.instMax | Init.Data.Nat.Basic | Max ℕ | null | true |
TopCat.Hom._mkInternal | Mathlib.Topology.Category.TopCat.Basic | {X Y : TopCat} → C(↑X, ↑Y) → X.Hom Y | null | false |
CategoryTheory.η_ε_app | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) (X : C)
[inst_3 : F.Monoidal],
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functo... | null | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.cast._proof_3 | Mathlib.Logic.Equiv.Defs | ∀ {α β : Sort u_1} (h : α = β), Function.RightInverse (cast ⋯) (cast h) | null | false |
LieSubalgebra.coe_set_eq._simp_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(L₁' L₂' : LieSubalgebra R L), (↑L₁' = ↑L₂') = (L₁' = L₂') | null | false |
Aesop.Goal.setAddedInIteration | Aesop.Tree.Data | Aesop.Iteration → Aesop.Goal → Aesop.Goal | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence_eq_prefixFunction._proof_1_4 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ 0 + 1 →
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≠ 1 →
¬String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ p... | null | false |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Submodule.range_lsum_smul._simp_1_1 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⊤ = Submodule.span R {x | ∃ i x_1, (fun₀ | i => x_1) = x} | null | false |
Std.DTreeMap.Internal.Impl.rotateL.fun_cases_unfolding | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (rk : α) (rv : β rk)
(rr : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (rl : Std.DTreeMap.Internal.Impl α β),
rl.size < Std.DTreeMap.Internal.ratio... | null | true |
Ordinal.omega0_opow_mul_nat_lt | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b : Ordinal.{u_1}}, a < b → ∀ (n : ℕ), Ordinal.omega0 ^ a * ↑n < Ordinal.omega0 ^ b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.