name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Quaternion.instNormOneClassReal | Mathlib.Analysis.Quaternion | NormOneClass (Quaternion ℝ) | null | true |
Ordnode.removeNth._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → ℕ → Ordnode α | null | false |
_private.Mathlib.SetTheory.Cardinal.EventuallyConst.0.Ordinal.eventuallyConst_of_monotone._simp_1_1 | Mathlib.SetTheory.Cardinal.EventuallyConst | ∀ {α : Type u}, (Cardinal.lift.{v + 1, u} (Cardinal.mk α) < Cardinal.univ.{v, max u (v + 1)}) = Small.{v, u} α | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryGTD | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → [Ord α] → α → (Std.DTreeMap.Internal.Impl α fun x => β) → α × β → α × β | Implementation detail of the tree map | true |
Lean.Elab.ConfigEval.EvalConfigItemHandler.mk | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Syntax →
Lean.Name →
Lean.Elab.ConfigEval.EvalConfigItemHandlerKind →
Lean.Term → Option Lean.Name → Option Lean.Name → Lean.Elab.ConfigEval.EvalConfigItemHandler | null | true |
Submodule.isIdempotentElemEquiv._proof_3 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_2} [inst : Ring R] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p : Submodule R E)
(f : { f // IsIdempotentElem f ∧ LinearMap.range f = p }) (x : E), ↑f x ∈ p | null | false |
instConcreteCategoryProfiniteGrpContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfinite._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : ProfiniteGrp.{u_1}} (f : ↑X.toProfinite.toTop →ₜ* ↑Y.toProfinite.toTop), { hom' := f }.hom' = f | null | false |
SimpleGraph.incidence_other_prop | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) [inst : DecidableEq V] {v : V} {e : Sym2 V} (h : e ∈ G.incidenceSet v),
G.otherVertexOfIncident h ∈ G.neighborSet v | null | true |
_private.Mathlib.Data.List.Sort.0.List.sortedGT_iff_pairwise._proof_1_4 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} (i : ℕ), i + 1 ≤ l.length → i < l.length | null | false |
AlgebraicGeometry.WeaklyEtale.instMorphismRestrict | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (V : Y.Opens) [AlgebraicGeometry.WeaklyEtale f],
AlgebraicGeometry.WeaklyEtale (f ∣_ V) | null | true |
MvPolynomial.funext_set_iff | Mathlib.Algebra.MvPolynomial.Funext | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] {σ : Type u_2} {p q : MvPolynomial σ R} (s : σ → Set R),
(∀ (i : σ), (s i).Infinite) → (p = q ↔ ∀ x ∈ Set.univ.pi s, (MvPolynomial.eval x) p = (MvPolynomial.eval x) q) | null | true |
SimpleGraph.chromaticNumber_le_iff_colorable | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ}, G.chromaticNumber ≤ ↑n ↔ G.Colorable n | null | true |
_private.Mathlib.Tactic.NormNum.GCD.0.Mathlib.Meta.NormNum.isInt_lcm.match_1_1 | Mathlib.Tactic.NormNum.GCD | ∀
(motive :
(x x_1 x_2 x_3 : ℤ) →
(x_4 : ℕ) → Mathlib.Meta.NormNum.IsInt x x_2 → Mathlib.Meta.NormNum.IsInt x_1 x_3 → x_2.lcm x_3 = x_4 → Prop)
(x x_1 x_2 x_3 : ℤ) (x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsInt x x_2) (x_6 : Mathlib.Meta.NormNum.IsInt x_1 x_3)
(x_7 : x_2.lcm x_3 = x_4),
(∀ (n n_1 : ℤ), m... | null | false |
Submonoid.unop.eq_1 | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] (x : Submonoid Mᵐᵒᵖ),
x.unop = { carrier := MulOpposite.op ⁻¹' ↑x, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
Lean.Meta.Sym.DSimp.Result.recOn | Lean.Meta.Sym.DSimp.DSimpM | {motive : Lean.Meta.Sym.DSimp.Result → Sort u} →
(t : Lean.Meta.Sym.DSimp.Result) →
((done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.rfl done)) →
((e' : Lean.Expr) → (done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.step e' done)) → motive t | null | false |
Std.DTreeMap.Equiv.of_forall_getKey?_unit_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {t₁ t₂ : Std.DTreeMap α (fun x => Unit) cmp},
(∀ (k : α), t₁.getKey? k = t₂.getKey? k) → t₁.Equiv t₂ | null | true |
MeromorphicAt.eventuallyEq_zero_nhdsNE_of_eventuallyEq_zero_codiscreteWithin | Mathlib.Analysis.Meromorphic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {U : Set 𝕜} {x : 𝕜} {f : 𝕜 → E},
MeromorphicAt f x →
x ∈ U → AccPt x (Filter.principal U) → f =ᶠ[Filter.codiscreteWithin U] 0 → f =ᶠ[nhdsWithin x {x}ᶜ] 0 | Variant of the principle of isolated zeros: Let `U` be a subset of `𝕜` and assume that `x ∈ U` is
not an isolated point of `U`. If a function `f` is meromorphic at `x` and vanishes along a subset
that is codiscrete within `U`, then `f` vanishes in a punctured neighbourhood of `f`.
For a typical application, let `U` b... | true |
Lean.Elab.Term.BodyInfo.rec | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.BodyInfo → Sort u} →
((value? : Option Lean.Expr) → motive { value? := value? }) → (t : Lean.Elab.Term.BodyInfo) → motive t | null | false |
Std.Http.Protocol.H1.RedirectPlan.rec | Std.Http.Protocol.H1.Redirect | {motive : Std.Http.Protocol.H1.RedirectPlan → Sort u} →
((origin : Std.Http.URI.Origin) →
(target : Std.Http.RequestTarget) →
(method : Std.Http.Method) →
(headers : Std.Http.Headers) →
(bodyAction : Std.Http.Protocol.H1.RedirectBodyAction) →
(isCrossOrigin : Bool) →
... | null | false |
_private.Mathlib.CategoryTheory.Dialectica.Monoidal.0.CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___macroRules__private_Mathlib_CategoryTheory_Dialectica_Monoidal_0_CategoryTheory_Dial_termπ₁_1 | Mathlib.CategoryTheory.Dialectica.Monoidal | Lean.Macro | null | false |
CategoryTheory.ShortComplex.opcyclesMap_zero | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S₁ S₂ : CategoryTheory.ShortComplex C) [inst_2 : S₁.HasRightHomology] [inst_3 : S₂.HasRightHomology],
CategoryTheory.ShortComplex.opcyclesMap 0 = 0 | null | true |
CompleteLatticeHom.cancel_right | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
[inst_2 : CompleteLattice γ] {g₁ g₂ : CompleteLatticeHom β γ} {f : CompleteLatticeHom α β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
add_left_inj._simp_1 | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] (a : G) {b c : G}, (b + a = c + a) = (b = c) | null | false |
Lean.Compiler.LCNF.StructProjCases.mkFieldParamsForCtorType | Lean.Compiler.LCNF.StructProjCases | Lean.Expr → ℕ → ℕ → Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) | null | true |
Matroid.closure_sInter_eq_biInter_closure_of_sUnion_indep | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} (Is : Set (Set α)),
Is.Nonempty → M.Indep (⋃₀ Is) → M.closure (⋂₀ Is) = ⋂ I ∈ Is, M.closure I | null | true |
RingHom.prod._proof_5 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_3} {S : Type u_2} {T : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
[inst_2 : NonAssocSemiring T] (f : R →+* S) (g : R →+* T), (↑((↑f).prod ↑g)).toFun 0 = 0 | null | false |
GenContFract.convs'.eq_1 | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_2} [inst : DivisionRing K] (g : GenContFract K) (n : ℕ), g.convs' n = g.h + GenContFract.convs'Aux g.s n | null | true |
cantorSequence.eq_1 | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ), cantorSequence x = Stream'.iterate cantorStep x | null | true |
IsLowerSet | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → [LE α] → Set α → Prop | A lower set in an order `α` is a set such that any element less than one of its
members is also a member. Also called down-set, downward-closed set. | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneLift._proof_2 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{t₁ t₂ : CategoryTheory.Limits.Cone K} (f : t₁ ⟶ t₂) (x : CategoryTheory.WithTerminal J),
CategoryTheory.CategoryStruct.comp ... | null | false |
CategoryTheory.Functor.IsEquivalence.recOn | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.IsEquivalence → Sort u} →
(t : F.IsEquivalence) →
((faithful : F.Faithful) → (full : F.Full... | null | false |
Lean.Grind.instCommRingUInt16._proof_2 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : UInt16), n • a = ↑n * a | null | false |
BesselPotentialSpace.casesOn | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | {E : Type u_1} →
{F : Type u_2} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : InnerProductSpace ℝ E] →
[inst_3 : FiniteDimensional ℝ E] →
[inst_4 : MeasurableSpace E] →
[inst_5 : BorelSpace E] →
[inst_6 : CompleteSpa... | null | false |
_private.Mathlib.Algebra.Order.Ring.Canonical.0.CanonicallyOrderedAdd.mul_pos._simp_1_2 | Mathlib.Algebra.Order.Ring.Canonical | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
Aesop.PhaseName._sizeOf_inst | Aesop.Rule.Name | SizeOf Aesop.PhaseName | null | false |
_private.Mathlib.Algebra.MvPolynomial.Monad.0.MvPolynomial.bind₁_bind₁._simp_1_2 | Mathlib.Algebra.MvPolynomial.Monad | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] [inst_2 : Algebra R S₁]
(f : σ → S₁) {B : Type u_2} [inst_3 : CommSemiring B] [inst_4 : Algebra R B] (φ : S₁ →ₐ[R] B),
(MvPolynomial.aeval fun i => φ (f i)) = φ.comp (MvPolynomial.aeval f) | null | false |
Mathlib.Tactic.Ring.Common.evalDiv | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a b : Q(«$α»)} →
(rα : ... | Divides two polynomials `va, vb` to get a normalized result polynomial.
* `a / b = a * b⁻¹`
| true |
hasFTaylorSeriesUpToOn_top_iff_add | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : 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 : Set E}
{f : E → F} {N : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
↑⊤ ≤ N → ∀ (k : ℕ), HasFTaylorS... | null | true |
Aesop.MVarClusterUnsafe.recOn | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
_private.Mathlib.Topology.Inseparable.0.stableUnderGeneralization_iff_exists_sInter_eq.match_1_3 | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} (S : Set (Set X)) (s : Set X) (motive : s ∈ (fun x => xᶜ) '' S → Prop) (x : s ∈ (fun x => xᶜ) '' S),
(∀ (t : Set X) (ht : t ∈ S) (e : (fun x => xᶜ) t = s), motive ⋯) → motive x | null | false |
_private.Mathlib.Analysis.Polynomial.Basic.0.Polynomial.tendsto_atBot_iff_leadingCoeff_nonpos._simp_1_3 | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P : Polynomial 𝕜)
[OrderTopology 𝕜],
Filter.Tendsto (fun x => Polynomial.eval x P) Filter.atTop Filter.atTop = (0 < P.degree ∧ 0 ≤ P.leadingCoeff) | null | false |
ULift.instCompleteLattice._proof_3 | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_2} [inst : CompleteLattice α] {x y : ULift.{u_1, u_2} α}, x.down ≤ y.down ↔ x.down ≤ y.down | null | false |
Lean.Widget.WidgetInstance.ctorIdx | Lean.Widget.Types | Lean.Widget.WidgetInstance → ℕ | null | false |
CategoryTheory.Limits.Multicofork.IsColimit.fac_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} {K : CategoryTheory.Limits.Multicofork I}
(hK : CategoryTheory.Limits.IsColimit K) {T : C} (k : (a : J.R) → I.right a ⟶ T)
(hk :
∀ (b : J.L),
CategoryTheory.... | null | true |
CategoryTheory.Limits.PreservesPushout.inr_iso_inv_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y)
[inst_2 : CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G]
[inst_3 : CategoryTheory.Limits.HasPusho... | null | true |
Matrix.conjTransposeLinearEquiv | Mathlib.LinearAlgebra.Matrix.ConjTranspose | (m : Type u_2) →
(n : Type u_3) →
(R : Type u_5) →
(α : Type v) →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : AddCommMonoid α] →
[inst_3 : StarAddMonoid α] → [inst_4 : Module R α] → [StarModule R α] → Matrix m n α ≃ₗ⋆[R] Matrix n m α | `Matrix.conjTranspose` as a `LinearMap` | true |
CategoryTheory.Dial.tensorObj_tgt | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X Y : CategoryTheory.Dial C),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).tgt = (X.tgt ⨯ Y.tgt) | null | true |
hasFDerivAtFilter_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {L : Filter (E × E)} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{Φ' : E →L[𝕜]... | null | true |
MeasureTheory.instSFiniteOfNatMeasure | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α}, MeasureTheory.SFinite 0 | null | true |
LowerSemicontinuousOn.exists_isMinOn | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : α → β} [inst_1 : LinearOrder β] {s : Set α},
s.Nonempty → IsCompact s → LowerSemicontinuousOn f s → ∃ a ∈ s, IsMinOn f s a | A lower semicontinuous function attains its lower bound on a nonempty compact set. | true |
VAdd.ofStabilizer._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ (G : Type u_2) [inst : AddGroup G] (α : Type u_1) [inst_1 : AddAction G α] (s : Set α)
(g : ↥(AddAction.stabilizer G s)) (x : ↑s), g +ᵥ ↑x ∈ s | null | false |
_private.Lean.Environment.0.Lean.AsyncContext.descr | Lean.Environment | Lean.AsyncContext✝ → String | null | true |
_private.Mathlib.Analysis.Convex.Segment.0.insert_endpoints_openSegment._simp_1_5 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), (openSegment 𝕜 x y ⊆ segment 𝕜 x y) = True | null | false |
Alexandrov.principals._proof_3 | Mathlib.Topology.Sheaves.Alexandrov | ∀ (X : Type u_1) [inst : TopologicalSpace X] [inst_1 : Preorder X] [inst_2 : Topology.IsUpperSet X] {x y : X}
(f : x ⟶ y), Alexandrov.principalOpen y ≤ Alexandrov.principalOpen x | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isRevMatch_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {s : String.Slice} {p : s.Pos} {t₂ : String}, ((s.sliceFrom p).copy = t₂) = ∃ t₁, p.Splits t₁ t₂ | null | false |
DoResultPR.return.sizeOf_spec | Init.Core | ∀ {α β σ : Type u} [inst : SizeOf α] [inst_1 : SizeOf β] [inst_2 : SizeOf σ] (a : β) (a_1 : σ),
sizeOf (DoResultPR.return a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
cardinal_lt_aleph0_of_finiteDimensional | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ (K : Type u) (V : Type v) [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Finite K] [Module.Free K V] [Module.Finite K V], Cardinal.mk V < Cardinal.aleph0 | null | true |
AlgebraicGeometry.Scheme.PartialMap.le_domain_toRationalMap | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialMap Y), f.domain ≤ f.toRationalMap.domain | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic.0.Affine.Simplex.affineCombination_mem_closedInterior_face_iff_nonneg.match_1_1 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} [inst : Ring k] [inst_1 : PartialOrder k] {n : ℕ} {fs : Finset (Fin (n + 1))} {w : Fin (n + 1) → k}
(motive : ((∀ i ∈ fs, 0 ≤ w i) ∧ ∀ i ∉ fs, w i = 0) → Prop) (x : (∀ i ∈ fs, 0 ≤ w i) ∧ ∀ i ∉ fs, w i = 0),
(∀ (hii : ∀ i ∈ fs, 0 ≤ w i) (hi0 : ∀ i ∉ fs, w i = 0), motive ⋯) → motive x | null | false |
Std.DTreeMap.Internal.Impl.Const.alter._unsafe_rec | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α (fun x => β) (t.size - 1) (t.size + 1) | null | false |
_private.Init.Data.Int.Gcd.0.Int.pow_dvd_pow_iff._simp_1_1 | Init.Data.Int.Gcd | ∀ {a b : ℤ}, (a ∣ b) = (a.natAbs ∣ b.natAbs) | null | false |
Right.add_nonneg | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightMono α], 0 ≤ a → b ≤ c → b ≤ a + c | Assumes right covariance.
The lemma assuming left covariance is `Left.add_nonneg`. | true |
Lean.MetavarContext.LevelMVarToParam.Context.mk | Lean.MetavarContext | Lean.Name → (Lean.Name → Bool) → (Lean.LMVarId → Bool) → Lean.MetavarContext.LevelMVarToParam.Context | null | true |
HasFDerivAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {x : E},
HasFDerivAt f f' x → HasFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x | null | true |
Lean.Grind.AC.Seq.beq'.eq_1 | Init.Grind.AC | ∀ (s₁ : Lean.Grind.AC.Seq),
s₁.beq' =
Lean.Grind.AC.Seq.rec (motive := fun x => Lean.Grind.AC.Seq → Bool)
(fun x s₂ => Lean.Grind.AC.Seq.rec (fun y => Nat.beq x y) (fun x x_1 x_2 => false) s₂)
(fun x x_1 ih s₂ => Lean.Grind.AC.Seq.rec (fun x => false) (fun y s₂ x_2 => Nat.beq x y && ih s₂) s₂) s₁ | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.decodeOrdering.match_1 | Batteries.Data.Fin.Coding | (motive : Fin 3 → Sort u_1) → (x : Fin 3) → (Unit → motive 0) → (Unit → motive 1) → (Unit → motive 2) → motive x | null | false |
AlgebraicTopology.DoldKan.DegeneraciesVanish | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Preadditive C] →
{X : CategoryTheory.SimplicialObject C} → {n : ℕ} → {T : C} → (X.obj (Opposite.op { len := n }) ⟶ T) → Prop | If `X` is a simplicial object in a preadditive category and `f : X _⦋n⦌ ⟶ T`
is a morphism, we say that is vanishes on degeneracies if `n = 0` or if
maps `X.σ i ≫ f` all vanish. | true |
ModelWithCorners.leftInverse | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
Function.LeftInverse ↑I.symm ↑I | null | true |
Lean.Grind.Linarith.Poly.append.eq_def | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly),
p₁.append p₂ =
match p₁ with
| Lean.Grind.Linarith.Poly.nil => p₂
| Lean.Grind.Linarith.Poly.add k x p₁ => Lean.Grind.Linarith.Poly.add k x (p₁.append p₂) | null | true |
toMeromorphicNFAt | Mathlib.Analysis.Meromorphic.NormalForm | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} → [inst_1 : NormedAddCommGroup E] → [NormedSpace 𝕜 E] → (𝕜 → E) → 𝕜 → 𝕜 → E | If `f` is meromorphic at `x`, convert `f` to normal form at `x` by changing its value at `x`.
Otherwise, returns the 0 function. | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.intercalate.match_1.splitter | Init.Data.String.Lemmas.Intercalate | (motive : List String → Sort u_1) →
(x : List String) → (Unit → motive []) → ((a : String) → (as : List String) → motive (a :: as)) → motive x | null | true |
fourierCoeffOn_of_hasDerivAt_Ioo | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ} {n : ℤ},
n ≠ 0 →
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt f (f' x) x) →
IntervalIntegrable f' MeasureTheory.volume a b →
fourierCoeffOn hab f n =
1 / (-2 * ↑Real.pi * Complex.I * ↑n) *
... | Express Fourier coefficients of `f` on an interval in terms of those of its derivative. | true |
MonoidAlgebra.semiring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Monoid M] (x : MonoidAlgebra R M), x ^ 0 = 1 | null | false |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.lo_eq_false_of_le._proof_1_1 | Init.Grind.Offset | ∀ (u v k : ℕ), 0 < k → u ≤ v → ¬u < v + k → False | null | false |
commandSudoSet_option___ | Mathlib.Tactic.SudoSetOption | Lean.ParserDescr | The command `sudo set_option name val` is similar to `set_option name val`,
but it also allows to set undeclared options.
| true |
CliffordAlgebraComplex.equiv | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | CliffordAlgebra CliffordAlgebraComplex.Q ≃ₐ[ℝ] ℂ | The clifford algebras over `CliffordAlgebraComplex.Q` is isomorphic as an `ℝ`-algebra to `ℂ`. | true |
Mathlib.Tactic.Ring.CSLift.rec | Mathlib.Tactic.Ring.Basic | {α β : Type u} →
{motive : Mathlib.Tactic.Ring.CSLift α β → Sort u_1} →
((lift : α → β) → (inj : Function.Injective lift) → motive { lift := lift, inj := inj }) →
(t : Mathlib.Tactic.Ring.CSLift α β) → motive t | null | false |
_private.Mathlib.Data.Set.Prod.0.Set.subset_fst_image_prod_snd_image.match_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)} (motive : (x : α × β) → x ∈ s → Prop) (x : α × β) (x_1 : x ∈ s),
(∀ (p₁ : α) (p₂ : β) (x : (p₁, p₂) ∈ s), motive (p₁, p₂) x) → motive x x_1 | null | false |
Aesop.ClusterState.update | Aesop.Forward.State | Aesop.ClusterState → Aesop.ClusterState.AddM Aesop.ClusterState | Update a cluster change, adding any enqueued hypotheses. This may result in
new complete matches. | true |
Std.HashSet.Raw.getD_eq_getD_get? | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → ∀ {a fallback : α}, m.getD a fallback = (m.get? a).getD fallback | null | true |
CategoryTheory.Functor.instFullProdUncurry | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E], CategoryTheory.Functor.uncurry.Full | null | true |
Lean.Meta.Match.MatcherResult.mk.injEq | Lean.Meta.Match.Basic | ∀ (matcher : Lean.Expr) (counterExamples : Array Lean.Meta.Match.CounterExample) (unusedAltIdxs : List ℕ)
(addMatcher : Lean.MetaM Unit) (matcher_1 : Lean.Expr) (counterExamples_1 : Array Lean.Meta.Match.CounterExample)
(unusedAltIdxs_1 : List ℕ) (addMatcher_1 : Lean.MetaM Unit),
({ matcher := matcher, counterExa... | null | true |
Polynomial.toFinsupp_C_mul_X_pow | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : R) (n : ℕ),
(Polynomial.C a * Polynomial.X ^ n).toFinsupp = AddMonoidAlgebra.single n a | null | true |
Std.Iterators.PostconditionT.run_pure | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type w} {x : α}, (pure x).run = pure x | null | true |
AddCommSemigroup.rec | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
{motive : AddCommSemigroup G → Sort u} →
([toAddSemigroup : AddSemigroup G] →
(add_comm : ∀ (a b : G), a + b = b + a) → motive { toAddSemigroup := toAddSemigroup, add_comm := add_comm }) →
(t : AddCommSemigroup G) → motive t | null | false |
_private.Mathlib.LinearAlgebra.DFinsupp.0.iSupIndep_iff_finsetSum_eq_zero_imp_eq_zero._proof_1_5 | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {N : Type u_2} [inst : AddCommGroup N] (i : ι) (f : ι →₀ N),
(f.sum fun _i xi => xi) ≠ 0 → ∃ i_1 ∈ insert i f.support, ¬(if i_1 = i then -f.sum fun x x_1 => x_1 else f i_1) = 0 | null | false |
AddCommGroup.toAddGroup_injective | Mathlib.Algebra.Group.Ext | ∀ {G : Type u_1}, Function.Injective (@AddCommGroup.toAddGroup G) | null | true |
Ideal.finite_setOf_absNorm_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Module.Free ℤ S] [Module.Finite ℤ S]
(n : ℕ), {I | Ideal.absNorm I ≤ n}.Finite | **Alias** of `Ideal.finite_setOfPred_absNorm_le`. | true |
CategoryTheory.Discrete.costructuredArrowEquivalenceOfUnique._proof_5 | Mathlib.CategoryTheory.Discrete.StructuredArrow | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : Type u_3}
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) (t : T) [inst_1 : Subsingleton T] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z),
CategoryTheory.CostructuredArrow.homMk (CategoryTheory.CategoryStruct.comp f g) ⋯ =
CategoryTheory.Cat... | null | false |
Std.IteratorLoop.ctorIdx | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → {inst : Std.Iterator α m β} → {n : Type x → Type x'} → Std.IteratorLoop α m n → ℕ | null | false |
instTopologicalSpaceStoneCech | Mathlib.Topology.Compactification.StoneCech | {α : Type u} → [inst : TopologicalSpace α] → TopologicalSpace (StoneCech α) | null | true |
Finmap.replace_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (b : β a) (s : AList β),
Finmap.replace a b s.toFinmap = (AList.replace a b s).toFinmap | null | true |
DFinsupp.mapRange_id | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β₁ : ι → Type v₁} [inst : (i : ι) → Zero (β₁ i)] (h : optParam (∀ (i : ι), id 0 = 0) ⋯)
(g : Π₀ (i : ι), β₁ i), DFinsupp.mapRange (fun i => id) h g = g | null | true |
Homeomorph.toHomotopyEquiv._proof_1 | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
((↑h.symm).comp ↑h).Homotopic (ContinuousMap.id X) | null | false |
Std.Http.Request.Builder.headers | Std.Http.Data.Request | Std.Http.Request.Builder → Std.Http.Headers → Std.Http.Request.Builder | Sets the headers for the request being built
| true |
CategoryTheory.CartesianMonoidalCategory.ofHasFiniteProducts._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasFiniteProducts C],
CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.empty C) | null | false |
Fin.val_natAdd | Init.Data.Fin.Lemmas | ∀ (n : ℕ) {m : ℕ} (i : Fin m), ↑(Fin.natAdd n i) = n + ↑i | null | true |
Set.decidableMemMul._proof_1 | Mathlib.Algebra.Group.Pointwise.Set.Finite | ∀ {α : Type u_1} [inst : Monoid α] {s t : Set α} (x : α), (∃ x_1 ∈ s, ∃ y ∈ t, x_1 * y = x) ↔ x ∈ s * t | null | false |
Lean.PersistentHashMap.Zipper.consCollision.inj | Lean.Data.Iterators.Producers.PersistentHashMap | ∀ {α : Type u} {β : Type v} {keys : Subarray α} {vals : Subarray β} {a : Std.Slice.size keys = Std.Slice.size vals}
{a_1 : Lean.PersistentHashMap.Zipper α β} {keys_1 : Subarray α} {vals_1 : Subarray β}
{a_2 : Std.Slice.size keys_1 = Std.Slice.size vals_1} {a_3 : Lean.PersistentHashMap.Zipper α β},
Lean.Persistent... | null | true |
MeasureTheory.VectorMeasure.dirac._proof_7 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_2} {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [inst_2 : MeasurableSpace β]
(x : β) (v : M) (f : ℕ → Set β),
(∀ (i : ℕ), MeasurableSet (f i)) →
Pairwise (Function.onFun Disjoint f) →
HasSum (fun i => if MeasurableSet (f i) ∧ x ∈ f i then v else 0)
(if Measur... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.