name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Functor.EpiMono.0.CategoryTheory.Functor.instIsSplitMonoApp._proof_1 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {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] {F G : CategoryTheory.Functor C D} (f : G ⟶ F)
[CategoryTheory.IsSplitMono f] (X : C), CategoryTheory.IsSplitMono (f.app X) | null | false |
Filter.tendsto_of_subseq_tendsto | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u_1} {ι : Type u_3} {x : ι → α} {f : Filter α} {l : Filter ι} [l.IsCountablyGenerated],
(∀ (ns : ℕ → ι), Filter.Tendsto ns Filter.atTop l → ∃ ms, Filter.Tendsto (fun n => x (ns (ms n))) Filter.atTop f) →
Filter.Tendsto x l f | A sequence converges if every subsequence has a convergent subsequence. | true |
MeasurableEquiv.measurableEmbedding | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
MeasurableEmbedding ⇑e | A measurable equivalence is a measurable embedding. | true |
Lean.FuzzyMatching.CharType.separator | Lean.Data.FuzzyMatching | Lean.FuzzyMatching.CharType | null | true |
CategoryTheory.MorphismProperty.Comma.lift._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} A] {B : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} B] {T : Type u_8} [inst_2 : CategoryTheory.Category.{u_7, u_8} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | null | false |
IsUnit.mul_left_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, IsUnit a → a * b = a * c → b = c | null | true |
_private.Mathlib.Order.Monotone.Defs.0.monotone_prodMk_iff._simp_1_3 | Mathlib.Order.Monotone.Defs | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
CategoryTheory.Functor.Elements.fromCostructuredArrow._proof_1 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor Cᵒᵖ (Type u_1))
{X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)ᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.CostructuredArrow.Hom.left f.unop).op))
(F.elementsMk (Opposi... | null | false |
GrpCat.shrinkFunctorMap_app | Mathlib.Algebra.Category.Grp.Shrink | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C GrpCat} (τ : F ⟶ G)
[inst_1 : ∀ (X : C), Small.{w, w'} ↑(F.obj X)] [inst_2 : ∀ (X : C), Small.{w, w'} ↑(G.obj X)] (X : C),
(GrpCat.shrinkFunctorMap τ).app X =
GrpCat.ofHom ((Shrink.mulEquiv.symm.toMonoidHom.comp (GrpCat.Hom... | null | true |
Int.instNormedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ (m n : ℤ), ‖m * n‖ ≤ ‖m‖ * ‖n‖ | null | false |
meromorphicOrderAt_ne_top_iff_mul_inv_eventuallyEq | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_4} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {x : 𝕜} {f : 𝕜 → 𝕜'},
MeromorphicAt f x → (meromorphicOrderAt f x ≠ ⊤ ↔ f * f⁻¹ =ᶠ[nhdsWithin x {x}ᶜ] 1) | The order of a meromorphic function `f` at `z₀` is finite iff `f` has multiplicative inverse
in a sufficiently small neighborhood of `z₀`. | true |
PosNum.decidableDvd | Mathlib.Data.Num.ZNum | DecidableRel fun x1 x2 => x1 ∣ x2 | null | true |
Lean.Expr.hasUnusedForallBindersWhere | Lean.Util.UnusedBinders | (Lean.BinderInfo → Lean.Expr → Bool) → Lean.Expr → Bool | Tests if any of the binders of `(x₀ : A₀) → (x₁ : A₁) → ⋯ → X` which satisfy `p Aᵢ bi` (with `bi`
the `binderInfo`) are unused in the renainder of the type (i.e. in `(xᵢ₊₁ : Aᵢ₊₁) → ⋯ → X`).
Note that the argument to `p` may have loose bvars. This is a performance optimization.
This function runs `cleanupAnnotations`... | true |
_private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.comm_ring_aux₁._proof_4 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : Fact (Nat.Prime p)], WittVector.ghostFun✝ 1 = 1 | null | false |
CategoryTheory.Functor.DenseAt | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → D → Type (max u₁ u₂ v₂) | A functor `F : C ⥤ D` is dense at `Y : D` if the obvious natural transformation
`F ⟶ F ⋙ 𝟭 D` makes `𝟭 D` a pointwise left Kan extension of `F` along itself at `Y`,
i.e. `Y` identifies to the colimit of the obvious functor `CostructuredArrow F Y ⥤ D`. | true |
RBTree.RBNode.Balanced.balRight | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {l : RBTree.RBNode α} {v : α} {r : RBTree.RBNode α} {cl : RBTree.RBColor} {n : ℕ},
l.Balanced cl (n + 1) →
RBTree.RBNode.RedRed True r n → RBTree.RBNode.RedRed (cl = RBTree.RBColor.red) (l.balRight v r) (n + 1) | The balancing properties of the `balRight` function. | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftRight_xor._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Aesop.GoalDiff.newGoal | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff → Lean.MVarId | The new goal. | true |
Set.image_image2_right_anticomm | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {s : Set α} {t : Set β} {f : α → β' → γ}
{g : β → β'} {f' : β → α → δ} {g' : δ → γ},
(∀ (a : α) (b : β), f a (g b) = g' (f' b a)) → Set.image2 f s (g '' t) = g' '' Set.image2 f' t s | Symmetric statement to `Set.image_image2_antidistrib_right`. | true |
LinearMap.BilinForm.isAlt_zero._simp_1 | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.BilinForm.IsAlt 0 = True | null | false |
MeasureTheory.ae_bdd_norm_condExp_of_ae_bdd_norm | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] {R : ℝ} {f : α → E},
(∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ R) → ∀ᵐ (x : α) ∂μ, ‖μ[f | m] x‖ ≤ R | If `‖f‖` is bounded almost everywhere by `R`, then so is its conditional expectation. | true |
_private.Std.Time.Format.Modifier.0.Std.Time.instReprFraction.repr.match_1 | Std.Time.Format.Modifier | (motive : Std.Time.Fraction → Sort u_1) →
(x : Std.Time.Fraction) →
(Unit → motive Std.Time.Fraction.nano) → ((a : ℕ) → motive (Std.Time.Fraction.truncated a)) → motive x | null | false |
ProbabilityTheory.iIndepSets.isProbabilityMeasure | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {π : ι → Set (Set Ω)} {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
ProbabilityTheory.iIndepSets π μ → MeasureTheory.IsProbabilityMeasure μ | null | true |
CategoryTheory.LocalizerMorphism.RightResolution.instCategory | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget.mk._flat_ctor | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
(n : ℕ) → aig.RefVec w → aig.RefVec n → ℕ → Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget aig w | null | false |
Std.HashSet.Raw.Equiv.refl._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} (m : Std.HashSet.Raw α), m.Equiv m = True | null | false |
Lean.IR.VarId.recOn | Lean.Compiler.IR.Basic | {motive : Lean.IR.VarId → Sort u} → (t : Lean.IR.VarId) → ((idx : Lean.IR.Index) → motive { idx := idx }) → motive t | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.monoidalOppositeLeftAction._proof_10 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_4) [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {c c' : Cᴹᵒᵖ} (c'' : Cᴹᵒᵖ) (f : c ⟶ c') (d : D),
CategoryTheory.MonoidalCate... | null | false |
Lean.Elab.withEnableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.Elab.MonadInfoTree m] → [MonadFinally m] → Bool → m α → m α | null | true |
Aesop.SafeRuleResult.postponed | Aesop.Search.Expansion | Aesop.PostponedSafeRule → Aesop.SafeRuleResult | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_le_iff | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ k ↔
∀ (k' : ℕ),
k < k' → k' ≤ stackPos → ¬String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1) | null | true |
Ordinal.omega_eq_preOmega | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), Ordinal.omega o = Ordinal.preOmega (Ordinal.omega0 + o) | null | true |
SSet.Subcomplex.Pairing.RankFunction.filtration_succ | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι)
[inst_1 : SuccOrder ι] (i : ι), ¬IsMax i → f.filtration (Order.succ i) = f.filtration i ⊔ ⨆ c, (↑(P.p c.s)).subcomplex | null | true |
Batteries.BinomialHeap.Imp.Heap.foldTreeM._unsafe_rec | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.BinomialHeap.Imp.Heap α → m β | null | false |
Complex.eventually_eq_or_eq_zero_of_isLocalMin_norm | Mathlib.Analysis.Complex.AbsMax | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {c : E},
(∀ᶠ (z : E) in nhds c, DifferentiableAt ℂ f z) → IsLocalMin (norm ∘ f) c → (∀ᶠ (z : E) in nhds c, f z = f c) ∨ f c = 0 | null | true |
Associates.factors_eq_some_iff_ne_zero | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : Associates α},
(∃ s, a.factors = ↑s) ↔ a ≠ 0 | null | true |
Fin.ne_zero_of_lt | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin (n + 1)}, a < b → b ≠ 0 | null | true |
ENNReal.lt_add_of_sub_lt_left | Mathlib.Basic.ENNReal.Operations | ∀ {a b c : ENNReal}, a ≠ ⊤ ∨ b ≠ ⊤ → a - b < c → a < b + c | null | true |
Lean.Elab.Do.MutVar.erased | Lean.Elab.Do.Basic | Lean.Elab.Do.MutVar → Bool | Whether the variable comes from `erased mut`. | true |
Set.subsingleton_univ_iff | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Set.univ.Subsingleton ↔ Subsingleton α | null | true |
_private.Mathlib.Analysis.Convex.Quasiconvex.0.QuasilinearOn.monotoneOn_or_antitoneOn._simp_1_1 | Mathlib.Analysis.Convex.Quasiconvex | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {s : Set α},
(MonotoneOn f s ∨ AntitoneOn f s) = ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ Set.uIcc a b → f c ∈ Set.uIcc (f a) (f b) | null | false |
JoinedIn.somePath_mem._simp_1 | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {F : Set X} (h : JoinedIn F x y) (t : ↑unitInterval),
(h.somePath t ∈ F) = True | null | false |
Submonoid.mem_map._simp_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N}, (y ∈ Submonoid.map f S) = ∃ x ∈ S, f x = y | null | false |
MeasureTheory.ProbabilityMeasure.eq_of_forall_apply_eq | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.ProbabilityMeasure Ω),
(∀ (s : Set Ω), MeasurableSet s → μ s = ν s) → μ = ν | null | true |
_private.Init.Grind.Module.NatModuleNorm.0.Lean.Grind.Linarith.Expr.denoteN.match_1.splitter | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Expr → Sort u_1) →
(x : Lean.Grind.Linarith.Expr) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.sub b)) →
((a : Lean.Grind.Linarith.Expr) → motive a.neg) →
((k : ℤ) → (a : Lean.Grind.Linarith.Expr) → motive (Lean.Grind.Linarith.Expr.intMul k a)) →
(Unit → mo... | null | true |
CategoryTheory.Monad.Algebra.ctorIdx | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {T : CategoryTheory.Monad C} → T.Algebra → ℕ | null | false |
Lean.MetavarContext.MkBinding.Context.mk.sizeOf_spec | Lean.MetavarContext | ∀ (quotContext : Lean.Name) (preserveOrder : Bool) (binderInfoForMVars : Lean.BinderInfo)
(mvarIdsToAbstract : Lean.MVarIdSet),
sizeOf
{ quotContext := quotContext, preserveOrder := preserveOrder, binderInfoForMVars := binderInfoForMVars,
mvarIdsToAbstract := mvarIdsToAbstract } =
1 + sizeOf quotC... | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_iff_of_ae_le._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
quasiIso_comp | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L M : HomologicalComplex C c} (φ : K ⟶ L)
(φ' : L ⟶ M) [inst_2 : ∀ (i : ι), K.HasHomology i] [inst_3 : ∀ (i : ι), L.HasHomology i]
[inst_4 : ∀ (i : ι), M.HasHomology ... | null | true |
Lean.Elab.Tactic.Conv.PatternMatchState.ctorElim | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.Conv.PatternMatchState) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.Conv.PatternMatchState.ctorElimType ctorIdx → motive t | null | false |
IO.Process.Stdio.rec | Init.System.IO | {motive : IO.Process.Stdio → Sort u} →
motive IO.Process.Stdio.piped →
motive IO.Process.Stdio.inherit → motive IO.Process.Stdio.null → (t : IO.Process.Stdio) → motive t | null | false |
Metric.instMetricSpaceInductiveLimit._proof_11 | 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.instMetricSpaceInductiveLimit._aux_9 Set.univ | null | false |
UpperSet.coe_nonempty._simp_2 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s).Nonempty = (s ≠ ⊤) | null | false |
CategoryTheory.TwoSquare.StructuredArrowRightwards.prodEquivalence.inverseObj_hom_left | Mathlib.CategoryTheory.GuitartExact.Prod | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {D₁ : Type u_5} {D₂ : Type u_6} {D₃ : Type u_7}
{D₄ : Type u_8} [inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u... | null | true |
_private.Mathlib.Order.Minimal.0.minimal_subtype._simp_1_2 | Mathlib.Order.Minimal | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y}, (⟨x, hx⟩ ≤ ⟨y, hy⟩) = (x ≤ y) | null | false |
Finset.card_mul_cast_divConst | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {𝕜 : Type u_2} [inst_2 : Semifield 𝕜] [CharZero 𝕜]
(A B : Finset G), ↑A.card * ↑(A.divConst B) = ↑(A / B).card | null | true |
Lean.Elab.Term.MVarErrorKind | Lean.Elab.Term.TermElabM | Type | We can optionally associate an error context with a metavariable (see `MVarErrorInfo`).
We have three different kinds of error context.
| true |
Rat.cast_inv._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionRing α] [CharZero α] (p : ℚ), (↑p)⁻¹ = ↑p⁻¹ | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.category._proof_5 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {W X Y Z : F.Grothendieck}
(f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryThe... | null | false |
Projectivization.orthogonal._proof_1 | Mathlib.LinearAlgebra.Projectivization.Constructions | ∀ {F : Type u_1} [inst : Field F] {m : Type u_2} [inst_1 : Fintype m] (x x_1 x_2 x_3 : { v // v ≠ 0 }),
x ≈ x_2 → x_1 ≈ x_3 → (↑x ⬝ᵥ ↑x_1 = 0) = (↑x_2 ⬝ᵥ ↑x_3 = 0) | null | false |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.logEmbedding_component_le._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a | null | false |
Algebra.Extension.Hom.sub._simp_2 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} [inst : CommRing R] (I : Ideal R) (x : ↥I), (I.toCotangent x = 0) = (↑x ∈ I ^ 2) | null | false |
RelSeries.append | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → (p q : RelSeries r) → (p.last, q.head) ∈ r → RelSeries r | If `a₀ -r→ a₁ -r→ ... -r→ aₙ` and `b₀ -r→ b₁ -r→ ... -r→ bₘ` are two strict series
such that `r aₙ b₀`, then there is a chain of length `n + m + 1` given by
`a₀ -r→ a₁ -r→ ... -r→ aₙ -r→ b₀ -r→ b₁ -r→ ... -r→ bₘ`.
| true |
Padic.instNorm | Mathlib.NumberTheory.Padics.PadicNumbers | (p : ℕ) → [inst : Fact (Nat.Prime p)] → Norm ℚ_[p] | null | true |
TwoSidedIdeal.instSMulNatSubtypeMem._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) (n : ℕ) (x : ↥I), n • ↑x ∈ I | null | false |
Mathlib.Tactic.Echelon.RingOps.mul | Mathlib.Tactic.Echelon.Core | {V : Type} → Mathlib.Tactic.Echelon.RingOps V → V → V → V | Multiplication. | true |
groupHomology.coe_mapCycles₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑↧↥(groupHomology.cycles₁ A)),
↑((CategoryTheory.ConcreteCategory.hom (groupHomology.mapCycles₁ f φ)) x) =
(CategoryTheory.ConcreteCategory.hom (gr... | null | true |
CategoryTheory.Bicategory.whiskerRight_comp_symm_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f' g) h ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheo... | null | true |
RatFunc.CompletionAtInfty.instUniformSpace | Mathlib.FieldTheory.RatFunc.Valuation | (F : Type u_1) → [inst : Field F] → [DecidableEq (RatFunc F)] → UniformSpace (RatFunc F) | The uniform space structure on `RatFunc F` coming from the valuation at infinity. | true |
RingPreordering.coe_set_mk | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (toSubsemiring : Subsemiring R)
(mem_of_isSquare : ∀ {x : R}, IsSquare x → x ∈ toSubsemiring.carrier) (neg_one_notMem : -1 ∉ toSubsemiring.carrier),
↑{ toSubsemiring := toSubsemiring, mem_of_isSquare' := mem_of_isSquare, neg_one_notMem' := neg_one_notMem } =
↑toSubsemiring | null | true |
Aesop.IndexMatchLocation.hyp | Aesop.Index.Basic | Lean.LocalDecl → Aesop.IndexMatchLocation | null | true |
OrderDual.instNontrivial | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [h : Nontrivial α], Nontrivial αᵒᵈ | null | true |
Lean.Compiler.LCNF.JoinPointFinder.FindCtx.mk | Lean.Compiler.LCNF.JoinPoints | ℕ → Lean.FVarIdMap ℕ → Option Lean.FVarId → Lean.Compiler.LCNF.JoinPointFinder.FindCtx | null | true |
_private.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.0.Asymptotics.IsEquivalent.smul._simp_1_6 | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Rack.act'_symm_apply | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] (x y : R), (Rack.act' x).symm y = Rack.invAct x y | null | true |
FreeAddGroup.zero_ne_of | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), 0 ≠ FreeAddGroup.of a | null | true |
Ordering.Compares.inj | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] {o₁ o₂ : Ordering} {a b : α}, o₁.Compares a b → o₂.Compares a b → o₁ = o₂ | null | true |
AddSubgroup.card_le_one_iff_eq_bot | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [Finite ↥H], Nat.card ↥H ≤ 1 ↔ H = ⊥ | null | true |
ModuleCat.instPreservesFiniteLimitsLocalizationLocalizedModuleFunctor | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] (S : Submonoid R),
CategoryTheory.Limits.PreservesFiniteLimits (ModuleCat.localizedModuleFunctor S) | null | true |
USize.toBitVec64_shiftRight | Init.Data.UInt.IntToBitVec | ∀ (a b : USize) (h : System.Platform.numBits = 64), (a >>> b).toBitVec64 h = a.toBitVec64 h >>> (b.toBitVec64 h % 64) | null | true |
Std.Async.ContextAsync.cancel | Std.Async.ContextAsync | Std.CancellationReason → Std.Async.ContextAsync Unit | Cancels the current context with the given reason, cascading to all child contexts.
Cancellation is cooperative, operations must explicitly check `isCancelled` or use `awaitCancellation` to respond.
| true |
_private.Lean.Compiler.LCNF.ElimDead.0.Lean.Compiler.LCNF.collectLocalDeclsLetValue.match_1 | Lean.Compiler.LCNF.ElimDead | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue pu) →
(Unit → motive Lean.Compiler.LCNF.LetValue.erased) →
((value : Lean.Compiler.LCNF.LitValue) → motive (Lean.Compiler.LCNF.LetValue.lit value)) →
((typeName : Lean... | null | false |
AddSubgroup.focalAddSubgroup.eq_1 | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G),
H.focalAddSubgroup = AddSubgroup.closure {g | g ∈ H ∧ ∃ x ∈ H, ∃ u, g = ⁅x, u⁆} | null | true |
CategoryTheory.Equalizer.Presieve.SecondObj._proof_1 | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (R : CategoryTheory.Presieve X)
[R.HasPairwisePullbacks] (fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }),
CategoryTheory.Limits.HasPullback ↑fg.1.snd ↑fg.2.snd | null | false |
Ring.instDirectLimit._proof_28 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (a : Ring.DirectLimit G f), -a + a = 0 | null | false |
CategoryTheory.ComposableArrows.homMk₃._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | 2 < 3 + 1 | null | false |
Nat.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {s : Finset ι} {f : ι → ℕ} {n : ℕ}, (∀ i ∈ s, n ∣ f i) → (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n | null | true |
AddSubmonoidClass.toAddMonoid._proof_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {A : Type u_2} [inst_1 : SetLike A M] [inst_2 : AddSubmonoidClass A M] (S : A)
(a : ↥S), 0 + a = a | null | false |
Matrix.GeneralLinearGroup.continuous_det | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} {R : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [IsTopologicalRing R], Continuous ⇑Matrix.GeneralLinearGroup.det | The determinant is continuous as a map from the general linear group to the units. | true |
_private.Mathlib.MeasureTheory.PiSystem.0.mem_generatePiSystem_iUnion_elim'._simp_1_1 | Mathlib.MeasureTheory.PiSystem | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Plausible.Configuration.numInst._default | Plausible.Testable | ℕ | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse._proof_6 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Comon D)} (f : X ⟶ Y) (g : Y ⟶ Z) (x x_1 : C) (f_1 : x ⟶ x_1),
CategoryTheory.CategoryStruct.... | null | false |
_private.Lean.Meta.Sym.ReplaceS.0.Lean.Meta.Sym.visitChild.match_1.eq_5 | Lean.Meta.Sym.ReplaceS | ∀ (motive : Lean.Expr → Sort u_1) (declName : Lean.Name) (us : List Lean.Level)
(h_1 : (a : Lean.Literal) → motive (Lean.Expr.lit a)) (h_2 : (mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId))
(h_3 : (deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex))
(h_4 : (fvarId : Lean.FVarId) → motive (Lean.Exp... | null | true |
Lean.Lsp.SymbolKind.variable | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind | null | true |
_private.Mathlib.Topology.UniformSpace.Separation.0.t0Space_iff_ker_uniformity._simp_1_4 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
FirstOrder.Language.LHom._sizeOf_1 | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → (L →ᴸ L') → ℕ | null | false |
IsMaxOn.dual | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α},
IsMaxOn f s a → IsMinOn (⇑OrderDual.toDual ∘ f) s a | **Alias** of the reverse direction of `isMinOn_dual_iff`. | true |
SimplexCategory.Hom.ext_one_left._auto_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | Lean.Syntax | null | false |
CategoryTheory.SplitEpi | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Type v₁ | A split epimorphism is a morphism `f : X ⟶ Y` with a given section `section_ f : Y ⟶ X`
such that `section_ f ≫ f = 𝟙 Y`.
(Note that `section` is a reserved keyword, so we append an underscore.)
Every split epimorphism is an epimorphism.
| true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.Defs.0.MvPolynomial.support_esymm''._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.