name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Filter.Germ.instIsCancelMul | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : Mul M] [IsCancelMul M], IsCancelMul (l.Germ M) | null | true |
Lean.parseImports' | Lean.Elab.ParseImportsFast | String → String → IO Lean.ModuleHeader | Simpler and faster version of `parseImports`. We use it to implement Lake.
| true |
Algebra.lmul._proof_3 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower R R A | null | false |
Int.IsFundamentalDiscr.ne_zero | Mathlib.NumberTheory.FundamentalDiscriminant | ∀ {D : ℤ}, D.IsFundamentalDiscr → D ≠ 0 | null | true |
Filter.high_scores | Mathlib.Order.Filter.AtTopBot.Finite | ∀ {β : Type u_3} [inst : LinearOrder β] [NoMaxOrder β] {u : ℕ → β},
Filter.Tendsto u Filter.atTop Filter.atTop → ∀ (N : ℕ), ∃ n ≥ N, ∀ k < n, u k < u n | If `u` is a sequence which is unbounded above,
then after any point, it reaches a value strictly greater than all previous values.
| true |
LieAlgebra.lieCharacterEquivLinearDual_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(χ : LieAlgebra.LieCharacter R L), LieAlgebra.lieCharacterEquivLinearDual χ = ↑χ | null | true |
IsDomain.recOn | Mathlib.Algebra.Ring.Defs | {α : Type u} →
[inst : Semiring α] →
{motive : IsDomain α → Sort u_1} →
(t : IsDomain α) → ([toIsCancelMulZero : IsCancelMulZero α] → [toNontrivial : Nontrivial α] → motive ⋯) → motive t | null | false |
FreeCommRing.eq_1 | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u), FreeCommRing α = MonoidAlgebra ℤ (Multiplicative (Multiset α)) | null | true |
Functor.Comp.mk_run | Mathlib.Control.Functor | ∀ {F : Type u → Type w} {G : Type v → Type u} {α : Type v} (x : Functor.Comp F G α), Functor.Comp.mk x.run = x | null | true |
_private.Mathlib.Tactic.Simps.Basic.0.Simps.splitOnNotNumber.process._f | Mathlib.Tactic.Simps.Basic | String → (arr : List String) → List.below (motive := fun arr => String → List String) arr → String → List String | null | false |
CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
[Category... | null | false |
Std.Tactic.BVDecide.BVExpr.Cache.Inv | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | Std.Tactic.BVDecide.BVExpr.Assignment →
(aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) → Std.Tactic.BVDecide.BVExpr.Cache aig → Prop | null | true |
CategoryTheory.ObjectProperty.ι_obj_lift_map | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) {X Y : C}
(f : X ⟶ Y), P.ι.map ((P.lift F hF).map f) = F.map f | null | true |
CategoryTheory.Triangulated.TStructure.isLE_of_le | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
groupHomology.H1CoresCoinfOfTrivial_g_epi | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (S : Subgroup G) [inst_2 : S.Normal]
[inst_3 : Representation.IsTrivial (MonoidHom.comp A.ρ S.subtype)],
CategoryTheory.Epi (groupHomology.H1CoresCoinfOfTrivial A S).g | Given a `G`-representation `A` on which a normal subgroup `S ≤ G` acts trivially, the
induced map `H₁(G, A) ⟶ H₁(G ⧸ S, A)` is an epimorphism. | true |
_private.Mathlib.Analysis.LocallyConvex.WithSeminorms.0.WithSeminorms.uniformEquicontinuous_iff_bddAbove_and_continuous_iSup._proof_1_1 | Mathlib.Analysis.LocallyConvex.WithSeminorms | 3 ≠ 0 | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.cc._proof_2 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_2} {ι : Type u_4} {κ : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
(r... | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.AffineSubspace.singleton_eq_singleton_iff._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = (↑p = ↑q) | null | false |
Asymptotics.isBigOWith_norm_right._simp_1 | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {c : ℝ} {f : α → E}
{g' : α → F'} {l : Filter α}, (Asymptotics.IsBigOWith c l f fun x => ‖g' x‖) = Asymptotics.IsBigOWith c l f g' | null | false |
Metric.smul_eball | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : Group G] [inst_2 : MulAction G X]
[IsIsometricSMul G X] (c : G) (x : X) (r : ENNReal), c • Metric.eball x r = Metric.eball (c • x) r | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.«term_†» | Mathlib.Analysis.InnerProductSpace.Defs | Lean.TrailingParserDescr | Local notation for `starRingEnd _` | true |
PerfectClosure.of | Mathlib.FieldTheory.PerfectClosure | (K : Type u) →
[inst : CommRing K] → (p : ℕ) → [inst_1 : Fact (Nat.Prime p)] → [inst_2 : CharP K p] → K →+* PerfectClosure K p | Embedding of `K` into `PerfectClosure K p` | true |
SSet.Truncated.IsStrictSegal.mk | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)},
(∀ (m : ℕ) (h : autoParam (m ≤ n + 1) SSet.Truncated.IsStrictSegal._auto_1), Function.Bijective (X.spine m h)) →
X.IsStrictSegal | null | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.recOn | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G → Sort u} →
... | null | false |
CategoryTheory.FunctorToTypes.naturality_symm | Mathlib.CategoryTheory.Types.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type u_1)}
{G : CategoryTheory.Functor C (Type u_2)} (e : (j : C) → F.obj j ≃ G.obj j),
(∀ {j j' : C} (f : j ⟶ j'),
⇑(e j') ∘ ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) =
⇑(CategoryTheory.ConcreteCategory.hom... | null | true |
_private.Mathlib.Order.WellFoundedSet.0.Set.WellFoundedOn.exists_maximal.match_1_1 | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} (motive : (∃ m, Maximal (fun x => x ∈ Set.univ) m) → Prop)
(x : ∃ m, Maximal (fun x => x ∈ Set.univ) m),
(∀ (m : { x // x ∈ s }) (hm : Maximal (fun x => x ∈ Set.univ) m), motive ⋯) → motive x | null | false |
Equiv.Perm.extendDomain_eq_one_iff._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] {e : Equiv.Perm α} {f : α ≃ Subtype p},
(e.extendDomain f = 1) = (e = 1) | null | false |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.CauSeq.not_limZero_of_pos.match_1_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {f : CauSeq α abs} (w : α)
(w_1 : ℕ) (motive : w ≤ ↑f w_1 ∧ |↑f w_1| < w → Prop) (x : w ≤ ↑f w_1 ∧ |↑f w_1| < w),
(∀ (h₁ : w ≤ ↑f w_1) (h₂ : |↑f w_1| < w), motive ⋯) → motive x | null | false |
Sym2.fromRel_top_iff | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} {sym : Std.Symm r}, Sym2.fromRel sym = Set.univ ↔ r = ⊤ | null | true |
Lean.Elab.ConfigEval.EvalExpr.evalNameExpr | Lean.Elab.ConfigEval.Instances | Lean.Expr → Lean.MetaM Lean.Name | null | true |
Module.finrank_directSum | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ (R : Type u) [inst : Semiring R] [StrongRankCondition R] {ι : Type v} [inst_2 : Fintype ι] (M : ι → Type w)
[inst_3 : (i : ι) → AddCommMonoid (M i)] [inst_4 : (i : ι) → Module R (M i)] [∀ (i : ι), Module.Free R (M i)]
[∀ (i : ι), Module.Finite R (M i)], Module.finrank R (DirectSum ι fun i => M i) = ∑ i, Module.fi... | The `finrank` of the direct sum is the sum of the `finrank`s. | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.ExBase.evalNatCast.match_3 | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{a : Q(ℕ)} →
(motive : Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a») → Sort u_1) →
(x : Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a»)) →
((expr : Q(«$α»)) ... | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_lt_natAbs_self_of_lt_neg_one_of_lt_neg_one._simp_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ} (c : ℤ), (a + c < b + c) = (a < b) | null | false |
_private.Batteries.Linter.UnreachableTactic.0.Batteries.Linter.UnreachableTactic.ignoreTacticKindsRef._proof_1 | Batteries.Linter.UnreachableTactic | Nonempty (ST.Ref IO.RealWorld Lean.NameHashSet) | null | false |
Polynomial.isIntegral_isLocalization_polynomial_quotient | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] {Rₘ : Type u_3} {Sₘ : Type u_4} [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(P : Ideal (Polynomial R)),
∀ pX ∈ P,
∀ [inst_3 : Algebra (R ⧸ Ideal.comap Polynomial.C P) Rₘ]
[inst_4 :
IsLocalization.Away (Polynomial.map (Ideal.Quotient.mk (Ideal.comap Polynomial... | If `I` is a prime ideal of `R[X]` and `pX ∈ I` is a non-constant polynomial,
then the map `R →+* R[x]/I` descends to an integral map when localizing at `pX.leadingCoeff`.
In particular `X` is integral because it satisfies `pX`, and constants are trivially integral,
so integrality of the entire extension follows by clos... | true |
CategoryTheory.ExponentiableMorphism.pushforwardComp | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J K : C} →
(f : I ⟶ J) →
(g : J ⟶ K) →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
[inst_2 : CategoryTheory.ChosenPullbacksAlong g] →
[inst_3 : CategoryTheory.ChosenPullbacksAlong (CategoryTheory... | The natural isomorphism between pushforward of the composition and the composition of
pushforward functors. | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.foldM.match_1.eq_2 | Batteries.Data.PairingHeap | ∀ {α : Type u_1} (motive : Option (α × Batteries.PairingHeapImp.Heap α) → Sort u_2) (hd : α)
(tl : Batteries.PairingHeapImp.Heap α) (h_1 : some (hd, tl) = none → motive none)
(h_2 :
(hd_1 : α) →
(tl_1 : Batteries.PairingHeapImp.Heap α) → some (hd, tl) = some (hd_1, tl_1) → motive (some (hd_1, tl_1))),
(... | null | true |
Lean.Elab.Command.removeFunctorPostfix | Lean.Elab.Coinductive | Lean.Name → Lean.Name | null | true |
CategoryTheory.GradedObject.mapIso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X Y : CategoryTheory.GradedObject I C} (e : X ≅ Y) (p : I → J) [inst_1 : X.HasMap p] [inst_2 : Y.HasMap p] (i : J),
(CategoryTheory.GradedObject.mapIso e p).hom i = CategoryTheory.GradedObject.mapMap e.hom p i | null | true |
Equiv.sumArrowEquivProdArrow_symm_apply_inl | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α → γ) (g : β → γ) (a : α),
(Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inl a) = f a | null | true |
_private.Mathlib.Basic.Logic.Basic.0.exists_exists_and_eq_and.match_1_1 | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop}
(motive : (∃ b, (∃ a, p a ∧ f a = b) ∧ q b) → Prop) (x : ∃ b, (∃ a, p a ∧ f a = b) ∧ q b),
(∀ (w : β) (a : α) (ha : p a) (hab : f a = w) (hb : q w), motive ⋯) → motive x | null | false |
_private.Lean.Linter.AmbiguousOpen.0.Lean.Linter.checkAmbiguousOpen.match_1 | Lean.Linter.AmbiguousOpen | (motive : Lean.Syntax.Preresolved → Sort u_1) →
(x : Lean.Syntax.Preresolved) →
((ns : Lean.Name) → motive (Lean.Syntax.Preresolved.namespace ns)) →
((x : Lean.Syntax.Preresolved) → motive x) → motive x | null | false |
Std.Iterators.PostconditionT.operation_pure | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] {α : Type w} {x : α}, (pure x).operation = pure ⟨x, ⋯⟩ | null | true |
IsTopologicalAddGroup.toHSpace._proof_4 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M], 0 + 0 = 0 | null | false |
LocalizedModule.smulOfIsLocalization._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (T : Type u_3) [inst_3 : CommSemiring T] [inst_4 : Algebra R T] [inst_5 : IsLocalization S T]
(x : T) (p p' : M × ↥S),
p ≈ p' →
LocalizedModule.mk ((IsLocalization.sec S x).1 • p.1) ((IsL... | null | false |
Nat.prod_Icc_factorial | Mathlib.Data.Nat.Factorial.SuperFactorial | ∀ (n : ℕ), ∏ x ∈ Finset.Icc 1 n, x.factorial = n.superFactorial | null | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_12 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (A : C) (a : (F.obj A).obj)
(isGalois : CategoryTheory.PreGaloisCategory.IsGalois A) (B : C) (b : (F.obj B).obj)
(isGalois_1 : CategoryTheory.PreGaloisCategory.IsGalo... | null | false |
ContinuousLinearMap.smulRightLₗ._proof_3 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ (𝕜 : Type u_3) (E' : Type u_2) (Fₗ' : Type u_1) [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E']
[inst_2 : Module 𝕜 E'] [inst_3 : TopologicalSpace E'] [inst_4 : AddCommGroup Fₗ'] [inst_5 : Module 𝕜 Fₗ']
[inst_6 : TopologicalSpace Fₗ'] [inst_7 : IsNormableSpace 𝕜 Fₗ'] [inst_8 : IsTopologicalAddGr... | null | false |
Hindman.FS.below.rec | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FS a a_1) → Hindman.FS.below t → Prop},
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
(∀ (a : Stream' M) (m : M) (h : Hindman.FS a.tail m) (ih : Hindman.FS.below... | null | false |
AntivaryOn.eq_1 | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (f : ι → α) (g : ι → β)
(s : Set ι), AntivaryOn f g s = ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → g i < g j → f j ≤ f i | null | true |
Matrix.transposeᵣ.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x : ℕ) (x_4 : Matrix (Fin x) (Fin 0) α), x_4.transposeᵣ = Matrix.of ![] | null | true |
instReprExcept.match_1 | Init.Data.ToString.Basic | {ε : Type u_1} →
{α : Type u_2} →
(motive : Except ε α → ℕ → Sort u_3) →
(x : Except ε α) →
(x_1 : ℕ) →
((e : ε) → (prec : ℕ) → motive (Except.error e) prec) →
((a : α) → (prec : ℕ) → motive (Except.ok a) prec) → motive x x_1 | null | false |
Similar.exists_pos_dist_eq | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂} [inst : PseudoMetricSpace P₁]
[inst_1 : PseudoMetricSpace P₂],
Similar v₁ v₂ → ∃ r, 0 < r ∧ ∀ (i₁ i₂ : ι), dist (v₁ i₁) (v₁ i₂) = r * dist (v₂ i₁) (v₂ i₂) | Scales distance with positive ratio. Forward direction of
`similar_iff_exists_pos_dist_eq`. | true |
_private.Lean.Parser.Extra.0.Lean.Parser.hygieneInfo._regBuiltin.Lean.Parser.hygieneInfo.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
CategoryTheory.Bicategory.InducedBicategory.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {P : Sort u} →
{B : Type u_1} →
{C : Type u_2} →
{inst : CategoryTheory.Bicategory C} →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{t : X.Hom Y} →
{B' : Type u_1} →
{C' : Type u_2} →
{inst' : CategoryT... | null | false |
CategoryTheory.CreatesColimitsOfShape.mk | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{F : CategoryTheory.Functor C D} →
autoParam ({K : CategoryTheory.Functor J ... | null | true |
Asymptotics.IsLittleO.sum_congr | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {E' : Type u_4} [inst : SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ι → α → E'}
{s : Finset ι} {B : ι → α → ℝ}, (∀ i ∈ s, A i =o[l] B i) → (fun H => ∑ i ∈ s, A i H) =o[l] fun H => ∑ i ∈ s, ‖B i H‖ | null | true |
Lean.Elab.Term.MutualClosure.LetRecClosure | Lean.Elab.MutualDef | Type | null | true |
LinearMap.coprod_inl | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃), f.coprod g ∘ₗ LinearMap.inl R M M₂ = f | null | true |
Interval.coeHom.match_1 | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(motive : Interval α → Sort u_2) →
(s : Interval α) → (Unit → motive none) → ((s : NonemptyInterval α) → motive (some s)) → motive s | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.WithZero.map'_mono._simp_1_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {p : WithZero α → Prop}, (∀ (x : WithZero α), p x) = (p 0 ∧ ∀ (a : α), p ↑a) | null | false |
Std.TreeSet.Equiv.of_forall_mem_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
(∀ (k : α), k ∈ t₁ ↔ k ∈ t₂) → t₁.Equiv t₂ | null | true |
List.Nodup.pairwise_coe | Mathlib.Data.Set.Pairwise.List | ∀ {α : Type u_1} {r : α → α → Prop} {l : List α} [Std.Symm r], l.Nodup → ({a | a ∈ l}.Pairwise r ↔ List.Pairwise r l) | null | true |
OpenNormalAddSubgroup.instLatticeOfSeparatelyContinuousAdd._proof_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (a b : OpenNormalAddSubgroup G),
SemilatticeInf.inf a b ≤ b | null | false |
_private.Lake.Util.Date.0.Lake.Date.fromJson?.match_4 | Lake.Util.Date | (motive : Lean.Json → Sort u_1) →
(j : Lean.Json) → ((s : String) → motive (Lean.Json.str s)) → ((x : Lean.Json) → motive x) → motive j | null | false |
TopologicalSpace.CompactOpens.instBooleanAlgebra._proof_6 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α],
autoParam (∀ (x y : TopologicalSpace.CompactOpens α), x ⇨ y = y ⊔ xᶜ) BooleanAlgebra.himp_eq._autoParam | null | false |
Heyting.Regular.instBooleanAlgebra._proof_9 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (x : Heyting.Regular α), x ⊓ xᶜ ≤ ⊥ | null | false |
Complex.UnitDisc.coe_neg._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitDisc), -↑z = ↑(-z) | null | false |
ProperCone.mem_dual._simp_1 | Mathlib.Analysis.Convex.Cone.Dual | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : TopologicalSpace R] [inst_4 : ClosedIciTopology R] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : TopologicalSpace M] [inst_8 : AddCommGroup N] [inst_9 : Module R N] [inst_10 ... | null | false |
SeparationQuotient.instNonUnitalNormedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {α : Type u_1} [inst : NonUnitalSeminormedRing α] (q₁ q₂ : Quotient (inseparableSetoid α)), ‖q₁ * q₂‖ ≤ ‖q₁‖ * ‖q₂‖ | null | false |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.nat_div._simp_1_2 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
PseudoMetricSpace.ofPreNNDist._proof_9 | Mathlib.Topology.Metrizable.Uniformity | ∀ {X : Type u_1} (d : X → X → NNReal),
(∀ (x : X), d x x = 0) →
(∀ (x y : X), d x y = d y x) → ∀ (x y : X), 0 ≤ ↑(⨅ l, (List.zipWith d (x :: l) (l ++ [y])).sum) | null | false |
analyticOnNhd_const | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {v : F} {s : Set E},
AnalyticOnNhd 𝕜 (fun x => v) s | null | true |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.jacobiSym.eq_zero_iff_not_coprime._simp_1_5 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
_private.Mathlib.Topology.MetricSpace.Isometry.0.isometry_iff_nndist_eq._simp_1_2 | Mathlib.Topology.MetricSpace.Isometry | ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) | null | false |
Semiring.directSumGSemiring._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ (ι : Type u_1) {R : Type u_2} [inst : AddMonoid ι] [inst_1 : Semiring R] (a b c : GradedMonoid fun x => R),
a * b * c = a * (b * c) | null | false |
ProfiniteGrp.ofProfinite._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : Profinite), CompactSpace ↑G.toTop | null | false |
LieHom.prod._proof_1 | Mathlib.Algebra.Lie.Prod | ∀ {R : Type u_4} {L₁ : Type u_1} {L₂ : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : LieRing L₁]
[inst_2 : LieAlgebra R L₁] [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] [inst_5 : LieRing L]
[inst_6 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L₁) (g : L →ₗ⁅R⁆ L₂) {x y : L},
((↑f).prod ↑g).toFun ⁅x, y⁆ = ⁅((↑f).pro... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_inter._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 |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0.Units.continuousOn_inv₀_spectrum._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ⊆ {a}ᶜ) = (a ∉ s) | null | false |
Std.Time.Nanosecond.instTransOrdOffset | Std.Time.Time.Unit.Nanosecond | Std.TransOrd Std.Time.Nanosecond.Offset | null | true |
_private.Mathlib.Topology.UniformSpace.Basic.0.Uniform.continuousOn_iff'_left._simp_1_1 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : TopologicalSpace β] {f : β → α} {b : β} {s : Set β},
ContinuousWithinAt f s b = Filter.Tendsto (fun x => (f x, f b)) (nhdsWithin b s) (uniformity α) | null | false |
List.diff_subset | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] (l₁ l₂ : List α), l₁.diff l₂ ⊆ l₁ | null | true |
Order.Ioo_succ_right_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
¬IsMax b → Set.Ioo a (Order.succ b) = Set.Ioc a b | null | true |
CategoryTheory.Iso.trans_refl | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y), α ≪≫ CategoryTheory.Iso.refl Y = α | null | true |
DFinsupp.Lex.isOrderedCancelAddMonoid | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddCommMonoid (α i)]
[inst_2 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), IsOrderedCancelAddMonoid (α i)],
IsOrderedCancelAddMonoid (Lex (Π₀ (i : ι), α i)) | null | true |
PowerSeries.mul_X_cancel | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {φ ψ : PowerSeries R}, φ * PowerSeries.X = ψ * PowerSeries.X → φ = ψ | null | true |
Finset.ruzsa_triangle_inequality_add_sub_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
B.card * (A + C).card ≤ (B - A).card * (B + C).card | **Ruzsa's triangle inequality**. Add-sub-add version. | true |
Bool.le_trans | Init.Data.Bool | ∀ {x y z : Bool}, x ≤ y → y ≤ z → x ≤ z | null | true |
Std.DTreeMap.Internal.Impl.Const.insertMany_cons | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} (h : t.WF)
{l : List (α × β)} {k : α} {v : β},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany t ((k, v) :: l) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl l ⋯) | null | true |
Std.DTreeMap.Raw.getKey_modify_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF → ∀ [Inhabited α] {k : α} {f : β k → β k} {hc : k ∈ t.modify k f}, (t.modify k f).getKey k hc = k | null | true |
Subarray.size_mkSlice_ric | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {hi : ℕ},
Std.Slice.size (Std.Ric.Sliceable.mkSlice xs *...=hi) = min (hi + 1) (Std.Slice.size xs) | null | true |
AddSubgroup.nsmul | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : AddGroup G] → (H : AddSubgroup G) → SMul ℕ ↥H | An `AddSubgroup` of an `AddGroup` inherits a natural scaling. | true |
Mathlib.Tactic.Linarith.CompSource.add.injEq | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | ∀ (a a_1 a_2 a_3 : Mathlib.Tactic.Linarith.CompSource), (a.add a_1 = a_2.add a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.isIso_functor_map_hom_h_f._proof_1_7 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (k : ℕ) {q₁ q₂ : ℕ}, q₁ + (k + 1) = q₂ → q₁ + k + 1 = q₂ | null | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Ext.0.CategoryTheory.ProjectiveResolution.smul_extMk._simp_1_4 | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {R : Type u_1} [inst_3 : Ring R]
[inst_4 : CategoryTheory.Linear R C] (r : R) {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ} (h : p + n = q) (p' : ℤ)
... | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddleHom | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} → {S : J.Cover X} → {T : (I : S.Arrow) → J.Cover I.Y} → (I : (S.bind T).Arrow) → I.Y ⟶ I.middle | An arrow in bind has the form `A ⟶ B ⟶ X` where `A ⟶ B` is an arrow in `T I` for some `I`.
and `B ⟶ X` is an arrow of `S`. This is the hom `A ⟶ B`. | true |
HomologicalComplex.singleObjHomologySelfIso | Mathlib.Algebra.Homology.SingleHomology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
{ι : Type u_1} →
[inst_3 : DecidableEq ι] →
(c : ComplexShape ι) → (j : ι) → (A : C) → ((HomologicalComplex.single... | The canonical isomorphism `((single C c j).obj A).homology j ≅ A` | true |
AlgebraicGeometry.isGermInjectiveAt_iff_of_isOpenImmersion | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X} [AlgebraicGeometry.IsOpenImmersion f],
Y.IsGermInjectiveAt (f x) ↔ X.IsGermInjectiveAt x | null | true |
Mathlib.PrintSorries.State._sizeOf_1 | Mathlib.Util.PrintSorries | Mathlib.PrintSorries.State → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.