name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.mk._flat_ctor | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} → {s : String.Slice} → s.Pos → String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher pat s | null | false |
LinearMap.addMonoid._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {M : Type u_3} {M₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} (a b c : M →ₛₗ[σ₁₂] M₂), a + b + c = a + (b + c) | null | false |
CategoryTheory.FreeGroupoid.liftNatIso.eq_1 | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : Type u₁} [inst_1 : CategoryTheory.Groupoid G]
(F₁ F₂ : CategoryTheory.Functor (CategoryTheory.FreeGroupoid C) G)
(τ : (CategoryTheory.FreeGroupoid.of C).comp F₁ ≅ (CategoryTheory.FreeGroupoid.of C).comp F₂),
CategoryTheory.FreeGroupoid.liftNatIso F₁ F₂... | null | true |
CategoryTheory.SingleFunctors.Hom.ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {A : Type u_5} {inst_2 : AddMonoid A}
{inst_3 : CategoryTheory.HasShift D A} {F G : CategoryTheory.SingleFunctors C D A} {x y : F.Hom G},
x = y ↔ x.hom = y.hom | null | true |
Homotopy.compRight._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i : ι),
(CategoryTheory.CategoryStruct.comp e g).f i =
(((dNext i) fun i j => CategoryTheory.C... | null | false |
Lean.Elab.Info | Lean.Elab.InfoTree.Types | Type | Header information for a node in `InfoTree`. | true |
StrictConvexOn.add_convexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : DistribMulAction 𝕜 β] {s : Set E} {f g : E → β},
StrictConvexOn 𝕜 s f → Conv... | null | true |
CategoryTheory.StructuredArrow.subobjectEquiv._proof_6 | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {S : D} {T : CategoryTheory.Functor C D}
[inst_2 : CategoryTheory.Limits.HasFiniteLimits C] [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits T]
(A : CategoryTheory.StructuredArrow S T... | null | false |
DiscreteTiling.PlacedTile.coe_smul | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} (g : G) (pt : DiscreteTiling.PlacedTile ps), ↑(g • pt) = g • ↑pt | null | true |
Lean.Elab.Tactic.Omega.MetaProblem.mk | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.Problem →
List Lean.Expr → List Lean.Expr → Std.HashSet Lean.Expr → Lean.Elab.Tactic.Omega.MetaProblem | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.pullbackToBaseIsOpenImmersion | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
[hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z)
[inst_1 : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion g],
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion
(CategoryT... | null | true |
WithBot.coe_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α}, ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_alter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
BoundedOrderHom.cancel_right | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedOrder γ] {g₁ g₂ : BoundedOrderHom β γ}
{f : BoundedOrderHom α β}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.match_50.splitter | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(cond ifTrue ifFalse : Std.Sat.AIG.Fanin) →
(hltt : ifTrue.gate < upper) →
(cstate : Std.Sat.AIG.toCNF.State✝ aig) →
(motive : { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ cstate out ifTrue.gate ⋯ } → Sort ... | null | true |
smul_mem_fixedPoints_of_normal | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {H : Subgroup G} [hH : H.Normal] (g : G)
{a : α}, a ∈ MulAction.fixedPoints (↥H) α → g • a ∈ MulAction.fixedPoints (↥H) α | null | true |
Lean.Elab.Info.ofErrorNameInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i i' : Lean.Elab.ErrorNameInfo} →
Lean.Elab.Info.ofErrorNameInfo i = Lean.Elab.Info.ofErrorNameInfo i' → (i = i' → P) → P | null | false |
WithBot.bot_wcovBy_coe._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (⊥ ⩿ ↑a) = IsMin a | null | false |
CategoryTheory.MorphismProperty.Comma.mapLeftComp | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(R : CategoryTheory.Functor B T) →
{P : CategoryTheory.MorphismPr... | The functor `P.Comma L₁ R Q W ⥤ P.Comma L₃ R Q W` induced by the composition of two natural
transformations `l : L₁ ⟶ L₂` and `l' : L₂ ⟶ L₃` is naturally isomorphic to the composition of the
two functors induced by these natural transformations. | true |
Std.DHashMap.Internal.Raw₀.Const.wf_insertManyIfNewUnit₀ | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w} [inst_4 : ForIn Id ρ α]
{m : Std.DHashMap.Raw α fun x => Unit} {h : 0 < m.buckets.size} {l : ρ},
m.WF → (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m, h⟩ l)).WF | null | true |
Num.Prime | Mathlib.Data.Num.Prime | Num → Prop | Primality predicate for a `Num`. | true |
Cycle.prev | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (s : Cycle α) → s.Nodup → (x : α) → x ∈ s → α | Given a `s : Cycle α` such that `Nodup s`, retrieve the previous element before `x ∈ s`. | true |
Matrix.kroneckerMap_transpose | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
(f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β),
Matrix.kroneckerMap f A.transpose B.transpose = (Matrix.kroneckerMap f A B).transpose | null | true |
contDiffWithinAt_inter | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s t : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, t ∈ nhds x → (ContDiffWithinAt 𝕜 n f (s ∩ t) x ↔ ContDiffWithin... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Defs.0.RootPairing.isFixedPt_reflectionPerm_iff._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {i j : ι},
((P.reflectionPerm i) j = j) = (P.pairing j i • P.root i = 0) | null | false |
Lake.SemVerCore.instLT | Lake.Util.Version | LT Lake.SemVerCore | null | true |
BoxIntegral.Integrable.convergenceR | Mathlib.Analysis.BoxIntegral.Basic | {ι : Type u} →
{E : Type v} →
{F : Type w} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{I : BoxIntegral.Box ι} →
[inst_4 : Fintype ι] →
{l : BoxInte... | If `ε > 0`, then `BoxIntegral.Integrable.convergenceR` is a function `r : ℝ≥0 → ℝⁿ → (0, ∞)`
such that for every `c : ℝ≥0`, for every tagged partition `π` subordinate to `r` (and satisfying
additional distortion estimates if `BoxIntegral.IntegrationParams.bDistortion l = true`), the
corresponding integral sum is `ε`-cl... | true |
CategoryTheory.Monoidal.rightUnitor_hom_app | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] {F : CategoryTheory.Functor C D} {X : C},
(CategoryTheory.MonoidalCategoryStruct.rightUnitor F).hom.app X =
(CategoryTheory.MonoidalCategoryStruct.... | null | true |
Array.getElem?_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {as : Array α} {bs : Array β} {f : α → β → γ} {i : ℕ},
(Array.zipWith f as bs)[i]? =
match as[i]?, bs[i]? with
| some a, some b => some (f a b)
| x, x_1 => none | See also `getElem?_zipWith'` for a variant
using `Option.map` and `Option.bind` rather than a `match`.
| true |
ModuleCat.localizedModuleMap._proof_2 | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Small.{u_2, u_1} R] {N : ModuleCat R} (S : Submonoid R),
SMulCommClass (Localization S) R ↑(N.localizedModule S) | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle_mul_norm_mul_norm._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
SkewMonoidAlgebra.instNonAssocRing._proof_9 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_2} {G : Type u_1} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k], ↑0 = 0 | null | false |
Std.ExtDHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIf... | null | true |
_private.Mathlib.Analysis.Asymptotics.Prod.0.Asymptotics.IsBigO.comp_fst.match_1_3 | Mathlib.Analysis.Asymptotics.Prod | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α}
(motive : (∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖) → Prop) (x : ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖),
(∀ (c : ℝ) (hc : ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖), motive ⋯) → motive x | null | false |
MvPFunctor.castLastB | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → {a a' : P.A} → a = a' → P.last.B a → P.last.B a' | Proof of type equality as a function | true |
mul_le_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {b c : α} [inst : Mul α] [inst_1 : LE α] [i : MulRightMono α], b ≤ c → ∀ (a : α), b * a ≤ c * a | null | true |
Finsupp.support_smul_eq | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_3} {R : Type u_6} [inst : Semiring R] [IsDomain R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [Module.IsTorsionFree R M] {b : R}, b ≠ 0 → ∀ {g : α →₀ M}, (b • g).support = g.support | null | true |
AddSubgroup.addOrderOf_mk | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (a : G) (ha : a ∈ H), addOrderOf ⟨a, ha⟩ = addOrderOf a | null | true |
Int.neg_inj | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, -a = -b ↔ a = b | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.IterM.toArray_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | null | true |
FirstOrder.Language.DefinableSet.instSetLike._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective Subtype.val | null | false |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.eq._simp_1_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.exists_mem_support_mem_erase_mem_support_takeUntil_eq_empty._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ∀ x ∈ p.support, x ∈ p.support | null | false |
Lean.Lsp.instInhabitedCallHierarchyIncomingCall.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CallHierarchyIncomingCall | null | true |
CategoryTheory.Limits.hasLimitsOfShape_thinSkeleton | Mathlib.CategoryTheory.Limits.Skeleton | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} C]
[Quiver.IsThin C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.ThinSkeleton C) | null | true |
FormalMultilinearSeries.unshift._proof_3 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_3} {E : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F], ContinuousAdd (E →L[𝕜] F) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isPath_iff_isSubwalk_imp_nil._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (i j : ℕ),
j < p.support.length → i < j → ¬((p.take j).drop i).Nil | null | false |
AlgebraicGeometry.IsClosedImmersion.lift_fac_assoc | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g) {Z_1 : AlgebraicGeometry.Scheme}
(h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g... | null | true |
CategoryTheory.MonoidalCategory.Arrow.PullbackHom.isInitialIso_hom_left | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.Arrow C) {I : C}
(i : CategoryTheory.Limits.IsIn... | null | true |
Filter.Germ.LiftRel | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → {l : Filter α} → (β → γ → Prop) → l.Germ β → l.Germ γ → Prop | Lift a relation `r : β → γ → Prop` to `Germ l β → Germ l γ → Prop`. | true |
Finset.HasAntidiagonal.sigmaAntidiagonalEquivProd_apply | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} [inst : Add A] [inst_1 : Finset.HasAntidiagonal A]
(x : (n : A) × ↥(Finset.HasAntidiagonal.antidiagonal n)), Finset.HasAntidiagonal.sigmaAntidiagonalEquivProd x = ↑x.snd | null | true |
DivisorChain.eq_pow_second_of_chain_of_has_chain | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [UniqueFactorizationMonoid M] {q : Associates M} {n : ℕ},
n ≠ 0 →
∀ {c : Fin (n + 1) → Associates M},
StrictMono c → (∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i) → q ≠ 0 → q = c 1 ^ n | null | true |
Lean.IR.CollectUsedDecls.collectFnBody | Lean.Compiler.IR.EmitUtil | Lean.IR.FnBody → Lean.IR.CollectUsedDecls.M Unit | null | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1 | Mathlib.Algebra.Homology.ExactSequenceFour | Lean.Syntax | null | false |
NNRat.cast_inj._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, (↑p = ↑q) = (p = q) | null | false |
SimplexCategory.δ₀Iter_δ'._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | Lean.Syntax | null | false |
UpperHalfPlane.atImInfty.eq_1 | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | UpperHalfPlane.atImInfty = Filter.comap UpperHalfPlane.im Filter.atTop | null | true |
Cardinal.mk_sum | Mathlib.SetTheory.Cardinal.Defs | ∀ (α : Type u) (β : Type v),
Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
MeasureTheory.Measure.instRegularOfIsHaarMeasureOfCompactSpace | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[BorelSpace G] [CompactSpace G] (μ : MeasureTheory.Measure G) [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ], μ.Regular | null | true |
LinearIsometryEquiv.piLpCongrRight._proof_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {𝕜 : Type u_4} {ι : Type u_1} {α : ι → Type u_3} {β : ι → Type u_2} [hp : Fact (1 ≤ p)]
[inst : Fintype ι] [inst_1 : Semiring 𝕜] [inst_2 : (i : ι) → SeminormedAddCommGroup (α i)]
[inst_3 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_4 : (i : ι) → Module 𝕜 (α i)]
[inst_5 : (i : ι) → Module 𝕜 ... | null | false |
Lean.Widget.instFromJsonRpcEncodablePacket.fromJson._@.Lean.Widget.Types.3328362917._hygCtx._hyg.14 | Lean.Widget.Types | Lean.Json → Except String Lean.Widget.RpcEncodablePacket✝ | null | false |
preordToCat._proof_1 | Mathlib.Order.Category.Preord | ∀ (X : Preord), ⋯.functor.toCatHom = CategoryTheory.CategoryStruct.id ↧↑X | null | false |
CategoryTheory.IsSplitEpi.exists_splitEpi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.IsSplitEpi f],
Nonempty (CategoryTheory.SplitEpi f) | There is a splitting | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.mkIterator.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.mkIterator s = { s := s, i := 0 } | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_280 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Lean.Environment.AddConstAsyncResult.mainEnv | Lean.Environment | Lean.Environment.AddConstAsyncResult → Lean.Environment | Resulting "main branch" environment which contains the declaration name as an asynchronous
constant. Accessing the constant or kernel environment will block until the corresponding
`AddConstAsyncResult.commit*` function has been called.
| true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.isIso_functor_map_hom_h_f._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (k : ℕ) {q₁ : ℕ}, q₁ ≤ q₁ + k | null | false |
Lean.Meta.Grind.TopSort.State.permMark._default | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr | null | false |
linearIndepOn_finset_iff | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} {s : Finset ι}, LinearIndepOn R v ↑s ↔ ∀ (f : ι → R), ∑ i ∈ s, f i • v i = 0 → ∀ i ∈ s, f i = 0 | null | true |
Lean.Server.TransientWorkerILean.hasRefs | Lean.Server.References | Lean.Server.TransientWorkerILean → Bool | Determines whether this transient worker ILean includes actual references. | true |
Polynomial.derivRootWeight.eq_1 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ (P : Polynomial ℂ) (z w : ℂ),
P.derivRootWeight z w =
if Polynomial.eval z P = 0 then Pi.single z 1 w else ↑(Polynomial.rootMultiplicity w P) / ‖z - w‖ ^ 2 | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._simp_1_4 | Mathlib.Topology.Sets.VietorisTopology | ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → (m₁.diff m₂ ⋯).getKeyD k fallback = m₁.getKeyD k fallback | null | true |
UniformFun.lipschitzWith_ofFun_iff | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace γ] [inst_1 : PseudoEMetricSpace β]
{f : γ → α → β} {K : NNReal},
(LipschitzWith K fun x => UniformFun.ofFun (f x)) ↔ ∀ (c : α), LipschitzWith K fun x => f x c | null | true |
Std.DTreeMap.Internal.Cell.ofEq.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (k' : α) (v' : β k')
(hcmp : ∀ [Std.OrientedOrd α], k k' = Ordering.eq),
Std.DTreeMap.Internal.Cell.ofEq k' v' hcmp = { inner := some ⟨k', v'⟩, property := ⋯ } | null | true |
Std.ExtDTreeMap.Const.size_le_size_insertMany_list | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)}, t.size ≤ (Std.ExtDTreeMap.Const.insertMany t l).size | null | true |
_private.Mathlib.RingTheory.IsPrimary.0.Submodule.isPrimary_iff_zero_divisor_quotient_imp_nilpotent_smul._simp_1_3 | Mathlib.RingTheory.IsPrimary | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) | null | false |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Basic.0.Nat.Internal.Linear.Expr.applyPerm.go._sunfold | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Perm → Nat.Internal.Linear.Expr → Nat.Internal.Linear.Expr | null | false |
Partition.instIsTransRel | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {u : Set α} (P : Partition u), IsTrans α P.Rel | null | true |
LocallyFiniteOrder.toLocallyFiniteOrderTop._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : OrderTop α] (a x : α),
x ∈ Finset.Icc a ⊤ ↔ a ≤ x | null | false |
Prod.continuousNeg | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ {G : Type u_1} {H : Type u_2} [inst : TopologicalSpace G] [inst_1 : Neg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace H] [inst_4 : Neg H] [ContinuousNeg H], ContinuousNeg (G × H) | null | true |
_private.Init.System.IO.0.System.FilePath.isDir.match_1 | Init.System.IO | (motive : Except IO.Error IO.FS.Metadata → Sort u_1) →
(__do_lift : Except IO.Error IO.FS.Metadata) →
((m : IO.FS.Metadata) → motive (Except.ok m)) → ((a : IO.Error) → motive (Except.error a)) → motive __do_lift | null | false |
CategoryTheory.SimplicialObject.Augmented.σ₀Iter_hom_app_assoc | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (Y : CategoryTheory.SimplicialObject.Augmented C)
{n m : ℕ} (i : ℕ) (hi : autoParam (n + i = m) CategoryTheory.SimplicialObject.Augmented.σ₀Iter_hom_app._auto_1)
{Z : C} (h : Y.right ⟶ Z),
CategoryTheory.CategoryStruct.comp (Y.left.σ₀Iter i hi)
... | null | true |
Lean.Meta.Grind.Action.andAlso | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Action → Lean.Meta.Grind.Action → Lean.Meta.Grind.Action | Sequential conjunction: executes both `x` and `y`.
- Runs `x` and always runs `y` afterward, regardless of whether `x` made progress.
- It is not applicable only if both `x` and `y` are not applicable.
| true |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.iff_exists_tensorProduct._simp_1_4 | Mathlib.RingTheory.Unramified.Finite | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
KaehlerDifferential.ideal R S = Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) | null | false |
Lake.normalizeToolchain | Lake.Util.Version | String → String | Converts a toolchain version to its normal form (e.g., with an origin). | true |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.normNatOfNatInst.declare_66._@.Lean.Meta.Tactic.Grind.Arith.Simproc.1661358275._hygCtx._hyg.14 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit | null | false |
SimpleGraph.Connected.rec | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{G : SimpleGraph V} →
{motive : G.Connected → Sort u_1} →
((preconnected : G.Preconnected) → [nonempty : Nonempty V] → motive ⋯) → (t : G.Connected) → motive t | null | false |
_private.Mathlib.Tactic.CategoryTheory.Map.0.Mathlib.Tactic.CategoryTheory.Map.collectCategoryUniverses._unsafe_rec | Mathlib.Tactic.CategoryTheory.Map | Lean.Expr → StateRefT' IO.RealWorld (Lean.CollectLevelParams.State × Lean.CollectLevelParams.State) Lean.MetaM Unit | null | false |
Functor.supp.eq_1 | Mathlib.Data.PFunctor.Univariate.Basic | ∀ {F : Type u → Type v} [inst : Functor F] {α : Type u} (x : F α),
Functor.supp x = {y | ∀ ⦃p : α → Prop⦄, Functor.Liftp p x → p y} | null | true |
CategoryTheory.Limits.colimitHomIsoLimitYoneda_inv_comp_π_assoc | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(F : CategoryTheory.Functor I C) [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) {Z : Type u₂} (h : (F.obj i ⟶ A) ⟶ Z)... | null | true |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNames.loop.match_1 | Batteries.Lean.Meta.UnusedNames | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
CategoryTheory.Limits.Cocone.category._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {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] {F : CategoryTheory.Functor J C}
{W X Y Z : CategoryTheory.Limits.Cocone F} (f : CategoryTheory.Limits.CoconeMorphism X W)
(g : CategoryTheory.Limits.CoconeMorphism Y X) (h : CategoryTheor... | null | false |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist a' b' ≠ 0 → dist a b / dist a' b' = dist b c / dist b' c' → dist a b = dist a b / dist a' b' * dist a' b' | null | false |
instCountablePLift | Mathlib.Basic.Countable.Defs | ∀ {α : Sort u} [Countable α], Countable (PLift α) | null | true |
generatePiSystem_subset_self | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)}, IsPiSystem S → generatePiSystem S ⊆ S | null | true |
Mathlib.Linter.linter.style.longLine | Mathlib.Tactic.Linter.Style | Lean.Option Bool | The "longLine" linter emits a warning on lines longer than
`linter.style.longLine.maxLineLength` (which defaults to 100) characters.
We allow lines containing URLs to be longer, though. | true |
_private.Mathlib.Analysis.Distribution.TestFunction.0.TestFunction.instIsTopologicalAddGroup.match_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (x : TopologicalSpace (TestFunction Ω F n))
(motive :
x ∈
{t |
TestFunction.originalTop Ω F n ≤ t ∧
... | null | false |
ProbabilityTheory.Kernel.iIndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
Probability... | null | true |
Int.Internal.Linear.of_var_eq_var | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (x y : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly),
Int.Internal.Linear.of_var_eq_var_cert x y p = true →
Int.Internal.Linear.Var.denote ctx x = Int.Internal.Linear.Var.denote ctx y →
Int.Internal.Linear.Poly.denote' ctx p = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.