name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
monotone_vecCons | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin (n + 1) → α} {a : α},
Monotone (Matrix.vecCons a f) ↔ a ≤ f 0 ∧ Monotone f | null | true |
Dense.exists_ge | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α] [NoMaxOrder α] {s : Set α},
Dense s → ∀ (x : α), ∃ y ∈ s, x ≤ y | null | true |
Std.TreeSet.Raw.size_filter_eq_size_iff | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] {f : α → Bool},
t.WF → ((Std.TreeSet.Raw.filter f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), f (t.get k h) = true) | null | true |
NNRat.cast_eq_zero | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionSemiring α] [CharZero α] {q : ℚ≥0}, ↑q = 0 ↔ q = 0 | null | true |
RingCat.ofHom | Mathlib.Algebra.Category.Ring.Basic | {R S : Type u} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → (↧R ⟶ ↧S) | Typecheck a `RingHom` as a morphism in `RingCat`. | true |
sub_right_injective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {b : G}, Function.Injective fun a => b - a | null | true |
MeasureTheory.memLp_of_memLp_trim | Mathlib.MeasureTheory.Function.LpSeminorm.Trim | ∀ {α : Type u_1} {ε : Type u_2} {m m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] (hm : m ≤ m0) {f : α → ε},
MeasureTheory.MemLp f p (μ.trim hm) → MeasureTheory.MemLp f p μ | null | true |
Std.Iterators.PostconditionT | Init.Data.Iterators.PostconditionMonad | (Type w → Type w') → Type w → Type (max w w') | `PostconditionT m α` represents an operation in the monad `m` together with a
intrinsic proof that some postcondition holds for the `α` valued monadic result.
It consists of a predicate `P` about `α` and an element of `m ({ a // P a })` and is a helpful tool
for intrinsic verification, notably termination proofs, in th... | true |
instWeakPseudoEMetricSpaceSubtype | Mathlib.Topology.EMetricSpace.Defs | {α : Type u_2} →
{p : α → Prop} → [inst : TopologicalSpace α] → [WeakPseudoEMetricSpace α] → WeakPseudoEMetricSpace (Subtype p) | Weak pseudo-emetric space instance on subsets of weak pseudo-emetric spaces | true |
instMulSemiringActionSubtypeMemSubalgebraIntegralClosure._proof_1 | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {G : Type u_3} {R : Type u_2} {K : Type u_1} [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K]
[inst_3 : Group G] [inst_4 : MulSemiringAction G K] [inst_5 : SMulCommClass G R K] (g h : G)
(x : ↥(integralClosure R K)), (g * h) • x = g • h • x | null | false |
TopRep.invariantsFunctor._proof_1 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ (k : Type u_2) [inst : TopologicalSpace k] [inst_1 : Ring k] (G : Type u_3) [inst_2 : Group G] (X : TopRep k G),
TopModuleCat.ofHom (TopRep.Hom.hom (CategoryTheory.CategoryStruct.id X)).mapInvariants =
CategoryTheory.CategoryStruct.id ↧↥X.ρ.invariants | null | false |
ContinuousMap.realToRCLikeStarAlgHom_apply | Mathlib.Analysis.RCLike.ContinuousMap | ∀ {X : Type u_1} (𝕜 : Type u_2) [inst : TopologicalSpace X] [inst_1 : RCLike 𝕜] (f : C(X, ℝ)),
(ContinuousMap.realToRCLikeStarAlgHom X 𝕜) f = ContinuousMap.realToRCLike 𝕜 f | null | true |
IsAddQuantale.recOn | Mathlib.Algebra.Order.Quantale | {α : Type u_1} →
[inst : AddSemigroup α] →
[inst_1 : CompleteLattice α] →
{motive : IsAddQuantale α → Sort u} →
(t : IsAddQuantale α) →
((add_sSup_distrib : ∀ (x : α) (s : Set α), x + sSup s = ⨆ y ∈ s, x + y) →
(sSup_add_distrib : ∀ (s : Set α) (y : α), sSup s + y = ⨆ x ∈ s, ... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_325 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Matroid.eq_loopyOn_iff_loops | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {E : Set α}, M = Matroid.loopyOn E ↔ M.loops = E ∧ M.E = E | null | true |
Std.Http.Status.conflict.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 32 → motive Std.Http.Status.conflict → motive t | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLog.0.circleAverage_log_norm_sub_const₂._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Integrals.PosLog | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
Fintype.existsUnique_notMem_image_of_injective_of_card_eq_add_one | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] [inst_2 : DecidableEq β] (f : α → β),
Function.Injective f → Fintype.card β = Fintype.card α + 1 → ∃! x, x ∉ Finset.image f Finset.univ | Given an injective map `f : α → β` such that `β` has cardinality one more
than `α`, there exists a unique element of `β` not in the image of `f`. | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalFirst.loop | Lean.Elab.Tactic.BuiltinTactic | Array Lean.Syntax → ℕ → Lean.Elab.Tactic.TacticM Unit | null | true |
Lean.Order.meet_le_left | Std.Internal.Order.Lemmas | ∀ {α : Type uₗ} [inst : Lean.Order.CompleteLattice α] (x y : α), Lean.Order.PartialOrder.rel (Lean.Order.meet x y) x | null | true |
Std.HashMap.Raw.getKey!_unitOfList_of_contains_eq_false | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α] {l : List α}
{k : α}, l.contains k = false → (Std.HashMap.Raw.unitOfList l).getKey! k = default | null | true |
Lean.Grind.Semiring.add_comm | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Semiring α] (a b : α), a + b = b + a | Addition is commutative. | true |
CliffordAlgebra.even.lift_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Even | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {A : Type u_3} [inst_3 : Ring A] [inst_4 : Algebra R A] (f : CliffordAlgebra.EvenHom Q A)
(m₁ m₂ : M), ((CliffordAlgebra.even.lift Q) f) (((CliffordAlgebra.even.ι Q).bilin m₁) m₂) = (f.bilin m... | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.stoppers | Mathlib.Tactic.Linter.FlexibleLinter | Std.HashSet Lean.Name | `SyntaxNodeKind`s that are mostly "formatting": mostly they are ignored
because we do not want the linter to spend time on them.
The nodes that they contain will be visited by the linter anyway.
The nodes that *follow* them, though, will *not* be visited by the linter.
| true |
CompactIccSpace.isCompact_Icc | Mathlib.Topology.Order.Compact | ∀ {α : Type u_1} {inst : TopologicalSpace α} {inst_1 : Preorder α} [self : CompactIccSpace α] {a b : α},
IsCompact (Set.Icc a b) | A closed interval `Set.Icc a b` is a compact set for all `a` and `b`. | true |
StrictAnti.prodMap | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β]
[inst_2 : Preorder γ] [inst_3 : Preorder δ] {f : α → γ} {g : β → δ},
StrictAnti f → StrictAnti g → StrictAnti (Prod.map f g) | null | true |
_private.Mathlib.GroupTheory.GroupAction.Jordan.0.Equiv.Perm.subgroup_eq_top_of_isPreprimitive_of_isSwap_mem._simp_1_3 | Mathlib.GroupTheory.GroupAction.Jordan | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {x : α},
(x ∈ SubMulAction.ofFixingSubgroup M s) = (x ∉ s) | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_139 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬lw = rw → ¬llhs.shiftRight lrhs = rlhs.shiftRight rrhs | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
BiheytingHom.comp | Mathlib.Order.Heyting.Hom | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : BiheytingAlgebra α] →
[inst_1 : BiheytingAlgebra β] →
[inst_2 : BiheytingAlgebra γ] → BiheytingHom β γ → BiheytingHom α β → BiheytingHom α γ | Composition of `BiheytingHom`s as a `BiheytingHom`. | true |
smul_iterate_apply | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} [inst : Monoid M] [inst_1 : MulAction M α] (a : M) (n : ℕ) (x : α),
(fun x => a • x)^[n] x = a ^ n • x | null | true |
Matroid.map_val_restrictSubtype_eq | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), (M.restrictSubtype X).map Subtype.val ⋯ = M.restrict X | `M.restrictSubtype X` is isomorphic to `M ↾ X`. | true |
CategoryTheory.Limits.fiberwiseColimitLimitIso._proof_8 | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {C : Type u_8} [inst : CategoryTheory.Category.{u_7, u_8} C] {H : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} H] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{F : CategoryTheory.Functor C CategoryTheory.Cat}
(K : CategoryTheory.Functor J (CategoryTheory.Functor (CategoryTheory.Groth... | null | false |
Std.Do.SPred.Notation.unpack | Std.Do.SPred.Notation.Basic | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → [Lean.MonadQuotation m] → Lean.Term → m Lean.Term | Removes an `spred` layer from a `term` syntax object. | true |
pow_right_monotone | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M}, 1 ≤ a → Monotone fun n => a ^ n | null | true |
_private.Mathlib.Tactic.Inclusion.Extension.Core.Core.0.Inclusion.andHyp._sparseCasesOn_2 | Mathlib.Tactic.Inclusion.Extension.Core.Core | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Std.DHashMap.Internal.Raw.WF.out | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [i₁ : EquivBEq α] [i₂ : LawfulHashable α]
{m : Std.DHashMap.Raw α β}, m.WF → Std.DHashMap.Internal.Raw.WFImp m | null | true |
ProbabilityTheory.iIndepFun.map_fun_eq_infinitePi_map₀' | Mathlib.Probability.Independence.InfinitePi | ∀ {ι : Type u_1} {Ω : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {𝓧 : ι → Type u_3}
{m𝓧 : (i : ι) → MeasurableSpace (𝓧 i)} {X : (i : ι) → Ω → 𝓧 i} [Countable ι],
(∀ (i : ι), AEMeasurable (X i) P) →
ProbabilityTheory.iIndepFun X P →
MeasureTheory.Measure.map (fun ω i => X i ω) P =... | If random variables are independent then their joint distribution is the product measure. This
is an `AEMeasurable` version of `iIndepFun.map_fun_eq_infinitePi_map`, which is why it requires
`ι` to be countable. | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_obj | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C)
(x : CategoryTheory.Discrete PUnit.{u + 1}),
(CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A).obj x = A.X | null | true |
HasFPowerSeriesWithinAt.continuousWithinAt_insert | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {s : Set E} {x : E},
HasFPowerSeriesWithinAt f p s x → Contin... | null | true |
Lean.Compiler.LCNF.CSE.instMonadFVarSubstMPureFalse | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.MonadFVarSubst Lean.Compiler.LCNF.CSE.M Lean.Compiler.LCNF.Purity.pure false | null | true |
Std.DTreeMap.Internal.Impl.get?_insertIfNew | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insertIfNew k v t ⋯).impl.get? a =
if h : compare k a = Ordering.eq ∧ k ∉ t then some (cast ⋯ v) else t.get? a | null | true |
Lean.Meta.ElimAltInfo.noConfusion | Lean.Meta.Tactic.ElimInfo | {P : Sort u} → {t t' : Lean.Meta.ElimAltInfo} → t = t' → Lean.Meta.ElimAltInfo.noConfusionType P t t' | null | false |
TrivSqZeroExt.fstHom._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (S : Type u_3) (R : Type u_1) (M : Type u_2) [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] (_r : S), (TrivSqZeroExt.inl ((algebraMap S R) _r)).fst = (algebraMap S R) _r | null | false |
LocallyLipschitz.iterate | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → α}, LocallyLipschitz f → ∀ (n : ℕ), LocallyLipschitz f^[n] | null | true |
Prod.rec._@.Mathlib.Util.CompileInductive.3167448894._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | {α : Type u} →
{β : Type v} → {motive : α × β → Sort u_1} → ((fst : α) → (snd : β) → motive (fst, snd)) → (t : α × β) → motive t | null | false |
Std.Time.DateFormatSymbols.amShort | Std.Time.Format.DateFormat | Std.Time.DateFormatSymbols → String | Short AM marker (used by `a`/`aa`/`aaa`).
| true |
SimpleGraph.IsTuranMaximal.finpartition | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | {V : Type u_1} →
[inst : Fintype V] →
{G : SimpleGraph V} →
[inst_1 : DecidableRel G.Adj] → {r : ℕ} → G.IsTuranMaximal r → [inst_2 : DecidableEq V] → Finpartition Finset.univ | The finpartition derived from `h.setoid`. | true |
Aesop.getUnusedNames | Aesop.Util.Basic | Lean.LocalContext → Array Lean.Name → Array Lean.Name × Lean.LocalContext | Note: the returned local context contains invalid `LocalDecl`s.
| true |
ImportGraph.Shake.ConstLocation._sizeOf_inst | ImportGraph.Shake.DeclNeeds | SizeOf ImportGraph.Shake.ConstLocation | null | false |
Bornology.forall_isBounded_image_eval_iff | Mathlib.Topology.Bornology.Constructions | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (i : ι) → Bornology (X i)] {s : Set ((i : ι) → X i)},
(∀ (i : ι), Bornology.IsBounded (Function.eval i '' s)) ↔ Bornology.IsBounded s | null | true |
Relation.SymmGen.rfl | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} {a : α} [Std.Refl r], Relation.SymmGen r a a | null | true |
MeasureTheory.AEEqFun.instLattice._proof_6 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
[inst_2 : Lattice β] [inst_3 : TopologicalLattice β] (f' f g : α →ₘ[μ] β), f' ≤ f → f' ≤ g → f' ≤ f ⊓ g | null | false |
Lean.MVarId.introsWithBinderIdents | Mathlib.Tactic.Core | Lean.MVarId →
List (Lean.TSyntax `Lean.binderIdent) →
optParam (Option ℕ) none → Lean.MetaM (List (Lean.TSyntax `Lean.binderIdent) × Array Lean.FVarId × Lean.MVarId) | Introduce variables, giving them names from a specified list. | true |
RingCon.mkₐ._proof_1 | Mathlib.RingTheory.Congruence.Basic | ∀ (α : Type u_2) {R : Type u_1} [inst : CommSemiring α] [inst_1 : Semiring R] [inst_2 : Algebra α R] (c : RingCon R)
(x : α), (↑↑c.mk').toFun ((algebraMap α R) x) = (↑↑c.mk').toFun ((algebraMap α R) x) | null | false |
SimpleGraph.Copy.toLineGraphEmbedding | Mathlib.Combinatorics.SimpleGraph.LineGraph | {V : Type u_1} → {V' : Type u_2} → {G : SimpleGraph V} → {G' : SimpleGraph V'} → G.Copy G' → G.lineGraph ↪g G'.lineGraph | Lift a copy between graphs to an embedding between their line graphs | true |
Function.Surjective.semiring._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_2} {S : Type u_1} (f : R → S) (hf : Function.Surjective f) [inst : Mul S] [inst_1 : Zero S]
[inst_2 : One S] [inst_3 : Pow S ℕ] [inst_4 : Semiring R] (zero : f 0 = 0) (one : f 1 = 1)
(mul : ∀ (x y : R), f (x * y) = f x * f y) (npow : ∀ (x : R) (n : ℕ), f (x ^ n) = f x ^ n) (x : S), x ^ 0 = 1 | null | false |
IsCompl.IicOrderIsoIci._to_dual_1 | Mathlib.Order.ModularLattice | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : BoundedOrder α] → [IsModularLattice α] → {a b : α} → IsCompl a b → ↑(Set.Ici a) ≃o ↑(Set.Iic b) | null | false |
ContMDiffMap.group._proof_4 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : Topologi... | null | false |
Set.Pairwise.eq | Mathlib.Logic.Pairwise | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α}, s.Pairwise r → a ∈ s → b ∈ s → ¬r a b → a = b | null | true |
AddGroupSeminorm.instSMul._proof_4 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_2} [inst : AddGroup E] [inst_1 : SMul R ℝ] (r : R) (p : AddGroupSeminorm E) (x : E),
r • p (-x) = r • p x | null | false |
ContinuousLinearMap.hasFDerivAtFilter | Mathlib.Analysis.Calculus.FDeriv.Linear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (f : E →L[𝕜] F) {L : Filter (E × E)}, HasFDerivAtFilter (⇑f) f L | null | true |
Lean.PrettyPrinter.ppConstNameWithInfos | Lean.PrettyPrinter | Lean.Name → Lean.MetaM Lean.FormatWithInfos | null | true |
HeytAlg | Mathlib.Order.Category.HeytAlg | Type (u_1 + 1) | The category of Heyting algebras. | true |
Std.DHashMap.Internal.Raw₀.Const.getKey?_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKey? k =
(m.getKey? k).pfilter fun x h' => f x (Std.DHashMap.Inter... | null | true |
Lean.Meta.Grind.EMatchDiagSource._sizeOf_1 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatchDiagSource → ℕ | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₀.match_1.splitter | Mathlib.CategoryTheory.ComposableArrows.Basic | (motive : Fin (0 + 1) → Sort u_1) → (i : Fin (0 + 1)) → ((isLt : 0 < 0 + 1) → motive ⟨0, isLt⟩) → motive i | null | true |
Irrational.of_natCast_add | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (m : ℕ), Irrational (↑m + x) → Irrational x | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_inter_of_contains_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 |
IsNilpotent.op | Mathlib.RingTheory.Nilpotent.Defs | ∀ {R : Type u_1} [inst : MonoidWithZero R] {x : R}, IsNilpotent x → IsNilpotent (MulOpposite.op x) | **Alias** of the reverse direction of `isNilpotent_op`. | true |
Mathlib.Tactic.Echelon.IsPivotedList.casesOn | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α]
{motive : (a : List (Fin n)) → (a_1 : List (List α)) → Mathlib.Tactic.Echelon.IsPivotedList a a_1 → Prop}
{a : List (Fin n)} {a_1 : List (List α)} (t : Mathlib.Tactic.Echelon.IsPivotedList a a_1),
(∀ {rows : List (List α)} (hz : rows = List.map (fun x => List.replicate n 0... | null | false |
List.merge_perm_append._unary | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (le : α → α → Bool) (_x : (_ : List α) ×' List α), (_x.1.merge _x.2 le).Perm (_x.1 ++ _x.2) | null | false |
CategoryTheory.CommShift₂Setup.hε._autoParam | Mathlib.CategoryTheory.Shift.CommShiftTwo | Lean.Syntax | null | false |
Function.locallyFinsuppWithin.single_pos_int_one._simp_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : DecidableEq X] {x : X},
(0 < Function.locallyFinsuppWithin.single x 1) = True | null | false |
AddMonoidAlgebra.instHopfAlgebraStruct._proof_2 | Mathlib.RingTheory.HopfAlgebra.MonoidAlgebra | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Finset.mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : Sigma α) (b : Sigma β) (x : Sigma γ),
x ∈ Finset.sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd) | null | true |
Std.Http.URI.EncodedUserInfo.ofByteArray! | Std.Http.Data.URI.Encoding | ByteArray → Std.Http.URI.EncodedUserInfo | Creates an encoded userinfo component from raw bytes, panicking on invalid encoding.
| true |
CategoryTheory.Abelian.SpectralObject.dKernelSequence_X₃ | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₂₃ : ... | null | true |
_private.Mathlib.RingTheory.PicardGroup.0.Submodule.ker_unitsToPic.match_1_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(I : (Submodule R A)ˣ) (e : R ≃ₗ[R] ↥↑I) (e' : R ≃ₗ[R] ↥↑I⁻¹)
(motive : (∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r) → Prop) (x : ∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r),
(∀ (r : Rˣ) (hr : ↑(e 1) * ↑(e' 1) =... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_1.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lk : α) (lv : β lk)
(size_1 : ℕ) (lrk : α) (lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
... | null | true |
instCommMonoidPNat._proof_7 | Mathlib.Data.PNat.Basic | autoParam (∀ (n : ℕ) (x : ℕ+), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
Units.coe_star_inv | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (u : Rˣ), ↑(star u)⁻¹ = star ↑u⁻¹ | null | true |
Order.IsSuccLimit.bot_lt | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderBot α], Order.IsSuccLimit a → ⊥ < a | null | true |
Std.Net.IPv6Addr.toString | Std.Net.Addr | Std.Net.IPv6Addr → String | Turn `addr` into a `String` in the IPv6 format described in
[RFC 2373](https://datatracker.ietf.org/doc/html/rfc2373).
| true |
AlgebraicGeometry.mono_pushoutSection_of_iSup_eq | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | null | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop | Init.Data.Nat.Fold | {α : Type u} → (n : ℕ) → ((i : ℕ) → i < n → α → α) → (j : ℕ) → j ≤ n → α → α | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.revAll_prop_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String},
s.revAll pat = s.toSlice.revAll pat | null | false |
Lean.Elab.InlayHintKind | Lean.Elab.InfoTree.InlayHints | Type | null | true |
CategoryTheory.forget_obj | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : outParam (C → C → Type u_2)}
{CC : outParam (C → Type w)} [inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))]
[inst_2 : CategoryTheory.ConcreteCategory C FC] (X : C), (CategoryTheory.forget C).obj X = CategoryTheory.ToType X | null | true |
SimpleGraph.natCast_card_dart_eq_dotProduct | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
[inst_2 : NonAssocSemiring α], ↑(Fintype.card G.Dart) = (SimpleGraph.adjMatrix α G).mulVec 1 ⬝ᵥ 1 | The number of all darts in a simple finite graph is equal to the dot product of
`G.adjMatrix α *ᵥ 1` and `1`. | true |
FreeAbelianGroup.liftMonoid._proof_8 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} {R : Type u_2} [inst : Monoid α] [inst_1 : Ring R] (f : α →* R),
(↑{ toFun := ⇑(FreeAbelianGroup.lift ⇑f), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).comp
FreeAbelianGroup.ofMulHom =
f | null | false |
RingHom.id_apply | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α} (x_1 : α), (RingHom.id α) x_1 = x_1 | null | true |
Nat.cast_pow._simp_1 | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) | null | false |
_private.Mathlib.Analysis.Complex.Harmonic.MeanValue.0.InnerProductSpace.HarmonicOnNhd.circleAverage_eq._simp_1_2 | Mathlib.Analysis.Complex.Harmonic.MeanValue | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPoly.match_4.eq_6 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a b : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_3 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (L... | null | true |
List.Cursor.casesOn | Std.Do.Triple.SpecLemmas | {α : Type u} →
{l : List α} →
{motive : l.Cursor → Sort u_1} →
(t : l.Cursor) →
((«prefix» suffix : List α) →
(property : «prefix» ++ suffix = l) →
motive { «prefix» := «prefix», suffix := suffix, property := property }) →
motive t | null | false |
_private.Lean.Compiler.IR.LLVMBindings.0.Lean.LLVM.Builder.mk._flat_ctor | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} → {ctx : Context} → USize → Lean.LLVM.Builder ctx | null | false |
WithIdealFilter.instTopologicalSpace._proof_2 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] {F : IdealFilter A} (s t : Set (WithIdealFilter F)),
(∀ a ∈ s, s ∈ F.addGroupFilterBasis.N a) →
(∀ a ∈ t, t ∈ F.addGroupFilterBasis.N a) → ∀ a ∈ s ∩ t, s ∩ t ∈ F.addGroupFilterBasis.N a | null | false |
Lean.IR.IRType.isDefiniteRef | Lean.Compiler.IR.Basic | Lean.IR.IRType → Bool | null | true |
_private.Init.Data.Sum.Lemmas.0.Sum.exists.match_1_3 | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop} (motive : ((∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)) → Prop)
(x : (∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)),
(∀ (a : α) (h : p (Sum.inl a)), motive ⋯) → (∀ (b : β) (h : p (Sum.inr b)), motive ⋯) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.