name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Atoms.0.IsCoatomic.Set.Ici.isCoatomic.match_3 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] {x : α} (motive : ↑(Set.Ici x) → Prop) (x_1 : ↑(Set.Ici x)),
(∀ (y : α) (hy : y ∈ Set.Ici x), motive ⟨y, hy⟩) → motive x_1 | null | false |
Lean.Parser.orelseInfo | Lean.Parser.Basic | Lean.Parser.ParserInfo → Lean.Parser.ParserInfo → Lean.Parser.ParserInfo | null | true |
List.findFinIdx?._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (a : α) (l_1 : List α) (i : ℕ), (a :: l_1).length + i = l.length → i < l.length | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.eval.match_21 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(dsα : Q(Semifield «$α»)) →
(expr expr_1 : Q(«$α»)) →
(motive :
Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.Common.ExSum bt sα) q(«$expr» / «$expr_1») →
... | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.throwCannotInferResultingUniverse | Lean.Elab.MutualInductive | {α : Type} → Lean.Level → Lean.MessageData → Lean.Elab.TermElabM α | null | true |
CategoryTheory.Limits.HasLimit | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} → [inst_1 : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor J C → Prop | `HasLimit F` represents the mere existence of a limit for `F`. | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractiveAux.go.match_5 | Lean.Widget.InteractiveDiagnostic | (motive : Option Lean.MessageData → Sort u_1) →
(x : Option Lean.MessageData) →
((msg : Lean.MessageData) → motive (some msg)) → ((x : Option Lean.MessageData) → motive x) → motive x | null | false |
Std.ExtDHashMap.size_inter_eq_size_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (∀ a ∈ m₁, a ∈ m₂) → (m₁ ∩ m₂).size = m₁.size | null | true |
Ideal.jacobson_eq_self_of_isMaximal | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [H : I.IsMaximal], I.jacobson = I | null | true |
_private.Mathlib.GroupTheory.Perm.List.0.List.formPerm_ext_iff._simp_1_2 | Mathlib.GroupTheory.Perm.List | ∀ {α : Type u_1} {a : α} {l : List α}, (a :: l).Nodup = (a ∉ l ∧ l.Nodup) | null | false |
Nat.count_lt_card | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {n : ℕ} (hp : (Set.ofPred p).Finite), p n → Nat.count p n < hp.toFinset.card | null | true |
Units.continuousConstSMul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : Monoid M] [inst_2 : MulAction M α]
[ContinuousConstSMul M α], ContinuousConstSMul Mˣ α | null | true |
ContinuousMap.Homotopic.refl | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)), f.Homotopic f | null | true |
IdemSemiring.ofSemiring._proof_7 | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : Semiring α] (h : ∀ (a : α), a + a = a) (a b : α), a + b = a ⊔ b | null | false |
AlgebraicGeometry.Scheme.OpenCover.isColimitCoconeOfLocallyDirected._proof_1 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [inst : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀]
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰]
(s : CategoryTheory.Limits.Cocone (AlgebraicGeometry.Scheme.Cover.functorOfLocallyDirected 𝒰)) {i j : 𝒰.I₀}
(x : i ⟶ j),
CategoryTheory.CategoryStr... | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.noConfusionType | Mathlib.CategoryTheory.Monoidal.Action.Basic | Sort u →
{C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategoryStruct C] →
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D →
{C' : ... | null | false |
Vector.mk_lt_mk | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} {data₁ : Array α} {size₁ : data₁.size = n} {data₂ : Array α} {size₂ : data₂.size = n}
[inst : LT α], Vector.mk data₁ size₁ < Vector.mk data₂ size₂ ↔ data₁ < data₂ | null | true |
MeasureTheory.laverage | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → (α → ENNReal) → ENNReal | Average value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`.
It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If
`μ` is a probability measure, then the average of any function is equal to its integral.
For the average on a set, use `⨍⁻ x... | true |
Complex.UnitDisc.im | Mathlib.Analysis.Complex.UnitDisc.Basic | Complex.UnitDisc → ℝ | Imaginary part of a point of the unit disc. | true |
Finset.singleton_product_singleton | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β}, {a} ×ˢ {b} = {(a, b)} | null | true |
Lean.IR.Expr.fap.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} →
{c : Lean.IR.FunId} →
{ys : Array Lean.IR.Arg} →
{c' : Lean.IR.FunId} →
{ys' : Array Lean.IR.Arg} → Lean.IR.Expr.fap c ys = Lean.IR.Expr.fap c' ys' → (c = c' → ys = ys' → P) → P | null | false |
ConjAct.units_smul_def | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {M : Type u_2} [inst : Monoid M] (g : ConjAct Mˣ) (h : M),
g • h = ↑(ConjAct.ofConjAct g) * h * ↑(ConjAct.ofConjAct g)⁻¹ | null | true |
Std.Do.SPred.imp_curry | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} {P Q : Std.Do.SVal.StateTuple σs → Prop},
((Std.Do.SVal.curry fun t => { down := P t }) → Std.Do.SVal.curry fun t => { down := Q t }) ⊣⊢ₛ
Std.Do.SVal.curry fun t => { down := P t → Q t } | null | true |
Lean.ForEachExprWhere.visited | Lean.Util.ForEachExprWhere | {ω : Type} →
{m : Type → Type} →
[inst : STWorld ω m] → [MonadLiftT (ST ω) m] → [Monad m] → Lean.Expr → Lean.ForEachExprWhere.ForEachM m Bool | null | true |
CategoryTheory.Presheaf.isSeparating | Mathlib.CategoryTheory.Generator.Presheaf | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] {ι : Type w} {S : ι → A},
(CategoryTheory.ObjectProperty.ofObj S).IsSeparating →
(CategoryTheory.ObjectProperty.ofObj fun x =>
match x wit... | null | true |
BinaryTree.get.match_1 | Mathlib.Data.Tree.Get | {α : Type u_1} →
(motive : PosNum → BinaryTree α → Sort u_2) →
(x : PosNum) →
(x_1 : BinaryTree α) →
((x : PosNum) → motive x BinaryTree.nil) →
((a : α) → (_t₁ _t₂ : BinaryTree α) → motive PosNum.one (BinaryTree.node a _t₁ _t₂)) →
((n : PosNum) → (_a : α) → (t₁ _t₂ : BinaryTree... | null | false |
ENNReal.tsum_const | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_4} (c : ENNReal), ∑' (x : α), c = ↑(ENat.card α) * c | null | true |
FirstOrder.Language.Substructure.gi | Mathlib.ModelTheory.Substructures | (L : FirstOrder.Language) →
(M : Type w) → [inst : L.Structure M] → GaloisInsertion (FirstOrder.Language.Substructure.closure L).toFun SetLike.coe | `closure` forms a Galois insertion with the coercion to set. | true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_assoc._simp_1_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat.0.SSet.Subcomplex.Pairing.isRegular_iff_nonempty_rankFunction.match_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) (motive : Nonempty (P.RankFunction ℕ) → Prop)
(x : Nonempty (P.RankFunction ℕ)), (∀ (h : P.RankFunction ℕ), motive ⋯) → motive x | null | false |
IsZGroup.mk._flat_ctor | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G], (∀ (p : ℕ), Nat.Prime p → ∀ (P : Sylow p G), IsCyclic ↥↑P) → IsZGroup G | null | false |
Lean.Lsp.InitializationOptions.mk.sizeOf_spec | Lean.Data.Lsp.InitShutdown | ∀ (hasWidgets? : Option Bool) (logCfg? : Option Lean.Lsp.LogConfig),
sizeOf { hasWidgets? := hasWidgets?, logCfg? := logCfg? } = 1 + sizeOf hasWidgets? + sizeOf logCfg? | null | true |
eulerFunction_eq_tsum_pentagonal | Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction | ∀ {R : Type u_1} [inst : NormedCommRing R] (x : R), eulerFunction x = ∑' (k : ℤ), ↑↑k.negOnePow * x ^ pentagonal k | null | true |
OrderIso.mulRight_symm | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a : α),
(OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ | null | true |
EuclideanGeometry.dist_div_cos_oangle_right_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → dist p₃ p₂ / (Euc... | A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse. | true |
MeasureTheory.Lp.toTemperedDistribution._proof_9 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℂ F], ContinuousConstSMul ℂ F | null | false |
MeasureTheory.spanningSetsIndex.congr_simp | Mathlib.MeasureTheory.Integral.Lebesgue.Countable | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ μ_1 : MeasureTheory.Measure α) (e_μ : μ = μ_1)
[inst : MeasureTheory.SigmaFinite μ] (x x_1 : α),
x = x_1 → MeasureTheory.spanningSetsIndex μ x = MeasureTheory.spanningSetsIndex μ_1 x_1 | null | true |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.recOn | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.Pseudofunctor B C} →
{η θ : F ⟶ G} →
{motive : CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ → Sort u} →
(t : Category... | null | false |
dist_le_tsum_dist_of_tendsto | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {f : ℕ → α} {a : α},
(Summable fun n => dist (f n) (f n.succ)) →
Filter.Tendsto f Filter.atTop (nhds a) → ∀ (n : ℕ), dist (f n) a ≤ ∑' (m : ℕ), dist (f (n + m)) (f (n + m).succ) | null | true |
_private.Mathlib.RingTheory.Extension.Presentation.Core.0.Algebra.Presentation.tensorModelOfHasCoeffsInv._simp_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.extensionValuation._simp_3 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.totallyBounded_iff_finite_residueField._simp_1_9 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a‖ ^ n = ‖a ^ n‖ | null | false |
ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_univ | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α),
(hf.stieltjesFunction a).measure Set.univ = 1 | null | true |
RingCon.recOn | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} →
[inst : Add R] →
[inst_1 : Mul R] →
{motive : RingCon R → Sort u} →
(t : RingCon R) →
((toCon : Con R) →
(add' : ∀ {w x y z : R}, toCon.toSetoid w x → toCon.toSetoid y z → toCon.toSetoid (w + y) (x + z)) →
motive { toCon := toCon, add' := add'... | null | false |
Lean.IR.IRType.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
((t : Lean.IR.IRType) → t.below → motive_1 t) →
((t : Array Lean.IR.IRType) → Lean.IR.IRType.below_1 t → motive_2 t) →
((t : Li... | null | false |
FreeAbelianGroup.map.eq_1 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} {β : Type v} (f : α → β), FreeAbelianGroup.map f = FreeAbelianGroup.lift (FreeAbelianGroup.of ∘ f) | null | true |
Std.DTreeMap.insertManyIfNew | Std.Data.DTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{ρ : Type u_1} → [ForIn Id ρ ((a : α) × β a)] → Std.DTreeMap α β cmp → ρ → Std.DTreeMap α β cmp | Inserts multiple mappings into the tree map by iterating over the given collection and calling
`insertIfNew`. If the same key appears multiple times, the first occurrence takes precedence.
| true |
AlgebraicGeometry.Scheme.GlueData.oneHypercover_Y | Mathlib.AlgebraicGeometry.GluingOneHypercover | ∀ (D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x : PUnit.{u + 1}), D.oneHypercover.Y x = D.V (i₁, i₂) | null | true |
CategoryTheory.Limits.coprod.rightUnitor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasInitial C] (P : C)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct P (⊥_ C)],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.Limits.coprod.desc (CategoryTheory.CategoryStru... | null | false |
Submodule.factor_surjective | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p p' : Submodule R M}
(H : p ≤ p'), Function.Surjective ⇑(Submodule.factor H) | null | true |
OrderMonoidIso.mk.inj | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} {inst : Preorder α} {inst_1 : Preorder β} {inst_2 : Mul α} {inst_3 : Mul β}
{toMulEquiv : α ≃* β} {map_le_map_iff' : ∀ {a b : α}, toMulEquiv.toFun a ≤ toMulEquiv.toFun b ↔ a ≤ b}
{toMulEquiv_1 : α ≃* β} {map_le_map_iff'_1 : ∀ {a b : α}, toMulEquiv_1.toFun a ≤ toMulEquiv_1.toFun b ↔ a... | null | true |
ONote.opowAux.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (e a0 a : ONote) (x x_1 : ℕ),
e.opowAux a0 a x x_1 =
match x, x_1 with
| x, 0 => 0
| 0, m.succ => e.oadd m.succPNat 0
| k.succ, m => (e + a0.mulNat k).scale a + e.opowAux a0 a k m | null | true |
AlgebraicClosure.instField._proof_1 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | null | false |
ContinuousMultilinearMap.toContinuousLinearMap._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_3} {ι : Type u_4} {M₁ : ι → Type u_1} {M₂ : Type u_2} [inst : Semiring 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 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f : ContinuousMulti... | null | false |
_private.Mathlib.RingTheory.Ideal.Height.0.exists_spanRank_le_and_le_height_of_le_height._simp_1_3 | Mathlib.RingTheory.Ideal.Height | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
_private.Mathlib.Condensed.Discrete.Colimit.0.LightCondensed.isoFinYonedaComponents_inv_comp._simp_1_2 | Mathlib.Condensed.Discrete.Colimit | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | null | false |
mul_pos_iff | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[MulPosStrictMono R] [AddLeftStrictMono R] [AddLeftReflectLT R], 0 < a * b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 | null | true |
CategoryTheory.Limits.parallelPair.ext._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | Lean.Syntax | null | false |
instReprNum | Mathlib.Data.Num.Basic | Repr Num | null | true |
Array.toList_range' | Init.Data.Array.Lemmas | ∀ {start size step : ℕ}, (Array.range' start size step).toList = List.range' start size step | null | true |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.congr_simp | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W W_1 : CategoryTheory.MorphismProperty C),
W = W_1 →
∀ (J : Type w) [inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J = W_1.IsStableUnderTransfiniteCompos... | null | true |
_private.Mathlib.Topology.Homotopy.Basic.0.ContinuousMap.homotopicRel_empty.match_1_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(motive : f₀.Homotopic f₁ → Prop) (x : f₀.Homotopic f₁), (∀ (F : f₀.Homotopy f₁), motive ⋯) → motive x | null | false |
Equiv.Perm.sumCongrHom.decidableMemRange | Mathlib.GroupTheory.Perm.Subgroup | {α : Type u_1} →
{β : Type u_2} →
[DecidableEq α] →
[DecidableEq β] → [Fintype α] → [Fintype β] → DecidablePred fun x => x ∈ (Equiv.Perm.sumCongrHom α β).range | null | true |
QuadraticAlgebra.instCommRing._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommRing R], ↑0 = 0 | null | false |
SkewMonoidAlgebra.mapDomain_comp | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {G'' : Type u_4} {f : G → G'} {g : G' → G''}
{v : SkewMonoidAlgebra k G},
(SkewMonoidAlgebra.mapDomain (g ∘ f)) v = (SkewMonoidAlgebra.mapDomain g) ((SkewMonoidAlgebra.mapDomain f) v) | null | true |
MulEquiv.toMagmaCatIso.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Type u} [inst : Mul X] [inst_1 : Mul Y] (e : X ≃* Y),
e.toMagmaCatIso =
{ hom := MagmaCat.ofHom e.toMulHom, inv := MagmaCat.ofHom e.symm.toMulHom, hom_inv_id := ⋯, inv_hom_id := ⋯ } | null | true |
exists_isCompact_superset_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R1Space X] {s : Set X}, (∃ K, IsCompact K ∧ s ⊆ K) = IsCompact (closure s) | null | false |
AlgebraicGeometry.Scheme.fromSpecStalk_closedPoint | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {x : ↥X}, (X.fromSpecStalk x) (IsLocalRing.closedPoint ↑(X.presheaf.stalk x)) = x | null | true |
_private.Batteries.Tactic.Lint.Frontend.0.Batteries.Tactic.Lint.lintCore.match_1 | Batteries.Tactic.Lint.Frontend | (motive : Except Lean.Exception (Option Lean.MessageData) → Sort u_1) →
(x : Except Lean.Exception (Option Lean.MessageData)) →
((msg? : Option Lean.MessageData) → motive (Except.ok msg?)) →
((err : Lean.Exception) → motive (Except.error err)) → motive x | null | false |
SubalgebraClass.val._proof_3 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [inst_2 : SubsemiringClass S A] (s : S),
(↑↑(SubsemiringClass.subtype s)).toFun 0 = 0 | null | false |
Vector.insertIdx_eraseIdx_of_le._proof_4 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ} {j : ℕ}, i < n → i + 1 < n + 1 | null | false |
Mathlib.Tactic.Widget.StringDiagram.IdNode.mk._flat_ctor | Mathlib.Tactic.Widget.StringDiagram | ℕ → ℕ → ℕ → Mathlib.Tactic.BicategoryLike.Atom₁ → Mathlib.Tactic.Widget.StringDiagram.IdNode | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.optEllipsis._regBuiltin.Lean.Parser.Term.optEllipsis.parenthesizer_7 | Lean.Parser.Term.Basic | IO Unit | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Basic.0.MvPowerSeries.instNontrivialSubalgebraOfNonempty._simp_1 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
(x ∈ ⊥) = (x ∈ Set.range ⇑(algebraMap R A)) | null | false |
Batteries.BinomialHeap.Imp.Heap.tail | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} → (α → α → Bool) → Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α | `O(log n)`. Remove the minimum element of the heap. | true |
Lean.Meta.altArity | Lean.Meta.Tactic.ElimInfo | Lean.Expr → ℕ → Lean.Expr → ℕ × Bool | Given the type `t` of an alternative, determines the number of parameters
(.forall and .let)-bound, and whether the conclusion is a `motive`-application. | true |
UInt64.toNat_or | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), (a ||| b).toNat = a.toNat ||| b.toNat | null | true |
Aesop.RuleState.erasePatSubst | Aesop.Forward.State | Aesop.Substitution → Aesop.PatSubstSource → Aesop.RuleState → Aesop.RuleState | Erase a pattern substitution that was obtained from the given source. | true |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.State.rec | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {motive : Lean.Elab.ConfigEval.State✝ → Sort u} →
((toDerive : Lean.NameMap Lean.ExprSet) →
(toOmit : Array (Lean.Ident × Lean.Name)) → motive { toDerive := toDerive, toOmit := toOmit }) →
(t : Lean.Elab.ConfigEval.State✝) → motive t | null | false |
Height.mulHeight_eq_mulHeight_restrict_support | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [Finite ι] (x : ι → K),
Height.mulHeight x = Height.mulHeight fun i => x ↑i | null | true |
Nat.factorial_two | Mathlib.Data.Nat.Factorial.Basic | Nat.factorial 2 = 2 | null | true |
ContMDiffVectorBundle.casesOn | Mathlib.Geometry.Manifold.VectorBundle.Basic | {n : WithTop ℕ∞} →
{𝕜 : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
{EB : Type u_6} →
[inst_1 : NormedAddCommGroup EB] →
[inst_2 : NormedSpace 𝕜 EB] →
{HB : Type u_7} ... | null | false |
Std.ExtTreeSet.getD_minD | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback | null | true |
WeierstrassCurve.Jacobian.polynomialZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → [inst : CommRing R] → WeierstrassCurve.Jacobian R → MvPolynomial (Fin 3) R | The partial derivative `W_Z(X, Y, Z)` with respect to `Z` of the polynomial `W(X, Y, Z)`
associated to a Weierstrass curve `W` in Jacobian coordinates. | true |
Std.DHashMap.Internal.AssocList.foldrM._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} → [Monad m] → ((a : α) → β a → δ → m δ) → δ → Std.DHashMap.Internal.AssocList α β → m δ | null | false |
ArithmeticFunction.prodPrimeFactors | Mathlib.NumberTheory.ArithmeticFunction.Misc | {R : Type u_1} → [inst : CommMonoidWithZero R] → (ℕ → R) → ArithmeticFunction R | The map $n \mapsto \prod_{p \mid n} f(p)$ as an arithmetic function | true |
CategoryTheory.Arrow.LeftHomotopy.equivSubZero._proof_7 | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{u v : CategoryTheory.Arrow V} {f g : u ⟶ v},
Function.RightInverse (fun h => { hom := h.hom, comm := ⋯ }) fun h => { hom := h.hom, comm := ⋯ } | null | false |
WithTop.add_left_cancel | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsLeftCancelAdd α], x ≠ ⊤ → x + y = x + z → y = z | null | true |
Std.ExtHashMap.getElem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → γ} {k : α} {h' : k ∈ Std.ExtHashMap.map f m}, (Std.ExtHashMap.map f m)[k] = f k m[k] | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CycleGraph.0.SimpleGraph.cycleGraph.isPath_tail_cycle._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.CycleGraph | ∀ {n : ℕ}, (n + 2) % (n + 3) < n + 3 | null | false |
Std.Http.Config.serverName._default | Std.Http.Server.Config | Option Std.Http.Header.Value | null | false |
MeasureTheory.Measure.InnerRegularWRT.comap | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure β}
{pa qa : Set α → Prop} {pb qb : Set β → Prop},
μ.InnerRegularWRT pb qb →
∀ {f : α → β},
MeasurableEmbedding f →
(∀ (U : Set α), qa U → qb (f '' U)) →
(∀ K ⊆ Set.range f, pb K... | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.IsDedekindDomain.HeightOneSpectrum.iInf_localization_eq_bot.match_1_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ (R : Type u_1) [inst : CommRing R] (motive : MaximalSpectrum R → Prop) (x : MaximalSpectrum R),
(∀ (v : Ideal R) (hv : v.IsMaximal), motive { asIdeal := v, isMaximal := hv }) → motive x | null | false |
IsLocalRing.instCommRingResidueField._aux_32 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | (R : Type u_1) →
[inst : CommRing R] → [inst_1 : IsLocalRing R] → IsLocalRing.ResidueField R → IsLocalRing.ResidueField R | null | false |
Continuous.nnnorm' | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} {E : Type u_4} [inst : SeminormedGroup E] [inst_1 : TopologicalSpace α] {f : α → E},
Continuous f → Continuous fun x => ‖f x‖₊ | null | true |
ENat.le_ceil_self | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal}, r ≤ ↑⌈r⌉ₑ | null | true |
NonUnitalSubring.mk_le_mk | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {S S' : NonUnitalSubsemiring R}
(h : ∀ {x : R}, x ∈ S.carrier → -x ∈ S.carrier) (h' : ∀ {x : R}, x ∈ S'.carrier → -x ∈ S'.carrier),
{ toNonUnitalSubsemiring := S, neg_mem' := h } ≤ { toNonUnitalSubsemiring := S', neg_mem' := h' } ↔ S ≤ S' | null | true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3._aux_Mathlib_Util_Notation3___elabRules_Mathlib_Notation3_notation3_1.match_3 | Mathlib.Util.Notation3 | (motive : Array (Lean.TSyntax `stx) × Array Lean.Syntax → Sort u_1) →
(x : Array (Lean.TSyntax `stx) × Array Lean.Syntax) →
((syntaxArgs : Array (Lean.TSyntax `stx)) → (pattArgs : Array Lean.Syntax) → motive (syntaxArgs, pattArgs)) →
motive x | null | false |
_private.Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM.0.UniformConvergenceCLM.topologicalSpace_mono._simp_1_2 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGr... | null | false |
subset_seqClosure | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s ⊆ seqClosure s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.