name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Quiver.Path.nil | Mathlib.Combinatorics.Quiver.Path | {V : Type u} → [inst : Quiver V] → {a : V} → Quiver.Path a a | null | true |
SpecialLinearGroup.coe_div | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A B : SpecialLinearGroup R V), ↑(A / B) = ↑A / ↑B | null | true |
MeasurableSpace.exists_eq_iUnion_countablyGeneratedAtom | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} {mα : MeasurableSpace α} [inst : MeasurableSpace.CountablyGenerated α] {s : Set α},
MeasurableSet s → ∃ q, s = ⋃ p, if q p then MeasurableSpace.countablyGeneratedAtom α p else ∅ | Any measurable set in a countably generated measurable space can be expressed as a union of
atoms. | true |
Lean.Parser.Tactic.MCasesPat | Std.Tactic.Do.Syntax | Type | null | true |
RingCat.ringObj._proof_46 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J RingCat) (j : J),
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go | Init.Data.List.Impl | ∀ (α : Type u_3) (β : Type u_2) (γ : Type u_1) (f : α → β → γ) (as : List α) (bs : List β) (acc : Array γ),
List.zipWithTR.go✝ f as bs acc = acc.toList ++ List.zipWith f as bs | null | true |
NonUnitalSubsemiring.inclusion._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {S : NonUnitalSubsemiring R},
NonUnitalRingHomClass (↥S →ₙ+* R) (↥S) R | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabMatchTypeAndDiscrs.elabDiscrs._unsafe_rec | Lean.Elab.Match | Array Lean.Syntax →
Array Lean.Elab.Term.TermMatchAltView →
Lean.Expr → ℕ → Array Lean.Elab.Term.Discr → Lean.Elab.TermElabM Lean.Elab.Term.ElabMatchTypeAndDiscrsResult | null | false |
WeierstrassCurve.Projective.Point.mk.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { ... | null | true |
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E}, IsIdempotentElem T → (T.IsSymmetric ↔ T.range ⟂ T.ker) | An idempotent operator is symmetric if and only if its range is
pairwise orthogonal to its kernel. | true |
Std.TreeMap.Raw.equiv_iff_keys_unit_perm | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α Unit cmp}, t₁.Equiv t₂ ↔ t₁.keys.Perm t₂.keys | null | true |
dist_le_range_sum_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (f : ℕ → α) (n : ℕ),
dist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, dist (f i) (f (i + 1)) | The triangle (polygon) inequality for sequences of points; `Finset.range` version. | true |
Array.forM_append | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] [LawfulMonad m] {xs ys : Array α}
{f : α → m PUnit.{u_1 + 1}},
forM (xs ++ ys) f = do
forM xs f
forM ys f | null | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(X : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.ComposableArrows.homMk₅ (CategoryTheory.CategoryStruct.id X).f₀.τ₁
(CategoryTheory.CategoryStruct.id X).f₀.τ₂ (CategoryTheory.CategoryStruct.id X).f... | null | false |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheorems | null | false |
CStarMatrix.ofMatrixRingEquiv._proof_2 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1) | null | false |
Ordinal.max_zero_right | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.{u_1}), max a 0 = a | null | true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_inter_Ioc._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Set.Ioc b₁ a₁ ∩ Set.Ioc b₂ a₂ = Set.Ioc (max b₁ b₂) (min a₁ a₂) | null | false |
Algebra.IsPushout.symm | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
{S' : Type u_7} [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' ... | null | true |
Interval._aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_termΙ_1 | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | null | false |
PiTensorProduct.mapMultilinear_apply | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ι → Type u_7) [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (t : ι → Type u_11) [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i →ₗ[R] t i),
(PiTensorProduct.mapMultilinear R ... | null | true |
«term_=_» | Init.Notation | Lean.TrailingParserDescr | The equality relation. It has one introduction rule, `Eq.refl`.
We use `a = b` as notation for `Eq a b`.
A fundamental property of equality is that it is an equivalence relation.
```
variable (α : Type) (a b c d : α)
variable (hab : a = b) (hcb : c = b) (hcd : c = d)
example : a = d :=
Eq.trans (Eq.trans hab (Eq.sym... | true |
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(Catego... | null | true |
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x | null | false |
Matrix.det_of_mem_unitary | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
{A : Matrix n n α}, A ∈ Matrix.unitaryGroup n α → A.det ∈ unitary α | null | true |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew? | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
α → β → t.Balanced → Option β × Std.DTreeMap.Internal.Impl α fun x => β | Implementation detail of the tree map | true |
instAB4AddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | CategoryTheory.AB4 AddCommGrpCat | null | true |
CategoryTheory.ObjectProperty.homMk_surjective | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C}
{X Y : P.FullSubcategory}, Function.Surjective CategoryTheory.ObjectProperty.homMk | null | true |
ContinuousAt.lineMap | Mathlib.Topology.Algebra.Affine | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace ... | null | true |
Lean.CollectMVars.State.result | Lean.Util.CollectMVars | Lean.CollectMVars.State → Array Lean.MVarId | null | true |
Module.Basis.constrL._proof_1 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
{ι : Type u_3} [Finite ι] (v : Module.Basis ι 𝕜 E), FiniteDimensional 𝕜 E | null | false |
AddMonoidAlgebra.le_infDegree_mul | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A →ₙ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMo... | null | true |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab | null | false |
Substring.Raw.str | Init.Prelude | Substring.Raw → String | The underlying string. | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.instFiniteUniversalFactorizationRing._proof_1 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
Module.Finite R (Polynomial.UniversalFactorizationRing m k hn p) | null | false |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a ≤ x ∧ x ≤ b → (x - a).toNat < (b + 1 - a).toNat ∧ a + ↑(x - a).toNat = x | null | false |
DirectLimit.instCommGroupWithZeroOfMonoidWithZeroHomClass._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
instCompleteLatticeStructureGroupoid._proof_7 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b ≤ SemilatticeSup.sup a b | null | false |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ : ℕ), max n₁ n₂ + 1 + (max n₁ n₂ + 1) ≤ 2 * max n₁ n₂ + 1 + 1 | null | false |
Lean.Meta.NormCast.normCastExt | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension | The `norm_cast` extension data. | true |
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames | Lean.Meta.Tactic.ExposeNames | Lean.MetaM Lean.LocalContext | Returns a copy of the local context in which all declarations have clear, accessible names. | true |
List.cons.inj | Init.Core | ∀ {α : Type u} {head : α} {tail : List α} {head_1 : α} {tail_1 : List α},
head :: tail = head_1 :: tail_1 → head = head_1 ∧ tail = tail_1 | null | true |
Empty.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | BorelSpace Empty | null | true |
TopCat.isoOfHomeo._proof_1 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat}, ContinuousMapClass (↑X ≃ₜ ↑Y) ↑X ↑Y | null | false |
LocallyFinite.exists_finset_support | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {X : Type u_5} [inst : TopologicalSpace X] {M : Type u_6} [inst_1 : Zero M] {f : ι → X → M},
(LocallyFinite fun i => Function.support (f i)) →
∀ (x₀ : X), ∃ I, ∀ᶠ (x : X) in nhds x₀, (Function.support fun i => f i x) ⊆ ↑I | null | true |
QuaternionAlgebra.Basis.k_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).k = F q.k | null | true |
Equiv.completeAtomicBooleanAlgebra._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : CompleteAtomicBooleanAlgebra β] (s : Set α),
e (e.symm (⨅ a ∈ s, e a)) = ⨅ a ∈ s, e a | null | false |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.go.match_3 | Lean.Server.Completion.CompletionInfoSelection | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((completionInfo : Lean.Elab.CompletionInfo) → motive (Lean.Elab.Info.ofCompletionInfo completionInfo)) →
((x : Lean.Elab.Info) → motive x) → motive info | null | false |
CategoryTheory.Limits.image.compIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Y Z : C} (g : Y ⟶ Z) [CategoryTheory.IsIso g],
CategoryTheory.Mono g | null | false |
Mathlib.Tactic.ToDual.data | Mathlib.Tactic.Translate.ToDual | Mathlib.Tactic.Translate.TranslateData | The bundle of environment extensions for `to_dual` | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w : ℕ) (eaig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(evec : eaig.RefVec w) (heaig : aig.decls.size ≤ { aig := eaig, vec := evec }.aig.decls.size),
(↑⟨{ aig := eaig, vec := evec }, heaig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastCpop (↑⟨{ aig ... | null | false |
Std.Time.Month.Ordinal.january | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal | The ordinal value representing the month of January.
| true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.Level) → motive a.succ) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Analysis.Fourier.ZMod.0.ZMod.auxDFT_smul | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module ℂ E] (c : ℂ) (Φ : ZMod N → E),
ZMod.auxDFT✝ (c • Φ) = c • ZMod.auxDFT✝ Φ | null | true |
cantorToTernary_ne_one | Mathlib.Topology.Instances.CantorSet | ∀ {x : ℝ} {n : ℕ}, (cantorToTernary x).get n ≠ 1 | null | true |
CategoryTheory.Tor._proof_4 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isRevMatch_sliceFrom_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch pat pos =
String.Slice.Pattern.Model.PatternModel.Matches pat (s.sliceFrom pos).copy | null | false |
CommAlgCat.inv_hom_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (e : A ≅ B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
Lean.AssocList.nil.elim | Lean.Data.AssocList | {α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) → t.ctorIdx = 0 → motive Lean.AssocList.nil → motive t | null | false |
CategoryTheory.SimplicialObject.Homotopy.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : CategoryTheory.SimplicialObject C} →
{f g : X ⟶ Y} →
(h : {n : ℕ} → Fin (n + 1) → (X.obj (Opposite.op { len := n }) ⟶ Y.obj (Opposite.op { len := n + 1 }))) →
(∀ (n : ℕ), CategoryTheory.CategoryStruct.comp (h 0) (Y.δ 0) = g.... | null | false |
Aesop.RuleResult.ctorIdx | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {w : ℕ}, ∀ curr < w, curr + 1 ≤ w | null | false |
clusterPt_principal_subtype_iff_frequently | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α},
s ⊆ t →
∀ {J : Set ↑s} {a : ↑s},
ClusterPt a (Filter.principal J) ↔ ∃ᶠ (x : α) in nhdsWithin (↑a) t, ∃ (h : x ∈ s), ⟨x, h⟩ ∈ J | null | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.eval.match_17 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(expr fst : Q(«$α»)) →
(motive :
Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.Common.ExSum bt sα) q(«$fst» * «$expr») →
Sort u_1) →
(__discr : Math... | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.LeftHomologyData) [CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂]
(wi : CategoryTheory.CategoryStruct.comp (CategoryTheory... | null | false |
Graph.inf_inc_iff._simp_1 | Mathlib.Combinatorics.Graph.Lattice | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
(G ⊓ H).Inc e x = ∃ y, G.IsLink e x y ∧ H.IsLink e x y | null | false |
LinearMap.tensorEqLocusInv._proof_2 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_3} [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
{P : Type u_4} [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup P] [inst_5 : Module R N] [inst_6 : Module R P]
(f g : N →ₗ[R] P) [Module.Flat R M], Function.Injective ⇑(LinearMap.lTensor M (f.eqLocus g... | null | false |
MeasureTheory.laverage_mul_measure_univ | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ]
(f : α → ENNReal), (⨍⁻ (a : α), f a ∂μ) * μ Set.univ = ∫⁻ (x : α), f x ∂μ | null | true |
Std.DTreeMap.Internal.Impl.Const.get!ₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : Type v} → [Ord α] → (Std.DTreeMap.Internal.Impl α fun x => β) → α → [Inhabited β] → β | Model implementation of the `get!` function.
Internal implementation detail of the tree map
| true |
String.skipPrefix? | Init.Data.String.TakeDrop | {ρ : Type} → (s : String) → (pat : ρ) → [String.Slice.Pattern.ForwardPattern pat] → Option s.Pos | If `pat` matches a prefix of `s`, returns the position at the start of the remainder.
Returns `none` otherwise.
This function is generic over all currently supported patterns.
| true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁_supportsStmt_mono._simp_1_15 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Subsemiring.instTop._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R], 0 ∈ ⊤.carrier | null | false |
Ideal.span_singleton_absNorm_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Module.Free ℤ S] (I : Ideal S),
Ideal.span {↑(Ideal.absNorm I)} ≤ I | null | true |
_private.Mathlib.RepresentationTheory.Induced.0.Rep.indResHomEquiv._simp_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tpr... | null | false |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.initFn._@.Lean.Meta.Tactic.Simp.Simproc.1481072680._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.Simproc | IO (IO.Ref Lean.Meta.Simp.BuiltinSimprocs) | null | false |
NormalizationMonoid.ofUniqueUnits | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [Subsingleton αˣ] → NormalizationMonoid α | null | true |
MonoidHom.toAdditiveRightMulEquiv._proof_1 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : CommMonoid N] (x x_1 : Multiplicative M →* N),
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) =
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) | null | false |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
QuadraticAlgebra.coe_injective | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Zero R], Function.Injective QuadraticAlgebra.C | **Alias** of `QuadraticAlgebra.C_injective`. | true |
Matroid.IsStrictMinor.trans | Mathlib.Combinatorics.Matroid.Minor.Order | ∀ {α : Type u_1} {M M' N : Matroid α}, N <m M → M <m M' → N <m M' | null | true |
RootPairing.Hom.comp._proof_3 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_6} {R : Type u_4} {M : Type u_7} {N : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₁ : Type u_8} {M₁ : Type u_9} {N₁ : Type u_5}
{ι₂ : Type u_2} {M₂ : Type u_10} {N₂ : Type u_3} [inst_5 : AddCommGroup M₁] [inst_6 : Modu... | null | false |
Polynomial.associated_of_dvd_of_natDegree_le_of_leadingCoeff | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {p q : Polynomial R},
p ∣ q → q.natDegree ≤ p.natDegree → q.leadingCoeff ∣ p.leadingCoeff → Associated p q | null | true |
Lean.Grind.CommRing.Poly | Init.Grind.Ring.CommSolver | Type | null | true |
TrivSqZeroExt.addMonoid._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M] (a : TrivSqZeroExt R M), 0 + a = a | null | false |
SchwartzMap.compCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], RingHomIsometric (RingHom.id 𝕜) | null | false |
CategoryTheory.MorphismProperty.precoverage_monotone | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P ≤ Q → P.precoverage ≤ Q.precoverage | null | true |
ContinuousWithinAt.eq_const_of_mem_closure | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T1Space Y] {f : X → Y}
{s : Set X} {x : X} {c : Y}, ContinuousWithinAt f s x → x ∈ closure s → (∀ y ∈ s, f y = c) → f x = c | null | true |
MeasureTheory.OuterMeasure.trim_zero | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.OuterMeasure.trim 0 = 0 | null | true |
RingHom.formallyEtale_algebraMap | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale ↔ Algebra.FormallyEtale R S | null | true |
Order.Ideal.coe_sup_eq | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'_obj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (a : B),
(CategoryTheory.StrictlyUnitaryLaxFunctor.mk' S).obj a = S.obj a | null | true |
SSet.splitting._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.Splitting | ∀ (X : SSet) (n : ℕ),
Nonempty
(CategoryTheory.Limits.IsColimit
(CategoryTheory.SimplicialObject.Splitting.cofan' (fun n => ↑(X.nonDegenerate n)) X
(fun n => TypeCat.ofHom Subtype.val) (Opposite.op { len := n }))) | null | false |
ContinuousMultilinearMap.smulRight_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : TopologicalSpace R] [inst_6 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_7 : TopologicalSp... | null | true |
Int.negOnePow_two_mul_add_one | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), (2 * n + 1).negOnePow = -1 | null | true |
Std.Time.FormatPart.noConfusionType | Std.Time.Format.Basic | Sort u → Std.Time.FormatPart → Std.Time.FormatPart → Sort u | null | false |
Nat.testBit_ofBits_lt | Batteries.Data.Nat.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ) (h : i < n), (Nat.ofBits f).testBit i = f ⟨i, h⟩ | null | true |
Std.Do.Internal.MayReturn.mk._flat_ctor | Std.Do.Internal.Ensures.Def | ∀ {m : Type u → Type v} [inst : Bind m] {α : Type u} {x : m α} {a : α},
(∀ {P : α → Prop}, Std.Do.Internal.Ensures P x → P a) → Std.Do.Internal.MayReturn x a | null | false |
HahnSeries.leadingCoeff_abs | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Γ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff| | null | true |
Lean.Parser.Term.doLetRec | Lean.Parser.Do | Lean.Parser.Parser | null | true |
isOpenMap_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.