name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Geometry.Convex.Cone.Basic.0.ConvexCone.Flat.mono.match_1_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {G : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup G]
[inst_3 : SMul R G] {C₁ : ConvexCone R G} (motive : C₁.Flat → Prop) (x : C₁.Flat),
(∀ (x : G) (hxS : x ∈ C₁) (hx : x ≠ 0) (hnxS : -x ∈ C₁), motive ⋯) → motive x | null | false |
Lean.Grind.Linarith.eq_eq_subst | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] (ctx : Lean.Grind.Linarith.Context α) (x : Lean.Grind.Linarith.Var)
(p₁ p₂ p₃ : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.eq_eq_subst_cert x p₁ p₂ p₃ = true →
Lean.Grind.Linarith.Poly.denote' ctx p₁ = 0 →
Lean.Grind.Linarith.Poly.denote' ctx p₂ = 0 → L... | null | true |
SSet.PtSimplex.relStructCastSuccEquivMulStruct._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex n x} {i : Fin n}
(h : f.RelStruct g i.castSucc),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.succ.succ) h.map = SSet.RelativeMorphism.const.map | null | false |
CategoryTheory.ShortComplex.exact_iff_isZero_leftHomology | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology], S.Exact ↔ CategoryTheory.Limits.IsZero S.leftHomology | null | true |
FormalMultilinearSeries.unshift_shift | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E (E →L[𝕜] F)} {z : F}, (p.unshift z).shift = p | null | true |
CategoryTheory.WithInitial.Hom.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithInitial C),
CategoryTheory.WithInitial.star.Hom x = PUnit.{v + 1} | null | true |
OreLocalization.instMul | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} → [inst : Monoid R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → Mul (OreLocalization S R) | null | true |
HasCompactMulSupport.submonoid.eq_1 | Mathlib.Topology.Algebra.Support | ∀ (α : Type u_2) (β : Type u_4) [inst : TopologicalSpace α] [inst_1 : MulOneClass β],
HasCompactMulSupport.submonoid α β = { carrier := {f | HasCompactMulSupport f}, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
Multiset.toList_eq_nil | Mathlib.Data.Multiset.Basic | ∀ {α : Type u_1} {s : Multiset α}, s.toList = [] ↔ s = 0 | null | true |
CategoryTheory.unmopFunctor._proof_1 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (X : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.id X).unmop = CategoryTheory.CategoryStruct.id X.unmop | null | false |
CategoryTheory.ShortComplex.gFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), CategoryTheory.ShortComplex.gFunctor.obj S = CategoryTheory.Arrow.mk S.g | null | true |
TopCat.piFanIsLimit._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ {ι : Type u_2} (α : ι → TopCat) (S : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor α)),
Continuous fun s i => (CategoryTheory.ConcreteCategory.hom (S.π.app { as := i })) s | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_15 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (cond ifTrue ifFalse : Std.Sat.AIG.Fanin), ifFalse.gate < upper → ifFalse.gate < aig.decls.size | null | false |
_private.Mathlib.Topology.Maps.Basic.0.Topology.IsInducing.dense_iff._simp_1_1 | Mathlib.Topology.Maps.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Bipointed.Hom.mk.noConfusion | Mathlib.CategoryTheory.Category.Bipointed | {X Y : Bipointed} →
{P : Sort u_1} →
{toFun : X.X → Y.X} →
{map_fst : toFun X.toProd.1 = Y.toProd.1} →
{map_snd : toFun X.toProd.2 = Y.toProd.2} →
{toFun' : X.X → Y.X} →
{map_fst' : toFun' X.toProd.1 = Y.toProd.1} →
{map_snd' : toFun' X.toProd.2 = Y.toProd.2} →
... | null | false |
Mathlib.Tactic.Module.NF.algebraMap_cons | Mathlib.Tactic.Module | ∀ {S : Type u_1} (R : Type u_2) {M : Type u_3} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
(p : S × M) (l : Mathlib.Tactic.Module.NF S M),
Mathlib.Tactic.Module.NF.algebraMap R (p ::ᵣ l) =
((algebraMap S R) p.1, p.2) ::ᵣ Mathlib.Tactic.Module.NF.algebraMap R l | null | true |
CommAlgCat.instMonoidalCategory._proof_20 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (X Y : CommAlgCat R),
CategoryTheory.CategoryStruct.comp (CommAlgCat.isoMk (Algebra.TensorProduct.assoc R R R ↑X ↑↧R ↑Y)).hom
(CommAlgCat.ofHom
(Algebra.TensorProduct.map (AlgHom.id R ↑X)
(CommAlgCat.Hom.hom (CommAlgCat.isoMk (Algebra.TensorProduct.lid R ↑Y... | null | false |
cfcₙHomSuperset_apply | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
_private.Init.Data.Order.Ord.0.Std.instOrientedOrdProd._proof_1 | Init.Data.Order.Ord | ∀ {α : Type u_2} {β : Type u_1} [inst : Ord α] [inst_1 : Ord β] [Std.OrientedOrd α] [Std.OrientedOrd β],
Std.OrientedOrd (α × β) | null | false |
conjneg_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R], conjneg 1 = 1 | null | true |
CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isIso_hom | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.LeftExtension F}
(h : E.IsPointwiseLeftKanExtension)... | null | true |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimitCore) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x | null | true |
VAddCommClass.op_left | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α]
[inst_3 : VAdd N α] [VAddCommClass M N α], VAddCommClass Mᵃᵒᵖ N α | null | true |
Std.TreeSet.mk._flat_ctor | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1} → Std.TreeMap α Unit cmp → Std.TreeSet α cmp | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData._sizeOf_1 | 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} → {S : C} → [SizeOf C₀] → [SizeOf C] → F.PreOneHypercoverDenseData S → ℕ | null | false |
USize.decEq | Init.Prelude | (a b : USize) → Decidable (a = b) | Decides whether two word-sized unsigned integers are equal. Usually accessed via the
`DecidableEq USize` instance.
This function is overridden at runtime with an efficient implementation.
Examples:
* `USize.decEq 123 123 = .isTrue rfl`
* `(if (6 : USize) = 7 then "yes" else "no") = "no"`
* `show (7 : USize) = 7 by... | true |
ContDiffMapSupportedIn.topologicalSpace._proof_4 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), IsBoundedSMul ℝ (E [×i]→L[ℝ] F) | null | false |
MonoidHom.cancel_right | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : MulOne M] [inst_1 : MulOne N] [inst_2 : MulOne P]
{g₁ g₂ : N →* P} {f : M →* N}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
Subfield.relfinrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relfinrank C = B.relfinrank C | null | true |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ioc._simp_1_3 | Mathlib.Order.Interval.Set.Fin | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.SpecialLinearGroup.diag2_coe.match_1.splitter | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | (motive : Fin 2 → Sort u_1) → (i : Fin 2) → (Unit → motive 0) → (Unit → motive 1) → motive i | null | true |
Std.Iterators.Types.Flatten.it₂ | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} → {m : Type w → Type u_1} → Std.Iterators.Types.Flatten α α₂ β m → Option (Std.IterM m β) | null | true |
Std.Internal.List.isEmpty_replaceEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k : α} {v : β k},
(Std.Internal.List.replaceEntry k v l).isEmpty = l.isEmpty | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocContext.closeAll | Lean.DocString.Extension | Lean.VersoModuleDocs.DocContext✝ → Except String Lean.VersoModuleDocs.DocContext✝ | null | true |
Lean.NameHashSet | Lean.Data.NameMap.Basic | Type | null | true |
OrderRingHom.toRingHom_apply | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β) (a : α), ↑f a = f a | null | true |
Std.LawfulOrderLT.mk | Init.Data.Order.Classes | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α], (∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a) → Std.LawfulOrderLT α | null | true |
Lean.Elab.Command.Scope.mk._flat_ctor | Lean.Elab.Command.Scope | String →
Lean.Options →
Lean.Name →
List Lean.OpenDecl →
List Lean.Name →
Array (Lean.TSyntax `Lean.Parser.Term.bracketedBinder) →
Array Lean.Name →
List Lean.Name →
List Lean.Name →
Bool → Bool → Bool → List (Lean.TSyntax `Lean.P... | null | false |
Set.BijOn.toPartialEquiv.congr_simp | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Nonempty α] (f f_1 : α → β) (e_f : f = f_1) (s s_1 : Set α) (e_s : s = s_1)
(t t_1 : Set β) (e_t : t = t_1) (hf : Set.BijOn f s t),
Set.BijOn.toPartialEquiv f s t hf = Set.BijOn.toPartialEquiv f_1 s_1 t_1 ⋯ | null | true |
Lean.Meta.DefEqContext.mk.sizeOf_spec | Lean.Meta.Basic | ∀ (lhs rhs : Lean.Expr) (lctx : Lean.LocalContext) (localInstances : Lean.LocalInstances),
sizeOf { lhs := lhs, rhs := rhs, lctx := lctx, localInstances := localInstances } =
1 + sizeOf lhs + sizeOf rhs + sizeOf lctx + sizeOf localInstances | null | true |
List.prefix_iff_getElem? | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ ↔ ∀ (i : ℕ) (h : i < l₁.length), l₂[i]? = some l₁[i] | null | true |
TensorProduct.instBialgebra._proof_2 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S | null | false |
_private.Mathlib.Topology.NoetherianSpace.0.TopologicalSpace.NoetherianSpace.exists_finite_set_closeds_irreducible._simp_1_3 | Mathlib.Topology.NoetherianSpace | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
UniformConvergenceCLM.«_aux_Mathlib_Topology_Algebra_Module_Spaces_UniformConvergenceCLM___delab_app_UniformConvergenceCLM_term_→SLᵤ[_,_]__1» | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Polynomial.smeval_neg | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Ring R] {S : Type u_2} [inst_1 : AddCommGroup S] [inst_2 : Pow S ℕ] [inst_3 : Module R S]
(p : Polynomial R) (x : S), (-p).smeval x = -p.smeval x | null | true |
TopCat.Presheaf.stalkSpecializes_comp_apply | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
(F : TopCat.Presheaf C X) {x y z : ↑X} (h : x ⤳ y) (h' : y ⤳ z) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : Category... | null | true |
ExceptCpsT.runK | Init.Control.ExceptCps | {m : Type u → Type u_1} → {β ε α : Type u} → ExceptCpsT ε m α → (α → m β) → (ε → m β) → m β | Use a monadic action that may throw an exception by providing explicit success and failure
continuations.
| true |
List.eraseP_replicate_of_pos | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {n : ℕ} {a : α},
p a = true → List.eraseP p (List.replicate n a) = List.replicate (n - 1) a | null | true |
Std.IterM._sizeOf_inst | Init.Data.Iterators.Basic | {α : Type w} →
(m : Type w → Type w') →
(β : Type w) → [SizeOf α] → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → SizeOf (Std.IterM m β) | null | false |
MeasureTheory.Measure.pi.isAddHaarMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → AddGroup (α i)] [inst_4 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsAddHaarMeasure]
[∀ (i : ι),... | null | true |
CategoryTheory.Limits.IsWeakLimit.noConfusion | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | {P : Sort u} →
{J : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} J} →
{C : Type u_3} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C} →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
{t_1 : CategoryTheory.Limits.IsWeakLimit t} →... | null | false |
IsLeftContinuous.fun_add | Mathlib.Topology.Order.Cadlag | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f g : X → Y} [inst_1 : Preorder X]
[inst_2 : TopologicalSpace Y] [inst_3 : Add Y] [ContinuousAdd Y],
IsLeftContinuous f → IsLeftContinuous g → IsLeftContinuous fun i => f i + g i | null | true |
Std.Http.Config.maxHeaderBytes | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum aggregate byte size of all header field lines in a single message
(name + value bytes plus 4 bytes per line for `: ` and `\r\n`). Default: 64 KiB.
| true |
ProbabilityTheory.gaussianReal_map_sub_const | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (y : ℝ),
MeasureTheory.Measure.map (fun x => x - y) (ProbabilityTheory.gaussianReal μ v) =
ProbabilityTheory.gaussianReal (μ - y) v | null | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1_6 | Mathlib.Algebra.Homology.ExactSequence | 2 < 2 + 1 | null | false |
Lean.Meta.Grind.instInhabitedCasesEntry.default | Lean.Meta.Tactic.Grind.Cases | Lean.Meta.Grind.CasesEntry | null | true |
_private.Mathlib.RingTheory.Localization.NormTrace.0.Algebra.trace_localization._simp_1_1 | Mathlib.RingTheory.Localization.NormTrace | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
lp.instNormedSpace | Mathlib.Analysis.Normed.Lp.lpSpace | {𝕜 : Type u_1} →
{α : Type u_3} →
{E : α → Type u_4} →
{p : ENNReal} →
[inst : (i : α) → NormedAddCommGroup (E i)] →
[inst_1 : NormedField 𝕜] → [(i : α) → NormedSpace 𝕜 (E i)] → [inst_3 : Fact (1 ≤ p)] → NormedSpace 𝕜 ↥(lp E p) | null | true |
Float.Model.UnpackedFloat.unpack.fun_cases_unfolding | Batteries.Data.Float.Lemmas | ∀ (spec : Float.Model.Format) (b : BitVec spec.numBits) (motive : Float.Model.UnpackedFloat → Prop),
(have mantissaVec := Float.Model.UnpackedFloat.unpackMantissa b;
have exponentVec := Float.Model.UnpackedFloat.unpackExponent b;
have signVec := Float.Model.UnpackedFloat.unpackSign b;
have sign := Float.M... | null | true |
List.getElem_intersperse_two_mul_add_one | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {sep : α} {i : ℕ} (h : 2 * i + 1 < (List.intersperse sep l).length),
(List.intersperse sep l)[2 * i + 1] = sep | null | true |
TwoSidedIdeal.recOn | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} →
[inst : NonUnitalNonAssocRing R] →
{motive : TwoSidedIdeal R → Sort u} →
(t : TwoSidedIdeal R) → ((ringCon : RingCon R) → motive { ringCon := ringCon }) → motive t | null | false |
BoundedRandom.noConfusion | Mathlib.Control.Random | {P : Sort u_2} →
{m : Type u → Type u_1} →
{α : Type u} →
{inst : Preorder α} →
{t : BoundedRandom m α} →
{m' : Type u → Type u_1} →
{α' : Type u} →
{inst' : Preorder α'} →
{t' : BoundedRandom m' α'} →
m = m' → α = α' → inst ≍ ins... | null | false |
Stream'.Seq.update_cons_zero | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α),
(Stream'.Seq.cons hd tl).update 0 f = Stream'.Seq.cons (f hd) tl | null | true |
Finset.inv_empty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α], ∅⁻¹ = ∅ | null | true |
Fin.instNeZeroHAddNatOfNat_mathlib_1 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [NeZero n], NeZero 1 | null | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.checkAllDeclNamesDistinct | Lean.Elab.MutualDef | Array Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit | Ensures that all declarations given by `preDefs` have distinct names.
Remark: we wait to perform this check until the pre-definition phase because we must account for
auxiliary declarations introduced by `where` and `let rec`.
| true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getD.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] (a : α) (fallback : β),
Std.DHashMap.Internal.AssocList.getD a fallback Std.DHashMap.Internal.AssocList.nil = fallback | null | true |
CategoryTheory.Quotient.functor_additive | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (r : HomRel C)
[inst_2 : CategoryTheory.Congruence r]
(hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y), r f₁ f₂ → r g₁ g₂ → r (f₁ + g₁) (f₂ + g₂)),
(CategoryTheory.Quotient.functor r).Additive | null | true |
Monotone.leftLim_le | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Monotone f → ∀ {x y : α}, x ≤ y → Function.leftLim f x ≤ f y | null | true |
Field.toSemifield._proof_1 | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_1} [inst : Field K] (a b : K), a * b = b * a | null | false |
instContinuousConstSMulMatrix | Mathlib.Topology.Instances.Matrix | ∀ {α : Type u_2} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : SMul α R]
[ContinuousConstSMul α R], ContinuousConstSMul α (Matrix m n R) | null | true |
LocallyFiniteOrder.orderAddMonoidHom.congr_simp | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_2) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : LocallyFiniteOrder G], LocallyFiniteOrder.orderAddMonoidHom G = LocallyFiniteOrder.orderAddMonoidHom G | null | true |
CategoryTheory.Limits.HasBiproduct.of_hasProduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[Finite J] (f : J → C) [CategoryTheory.Limits.HasProduct f], CategoryTheory.Limits.HasBiproduct f | In a preadditive category, if the product over `f : J → C` exists,
then the biproduct over `f` exists. | true |
Lean.LevelMetavarDecl | Lean.MetavarContext | Type | null | true |
CompactlySupportedContinuousMap.coe_inf._simp_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousInf β] (f g : CompactlySupportedContinuousMap α β),
⇑f ⊓ ⇑g = ⇑(f ⊓ g) | null | false |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {C : Type u_2} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (x : B),
CategoryTheory.CategoryStruct.id (S.obj x) = S.map (CategoryTheory.CategoryStruct.id x) | null | false |
Int.gcd.eq_1 | Init.Data.Int.Linear | ∀ (m n : ℤ), m.gcd n = m.natAbs.gcd n.natAbs | null | true |
map_ratCast_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_3}
[inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (R : Type u_4) (S : Type u_5) [inst_4 : DivisionRing R]
[inst_5 : DivisionRing S] [inst_6 : Module R M] [inst_7 : Module S M₂] (c : ℚ) (x : M), f (↑c • x) =... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.printEqns._regBuiltin.Lean.Parser.Command.printEqns_1 | Lean.Parser.Command | IO Unit | null | false |
Std.ExtTreeSet.isEmpty_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {l : List α},
(t.insertMany l).isEmpty = (t.isEmpty && l.isEmpty) | null | true |
UpperHalfPlane.instIsPretransitiveGeneralLinearGroupFinOfNatNatReal | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | MulAction.IsPretransitive (GL (Fin 2) ℝ) UpperHalfPlane | null | true |
sInfHom.dual_apply_toFun | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] (f : sInfHom α β) (a : αᵒᵈ),
(sInfHom.dual f) a = (⇑OrderDual.toDual ∘ ⇑f ∘ ⇑OrderDual.ofDual) a | null | true |
Std.Time.Database.WindowsDb.default | Std.Time.Zoned.Database.Windows | Std.Time.Database.WindowsDb | Returns a default `WindowsDb` instance.
| true |
Lean.Meta.Grind.SplitAnchorRefInfo.anchor | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitAnchorRefInfo → UInt64 | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_σ_comp_of_not_injective._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (x y : Fin (n + 1 + 1)), ¬x = y → ¬x < y → y < x | null | false |
FGModuleCat.instCreatesColimitsOfShapeModuleCatForget₂LinearMapIdCarrierObjIsFG | Mathlib.Algebra.Category.FGModuleCat.Colimits | {J : Type} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.FinCategory J] →
{k : Type u} →
[inst_2 : Ring k] →
CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k)) | null | true |
Std.DHashMap.Internal.AssocList.getKey._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
(a : α) → (l : Std.DHashMap.Internal.AssocList α β) → Std.DHashMap.Internal.AssocList.contains a l = true → α | null | false |
Lean.Parser.FirstTokens.tokens.inj | Lean.Parser.Types | ∀ {a a_1 : List Lean.Parser.Token}, Lean.Parser.FirstTokens.tokens a = Lean.Parser.FirstTokens.tokens a_1 → a = a_1 | null | true |
Nat.a_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, 'a' = n.digitChar ↔ n = 10 | null | true |
Finset.instMulLeftMono | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], MulLeftMono (Finset α) | null | true |
Submodule.orthogonalBilin_iSup | Mathlib.LinearAlgebra.SesquilinearForm.Orthogonal | ∀ {R : Type u_1} {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_4} {M₁ : Type u_5} {M₂ : Type u_6} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : CommSemiring R₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R₁ M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Mod... | null | true |
instSemiringCorner._proof_5 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalSemiring R] (idem : IsIdempotentElem e) (a b c : idem.Corner),
a + b + c = a + (b + c) | null | false |
RBTree.RBNode.All.upperBound?_ub | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {p : α → Prop} {ub : Option α} {cut : α → Ordering} {x : α} {t : RBTree.RBNode α},
RBTree.RBNode.All p t → (∀ {x : α}, ub = some x → p x) → RBTree.RBNode.upperBound? cut t ub = some x → p x | null | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.intercalate.go.match_1.eq_2 | Init.Data.String.Lemmas.Intercalate | ∀ (motive : List String → Sort u_1) (h_1 : (a : String) → (as : List String) → motive (a :: as))
(h_2 : Unit → motive []),
(match [] with
| a :: as => h_1 a as
| [] => h_2 ()) =
h_2 () | null | true |
minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Ring E] [IsDomain E] [inst_3 : Algebra F E] (q : ℕ)
[hF : ExpChar F q] {x : E},
(minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = (Polynomial.expand F (q ^ n)) (Polynomial.X - Polynomial.C y) | The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`Polynomial.expand F (q ^ n) (X - C y)` for some `n : ℕ` and `y : F`. | true |
le_iff_forall_isCompactElement | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b : α} [IsCompactlyGenerated α],
a ≤ b ↔ ∀ (x : α), IsCompactElement x → x ≤ a → x ≤ b | null | true |
Submonoid.powers._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (n n_1 : M) (i : ℕ), (fun x => n ^ x) i = n_1 ↔ ((powersHom M) n) i = n_1 | null | false |
LowerSet.erase_lt._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α}, (s.erase a < s) = (a ∈ s) | null | false |
Std.ExtDHashMap.containsThenInsert.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β),
m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.containsThenInsert a b = m_1.containsThenInsert a b_1 | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.isBigO_image_sub_image_sub_deriv_principal._simp_1_4 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.