name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.IterM.anyM_pure | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{p : β → ULift.{w, 0} Bool}, Std.IterM.anyM (fun x => pure (p x)) it = Std.IterM.any (fun x => (p x)... | null | true |
NonUnitalAlgHom.lmul._proof_4 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] (x y : A),
(LinearMap.mul R A).toFun (x + y) = (LinearMap.mul R A).toFun x + (LinearMap.mul R A).toFun y | null | false |
MeasureTheory.le_measureReal_sdiff._auto_1 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | null | false |
RingEquiv.equivIntAlgEquiv._proof_2 | Mathlib.Algebra.Algebra.Equiv | ∀ (R : Type u_1) (S : Type u_2) [inst : Ring R] [inst_1 : Ring S],
Function.RightInverse AlgEquiv.toRingEquiv RingEquiv.toIntAlgEquiv | null | false |
Lean.Elab.WF.GuessLex.instInhabitedBasicMeasure.default | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.BasicMeasure | null | true |
ULift.nonAssocRing._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_1} [inst : NonAssocRing R], ↑0 = 0 | null | false |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.exact₂_iff._proof_1_9 | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ComposableArrows C 2),
S.IsComplex →
CategoryTheory.CategoryStruct.comp
(S.map' 0 1 CategoryTheory.ComposableArrows.isComplex₂_iff._proof_2
CategoryTheory.Comp... | null | false |
MeasureTheory.lpTrimToLpMeas | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | {α : Type u_1} →
(F : Type u_2) →
(𝕜 : Type u_3) →
(p : ENNReal) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace 𝕜 F] →
{m m0 : MeasurableSpace α} →
(μ : MeasureTheory.Measure α) →
(hm : m ≤ m0) → ... | Map from `Lp F p (μ.trim hm)` to `lpMeas`, inverse of `Lp_meas_to_Lp_trim`. | true |
Filter.inf_liminf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {u : β → α} [f.NeBot] (a : α),
a ⊓ Filter.liminf u f = Filter.liminf (fun x => a ⊓ u x) f | null | true |
_private.Mathlib.Order.Filter.Extr.0.IsMinFilter.bicomp_mono.match_1_1 | Mathlib.Order.Filter.Extr | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {a : α} {g : α → γ}
(_x : α) (motive : _x ∈ {x | (fun x => f a ≤ f x) x} ∩ {x | (fun x => g a ≤ g x) x} → Prop)
(x : _x ∈ {x | (fun x => f a ≤ f x) x} ∩ {x | (fun x => g a ≤ g x) x}),
(∀ (hfx : _x ∈ {x | (fun x =>... | null | false |
Differentiable.sigmoid | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ},
Differentiable ℝ f → Differentiable ℝ (Real.sigmoid ∘ f) | null | true |
AddOpposite.instRightCancelSemigroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : RightCancelSemigroup α] (x x_1 : αᵃᵒᵖ), AddOpposite.unop (x * x_1) = AddOpposite.unop (x * x_1) | null | false |
_private.Mathlib.CategoryTheory.Subobject.Basic.0.CategoryTheory.Subobject.exists_le_exists_iff_of_mono.match_1_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : X ⟶ Y) (x x_1 : CategoryTheory.MonoOver X)
(motive :
(CategoryTheory.Subobject.exists f).obj (Quotient.mk'' x) ≤
(CategoryTheory.Subobject.exists f).obj (Quotient.mk'' x_1) →
... | null | false |
StarModule.decomposeProdAdjoint_apply | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) (A : Type u_2) [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (i : A),
(StarModule.decomposeProdAdjoint R A) i = ((selfAdjointPart R) i, (skewAdjointPart... | null | true |
inv_mul_le_iff_le_mul' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c : α}, c⁻¹ * a ≤ b ↔ a ≤ b * c | null | true |
CategoryTheory.Limits.KernelFork.mapIsLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{X Y : C} →
{f : X ⟶ Y} →
... | A limit kernel fork is mapped to a limit kernel fork by a functor `G` when this functor
preserves the corresponding limit. | true |
TensorProduct.lift._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} {R₂ : Type u_5} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_2}
{N : Type u_3} {P₂ : Type u_4} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂] (f' : M →ₛₗ[σ₁₂] N ... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_modify_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
ContinuousMap.HomotopyWith.coeFn_injective | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop}, Function.Injective DFunLike.coe | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Mathlib.Meta.Positivity.evalGamma._proof_1 | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Real.instZero)), «$_zα» =Q Real.instZero | null | false |
Set.insert_eq_self._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (insert a s = s) = (a ∈ s) | null | false |
PNat.natPred.eq_1 | Mathlib.Data.PNat.Basic | ∀ (i : ℕ+), i.natPred = ↑i - 1 | null | true |
Matrix.swap | Mathlib.LinearAlgebra.Matrix.Swap | (R : Type u_1) → {n : Type u_2} → [Zero R] → [One R] → [DecidableEq n] → n → n → Matrix n n R | The swap matrix `swap R i j` is the identity matrix with the
`i`-th and `j`-th rows modified such that multiplying by it on the
left (resp. right) corresponds to swapping the `i`-th and `j`-th row (resp. column). | true |
String.Pos.cast_lt_cast_iff._simp_1 | Init.Data.String.Basic | ∀ {s t : String} {pos pos' : s.Pos} {h : s = t}, (pos.cast h < pos'.cast h) = (pos < pos') | null | false |
Lean.Elab.Term.Do.Code.brecOn_5.eq | Lean.Elab.Do.Legacy | ∀ {motive_1 : Lean.Elab.Term.Do.Code → Sort u}
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_5 : List (Lean.Elab.Term.Do.A... | null | true |
Bool.or_eq_false_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = false ↔ x = false ∧ y = false | null | true |
_private.Mathlib.Data.Nat.Factors.0.Nat.isChain_cons_primeFactorsList.match_1_1 | Mathlib.Data.Nat.Factors | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → (∀ (k : ℕ), motive k.succ.succ) → motive n | null | false |
ImportGraph.Shake.ConstLocation.value.elim | ImportGraph.Shake.DeclNeeds | {motive : ImportGraph.Shake.ConstLocation → Sort u} →
(t : ImportGraph.Shake.ConstLocation) → t.ctorIdx = 1 → motive ImportGraph.Shake.ConstLocation.value → motive t | null | false |
TopCat.GlueData.MkCore.mk.inj | Mathlib.Topology.Gluing | ∀ {J : Type u} {U : J → TopCat} {V : (i : J) → J → TopologicalSpace.Opens ↑(U i)}
{t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i)}
{V_id : ∀ (i : J), V i i = ⊤} {t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id... | null | true |
SemiNormedGrp₁.Hom.normNoninc | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp₁} (self : M.Hom N), self.hom'.NormNoninc | null | true |
LinearEquiv.isIsotypicOfType_iff_type | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} {N : Type u_3} {S : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup S] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R S]
(e : N ≃ₗ[R] S), IsIsotypicOfType R M N ↔ IsIsotypicOfType R M S | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Checker.0.Std.Tactic.BVDecide.LRAT.Internal.check.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Checker | ∀ (proof : Array Std.Tactic.BVDecide.LRAT.IntAction) (formula : Std.Sat.CNF ℕ),
Std.Tactic.BVDecide.LRAT.Internal.check proof formula =
Std.Tactic.BVDecide.LRAT.Internal.check.go✝ (Std.Tactic.BVDecide.LRAT.Internal.State.ofCNF formula) proof 0 | null | true |
Std.Internal.instInhabitedIndexMultiMap._proof_1 | Std.Http.Internal.IndexMultiMap | ∀ {α : Type u_1} {β : Type u_2} [inst : BEq α] [inst_1 : Hashable α] (k : α) (p : k ∈ Std.HashMap.emptyWithCapacity),
let idx := Std.HashMap.emptyWithCapacity.get k p;
idx.size > 0 ∧ ∀ i ∈ idx, i < #[].size | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{a b toIntThm : Lean.Expr} →
{lhs rhs : Int.Internal.Linear.Expr} →
{a' b' toIntThm' : Lean.Expr} →
{lhs' rhs' : Int.Internal.Linear.Expr} →
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a b toIntThm lhs rhs =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrPro... | null | false |
Set.image_mul_left_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀},
0 < a → ∀ (b c : G₀), (fun x => a * x) '' Set.Ioo b c = Set.Ioo (a * b) (a * c) | null | true |
_private.Mathlib.RingTheory.NoetherNormalization.0.NoetherNormalization.hom2._proof_3 | Mathlib.RingTheory.NoetherNormalization | ∀ {k : Type u_1} [inst : Field k] {n : ℕ},
IsScalarTower k (Polynomial (MvPolynomial (Fin n) k)) (Polynomial (MvPolynomial (Fin n) k)) | null | false |
Except.bind.eq_2 | Init.Control.Lawful.MonadLift.Instances | ∀ {ε : Type u} {α : Type u_1} {β : Type u_2} (f : α → Except ε β) (v : α), (Except.ok v).bind f = f v | null | true |
Finset.fold_sup_bot_singleton | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Finset.fold (fun x1 x2 => x1 ⊔ x2) ⊥ singleton s = s | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.ctorIdx | Lean.Compiler.LCNF.InferBorrow | Lean.Compiler.LCNF.ParamMap✝ → ℕ | null | false |
IsUnit.isQuotientMap_nsmul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} [inst : TopologicalSpace α] {M : Type u_4} {β : Type u_5} [inst_1 : Semiring M]
[inst_2 : AddCommMonoid α] [inst_3 : Module M α] [ContinuousConstSMul M α] [inst_5 : AddMonoid β] (f : α →+ β)
[inst_6 : TopologicalSpace β],
Topology.IsQuotientMap ⇑f → ∀ (n : ℕ), IsUnit ↑n → Topology.IsQuotientMap f... | null | true |
Set.Ioi.eq_1 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (b : α), Set.Ioi b = {x | b < x} | null | true |
LinearPMap.instSubtractionCommMonoid._proof_3 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_3} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_4} [inst_4 : AddCommGroup F] [inst_5 : Module S F] (a : E →ₛₗ.[σ] F), 0 • a = 0 | null | false |
TensorProduct.assoc._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R (TensorProduct R M N) P) | null | false |
IsLocalRing.ResidueField.mapAlgEquiv._proof_6 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_3} {S : Type u_2} {T : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsLocalRing S]
[inst_3 : CommRing T] [inst_4 : IsLocalRing T] [inst_5 : Algebra R S] [inst_6 : Algebra R T] (e : S ≃ₐ[R] T) (r : R),
(↑↑(IsLocalRing.ResidueField.mapAlgHom ↑e).toRingHom).toFun ((algebraMap R (IsLocalR... | null | false |
Int64.ofIntTruncate | Init.Data.SInt.Basic | ℤ → Int64 | Constructs an `Int64` from an `Int`, clamping if the value is too small or too large. | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.eq_swap_mul_swap_iff_mem_support._proof_1_5 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} (x : α), [x, g x, g (g x)].Nodup → ¬x = g (g x) | null | false |
Stream'.WSeq.length.match_3 | Mathlib.Data.WSeq.Defs | {α : Type u_1} →
(motive : ℕ × Stream'.WSeq α → Sort u_2) →
(x : ℕ × Stream'.WSeq α) → ((n : ℕ) → (s : Stream'.WSeq α) → motive (n, s)) → motive x | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withUsed | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.InductiveElabStep2 →
Array Lean.Expr → List Lean.InductiveType → (Array Lean.Expr → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α | null | true |
AddAction.IsQuasiPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | (G : Type u_1) → (X : Type u_2) → [inst : AddGroup G] → [AddAction G X] → Prop | An additive action of an additive group is quasipreprimitive if any normal subgroup
that has no fixed point acts pretransitively | true |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.filter_ne_eq_erase._proof_1_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (f : Π₀ (i : ι), β i)
(i : ι), DFinsupp.filter (fun x => ¬x = i) f = DFinsupp.erase i f | null | false |
CategoryTheory.nerve.δ₁_mk₂_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₀ X₁ X₂ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 1))
(CategoryTheory.ComposableArrows.mk₂ f g) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategorySt... | null | true |
Std.Do.SPred.Tactic.instPropAsSPredTautologyEntailsPureTrue | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, Std.Do.SPred.Tactic.PropAsSPredTautology (⊢ₛ P) P | null | true |
Std.Http.Header.TransferEncoding.mk._flat_ctor | Std.Http.Data.Headers.Basic | (codings : Array String) → Std.Http.Header.TransferEncoding.Validate codings = true → Std.Http.Header.TransferEncoding | null | false |
Algebra.IsAlgebraic.algEquivEquivAlgHom.congr_simp | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (L : Type u_2) [inst : CommRing K] [inst_1 : IsDomain K] [inst_2 : Field L] [inst_3 : Algebra K L]
[inst_4 : Module.IsTorsionFree K L] [inst_5 : Algebra.IsAlgebraic K L],
Algebra.IsAlgebraic.algEquivEquivAlgHom K L = Algebra.IsAlgebraic.algEquivEquivAlgHom K L | null | true |
LaurentSeries.instFieldSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._proof_26 | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_1} [inst : Field K] (a b c : LaurentSeries.ratfuncAdicComplPkg.space), a * (b + c) = a * b + a * c | null | false |
MvPowerSeries.coeff_truncTotal_eq_ite | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} {n : ℕ} [inst : Finite σ] [inst_1 : CommSemiring R] (p : MvPowerSeries σ R)
{x : σ →₀ ℕ}, ((MvPowerSeries.truncTotal n) p).coeff x = if Finsupp.degree x < n then (MvPowerSeries.coeff x) p else 0 | null | true |
CategoryTheory.GrothendieckTopology.instHasIsosToPrecoverage | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (J : CategoryTheory.GrothendieckTopology C),
J.toPrecoverage.HasIsos | null | true |
Module.IsStablyFree.equiv_iff | Mathlib.Algebra.Module.StablyFree.Basic | ∀ {R : Type u} [inst : Ring R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type w}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (e : M ≃ₗ[R] N), Module.IsStablyFree R M ↔ Module.IsStablyFree R N | null | true |
Lean.SubExpr.Pos.pushNthBindingDomain._unsafe_rec | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | false |
Std.DHashMap.Raw.inter_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β},
m₁.inter m₂ = m₁ ∩ m₂ | null | true |
CategoryTheory.DifferentialObject.Hom | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
CategoryTheory.DifferentialObject S C → CategoryTheory.DifferentialObject S... | A morphism of differential objects is a morphism commuting with the differentials. | true |
Std.TreeMap.Raw.getKey?_filter_key | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {f : α → Bool}
{k : α}, t.WF → (Std.TreeMap.Raw.filter (fun k x => f k) t).getKey? k = Option.filter f (t.getKey? k) | null | true |
MeasureTheory.ae_tendsto_ofReal_norm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{F : ℕ → α → β} {f : α → β},
(∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => F n a) Filter.atTop (nhds (f a))) →
∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => ENNReal.ofReal ‖F n a‖) Filter.atTop (nhds (ENNRea... | null | true |
Mathlib.Meta.FunProp.instToStringTheoremForm | Mathlib.Tactic.FunProp.Theorems | ToString Mathlib.Meta.FunProp.TheoremForm | TheoremForm to string | true |
Lean.Order.PredTrans.apply_pushOptionT | Std.Internal.Order.PredTrans | ∀ {Pred : Type u} {EPred : Type v} {α : Type w} (x : Lean.Order.PredTrans Pred EPred (Option α)) (post : α → Pred)
(epost : (Unit → Pred) × EPred), x.pushOptionT.apply post epost = x.apply (Lean.Order.pushOption post epost.1) epost.2 | Unfolding lemma for `pushOptionT`. | true |
eq_inv_smul_iff | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_3} {α : Type u_5} [inst : Group G] [inst_1 : MulAction G α] {g : G} {a b : α}, a = g⁻¹ • b ↔ g • a = b | null | true |
_private.Init.Data.List.MapIdx.0.List.getElem_mapFinIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_2} {β : Type u_1} {as : List α} {f : (i : ℕ) → α → i < as.length → β} {i : ℕ} (head : α) (tail : List α)
{acc : Array β} {h : (head :: tail).length + acc.size = as.length},
¬i < acc.size + 1 → ¬i - acc.size = i - (acc.size + 1) + 1 → False | null | false |
Quiver.Path.decidableEqBddPathsOfDecidableEq | Mathlib.Combinatorics.Quiver.Path | {V : Type u_1} →
[inst : Quiver V] →
(n : ℕ) →
DecidableEq V →
((v w : V) → DecidableEq (v ⟶ w)) →
((v w : V) → DecidableEq (Quiver.Path.BoundedPaths v w n)) →
(v w : V) → DecidableEq (Quiver.Path.BoundedPaths v w (n + 1)) | Given decidable equality on paths of length up to `n`, we can construct
decidable equality on paths of length up to `n + 1`. | true |
_private.Mathlib.Algebra.Module.Torsion.PrimaryComponent.0.Ideal.primaryComponent_torsionBySet_of_isCoprime._simp_1_8 | Mathlib.Algebra.Module.Torsion.PrimaryComponent | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
AddMonCat.adj._proof_2 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X : Type u_1} {Y Y' : AddMonCat} (f : AddMonCat.free.obj X ⟶ Y) (g : Y ⟶ Y'),
(CategoryTheory.ConcreteCategory.homEquiv.trans (FreeAddMonoid.lift.symm.trans TypeCat.homEquiv.symm))
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ConcreteCategory.homEqu... | null | false |
Affine.Triangle.two_mul_angle_excenter_singleton_eq_angle_add_pi | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂ ≠ i₃ →
2 * EuclideanGeometry.angle (t.points i₁) (t.points i₂) (Affine.Simplex... | The excenter of a triangle opposite a vertex bisects the angle at another vertex. | true |
meromorphicTrailingCoeffAt | Mathlib.Analysis.Meromorphic.TrailingCoefficient | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} → [inst_1 : NormedAddCommGroup E] → [NormedSpace 𝕜 E] → (𝕜 → E) → 𝕜 → E | If `f` is meromorphic of finite order at a point `x`, the trailing coefficient is defined as the
(unique!) value `g x` for a presentation of `f` in the form `(z - x) ^ order • g z` with `g`
analytic at `x`. In all other cases, the trailing coefficient is defined to be zero.
| true |
Finset.sup'_id_eq_csSup | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {α : Type u_2} [inst : ConditionallyCompleteLattice α] (s : Finset α) (hs : s.Nonempty), s.sup' hs id = sSup ↑s | null | true |
CategoryTheory.Sieve.pullback_arrows | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (S : CategoryTheory.Sieve Y),
(CategoryTheory.Sieve.pullback f S).arrows = CategoryTheory.Presieve.pullback f S.arrows | null | true |
FormalMultilinearSeries.hasFPowerSeriesOnBall | 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] [CompleteSpace F]
(p : FormalMultilinearSeries 𝕜 E F), 0 < p.radius → HasFPowerSeriesOnBall p.sum p 0 p.radius | In a complete space, the sum of a converging power series `p` admits `p` as a power series.
This is not totally obvious as we need to check the convergence of the series. | true |
Submodule.topEquiv._proof_1 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Function.LeftInverse (fun x => ⟨x, ⋯⟩) fun x => ↑x | null | false |
_private.Mathlib.Util.AddRelatedDecl.0.Mathlib.Tactic.addRelatedDecl.match_3 | Mathlib.Util.AddRelatedDecl | (motive : Lean.Expr × List Lean.Name → Sort u_1) →
(x : Lean.Expr × List Lean.Name) →
((newValue : Lean.Expr) → (newLevels : List Lean.Name) → motive (newValue, newLevels)) → motive x | null | false |
_private.Mathlib.RingTheory.Support.0.Module.support_of_isTorsionFree._simp_1_1 | Mathlib.RingTheory.Support | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Lean.Meta.Grind.SplitSource.beta.inj | Lean.Meta.Tactic.Grind.Types | ∀ {e e_1 : Lean.Expr}, Lean.Meta.Grind.SplitSource.beta e = Lean.Meta.Grind.SplitSource.beta e_1 → e = e_1 | null | true |
USize.toBitVec_one | Init.Data.UInt.Lemmas | USize.toBitVec 1 = 1#System.Platform.numBits | null | true |
MonoidHom.op._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x * y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x * (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | null | false |
Finset.compl_insert | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {s : Finset α} [inst : Fintype α] [inst_1 : DecidableEq α] {a : α}, (insert a s)ᶜ = sᶜ.erase a | null | true |
List.eq_of_sum_take_eq | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddLeftCancelMonoid M] {L L' : List M},
L.length = L'.length → (∀ i ≤ L.length, (List.take i L).sum = (List.take i L').sum) → L = L' | null | true |
MeasureTheory.L1.SimpleFunc.integral_add | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedSpace ℝ E] (f g : ↥(α →₁ₛ[μ] E)),
MeasureTheory.L1.SimpleFunc.integral (f + g) =
MeasureTheory.L1.SimpleFunc.integral f + MeasureTheory.L1.SimpleFunc.integral g | null | true |
BialgHomClass.casesOn | Mathlib.RingTheory.Bialgebra.Hom | {F : Type u_1} →
{R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Semiring B] →
[inst_4 : Algebra R B] →
[inst_5 : CoalgebraStruct R A] →
... | null | false |
KaehlerDifferential.kerCotangentToTensor._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_3) [inst : CommRing R] (A : Type u_1) (B : Type u_2) [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra A B],
RingHom.ker (algebraMap A B) • ⊤ ≤ (KaehlerDifferential.kerToTensor R A B).ker | null | false |
List.map_snd_zip._f | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} (x : List α)
(f : List.below (motive := fun x => ∀ (x_1 : List β), x_1.length ≤ x.length → List.map Prod.snd (x.zip x_1) = x_1) x)
(x_1 : List β), x_1.length ≤ x.length → List.map Prod.snd (x.zip x_1) = x_1 | null | false |
Std.Time.TimeZone.Offset.ofHoursAndMinutes | Std.Time.Zoned.TimeZone | Std.Time.Hour.Offset → Std.Time.Minute.Offset → Std.Time.TimeZone.Offset | Creates an `Offset` from a given number of hours and minutes.
| true |
CStarMatrix.transpose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} (M : CStarMatrix m n A) (i : n) (j : m), M.transpose i j = M j i | null | true |
AlgebraicGeometry.tilde.map._proof_1 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {M N : ModuleCat ↑R} (f : M ⟶ N) ⦃X Y : (TopologicalSpace.Opens ↥(AlgebraicGeometry.Spec R))ᵒᵖ⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.structurePresheafInModuleCat ↑R ↑M).map f_1)
(ModuleCat.ofHom
(AlgebraicGeometry.StructureSheaf.comapₗ (ModuleCat.Ho... | null | false |
IsUniformEmbedding.casesOn | Mathlib.Topology.UniformSpace.Defs | {α : Type ua} →
{β : Type ub} →
[inst : UniformSpace α] →
[inst_1 : UniformSpace β] →
{f : α → β} →
{motive : IsUniformEmbedding f → Sort u} →
(t : IsUniformEmbedding f) →
((toIsUniformInducing : IsUniformInducing f) → (injective : Function.Injective f) → motive ⋯... | null | false |
CategoryTheory.IsRegularMono.lift | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y W : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.IsRegularMono f] →
(k : W ⟶ Y) →
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.left f) =
CategoryTheory.CategoryStruct.comp k ... | Lift a morphism `k : W ⟶ Y`, equalized by the two morphisms `left` and `right`, along `f`. | true |
ContinuousLinearMap.comp_finsetSum | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} {M₁ : Type u_4} [inst_3 : TopologicalSpace M₁]
[inst_4 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_5 : TopologicalSpace M₂] [inst_6 : AddCommMonoid... | null | true |
Mathlib.Tactic.BicategoryLike.MonadHorizontalComp.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.WhiskerRight →
Mathlib.Tactic.BicategoryLike.Atom₁ → m Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(Mathlib.Tactic.BicategoryLike.WhiskerRight →
Mathlib.Tactic.BicategoryLike.HorizontalComp → m Mathlib.Tactic.BicategoryLike.HorizontalComp) →
... | null | false |
LipschitzWith.nnorm_le_mul | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F] {f : E → F} {K : NNReal},
LipschitzWith K f → f 0 = 0 → ∀ (x : E), ‖f x‖₊ ≤ K * ‖x‖₊ | **Alias** of `LipschitzWith.nnnorm_le_mul`. | true |
CategoryTheory.InitiallySmall.initial_smallCategory | Mathlib.CategoryTheory.Limits.FinallySmall | ∀ {J : Type u} {inst : CategoryTheory.Category.{v, u} J} [self : CategoryTheory.InitiallySmall J], ∃ S x F, F.Initial | There is an initial functor from a small category. | true |
Array.findFinIdx?_eq_pmap_findIdx?._simp_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool} {i : ℕ},
(Array.findIdx? p xs = some i) = ∃ (h : i < xs.size), p xs[i] = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p xs[j] = true | null | false |
ContDiffMapSupportedIn.toFun | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} → {K : TopologicalSpace.Compacts E} → ContDiffMapSupportedIn E F n K → E → F | The underlying function. Use coercion instead. | true |
Int.«_aux_Mathlib_Algebra_Order_Floor_Defs___macroRules_Int_term⌈_⌉_1» | Mathlib.Algebra.Order.Floor.Defs | Lean.Macro | null | false |
AddMonoidAlgebra.coeff_single_mul_add | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddMonoid M] [IsCancelAdd M] (x : AddMonoidAlgebra R M)
(r : R) (m m' : M), (AddMonoidAlgebra.single m r * x).coeff (m + m') = r * x.coeff m' | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.