name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Internal.Impl.get.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] (t t_1 : Std.DTreeMap.Internal.Impl α β)
(e_t : t = t_1) (k : α) (hlk : k ∈ t), t.get k hlk = t_1.get k ⋯ | true |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.MemLp.induction_dense._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | (0 < ⊤) = True | false |
CategoryTheory.Functor.mapGrpIdIso_hom_app_hom_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : CategoryTheory.Grp C),
(CategoryTheory.Functor.mapGrpIdIso.hom.app X).hom.hom = CategoryTheory.CategoryStruct.id X.X | true |
DirichletCharacter.Even.to_fun | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {S : Type u_2} [inst : CommRing S] {m : ℕ} {χ : DirichletCharacter S m}, χ.Even → Function.Even ⇑χ | true |
HasDerivWithinAt.eq_1 | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] [inst_4 : ContinuousSMul 𝕜 F] (f : 𝕜 → F) (f' : F) (s : Set 𝕜) (x : 𝕜),
HasDerivWithinAt f f' s x = HasDerivAtFilter f f' (nhdsWithin x s ×ˢ pure x) | true |
analyticWithinAt_insert | 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] {f : E → F} {s : Set E}
{x y : E}, AnalyticWithinAt 𝕜 f (insert y s) x ↔ AnalyticWithinAt 𝕜 f s x | true |
OreLocalization.npow | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : Monoid R] →
{S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → ℕ → OreLocalization S R → OreLocalization S R | true |
Submodule.quotientEquivOfIsCompl._proof_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
CategoryTheory.Pretriangulated.triangleRotation_unitIso | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive],
(CategoryTheory.Pretriangulated.triangleRotation C).unitIso = CategoryTheory.Pretriangulated.rotCompInvRot | true |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.tryToProveFalse.match_1 | Lean.Meta.Tactic.Grind.MatchCond | (motive : Option (Bool × Subarray Bool) → Sort u_1) →
(x : Option (Bool × Subarray Bool)) →
(Unit → motive none) → ((target : Bool) → (s' : Subarray Bool) → motive (some (target, s'))) → motive x | false |
SheafOfModules.Presentation._sizeOf_inst | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat} →
{inst_2 : J.WEqualsLocallyBijective AddCommGrpCat} →
{inst_3 : J.HasShe... | false |
_private.Init.Data.String.Lemmas.Pattern.Find.String.0.String.Slice.contains.eq_1 | Init.Data.String.Lemmas.Pattern.Find.String | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)]
[inst_1 : (s : String.Slice) → Std.IteratorLoop (σ s) Id Id] (s : String.Slice) (pat : ρ)
[inst_2 : String.Slice.Pattern.ToForwardSearcher pat σ],
s.contains pat =
Std.Iter.any
... | true |
CategoryTheory.Limits.Types.Pushout.mono_inr | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) [CategoryTheory.Mono f],
CategoryTheory.Mono (CategoryTheory.Limits.Types.Pushout.inr f g) | true |
LSeriesSummable_iff_of_re_eq_re | Mathlib.NumberTheory.LSeries.Basic | ∀ {f : ℕ → ℂ} {s s' : ℂ}, s.re = s'.re → (LSeriesSummable f s ↔ LSeriesSummable f s') | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Command.elabSyntaxAux._regBuiltin._private.Lean.Elab.Syntax.0.Lean.Elab.Command.elabSyntaxAux_1 | Lean.Elab.Syntax | IO Unit | false |
groupCohomology.isoShortComplexH2._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | (ComplexShape.up ℕ).prev 2 = 1 | false |
Nat.Linear.Expr.inc | Init.Data.Nat.Linear | Nat.Linear.Expr → Nat.Linear.Expr | true |
Matrix.IsHermitian.neg | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {n : Type u_4} [inst : AddGroup α] [inst_1 : StarAddMonoid α] {A : Matrix n n α},
A.IsHermitian → (-A).IsHermitian | true |
IsDedekindDomain.HeightOneSpectrum.adicAbv.eq_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {b : NNReal}
(hb : 1 < b),
v.adicAbv hb = { toFun := fun x => ↑(v.adicAbvDef hb x), map_mul' := ⋯, nonneg' := ⋯, eq_z... | true |
Aesop.Frontend.Parser.usingRuleSets | Aesop.Frontend.Saturate | Lean.ParserDescr | true |
_private.Lean.Server.FileWorker.SetupFile.0.Lean.Server.FileWorker.setupFile._sparseCasesOn_6 | Lean.Server.FileWorker.SetupFile | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
LieAlgebra.IsExtension.extension_incl | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : LieRing N] [inst_4 : LieAlgebra R N] [inst_5 : LieRing M]
[inst_6 : LieAlgebra R M] {i : N →ₗ⁅R⁆ L} {p : L →ₗ⁅R⁆ M} (h : LieAlgebra.IsExtension i p), h.extension.incl = i | true |
HeytAlg.Iso.mk._proof_9 | Mathlib.Order.Category.HeytAlg | ∀ {α β : HeytAlg} (e : ↑α ≃o ↑β), e.symm ⊥ = ⊥ | false |
Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rewrite______1 | Mathlib.Tactic.NthRewrite | Lean.Macro | false |
Quiver.isSStronglyConnected_iff | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_2) [inst : Quiver V], Quiver.IsSStronglyConnected V ↔ ∀ (i j : V), ∃ p, 0 < p.length | true |
Ideal.eq_zero_of_constant_mem_of_maximal | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Ring R],
IsField R → ∀ (I : Ideal (Polynomial R)) [hI : I.IsMaximal] (x : R), Polynomial.C x ∈ I → x = 0 | true |
Std.Iterators.instFunctorHetT | Std.Data.Iterators.Lemmas.Equivalence.HetT | {m : Type w → Type w'} → [Functor m] → Functor (Std.Iterators.HetT m) | true |
ProbabilityTheory.HasGaussianLaw.isProbabilityMeasure | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : TopologicalSpace E]
[inst_1 : AddCommMonoid E] [inst_2 : Module ℝ E] [mE : MeasurableSpace E] {X : Ω → E},
ProbabilityTheory.HasGaussianLaw X P → MeasureTheory.IsProbabilityMeasure P | true |
CategoryTheory.Subobject.factors_add | Mathlib.CategoryTheory.Subobject.FactorThru | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{P : CategoryTheory.Subobject Y} (f g : X ⟶ Y), P.Factors f → P.Factors g → P.Factors (f + g) | true |
CategoryTheory.Pretriangulated.Triangle.isZero₂_of_isIso₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.go._proof_19 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w n : ℕ) (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs : aig.RefVec w)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_1.RefVec n)
(hraig : aig.decls.size ≤ { aig := aig_1, vec := rhs }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bi... | false |
Lean.Lsp.instInhabitedResolvableCompletionItem | Lean.Data.Lsp.LanguageFeatures | Inhabited Lean.Lsp.ResolvableCompletionItem | true |
CategoryTheory.Limits.compYonedaSectionsEquiv | Mathlib.CategoryTheory.Limits.Types.Yoneda | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
(F : CategoryTheory.Functor J Cᵒᵖ) →
(X : C) →
↑(F.comp (CategoryTheory.yoneda.obj X)).sections ≃
((CategoryTheory.Functor.const J).... | true |
Std.Iterators.Types.Attach.instProductive | Init.Data.Iterators.Combinators.Monadic.Attach | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [Std.Iterators.Productive α m]
{P : β → Prop}, Std.Iterators.Productive (Std.Iterators.Types.Attach α m P) m | true |
Bool.dite_else_true_eq_false._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : p → Bool}, ((if h : p then x h else true) = false) = ∃ (h : p), x h = false | false |
OrderIso.equivalence._proof_5 | Mathlib.CategoryTheory.Category.Preorder | ∀ {X : Type u_2} {Y : Type u_1} [inst : Preorder X] [inst_1 : Preorder Y] (e : X ≃o Y) {X_1 Y_1 : Y} (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((⋯.functor.comp ⋯.functor).map f) ((fun x => CategoryTheory.eqToIso ⋯) Y_1).hom =
CategoryTheory.CategoryStruct.comp ((fun x => CategoryTheory.eqToIso ⋯) X_1).h... | false |
AddGroupNorm.instAdd.eq_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E],
AddGroupNorm.instAdd =
{
add := fun p q =>
let __src := p.toAddGroupSeminorm + q.toAddGroupSeminorm;
{ toAddGroupSeminorm := __src, eq_zero_of_map_eq_zero' := ⋯ } } | true |
Filter.HasBasis.clusterPt_iff_forall_mem_closure | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {ι : Sort u_3} {p : ι → Prop} {s : ι → Set X} {F : Filter X},
F.HasBasis p s → (ClusterPt x F ↔ ∀ (i : ι), p i → x ∈ closure (s i)) | true |
Mathlib.Tactic.Module.tacticMatch_scalars | Mathlib.Tactic.Module | Lean.ParserDescr | true |
EuclideanGeometry.mapsTo_inversion_affineSubspace_of_mem | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c : P} {R : ℝ} {p : AffineSubspace ℝ P},
c ∈ p → Set.MapsTo (EuclideanGeometry.inversion c R) ↑p ↑p | true |
Std.Internal.IO.Async.Signal.sigterm | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal | true |
OpenNormalSubgroup.noConfusion | Mathlib.Topology.Algebra.OpenSubgroup | {P : Sort u_1} →
{G : Type u} →
{inst : Group G} →
{inst_1 : TopologicalSpace G} →
{t : OpenNormalSubgroup G} →
{G' : Type u} →
{inst' : Group G'} →
{inst'_1 : TopologicalSpace G'} →
{t' : OpenNormalSubgroup G'} →
G = G' → inst ≍ ... | false |
Lean.Elab.Term.Do.ToTerm.Kind.forIn | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind | true |
Class._aux_Mathlib_SetTheory_ZFC_Class___unexpand_Class_fval_1 | Mathlib.SetTheory.ZFC.Class | Lean.PrettyPrinter.Unexpander | false |
String.Pos.Raw.Valid.intro | Batteries.Data.String.Lemmas | ∀ {s : String} {p : String.Pos.Raw},
(∃ cs cs', cs ++ cs' = s.toList ∧ p.byteIdx = String.utf8Len cs) → String.Pos.Raw.Valid s p | true |
CategoryTheory.Limits.CokernelCofork.map_condition_assoc | 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} (c : CategoryTheory.Limits.CokernelCofork f) (G : CategoryTheory.Funct... | true |
EReal.mul.match_1 | Mathlib.Data.EReal.Basic | (motive : EReal → EReal → Sort u_1) →
(x x_1 : EReal) →
(Unit → motive none none) →
(Unit → motive none (some none)) →
((y : ℝ) → motive none (some (some y))) →
(Unit → motive (some none) none) →
(Unit → motive (some none) (some none)) →
((y : ℝ) → motive (some no... | false |
Lean.KeyedDeclsAttribute.ExtensionState.rec | Lean.KeyedDeclsAttribute | {γ : Type} →
{motive : Lean.KeyedDeclsAttribute.ExtensionState γ → Sort u} →
((newEntries : List Lean.KeyedDeclsAttribute.OLeanEntry) →
(table : Lean.KeyedDeclsAttribute.Table γ) →
(declNames erased : Lean.PHashSet Lean.Name) →
motive { newEntries := newEntries, table := table, declN... | false |
AddSubgroup.normalClosure_normal | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G}, (AddSubgroup.normalClosure s).Normal | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_mk.match_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {size : xs.size = n} {a : α} (motive : a ∈ Vector.mk xs size → Prop)
(x : a ∈ Vector.mk xs size), (∀ (h : a ∈ (Vector.mk xs size).toArray), motive ⋯) → motive x | false |
VitaliFamily.ae_tendsto_lintegral_enorm_sub_div | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) {E : Type u_2} [inst_1 : NormedAddCommGroup E] [SecondCountableTopology α] [BorelSpace α]
[MeasureTheory.IsLocallyFiniteMeasure μ] {f : α → E},
MeasureTheory.LocallyIntegrable f μ →
∀ᵐ (x ... | true |
selfAdjoint.instOneSubtypeMemAddSubgroup._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : StarRing R], IsSelfAdjoint 1 | false |
ModuleCat.hom_inv_apply | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} (e : M ≅ N) (x : ↑N),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) x) = x | true |
Lean.Server.LspResponse.noConfusionType | Lean.Server.Requests | Sort u → {α : Type} → Lean.Server.LspResponse α → {α' : Type} → Lean.Server.LspResponse α' → Sort u | false |
Matrix.cons_val_two | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {m : ℕ} (x : α) (u : Fin m.succ.succ → α), Matrix.vecCons x u 2 = Matrix.vecHead (Matrix.vecTail u) | true |
Function.Semiconj.mapsTo_fixedPoints | Mathlib.Dynamics.FixedPoints.Basic | ∀ {α : Type u} {β : Type v} {fa : α → α} {fb : β → β} {g : α → β},
Function.Semiconj g fa fb → Set.MapsTo g (Function.fixedPoints fa) (Function.fixedPoints fb) | true |
CategoryTheory.Limits.Multifork.ofPiFork_π_app_left | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
{I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left}
{d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d)
(a : CategoryTheory.Limits.Fork (I.fstPiMapOf... | true |
FreeRing.instCommRing._proof_1 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1) [Subsingleton α] (x y : FreeRing α), x * y = y * x | false |
Filter.EventuallyEq.div_mul_cancel_atTop | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_4} {K : Type u_5} [inst : DivisionSemiring K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
{f g : α → K} {l : Filter α}, Filter.Tendsto g l Filter.atTop → (fun x => f x / g x * g x) =ᶠ[l] fun x => f x | true |
FiniteField.finrank_zmod_extension | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] [Finite k] (p : ℕ) [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP k p] (n : ℕ)
[NeZero n] [inst_5 : Algebra (ZMod p) k],
Module.finrank (ZMod p) (FiniteField.Extension k p n) = Module.finrank (ZMod p) k * n | true |
MeromorphicOn.isClopen_setOf_meromorphicOrderAt_eq_top | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → IsClopen {u | meromorphicOrderAt f ↑u = ⊤} | true |
CategoryTheory.evaluation._proof_1 | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (X : C) (X_1 : CategoryTheory.Functor C D),
(CategoryTheory.CategoryStruct.id X_1).app X = CategoryTheory.CategoryStruct.id (X_1.obj X) | false |
CategoryTheory.ConcreteCategory.hom_ext_iff | Mathlib.CategoryTheory.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
{f g : X ⟶ Y},
f = g ↔
∀ (x : CategoryTheory.ToType X),
(CategoryTheory.ConcreteCategory.hom ... | true |
compHausToCondensed' | Mathlib.Condensed.Functors | CategoryTheory.Functor CompHaus (Condensed (Type u)) | true |
Coalgebra.IsCocomm.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A],
↑(TensorProduct.comm R A A) ∘ₗ CoalgebraStruct.comul = CoalgebraStruct.comul → Coalgebra.IsCocomm R A | false |
AddSubmonoid.casesOn | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
{motive : AddSubmonoid M → Sort u} →
(t : AddSubmonoid M) →
((toAddSubsemigroup : AddSubsemigroup M) →
(zero_mem' : 0 ∈ toAddSubsemigroup.carrier) →
motive { toAddSubsemigroup := toAddSubsemigroup, zero_mem' := zero_mem' }) →
... | false |
ProfiniteAddGrp.id_apply | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (A : ProfiniteAddGrp.{u}) (a : ↑A.toProfinite.toTop),
(ProfiniteAddGrp.Hom.hom (CategoryTheory.CategoryStruct.id A)) a = a | true |
ZetaAsymptotics.term_sum.eq_1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ (s : ℝ) (N : ℕ), ZetaAsymptotics.term_sum s N = ∑ n ∈ Finset.range N, ZetaAsymptotics.term (n + 1) s | true |
Std.Tactic.BVDecide.BVExpr.Cache.Key.expr | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | (self : Std.Tactic.BVDecide.BVExpr.Cache.Key) → Std.Tactic.BVDecide.BVExpr self.w | true |
Fin.odd_iff_imp | Mathlib.Data.Fin.Parity | ∀ {n : ℕ} {k : Fin n} [inst : NeZero n], Odd k ↔ Even n → Odd ↑k | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.StructInstState.mk.injEq | Lean.Elab.StructInst | ∀ (type : Lean.Expr) (structNameSet : Lean.NameSet) (fieldMap : Lean.NameMap Lean.Expr) (fields : Array Lean.Expr)
(instMVars : Array Lean.MVarId) (liftedFVars : Array Lean.Expr) (liftedFVarRemap : Lean.FVarIdMap Lean.FVarId)
(optParamFields : Array (Lean.Name × Lean.Expr × Bool)) (type_1 : Lean.Expr) (structNameSe... | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.tail.aux.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u_1} (motive : Option (α × Stream'.WSeq α) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (fst : α) → (s : Stream'.WSeq α) → motive (some (fst, s))),
(match none with
| none => h_1 ()
| some (fst, s) => h_2 fst s) =
h_1 () | true |
Pi.Colex.completeLattice._proof_2 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedGT ι] (x : Set (Colex ((i : ι) → α i))), IsGLB x (sInf x) | false |
Lean.Meta.Grind.activateInjectiveTheorem | Lean.Meta.Tactic.Grind.Internalize | Lean.Meta.Grind.InjectiveTheorem → ℕ → Lean.Meta.Grind.GoalM Unit | true |
OpenAddSubgroup.instInhabited.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G], OpenAddSubgroup.instInhabited = { default := ⊤ } | true |
Lean.AsyncConstantInfo.rec | Lean.Environment | {motive : Lean.AsyncConstantInfo → Sort u} →
((name : Lean.Name) →
(kind : Lean.ConstantKind) →
(sig : Task Lean.ConstantVal) →
(constInfo : Task Lean.ConstantInfo) →
motive { name := name, kind := kind, sig := sig, constInfo := constInfo }) →
(t : Lean.AsyncConstantInfo) → mot... | false |
Lean.Lsp.TextDocumentRegistrationOptions.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (documentSelector? : Option Lean.Lsp.DocumentSelector),
sizeOf { documentSelector? := documentSelector? } = 1 + sizeOf documentSelector? | true |
Rat.IsIntegralClosure.intEquiv_apply_eq_ringOfIntegersEquiv | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (x : NumberField.RingOfIntegers ℚ),
(Rat.IsIntegralClosure.intEquiv (NumberField.RingOfIntegers ℚ)) x = Rat.ringOfIntegersEquiv x | true |
Bicategory.Opposite.bicategory._proof_7 | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {a b c : Bᵒᵖ} (f : a ⟶ b) (g : b ⟶ c),
Bicategory.Opposite.op2
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator g.unop (CategoryTheory.CategoryStruct.id b).unop
f.unop).op2_unop.symm.hom.unop2
(Bicat... | false |
GaussianFourier.norm_cexp_neg_mul_sq_add_mul_I' | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ},
b.re ≠ 0 →
∀ (c T : ℝ),
‖Complex.exp (-b * (↑T + ↑c * Complex.I) ^ 2)‖ =
Real.exp (-(b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re))) | true |
PowerSeries.IsWeierstrassDivisorAt.mod'._proof_1 | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {I : Ideal A} (H : g.IsWeierstrassDivisorAt I)
[inst_1 : IsAdicComplete I A] (f f' : PowerSeries A), f ≈ f' → (fun f => H.mod f) f = (fun f => H.mod f) f' | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_imp_distrib_right._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p q : α → Prop},
(∃ᶠ (x : α) in f, p x → q x) = ((∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x) | false |
Num.castNum_shiftRight._simp_1 | Mathlib.Data.Num.Lemmas | ∀ (m : Num) (n : ℕ), ↑m >>> n = ↑(m >>> n) | false |
Nat.lt_sub_iff_add_lt | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a < c - b ↔ a + b < c | true |
Lean.Compiler.LCNF.Pass.saveBase | Lean.Compiler.LCNF.Passes | Lean.Compiler.LCNF.Pass | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt16.reduceLT.declare_115._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.142 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
PowerBasis.rec | Mathlib.RingTheory.PowerBasis | {R : Type u_7} →
{S : Type u_8} →
[inst : CommRing R] →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{motive : PowerBasis R S → Sort u} →
((gen : S) →
(dim : ℕ) →
(basis : Module.Basis (Fin dim) R S) →
(basis_eq_pow : ∀ (i :... | false |
_private.Mathlib.Algebra.Group.ForwardDiff.0.fwdDiff_iter_sum_mul_pow_eq_zero._simp_1_3 | Mathlib.Algebra.Group.ForwardDiff | ∀ {α : Type u_7} {M : α → Type u_8} {ι : Type u_9} [inst : (a : α) → AddCommMonoid (M a)] (s : Finset ι)
(g : ι → (a : α) → M a), (fun a => ∑ c ∈ s, g c a) = ∑ c ∈ s, g c | false |
DoldKan._aux_Mathlib_AlgebraicTopology_DoldKan_Notations___unexpand_AlgebraicTopology_NormalizedMooreComplex_obj_1 | Mathlib.AlgebraicTopology.DoldKan.Notations | Lean.PrettyPrinter.Unexpander | false |
Filter.addLeftMono | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α], AddLeftMono (Filter α) | true |
isJacobsonRing_iff_prime_eq | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R], IsJacobsonRing R ↔ ∀ (P : Ideal R), P.IsPrime → P.jacobson = P | true |
EReal.instDivInvMonoid._proof_2 | Mathlib.Data.EReal.Inv | ∀ (a : EReal), zpowRec npowRec 0 a = 1 | false |
NNReal.coe_le_one | Mathlib.Data.NNReal.Defs | ∀ {r : NNReal}, ↑r ≤ 1 ↔ r ≤ 1 | true |
_private.Init.Data.UInt.Bitwise.0.UInt64.not_eq_comm._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | false |
CategoryTheory.Functor.Monoidal.μ_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) {Z : D} (h : F.obj Y ⟶ ... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_add._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (n m i : ℕ), i < w → ¬i - m - n < w → False | false |
NumberField.instCommRingInfiniteAdeleRing._proof_47 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | ∀ (K : Type u_1) [inst : Field K] (a b : NumberField.InfiniteAdeleRing K), a * b = b * a | false |
Std.Internal.IO.Async.System.GroupInfo.mk.inj | Std.Internal.Async.System | ∀ {groupName : String} {groupId : Std.Internal.IO.Async.System.GroupId} {members : Array String} {groupName_1 : String}
{groupId_1 : Std.Internal.IO.Async.System.GroupId} {members_1 : Array String},
{ groupName := groupName, groupId := groupId, members := members } =
{ groupName := groupName_1, groupId := gro... | true |
Complex.HadamardThreeLines.verticalClosedStrip | Mathlib.Analysis.Complex.Hadamard | ℝ → ℝ → Set ℂ | true |
Filter.IsMeasurablyGenerated.recOn | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} →
[inst : MeasurableSpace α] →
{f : Filter α} →
{motive : f.IsMeasurablyGenerated → Sort u} →
(t : f.IsMeasurablyGenerated) →
((exists_measurable_subset : ∀ ⦃s : Set α⦄, s ∈ f → ∃ t ∈ f, MeasurableSet t ∧ t ⊆ s) → motive ⋯) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.