name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.InjectionAnyResult.failed.sizeOf_spec | Lean.Meta.Match.SolveOverlap | sizeOf Lean.Meta.Match.InjectionAnyResult.failed✝ = 1 | null | true |
FreeAbelianGroup.instCommApplicative | Mathlib.GroupTheory.FreeAbelianGroup | CommApplicative FreeAbelianGroup | null | true |
dslope_eventuallyEq_slope_of_ne | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {a b : 𝕜} (f : 𝕜 → E), b ≠ a → dslope f a =ᶠ[nhds b] slope f a | null | true |
SimpleGraph.IsAcyclic.isPath_iff_isTrail | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsAcyclic → ∀ {v w : V} (p : G.Walk v w), p.IsPath ↔ p.IsTrail | null | true |
FirstOrder.Language.Substructure.closure_empty | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M],
(FirstOrder.Language.Substructure.closure L).toFun ∅ = ⊥ | null | true |
CategoryTheory.Limits.hasEqualizer_of_hasSplitEqualizer | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.HasSplitEqualizer f g],
CategoryTheory.Limits.HasEqualizer f g | If a pair has a split equalizer, it has an equalizer. | true |
LocallyConstant.comap._proof_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(g : LocallyConstant Y Z), IsLocallyConstant (g.toFun ∘ ⇑f) | null | false |
Metric.unitBall.coe_mul | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x y : ↑(Metric.ball 0 1)), ↑(x * y) = ↑x * ↑y | null | true |
Lean.instToMessageDataProd | Lean.Message | {α β : Type} → [Lean.ToMessageData α] → [Lean.ToMessageData β] → Lean.ToMessageData (α × β) | null | true |
DirectLimit.instModule._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_3} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : Semiring R]
[inst_3 : (i : ι) → AddCommMonoid (G i)] [inst_4 : (i : ι) → Module R (G i)]
[∀ (i j : ι) (h : i ≤ j), LinearMapClass (T h)... | null | false |
_private.Lean.Environment.0.Lean.ImportState.markAllExported.match_1 | Lean.Environment | (motive : Lean.Name × Lean.ImportedModule✝ → Sort u_1) →
(x : Lean.Name × Lean.ImportedModule✝) → ((k : Lean.Name) → (v : Lean.ImportedModule✝) → motive (k, v)) → motive x | null | false |
PNat.sub_le | Mathlib.Data.PNat.Basic | ∀ (a b : ℕ+), a - b ≤ a | null | true |
Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m) →
((associatorM :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →... | null | false |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.rec | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{motive : W.IsStableUnderTr... | null | false |
ContinuousAt.fun_add | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f g : X → M} {x : X},
ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun i => f i + g i) x | null | true |
Mathlib.Tactic.Linarith.GlobalPreprocessor.rec | Mathlib.Tactic.Linarith.Datatypes | {motive : Mathlib.Tactic.Linarith.GlobalPreprocessor → Sort u} →
((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) →
(transform : List Lean.Expr → Lean.MetaM (List Lean.Expr)) →
motive { toPreprocessorBase := toPreprocessorBase, transform := transform }) →
(t : Mathlib.Tactic.Linarith... | null | false |
SignType.neg | Mathlib.Basic.Sign.Defs | SignType | null | true |
BoxIntegral.integral_zero | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxIntegral.integral I l... | null | true |
SlashInvariantForm.instAddCommGroup._proof_5 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ},
autoParam (∀ (n : ℕ) (x : SlashInvariantForm Γ k), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
Monoid.End.equiv._proof_2 | Mathlib.Algebra.Group.Equiv.Defs | ∀ (M : Type u_1) [inst : MulOne M] (x : M →* M), id (id x) = id (id x) | null | false |
Polynomial.Chebyshev.integral_eval_T_real_mul_self_measureT_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality | ∫ (x : ℝ),
Polynomial.eval x (Polynomial.Chebyshev.T ℝ 0) *
Polynomial.eval x (Polynomial.Chebyshev.T ℝ 0) ∂Polynomial.Chebyshev.measureT =
Real.pi | null | true |
CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi_hom_comp_pi_assoc | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C] (ι : Type w)
[inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : Finite ι] (X : C) (j : ι) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CechNerveTerminalFrom.wideCospan.limit... | null | true |
CategoryTheory.Pseudofunctor.DescentData.toDescentDataCompPullFunctorIso._proof_9 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_5, u_3} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_6} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_1} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.LeibnizAdjunction.adj._simp_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} ... | null | false |
Besicovitch.SatelliteConfig.inter' | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (a : Besicovitch.SatelliteConfig α N τ) (i : Fin N.succ),
dist (a.c i) (a.c (Fin.last N)) ≤ a.r i + a.r (Fin.last N) | null | true |
ULift.semigroup | Mathlib.Algebra.Group.ULift | {α : Type u} → [Semigroup α] → Semigroup (ULift.{u_1, u} α) | null | true |
Aesop.RulePatternIndex.instInhabitedEntry.default | Aesop.Index.RulePattern | Aesop.RulePatternIndex.Entry | null | true |
AlgEquiv.commutes' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (self : A ≃ₐ[R] B) (r : R),
self.toFun ((algebraMap R A) r) = (algebraMap R B) r | An equivalence of algebras commutes with the action of scalars. | true |
CategoryTheory.Subobject.imageFactorisation_F_I | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : X ⟶ Y) (x : CategoryTheory.Subobject X),
(CategoryTheory.Subobject.imageFactorisation f x).F.I =
CategoryTheory.Subobject.underlying.obj ((CategoryTheory.Subobject.exists f).obj x) | null | true |
_private.Mathlib.Analysis.Complex.Basic.0.Complex.mem_slitPlane_or_neg_mem_slitPlane._simp_1_1 | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (0 < -a) = (a < 0) | null | false |
FreeLieAlgebra.liftAux_map_add | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(a b : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (a + b) = (FreeLieAlgebra.liftAux R f) a + (FreeLieAlgebra.liftAux R f) b | null | true |
Finset.prod_range_div_prod_range | Mathlib.Algebra.BigOperators.Intervals | ∀ {G : Type u_4} [inst : CommGroup G] {f : ℕ → G} {n m : ℕ},
n ≤ m → (∏ k ∈ Finset.range m, f k) / ∏ k ∈ Finset.range n, f k = ∏ k ∈ Finset.range m with n ≤ k, f k | null | true |
ModularForm.coe_mcast | Mathlib.NumberTheory.ModularForms.Basic | ∀ {a b : ℤ} {Γ Γ' : Subgroup (GL (Fin 2) ℝ)} (h : a = b) (f : ModularForm Γ a)
(hΓ : autoParam (Γ' = Γ) ModularForm.mcast._auto_1), ⇑(ModularForm.mcast h f hΓ) = ⇑f | null | true |
Set.union_add_inter_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddCommSemigroup α] {s t : Set α}, s ∪ t + s ∩ t ⊆ s + t | null | true |
Ordnode.Bounded.weak_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}, t.Bounded o₁ o₂ → t.Bounded o₁ ⊤ | null | true |
SetLike.gmodule | Mathlib.Algebra.Module.GradedModule | {ιA : Type u_1} →
{ιM : Type u_2} →
{A : Type u_3} →
{M : Type u_4} →
{σ : Type u_5} →
{σ' : Type u_6} →
[inst : AddMonoid ιA] →
[inst_1 : AddAction ιA ιM] →
[inst_2 : Semiring A] →
(𝓐 : ιA → σ') →
[inst_3 : S... | `[SetLike.GradedMonoid 𝓐] [SetLike.GradedSMul 𝓐 𝓜]` is the internal version of graded
module, the internal version can be translated into the external version `gmodule`. | true |
Ideal.span_pow_eq_top | Mathlib.RingTheory.Ideal.Basic | ∀ {α : Type u_2} [inst : CommSemiring α] (s : Set α),
Ideal.span s = ⊤ → ∀ (n : ℕ), Ideal.span ((fun x => x ^ n) '' s) = ⊤ | null | true |
Matroid.rankPos_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [M.RankPos], M.Nonempty | null | true |
Vector.replace_toArray | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs : Vector α n} {a b : α}, xs.toArray.replace a b = (xs.replace a b).toArray | null | true |
ContinuousMultilinearMap.flipLinear._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_4} {ι : Type u_1} {E : ι → Type u_2} {G : Type u_5} {G' : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | null | false |
Lean.Meta.DiscrTree.Key.other.elim | Lean.Meta.DiscrTree.Types | {motive : Lean.Meta.DiscrTree.Key → Sort u} →
(t : Lean.Meta.DiscrTree.Key) → t.ctorIdx = 1 → motive Lean.Meta.DiscrTree.Key.other → motive t | null | false |
ENat.map_natCast_strictMono | Mathlib.Data.ENat.Monoid | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α],
StrictMono (ENat.map Nat.cast) | null | true |
AddGroupExtension._sizeOf_1 | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
{inst : AddGroup N} →
{inst_1 : AddGroup E} →
{inst_2 : AddGroup G} → [SizeOf N] → [SizeOf E] → [SizeOf G] → AddGroupExtension N E G → ℕ | null | false |
ModuleCon.instAddMonoidQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
(M : Type u_3) → [inst : SMul S M] → [inst_1 : AddMonoid M] → (c : ModuleCon S M) → AddMonoid (ModuleCon.Quotient M c) | null | true |
LieSubalgebra.normalizer._proof_1 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) {y z : L},
y ∈ (↑H.toLieSubmodule.normalizer).carrier →
z ∈ (↑H.toLieSubmodule.normalizer).carrier → ∀ (x : ↥H), ⁅x, ⁅y, z⁆⁆ ∈ H.toLieSubmodule | null | false |
Subring.smul_sup | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (a : M)
(S T : Subring R), a • (S ⊔ T) = a • S ⊔ a • T | null | true |
Manifold.IsSubmersion.isSubmersionAt | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E'' : Type u_3} {H : Type u_7} {G : Type u_9} {E : Type u} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : TopologicalSpace H] [inst_6 : TopologicalSpace G] {I : ModelWithCorn... | If `f` is a submersion, it is a submersion at each point. | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.FnBody.alphaEqv._sparseCasesOn_9 | Lean.Compiler.IR.Basic | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) → (cidx : ℕ) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.setTag x cidx b)) →
(Nat.hasNotBit 8 t.ctorIdx → motive_2 t) → motive_2 t | null | false |
AddSubsemigroup.map_map | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Add M] [inst_1 : Add N] [inst_2 : Add P] (S : AddSubsemigroup M)
(g : N →ₙ+ P) (f : M →ₙ+ N), AddSubsemigroup.map g (AddSubsemigroup.map f S) = AddSubsemigroup.map (g.comp f) S | null | true |
CompHausLike.toCompHausLike._proof_1 | Mathlib.Topology.Category.CompHausLike.Basic | ∀ {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) (X : CompHausLike P),
CategoryTheory.ConcreteCategory.ofHom (TopCat.Hom.hom (CategoryTheory.CategoryStruct.id X).hom) =
CategoryTheory.CategoryStruct.id ↧↑X.toTop | null | false |
Bicategory.Opposite.opFunctor | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → (a b : B) → CategoryTheory.Functor (a ⟶ b) (Opposite.op b ⟶ Opposite.op a) | The natural functor from the hom-category `a ⟶ b` in `B` to its bicategorical opposite
`bop b ⟶ bop a`. | true |
FunLike.commSemigroup.eq_1 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Mul F] [inst_2 : CommSemigroup β]
[inst_3 : IsMulApply F α β], FunLike.commSemigroup = Function.Injective.commSemigroup (fun f => ⇑f) ⋯ ⋯ | null | true |
Lean.Lsp.DidOpenTextDocumentParams.mk | Lean.Data.Lsp.TextSync | Lean.Lsp.TextDocumentItem → Lean.Lsp.DidOpenTextDocumentParams | null | true |
_private.Mathlib.Data.List.Destutter.0.List.le_length_destutter'_cons._simp_1_3 | Mathlib.Data.List.Destutter | ∀ (n : ℕ), (n ≤ n.succ) = True | null | false |
ProbabilityTheory.Kernel.Indep.eq_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
(κ : ProbabilityTheory.Kernel α Ω) (μ : MeasureTheory.Measure α),
ProbabilityTheory.Kernel.Indep m₁ m₂ κ μ =
ProbabilityTheory.Kernel.IndepSets {s | MeasurableSet s} {s | MeasurableSet s} κ μ | null | true |
Filter.Germ.instSemifield._proof_1 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_1} {β : Type u_2} {φ : Ultrafilter α} [inst : Semifield β] (a b : (↑φ).Germ β), a / b = a * b⁻¹ | null | false |
_private.Mathlib.Data.Set.Prod.0.Set.univ_pi_singleton._simp_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_eq_false_iff._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 |
Matrix.conjTranspose_intCast_smul | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} {α : Type v} [inst : Ring R] [inst_1 : AddCommGroup α]
[inst_2 : StarAddMonoid α] [inst_3 : Module R α] (c : ℤ) (M : Matrix m n α),
(↑c • M).conjTranspose = ↑c • M.conjTranspose | null | true |
Algebra.TensorProduct.tensorQuotientEquiv_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A] (I : Ideal T) (a : A) (t : T),
(Algebra.Ten... | null | true |
Lean.Elab.Term.MutualClosure.ClosureState.mk.noConfusion | Lean.Elab.MutualDef | {P : Sort u} →
{newLocalDecls localDecls newLetDecls : Array Lean.LocalDecl} →
{exprArgs : Array Lean.Expr} →
{newLocalDecls' localDecls' newLetDecls' : Array Lean.LocalDecl} →
{exprArgs' : Array Lean.Expr} →
{ newLocalDecls := newLocalDecls, localDecls := localDecls, newLetDecls := newLet... | null | false |
HomotopicalAlgebra.mem_trivialCofibrations_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_2 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.trivialCofibrations C f ↔ HomotopicalAlgebra.Cofibration f ∧ HomotopicalAlgebra.WeakEquivalence f | null | true |
instMetricSpaceEmpty._proof_2 | Mathlib.Topology.MetricSpace.Defs | ∀ (x y : Empty), 0 = ENNReal.ofReal 0 | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Irreducible.Defs.0.Matrix.isIrreducible_transpose_iff._simp_1_3 | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
Lean.Grind.LinarithConfig.mk.inj | Init.Grind.Config | ∀ {toNoopConfig toNoopConfig_1 : Lean.Grind.NoopConfig},
{ toNoopConfig := toNoopConfig } = { toNoopConfig := toNoopConfig_1 } → toNoopConfig = toNoopConfig_1 | null | true |
SimpleGraph.Walk.isTrail_rotate | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} [inst : DecidableEq V] {c : G.Walk v v} (hu : u ∈ c.support),
(c.rotate u hu).IsTrail ↔ c.IsTrail | null | true |
TendstoLocallyUniformlyOn.mul₀ | Mathlib.Topology.MetricSpace.Algebra | ∀ {X : Type u_3} {M : Type u_4} {ι : Type u_5} [inst : TopologicalSpace X] [inst_1 : PseudoMetricSpace M]
[inst_2 : Zero M] [inst_3 : Mul M] [IsBoundedSMul M M] {s : Set X} {F G : ι → X → M} {f g : X → M} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
ContinuousOn ... | null | true |
CategoryTheory.Limits.limit.post.eq_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasLimit F] (G : CategoryTheory.Functor C D)
[inst_4 : CategoryTheory.Li... | null | true |
Filter.pureMulHom | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [inst : Mul α] → α →ₙ* Filter α | `pure` operation as a `MulHom`. | true |
AnalyticWithinAt.mul | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f g : E → A}
{s : Set E} {z : E}, AnalyticWithinAt 𝕜 f s z → AnalyticWithinAt 𝕜 g s z → AnalyticWithinAt 𝕜 (fun x ... | Multiplication of analytic functions (valued in a normed `𝕜`-algebra) is analytic. | true |
CategoryTheory.Pretriangulated.Triangle.π₁._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id X).hom₁ = CategoryTheory.CategoryStruct.id X.obj₁ | null | false |
WithTop.tendsto_nhds_top_iff | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] {α : Type u_2}
{f : Filter α} (x : α → WithTop ι), Filter.Tendsto x f (nhds ⊤) ↔ ∀ (i : ι), ∀ᶠ (a : α) in f, ↑i < x a | null | true |
CStarAlgebra.isUnit_of_le | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] (a : A) {b : A},
a ≤ b → autoParam (IsStrictlyPositive a) CStarAlgebra.isUnit_of_le._auto_1 → IsUnit b | In a unital C⋆-algebra, if `a` is strictly positive, and `a ≤ b`, then `b` is
invertible. | true |
unexpandSubtype | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
_private.Batteries.Data.Float.Basic.0.Float32.toRatParts.match_1 | Batteries.Data.Float.Basic | (motive : Float32 × ℤ → Sort u_1) → (x : Float32 × ℤ) → ((f' : Float32) → (exp : ℤ) → motive (f', exp)) → motive x | null | false |
SimplexCategory.const_apply | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (x y : SimplexCategory) (i : Fin (y.len + 1)) (a : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom (x.const y i)) a = i | null | true |
_private.Lean.Environment.0.Lean.Environment.PromiseCheckedResult.mk.inj | Lean.Environment | ∀ {mainEnv asyncEnv : Lean.Environment} {checkedEnvPromise : IO.Promise Lean.Kernel.Environment}
{mainEnv_1 asyncEnv_1 : Lean.Environment} {checkedEnvPromise_1 : IO.Promise Lean.Kernel.Environment},
{ mainEnv := mainEnv, asyncEnv := asyncEnv, checkedEnvPromise := checkedEnvPromise } =
{ mainEnv := mainEnv_1, ... | null | true |
PredOrder.ofCore.eq_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (succ : α → α) (hn : ∀ {a : α}, ¬IsMin a → ∀ (b : α), b < a ↔ b ≤ succ a)
(hm : ∀ (a : α), IsMin a → succ a = a),
PredOrder.ofCore succ hn hm = { pred := succ, pred_le := ⋯, min_of_le_pred := ⋯, le_pred_of_lt := ⋯ } | null | true |
ModuleCat.limitModule._proof_8 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections]
(x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget... | null | false |
Mathlib.TacticAnalysis.Config.mk.noConfusion | Mathlib.Tactic.TacticAnalysis | {P : Sort u} →
{run run' : Array Mathlib.TacticAnalysis.TacticNode → Lean.Elab.Command.CommandElabM Unit} →
{ run := run } = { run := run' } → (run = run' → P) → P | null | false |
CategoryTheory.Limits.Concrete.widePullback_ext | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type (max v w)}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {B : C}
{ι : Type w} {X : ι → C} (f : (j : ι) → X j ⟶ B) [inst_3 : CategoryTheory.Limits.HasWidePullback B ... | null | true |
ProofWidgets.Penrose.RpcEncodablePacket.mk.«_@».ProofWidgets.Component.PenroseDiagram.3621647104._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.PenroseDiagram | {P : Sort u} →
{embeds dsl sty sub maxOptSteps embeds' dsl' sty' sub' maxOptSteps' : Lean.Json} →
{ embeds := embeds, dsl := dsl, sty := sty, sub := sub, maxOptSteps := maxOptSteps } =
{ embeds := embeds', dsl := dsl', sty := sty', sub := sub', maxOptSteps := maxOptSteps' } →
(embeds = embeds' → dsl... | null | false |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic._aux_Mathlib_Tactic_CancelDenoms_Core___elabRules_Mathlib_Tactic_tacticCancel_denoms__1.match_1 | Mathlib.Tactic.CancelDenoms.Core | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc? : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc? : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc?)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc? | null | false |
CategoryTheory.SimplicialObject.augmentOfIsTerminal | Mathlib.AlgebraicTopology.SimplicialObject.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.SimplicialObject C →
{T : C} → CategoryTheory.Limits.IsTerminal T → CategoryTheory.SimplicialObject.Augmented C | The augmented simplicial object that is deduced from a simplicial object and
a terminal object. | true |
_private.Mathlib.CategoryTheory.Galois.Prorepresentability.0.CategoryTheory.PreGaloisCategory.AutGalois.π_surjective._proof_1_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (i : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
Finite (((CategoryTheory.PreGaloisCategory.autGaloisSystem F).comp (CategoryTheory.forget GrpCat)).obj i) | null | false |
Mathlib.Deriving.Encodable.mkEncodableInstance | Mathlib.Tactic.DeriveEncodable | Array Lean.Name → Lean.Elab.Command.CommandElabM Bool | The deriving handler for the `Encodable` class.
Handles non-nested non-reflexive inductive types.
They can be mutual too — in that case, there is an optimization to re-use all the generated
functions and proofs.
| true |
Array.scanl_singleton | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {a : α} {f : β → α → β}, Array.scanl f init #[a] = #[init, f init a] | null | true |
Bundle.Trivialization.proj_surjOn_baseSet | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) [Nonempty F], Set.SurjOn proj e.source e.baseSet | null | true |
Std.DHashMap.Internal.Raw₀.Const.mem_toArray_iff_get?_eq_some | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[LawfulBEq α],
(↑m).WF →
∀ {k : α} {v : β}, (k, v) ∈ Std.DHashMap.Raw.Const.toArray ↑m ↔ Std.DHashMap.Internal.Raw₀.Const.get? m k = some v | null | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl_h | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {Y : C}
(f : X ⟶ Y), (HomotopicalAlgebra.Precylinder.LeftHomotopy.refl P f).h = CategoryTheory.CategoryStruct.comp P.π f | null | true |
_private.Init.Ext.0.PProd.ext.match_1 | Init.Ext | ∀ {α : Sort u_1} {β : Sort u_2} (motive : α ×' β → Prop) (h : α ×' β),
(∀ (fst : α) (snd : β), motive ⟨fst, snd⟩) → motive h | null | false |
WellFounded.prop_min | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) {p : α → Prop} (h : ∃ a, p a), p (H.min {a | p a} h) | null | true |
SheafOfModules.pushforwardCompForgetToSheafModuleCat | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
{F : CategoryTheory.Functor C D} →
{S : Catego... | Pushforward commutes with `SheafOfModules.forgetToSheafModuleCat` | true |
Lean.Lsp.SemanticTokenType.class | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenType | null | true |
Lean.Meta.Sym.DSimp.Methods.rec | Lean.Meta.Sym.DSimp.DSimpM | {motive : Lean.Meta.Sym.DSimp.Methods → Sort u} →
((pre post : Lean.Meta.Sym.DSimp.DSimproc) → motive { pre := pre, post := post }) →
(t : Lean.Meta.Sym.DSimp.Methods) → motive t | null | false |
MeasureTheory.integral_coe_le_of_lintegral_coe_le | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → NNReal} {b : NNReal},
∫⁻ (a : α), ↑(f a) ∂μ ≤ ↑b → ∫ (a : α), ↑(f a) ∂μ ≤ ↑b | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rup.0.Std.Tactic.BVDecide.LRAT.Internal.State.checkRup.match_1 | Std.Tactic.BVDecide.LRAT.Internal.Rup | (motive : Option Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u_1) →
(x : Option Std.Tactic.BVDecide.LRAT.Internal.Assignment) →
((assignment : Std.Tactic.BVDecide.LRAT.Internal.Assignment) → motive (some assignment)) →
((x : Option Std.Tactic.BVDecide.LRAT.Internal.Assignment) → motive x) → motive x | null | false |
Quiver.Arborescence.mk._flat_ctor | Mathlib.Combinatorics.Quiver.Arborescence | {V : Type u} → [inst : Quiver V] → (root : V) → ((b : V) → Unique (Quiver.Path root b)) → Quiver.Arborescence V | null | false |
ArithmeticFunction.carmichael_dvd | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {a b : ℕ}, a ∣ b → ArithmeticFunction.carmichael a ∣ ArithmeticFunction.carmichael b | null | true |
Finset.sum_Ico_Ico_comm | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} [inst : AddCommMonoid M] (a b : ℕ) (f : ℕ → ℕ → M),
∑ i ∈ Finset.Ico a b, ∑ j ∈ Finset.Ico i b, f i j = ∑ j ∈ Finset.Ico a b, ∑ i ∈ Finset.Ico a (j + 1), f i j | The two ways of summing over `(i, j)` in the range `a ≤ i ≤ j < b` are equal. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.