name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
TensorialAt.mkHom._proof_3 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {M : Type u_2} [inst : TopologicalSpace M] {F : Type u_3} [inst_1 : NormedAddCommGroup F] {V : M → Type u_1}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F V)] [inst_3 : (x : M) → TopologicalSpace (V x)] [FiberBundle F V]
(x : M), T2Space (V x) | false |
Stream'.Seq.destruct | Mathlib.Data.Seq.Defs | {α : Type u} → Stream'.Seq α → Option (Stream'.Seq1 α) | true |
_private.Lean.PrettyPrinter.Formatter.0.Lean.PrettyPrinter.Formatter.visitAtom._sparseCasesOn_1 | Lean.PrettyPrinter.Formatter | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.ideal_fg._simp_1_2 | Mathlib.RingTheory.Kaehler.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
Std.Iter.count_eq_count_toIterM | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
{it : Std.Iter β}, it.length = it.toIterM.length.run.down | true |
Subalgebra.pi._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Pi | ∀ {ι : Type u_1} {R : Type u_3} {S : ι → Type u_2} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (S i)]
[inst_2 : (i : ι) → Algebra R (S i)] (s : Set ι) (t : (i : ι) → Subalgebra R (S i)) {a b : (i : ι) → S i},
a ∈ (Submodule.pi s fun i => Subalgebra.toSubmodule (t i)).carrier →
b ∈ (Submodule.pi s fun i... | false |
Summable.map_tsum | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.NeBot] [inst_3 : AddCommMonoid γ] [inst_4 : TopologicalSpace γ] [T2Space γ],
Summable f L →
∀ {G : Type u_4} [inst_6 : FunLike G α γ] [AddMonoidHomClass G α γ] (g : G),
... | true |
Turing.ToPartrec.Code._sizeOf_inst._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.13 | Mathlib.Computability.TuringMachine.ToPartrec | SizeOf Turing.ToPartrec.Code | false |
IsCauSeq.neg | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [IsAbsoluteValue abv] {f : ℕ → β}, IsCauSeq abv f → IsCauSeq abv (-f) | true |
Affine.Simplex.touchpoint_empty_mem_interior_faceOpposite | Mathlib.Geometry.Euclidean.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] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) [n.AtLeastTwo]
(i : Fin (n + 1)), s.touchpoint ∅ i ∈ (s.faceOpposite i).interior | true |
CategoryTheory.ShortComplex.moduleCatLeftHomologyData._proof_2 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (ModuleCat.Hom.hom S.g).ker.subtype) S.g = 0 | false |
MeasureTheory.Measure.pi_Ioo_ae_eq_pi_Ioc | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), MeasureTheory.NoAtoms (μ i)] {s : Set ι} {f g : (i : ι) → α i},
(s.pi fun i... | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.IterM.step_intermediateDropWhileM.match_1.splitter | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : MonadAttach m] →
{P : β → m (ULift.{u_1, 0} Bool)} →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (P out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (P out))) →
((hP : MonadAttach.CanRetu... | true |
DividedPowers.DPMorphism.mk._flat_ctor | Mathlib.RingTheory.DividedPowers.DPMorphism | {A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring A] →
[inst_1 : CommSemiring B] →
{I : Ideal A} →
{J : Ideal B} →
{hI : DividedPowers I} →
{hJ : DividedPowers J} →
(toFun : A → B) →
(map_one' : toFun 1 = 1) →
... | false |
CategoryTheory.Abelian.Preradical.r_map_ι_app | Mathlib.CategoryTheory.Abelian.Preradical.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
(Φ : CategoryTheory.Abelian.Preradical C) (X : C), Φ.r.map (Φ.ι.app X) = Φ.ι.app (Φ.r.obj X) | true |
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.RingIneqCnstr →
ℤ → Lean.Grind.Linarith.Var → Lean.Grind.Linarith.Var → Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof | true |
PFunctor.Approx.CofixA | Mathlib.Data.PFunctor.Univariate.M | PFunctor.{uA, uB} → ℕ → Type (max uA uB) | true |
Std.Tactic.BVDecide.BVExpr.WithCache.mk.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ {α : Type u} {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} (val : α) (cache : Std.Tactic.BVDecide.BVExpr.Cache aig)
(val_1 : α) (cache_1 : Std.Tactic.BVDecide.BVExpr.Cache aig),
({ val := val, cache := cache } = { val := val_1, cache := cache_1 }) = (val = val_1 ∧ cache = cache_1) | true |
Std.DTreeMap.Const.get?_map' | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {γ : Type w} {t : Std.DTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] {f : α → β → γ} {k : α},
Std.DTreeMap.Const.get? (Std.DTreeMap.map f t) k =
Option.pmap (fun v h' => f (t.getKey k h') v) (Std.DTreeMap.Const.get? t k) ⋯ | true |
CategoryTheory.FinCategory.fintypeObj._autoParam | Mathlib.CategoryTheory.FinCategory.Basic | Lean.Syntax | false |
invertibleThree | Mathlib.Algebra.CharP.Invertible | {K : Type u_2} → [inst : DivisionSemiring K] → [CharZero K] → Invertible 3 | true |
ConnectedSpace.casesOn | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : ConnectedSpace α → Sort u_1} →
(t : ConnectedSpace α) →
([toPreconnectedSpace : PreconnectedSpace α] → (toNonempty : Nonempty α) → motive ⋯) → motive t | false |
instDecidableIrrationalSqrtCastReal_1 | Mathlib.NumberTheory.Real.Irrational | (z : ℤ) → Decidable (Irrational √↑z) | true |
_private.Init.Data.Array.Extract.0.Array.popWhile_map._simp_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, (List.map f l).reverse = List.map f l.reverse | false |
FirstOrder.Language.Term.func.sizeOf_spec | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} [inst : SizeOf α] {l : ℕ} (_f : L.Functions l) (_ts : Fin l → L.Term α),
sizeOf (FirstOrder.Language.func _f _ts) = 1 + sizeOf l + sizeOf _f | true |
Aesop.Goal.setId | Aesop.Tree.Data | Aesop.GoalId → Aesop.Goal → Aesop.Goal | true |
CategoryTheory.Endofunctor.coalgebraPreadditive._proof_2 | Mathlib.CategoryTheory.Preadditive.EndoFunctor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(F : CategoryTheory.Functor C C) [inst_2 : F.Additive] (A₁ A₂ : CategoryTheory.Endofunctor.Coalgebra F)
(a b c : A₁ ⟶ A₂), a + b + c = a + (b + c) | false |
AddAction.zsmul_period_add_vadd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] (i : ℤ) (g : G) (a : α),
(↑(AddAction.period g a) + i) • g +ᵥ a = i • g +ᵥ a | true |
AddCommGrpCat.Colimits.toCocone_ι_app | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J] {A : Type w} [inst_2 : AddCommGroup A] (f : AddCommGrpCat.Colimits.Quot F →+ A) (j : J),
(AddCommGrpCat.Colimits.toCocone F f).ι.app j = AddCommGrpCat.ofHom (f.comp (AddCommGrpCat.Colimits.... | true |
Lean.instBEqAttributeApplicationTime | Lean.Attributes | BEq Lean.AttributeApplicationTime | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.p.eq_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] (n : ℤ),
CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.p✝ f n =
HomologicalComplex.mkHomToSingle (CategoryTheory.Inject... | true |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabWhere._sparseCasesOn_3 | Lean.Elab.BuiltinCommand | {motive : Lean.DataValue → Sort u} →
(t : Lean.DataValue) →
((v : Bool) → motive (Lean.DataValue.ofBool v)) →
((v : String) → motive (Lean.DataValue.ofString v)) →
((v : ℕ) → motive (Lean.DataValue.ofNat v)) → (Nat.hasNotBit 11 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ObjectProperty.retractClosure_extensionProductIter_retractClosure | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | true |
DifferentiableAt.eq_1 | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (f : E → F) (x : E), DifferentiableAt 𝕜 f x = ∃ f', HasFDerivAt f f' x | true |
ContinuousLinearMap.isPositive_iff | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E), T.IsPositive ↔ (↑T).IsSymmetric ∧ ∀ (x : E), 0 ≤ inner 𝕜 (T x) x | true |
Subtype.coe_prop._simp_1 | Mathlib.Data.Subtype | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), (↑a ∈ S) = True | false |
Lean.PPFns.mk | Lean.Util.PPExt | (Lean.PPContext → Lean.Expr → IO Lean.FormatWithInfos) →
(Lean.PPContext → Lean.Name → IO Lean.FormatWithInfos) →
(Lean.PPContext → Lean.Term → IO Std.Format) →
(Lean.PPContext → Lean.Level → BaseIO Std.Format) → (Lean.PPContext → Lean.MVarId → IO Std.Format) → Lean.PPFns | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.mem_of_mem_keys._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
Std.Sat.CNF.Clause.relabel_id' | Std.Sat.CNF.Relabel | ∀ {α : Type u_1}, Std.Sat.CNF.Clause.relabel id = id | true |
Std.Time.Second.instOfNatOrdinal | Std.Time.Time.Unit.Second | {leap : Bool} → {n : ℕ} → OfNat (Std.Time.Second.Ordinal leap) n | true |
CategoryTheory.ShortComplex.RightHomologyData.copy_H | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {Q' H' : C} (eQ : Q' ≅ h.Q) (eH : H' ≅ h.H),
(h.copy eQ eH).H = H' | true |
CategoryTheory.Preadditive.rec | Mathlib.CategoryTheory.Preadditive.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Preadditive C → Sort u_1} →
((homGroup : (P Q : C) → AddCommGroup (P ⟶ Q)) →
(add_comp :
∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTheory.CategoryStruct.comp (f + f') g =
... | false |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.namedParserHasAtomPrefixUnsafe | Lean.Elab.DocString.Builtin.Keywords | List String → Lean.Name → Lean.Elab.TermElabM Bool | true |
_private.Lean.Elab.PreDefinition.Structural.SmartUnfolding.0.Lean.Elab.Structural.addSmartUnfoldingDefAux.visit._sparseCasesOn_6 | Lean.Elab.PreDefinition.Structural.SmartUnfolding | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(... | false |
MeasureTheory.SimpleFunc.nearestPt | Mathlib.MeasureTheory.Function.SimpleFuncDense | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : PseudoEMetricSpace α] → [OpensMeasurableSpace α] → (ℕ → α) → ℕ → MeasureTheory.SimpleFunc α α | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigits_of_base_le._proof_1_2 | Init.Data.Nat.ToString | ∀ {b : ℕ} {n : ℕ}, 1 < b → ¬0 < b → False | false |
Affine.Simplex.PointsWithCircumcenterIndex.ctorElim | Mathlib.Geometry.Euclidean.Circumcenter | {n : ℕ} →
{motive : Affine.Simplex.PointsWithCircumcenterIndex n → Sort u} →
(ctorIdx : ℕ) →
(t : Affine.Simplex.PointsWithCircumcenterIndex n) →
ctorIdx = t.ctorIdx → Affine.Simplex.PointsWithCircumcenterIndex.ctorElimType ctorIdx → motive t | false |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.tfae_equational_criterion._simp_1_6 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X), c • f x = f (c • x) | false |
FiniteField.instFieldExtension._proof_52 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] (n : ℕ) [inst_2 : CharP k p],
autoParam (∀ (a b : FiniteField.Extension k p n), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | false |
HomotopicalAlgebra.BifibrantObject.instIsLocalizationCompιWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {D : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] (L : CategoryTheory.Functor C D)
[L.IsLocalization (HomotopicalAlgebra.weakEquivalences C)],
(HomotopicalAlgebra.BifibrantObject.ι.comp L).IsLocaliz... | true |
Associates.out_one | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : IsCancelMulZero α] [inst_2 : NormalizationMonoid α],
Associates.out 1 = 1 | true |
CompHausLike._sizeOf_1 | Mathlib.Topology.Category.CompHausLike.Basic | {P : TopCat → Prop} → [(a : TopCat) → SizeOf (P a)] → CompHausLike P → ℕ | false |
Std.Do.Spec.throw_ExceptT_lift | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ε α ε' : Type u} {e : ε} [inst : Std.Do.WP m ps]
[inst_1 : MonadExceptOf ε m] (Q : Std.Do.PostCond α (Std.Do.PostShape.except ε' ps)),
⦃(Std.Do.wp (MonadExceptOf.throw e)).apply (fun e => Except.casesOn e Q.2.1 Q.1, Q.2.2)⦄ MonadExceptOf.throw e ⦃Q⦄ | true |
isSolvable_def | Mathlib.GroupTheory.Solvable | ∀ (G : Type u_1) [inst : Group G], IsSolvable G ↔ ∃ n, derivedSeries G n = ⊥ | true |
TopCat.Sheaf.instAbelian._proof_8 | Mathlib.Topology.Sheaves.Abelian | ∀ {X : TopCat} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
[CategoryTheory.HasSheafify (Opens.grothendieckTopology ↑X) C] [inst_2 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels (TopCat.Sheaf C X) | false |
SeminormedCommRing.toNonUnitalSeminormedCommRing._proof_10 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : SeminormedCommRing α] (a : α), a * 0 = 0 | false |
MulActionSemiHomClass | Mathlib.GroupTheory.GroupAction.Hom | (F : Type u_8) →
{M : outParam (Type u_9)} →
{N : outParam (Type u_10)} →
outParam (M → N) →
(X : outParam (Type u_11)) → (Y : outParam (Type u_12)) → [SMul M X] → [SMul N Y] → [FunLike F X Y] → Prop | true |
ArchimedeanOrder.lt_def | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddGroup M] [inst_1 : Lattice M] {a b : ArchimedeanOrder M},
a < b ↔ ∀ (n : ℕ), n • |ArchimedeanOrder.val b| < |ArchimedeanOrder.val a| | true |
instEssentiallySmallLightProfinite | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.EssentiallySmall.{u, u, u + 1} LightProfinite | true |
AddCommMonCat.hasLimitsOfShape | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] [Small.{u, v} J],
CategoryTheory.Limits.HasLimitsOfShape J AddCommMonCat | true |
_private.Mathlib.Algebra.Polynomial.Splits.0.Polynomial.«_aux_Mathlib_Algebra_Polynomial_Splits___macroRules__private_Mathlib_Algebra_Polynomial_Splits_0_Polynomial_term_~ᵤ__1» | Mathlib.Algebra.Polynomial.Splits | Lean.Macro | false |
Lean.Meta.Grind.Arith.CommRing.Ring.varMap | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.Ring → Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing.Var | true |
HahnSeries.leadingCoeff_one | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : Zero Γ] [inst_1 : PartialOrder Γ] [inst_2 : MulZeroOneClass R],
HahnSeries.leadingCoeff 1 = 1 | true |
Lat.coe_id | Mathlib.Order.Category.Lat | ∀ {X : Lat}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | true |
FreeAddMonoid.instUniqueOfIsEmpty | Mathlib.Algebra.FreeMonoid.Basic | {α : Type u_1} → [IsEmpty α] → Unique (FreeAddMonoid α) | true |
_private.Lean.Data.JsonRpc.0.Lean.JsonRpc.instOrdRequestID.ord._sparseCasesOn_1 | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.RequestID → Sort u} →
(t : Lean.JsonRpc.RequestID) →
((s : String) → motive (Lean.JsonRpc.RequestID.str s)) →
((n : Lean.JsonNumber) → motive (Lean.JsonRpc.RequestID.num n)) →
(Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Tactic.Apply.0.Lean.Meta.throwApplyError | Lean.Meta.Tactic.Apply | {α : Type} → Lean.MVarId → Lean.Expr → Option Lean.Expr → Lean.Expr → Option Lean.MessageData → Lean.MetaM α | true |
ProbabilityTheory.Kernel.instAddCommMonoid._proof_2 | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}, Function.Injective fun f => ⇑f | false |
Lean.instCoeSyntaxNodeKindSyntaxNodeKinds | Init.Notation | Coe Lean.SyntaxNodeKind Lean.SyntaxNodeKinds | true |
AddMonoidHom.coe_flip_mul | Mathlib.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R], ⇑AddMonoidHom.mul.flip = AddMonoidHom.mulRight | true |
ENat.toNat_sum | Mathlib.Data.ENat.BigOperators | ∀ {α : Type u_1} {s : Finset α} {f : α → ℕ∞}, (∀ a ∈ s, f a ≠ ⊤) → (∑ a ∈ s, f a).toNat = ∑ a ∈ s, (f a).toNat | true |
IsStrictOrderedModule.toPosSMulStrictMono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {inst : SMul α β} {inst_1 : Preorder α} {inst_2 : Preorder β} {inst_3 : Zero α}
{inst_4 : Zero β} [self : IsStrictOrderedModule α β], PosSMulStrictMono α β | true |
Sym2.IsDiag.not_mem_edgeSet | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {e : Sym2 V}, e.IsDiag → e ∉ G.edgeSet | true |
_private.Mathlib.Order.Interval.Set.Nat.0.Set.ncard_uIcc_nat._simp_1_1 | Mathlib.Order.Interval.Set.Nat | ∀ {α : Type u_1} (s : Finset α), s.card = (↑s).ncard | false |
Std.Barrier._sizeOf_1 | Std.Sync.Barrier | Std.Barrier → ℕ | false |
FirstOrder.Field.FieldAxiom.toSentence.eq_1 | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom.addAssoc.toSentence =
(((FirstOrder.Language.var ∘ Sum.inr) 0 + (FirstOrder.Language.var ∘ Sum.inr) 1 +
(FirstOrder.Language.var ∘ Sum.inr) 2).bdEqual
((FirstOrder.Language.var ∘ Sum.inr) 0 +
((FirstOrder.Language.var ∘ Sum.inr) 1 + (FirstOrder.Language.... | true |
Lean.SubExpr.noConfusionType | Lean.SubExpr | Sort u → Lean.SubExpr → Lean.SubExpr → Sort u | false |
tsum_def | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_4} {β : Type u_5} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (f : β → α)
(L : SummationFilter β),
tsum f L =
if h : Summable f L then
if L.HasSupport ∧ (Function.support f ∩ L.support).Finite then finsum (L.support.indicator f)
else if HasSum f 0 L then 0 else Exists.choose... | true |
ContDiffAt.contDiffWithinAt | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, ContDiffAt 𝕜 n f x → ContDiffWithinAt 𝕜 n f s x | true |
Lean.MData | Lean.Expr | Type | true |
Lean.TSyntax.raw | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → Lean.TSyntax ks → Lean.Syntax | true |
FreeAlgebra.Pre.of.elim | Mathlib.Algebra.FreeAlgebra | {R : Type u_1} →
{X : Type u_2} →
{motive : FreeAlgebra.Pre R X → Sort u} →
(t : FreeAlgebra.Pre R X) → t.ctorIdx = 0 → ((a : X) → motive (FreeAlgebra.Pre.of a)) → motive t | false |
_private.Mathlib.Algebra.MvPolynomial.Division.0.MvPolynomial.monomial_dvd_monomial._simp_1_1 | Mathlib.Algebra.MvPolynomial.Division | ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), (a ∣ 0) = True | false |
IsGalois.intermediateFieldEquivSubgroup_apply | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
[inst_3 : FiniteDimensional F E] [inst_4 : IsGalois F E] (a : IntermediateField F E),
IsGalois.intermediateFieldEquivSubgroup a = OrderDual.toDual a.fixingSubgroup | true |
ContMDiffAddMonoidMorphism.noConfusionType | Mathlib.Geometry.Manifold.Algebra.Monoid | Sort u →
{𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{H' : Type u_5} →
[inst_4 : Topolog... | false |
Std.DHashMap.Raw.get_erase | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
(h : m.WF) {k a : α} {h' : k ∈ m.erase a}, (m.erase a).get k h' = m.get k ⋯ | true |
Lean.Elab.Tactic.GuardMsgs.FilterSpec.noConfusion | Lean.Elab.GuardMsgs | {P : Sort v✝} →
{x y : Lean.Elab.Tactic.GuardMsgs.FilterSpec} → x = y → Lean.Elab.Tactic.GuardMsgs.FilterSpec.noConfusionType P x y | false |
Lean.Meta.synthInstance? | Lean.Meta.SynthInstance | Lean.Expr → optParam (Option ℕ) none → Lean.MetaM (Option Lean.Expr) | true |
Lean.Meta.isDefEq | Lean.Meta.Basic | Lean.Expr → Lean.Expr → Lean.MetaM Bool | true |
NormedField.toAbsoluteValue._proof_2 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ (R : Type u_1) [inst : NormedField R] (a : R), 0 ≤ ‖a‖ | false |
MeasureTheory.Measure.WeaklyRegular.toOuterRegular | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {inst : MeasurableSpace α} {inst_1 : TopologicalSpace α} {μ : MeasureTheory.Measure α}
[self : μ.WeaklyRegular], μ.OuterRegular | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_eq_zero_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → (a ≤ b) = True | false |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_11 | Mathlib.Probability.Process.HittingTime | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult.noConfusionType | Lean.Meta.Basic | Sort u → Lean.Meta.RealizeConstantResult✝ → Lean.Meta.RealizeConstantResult✝ → Sort u | false |
Lean.ResolveName.resolveNamespaceUsingScope?._f | Lean.ResolveName | Lean.Environment → Lean.Name → (ns : Lean.Name) → Lean.Name.below ns → Option Lean.Name | false |
_private.Mathlib.RingTheory.GradedAlgebra.Radical.0.Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem._simp_1_6 | Mathlib.RingTheory.GradedAlgebra.Radical | ∀ {a : Prop}, (¬¬a) = a | false |
Partrec.cond | Mathlib.Computability.Halting | ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Bool} {f g : α →. σ},
Computable c → Partrec f → Partrec g → Partrec fun a => bif c a then f a else g a | true |
T2Space.mk | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u} [inst : TopologicalSpace X],
(Pairwise fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v) → T2Space X | true |
Lean.SerialMessage.caption._inherited_default | Lean.Message | String | false |
OrderMonoidHom.comp.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] (f : β →*o γ) (g : α →*o β),
f.comp g = { toMonoidHom := f.comp ↑g, monotone' := ⋯ } | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.