name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matroid.IsRkFinite.indep_of_encard_le_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.IsRkFinite I → I.encard ≤ M.eRk I → M.Indep I | null | true |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_4 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] (M : Type u_1) [inst_4 : AddCommGroup M]
[inst_5 : Module R M] [inst_6 : LieRingModule L M] [inst_7 : LieModule R L M] {χ₁ χ₂ χ₃ : ↥H → R} (hχ : χ₁ + χ₂ = χ₃)
... | null | false |
Ideal.instMulActionElemPrimesOver._proof_3 | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
{G : Type u_3} [inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] (σ τ : G)
(Q : ↑(p.primesOver B)), (σ * τ) • Q = σ • τ • Q | null | false |
Lean.Meta.Canonicalizer.ExprVisited.noConfusion | Lean.Meta.Canonicalizer | {P : Sort u} →
{t t' : Lean.Meta.Canonicalizer.ExprVisited} → t = t' → Lean.Meta.Canonicalizer.ExprVisited.noConfusionType P t t' | null | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_union_eq._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), a ∈ s → s.erase a ∪ {a} = s | null | false |
Mathlib.Meta.NormNum.isNat_lt_false | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {a b : α} {a' b' : ℕ},
Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.ble a' = true → ¬a < b | null | true |
WithZero.coe_zpow | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℤ] (a : α) (n : ℤ), ↑(a ^ n) = ↑a ^ n | null | true |
HasFDerivAt.tendsto_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E},
HasFDerivAt f f' x → (∃ C, AntilipschitzWith C ⇑f') → Filter.Tendsto f ... | null | true |
Lean.Lsp.WorkspaceSymbolParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.WorkspaceSymbolParams} → t = t' → Lean.Lsp.WorkspaceSymbolParams.noConfusionType P t t' | null | false |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_4 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_1) (P : Type u_2) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P] (x y : P),
↑(NNReal.mk ((fun x y => ‖x -ᵥ y‖) x y) ⋯) = ENNReal.ofReal ‖x -ᵥ y‖ | null | false |
AlgebraicGeometry.localRingHom_comp_stalkIso | Mathlib.AlgebraicGeometry.Spec | ∀ {R S : CommRingCat} (f : R ⟶ S) (p : PrimeSpectrum ↑S),
CategoryTheory.CategoryStruct.comp
(CommRingCat.ofHom
(AlgebraicGeometry.StructureSheaf.stalkIso (↑R)
(PrimeSpectrum.comap (CommRingCat.Hom.hom f) p)).symm.toRingEquiv.toRingHom)
(CategoryTheory.CategoryStruct.comp
(... | Under the isomorphisms `stalkIso`, the map `stalkMap (Spec.sheafedSpaceMap f) p` corresponds
to the induced local ring homomorphism `Localization.localRingHom`.
| true |
AffineIsometry.continuous | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | null | true |
_private.Mathlib.CategoryTheory.Preadditive.CommGrp_.0.CategoryTheory.Preadditive.instGrpObj._simp_3 | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X : C),
CategoryTheory.SemiCartesianMonoidalCategory.fst X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom | null | false |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun P => GrpCat.of ↑P.toProfinite.toTop,
map := fun {X Y} f => GrpCat.ofHom (ProfiniteGrp.Hom.hom f).toMonoidHom,
map_id :=
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_1,
map_comp :=
@Prof... | null | false |
Lean.Elab.Term.LValResolution.const.elim | Lean.Elab.App | {motive : Lean.Elab.Term.LValResolution → Sort u} →
(t : Lean.Elab.Term.LValResolution) →
t.ctorIdx = 2 →
((baseStructName structName constName : Lean.Name) →
(levels : List Lean.Level) →
motive (Lean.Elab.Term.LValResolution.const baseStructName structName constName levels)) →
... | null | false |
Nat.log2 | Init.Data.Nat.Log2 | ℕ → ℕ | Base-two logarithm of natural numbers. Returns `⌊max 0 (log₂ n)⌋`.
This function is overridden at runtime with an efficient implementation. This definition is
the logical model.
Examples:
* `Nat.log2 0 = 0`
* `Nat.log2 1 = 0`
* `Nat.log2 2 = 1`
* `Nat.log2 4 = 2`
* `Nat.log2 7 = 2`
* `Nat.log2 8 = 3`
| true |
MeasureTheory.OuterMeasure.instPartialOrder._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} (x : MeasureTheory.OuterMeasure α) (x_1 : Set α), x x_1 ≤ x x_1 | null | false |
Lean.Lsp.CreateFile.Options.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.CreateFile.Options → Sort u} →
(t : Lean.Lsp.CreateFile.Options) →
((overwrite ignoreIfExists : Bool) → motive { overwrite := overwrite, ignoreIfExists := ignoreIfExists }) → motive t | null | false |
Subsemigroup.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) (f : M →ₙ* N)
(hf : Function.Injective ⇑f) (x : ↥S), ↑((S.equivMapOfInjective f hf) x) = f ↑x | null | true |
Set.biInter_finsetSigma' | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : Type u_3} (s : Finset ι) (t : (i : ι) → Finset (α i))
(f : (i : ι) → α i → Set β), ⋂ i ∈ s, ⋂ j ∈ t i, f i j = ⋂ ij ∈ s.sigma t, f ij.fst ij.snd | null | true |
CategoryTheory.bicategoricalIsoComp | Mathlib.Tactic.CategoryTheory.BicategoricalComp | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} → {f g h i : a ⟶ b} → [CategoryTheory.BicategoricalCoherence g h] → (f ≅ g) → (h ≅ i) → (f ≅ i) | Compose two isomorphisms in a bicategorical category,
inserting unitors and associators between as necessary. | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic.0.MeasureTheory.charFun_prod._simp_1_3 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {L : Type u_5} [inst_4 : RCLike L]
(f : α → L) (g : β → L), (∫ (x : α), f x ∂μ) * ∫ (y : β), g y ∂ν = ∫ (z : α × β),... | null | false |
SchwartzMap.bilinLeftCLM._proof_13 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G], ContinuousConstSMul ℝ G | null | false |
MeasurableSet.inf_eq_inter | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s t : { s // MeasurableSet s }), s ⊓ t = s ∩ t | null | true |
Std.TreeMap.Equiv.keyAtIdx_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {i : ℕ}
{h' : i < t₁.size} (h : t₁.Equiv t₂), t₁.keyAtIdx i h' = t₂.keyAtIdx i ⋯ | null | true |
Equiv.removeNoneAux | Mathlib.Logic.Equiv.Option | {α : Type u_1} → {β : Type u_2} → Option α ≃ Option β → α → β | If we have a value on one side of an `Equiv` of `Option`
we also have a value on the other side of the equivalence
| true |
_private.Mathlib.LinearAlgebra.SpecialLinearGroup.0.SpecialLinearGroup.centerEquivRootsOfUnity_invFun._simp_4 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [Module.Free R V]
[Module.Finite R V] {g : SpecialLinearGroup R V},
(g ∈ Subgroup.center (SpecialLinearGroup R V)) = ∃ r, r ^ Module.finrank R V = 1 ∧ ↑↑g = r • LinearMap.id | null | false |
essSup_eq_iSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
(∀ (a : α), μ {a} ≠ 0) → ∀ (f : α → β), essSup f μ = ⨆ i, f i | null | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.testBit.match_1.eq_2 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive PosNum.one 0) (h_2 : (x : ℕ) → motive PosNum.one x)
(h_3 : (a : PosNum) → motive a.bit0 0) (h_4 : (p : PosNum) → (n : ℕ) → motive p.bit0 n.succ)
(h_5 : (a : PosNum) → motive a.bit1 0) (h_6 : (p : PosNum) → (n : ℕ) → motive p.bit1 n.succ),
(x = 0 → Fa... | null | true |
Subgroup.upperCentralSeriesStep.hcongr_4 | Mathlib.GroupTheory.Nilpotent | ∀ (G G' : Type u_1),
G = G' →
∀ (inst : Group G) (inst' : Group G'),
inst ≍ inst' →
∀ (N : Subgroup G) (N' : Subgroup G'),
N ≍ N' →
∀ (inst_1 : N.Normal) (inst'_1 : N'.Normal),
inst_1 ≍ inst'_1 → N.upperCentralSeriesStep ≍ N'.upperCentralSeriesStep | null | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.meromorphicOrderAt_eq_top_iff._simp_1_4 | Mathlib.Analysis.Meromorphic.Order | ∀ {n : ℕ∞} {α : Type u_1} {f : ℕ → α}, (ENat.map f n = ⊤) = (n = ⊤) | null | false |
Real.casesOn | Mathlib.Data.Real.Basic | {motive : ℝ → Sort u} → (t : ℝ) → ((cauchy : CauSeq.Completion.Cauchy abs) → motive { cauchy := cauchy }) → motive t | null | false |
multiplicity_addValuation._proof_2 | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] {p : R}, Prime p → emultiplicity p 1 = 0 | null | false |
CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom_assoc | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K) {Z : C}... | null | true |
HahnEmbedding.ArchimedeanStrata.isInternal_stratum' | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] (u : HahnEmbedding.ArchimedeanStrata K M),
Di... | null | true |
CategoryTheory.GrothendieckTopology.mem_toCoverage_iff | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {S : CategoryTheory.Presieve X}
(J : CategoryTheory.GrothendieckTopology C), S ∈ J.toCoverage.coverings X ↔ CategoryTheory.Sieve.generate S ∈ J X | null | true |
CategoryTheory.MonoidalCategory.tensorRightTensor._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z Z' : C} (f : Z ⟶ Z'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).map f)
(CategoryTheory.Mo... | null | false |
MeasureTheory.Measure.withDensityᵥ._proof_2 | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (f : α → E),
MeasureTheory.Integrable f μ →
∀ (s : ℕ → Set α),
(∀ (i : ℕ), MeasurableSet (s i)) →
Pairwise (Function.onFun Disjoint s) →
HasSum (... | null | false |
Finsupp.mapDomain_support_of_injective | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : DecidableEq β] {f : α → β},
Function.Injective f → ∀ (s : α →₀ M), (Finsupp.mapDomain f s).support = Finset.image f s.support | null | true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.InnerProductGeometry.sin_angle_eq_sin_angle_add_add_angle_add | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
x ≠ 0 →
y ≠ 0 →
Real.sin (InnerProductGeometry.angle x y) =
Real.sin (InnerProductGeometry.angle x (x + y) + InnerProductGeometry.angle y (y + x)) | The sine of the sum of two angles in a possibly degenerate
triangle (where two given sides are nonzero), vector angle form. | true |
Fin.dfoldlM_zero | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {α : Fin (0 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin 0) → α i.castSucc → m (α i.succ)) (x : α 0), Fin.dfoldlM 0 α f x = pure x | null | true |
Std.DHashMap.Internal.AssocList.getKey_eq | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : Std.DHashMap.Internal.AssocList α β} {a : α}
{h : Std.DHashMap.Internal.AssocList.contains a l = true},
Std.DHashMap.Internal.AssocList.getKey a l h = Std.Internal.List.getKey a l.toList ⋯ | null | true |
HasProdLocallyUniformlyOn.mono | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] {t : Set β},
HasProdLocallyUniformlyOn f g t → s ⊆ t → HasProdLocallyUniformlyOn f g s | null | true |
_private.Mathlib.Analysis.SpecificLimits.Fibonacci.0.tendsto_fib_succ_div_fib_atTop._simp_1_6 | Mathlib.Analysis.SpecificLimits.Fibonacci | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.GrothendieckTopology.liftToDiagramLimitObj._proof_1 | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
{X : C} {K : Ty... | null | false |
AlgEquiv.uniqueProd_apply | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Unique B] (self : B × A), AlgEquiv.uniqueProd self = self.2 | null | true |
Finset.card_le_card_of_forall_subsingleton | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {t : Finset β},
(∀ a ∈ s, ∃ b ∈ t, r a b) → (∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton) → s.card ≤ t.card | null | true |
Affine.Triangle.prod_div_one_sub_eq_one_of_mem_line_point_lineMap | Mathlib.LinearAlgebra.AffineSpace.Ceva | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {t : Affine.Triangle k P} {r : Fin 3 → k},
(∀ (i : Fin 3), r i ≠ 0) →
∀ {p' : P},
(∀ (i : Fin 3), p' ∈ line[k, t.points i, (AffineMap.lineMap (t.points (i + 1)) (t.point... | **Ceva's theorem** for a triangle, expressed using division. | true |
ENNReal.measurable_of_tendsto | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : ℕ → α → ENNReal} {g : α → ENNReal},
(∀ (i : ℕ), Measurable (f i)) → Filter.Tendsto f Filter.atTop (nhds g) → Measurable g | A sequential limit of measurable `ℝ≥0∞`-valued functions is measurable. | true |
SSet.stdSimplex.objEquiv_symm_comp | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n n' : SimplexCategory} {m : SimplexCategoryᵒᵖ} (f : Opposite.unop m ⟶ n) (g : n ⟶ n'),
SSet.stdSimplex.objEquiv.symm (CategoryTheory.CategoryStruct.comp f g) =
(CategoryTheory.ConcreteCategory.hom ((SSet.stdSimplex.map g).app m)) (SSet.stdSimplex.objEquiv.symm f) | null | true |
Quot.map₂._proof_2 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_2} {γ : Sort u_1} {r : α → α → Prop} {t : γ → γ → Prop} (f : α → β → γ),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → t (f a₁ b) (f a₂ b)) →
∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → Quot.mk t (f a₁ b) = Quot.mk t (f a₂ b) | null | false |
Lean.FromJson.ctorIdx | Lean.Data.Json.FromToJson.Basic | {α : Type u} → Lean.FromJson α → ℕ | null | false |
Finsupp.instAddCommGroup._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddCommGroup G] (a b : ι →₀ G), a + b = b + a | null | false |
Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic.elim | Lean.Elab.Tactic.Guard | {motive : Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u} →
(t : Lean.Elab.Tactic.GuardExpr.MatchKind) →
t.ctorIdx = 0 → motive Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic → motive t | null | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.ofExistsUnique._simp_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} {ι : Type u_3} [inst : DistribLattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α},
s.SupIndep f = (↑s).PairwiseDisjoint f | null | false |
CategoryTheory.constant_of_preserves_morphisms' | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsConnected J] {α : Type u₂} (F : J → α),
(∀ (j₁ j₂ : J) (x : j₁ ⟶ j₂), F j₁ = F j₂) → ∃ a, ∀ (j : J), F j = a | If `J` is connected, then given any function `F` such that the presence of a
morphism `j₁ ⟶ j₂` implies `F j₁ = F j₂`, there exists `a` such that `F j = a`
holds for any `j`. See `constant_of_preserves_morphisms` for a different
formulation of the fact that `F` is constant.
This can be thought of as a local-to-global p... | true |
Std.HashSet.get?_union_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | null | true |
Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult.goals.noConfusion | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | {P : Sort u} →
{subgoals subgoals' : List Lean.MVarId} →
Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult.goals subgoals =
Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult.goals subgoals' →
(subgoals = subgoals' → P) → P | null | false |
Manifold._aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termMDiffAt___1 | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab | `MDiffAt f x` elaborates to `MDifferentiableAt I J f x`,
trying to determine `I` and `J` from the local context.
The argument `x` can be omitted. | false |
UniformEquiv.coe_prodCongr | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ), ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂ | null | true |
IsCyclic.card_mulAut | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (G : Type u_2) [inst : Group G] [Finite G] [h : IsCyclic G], Nat.card (MulAut G) = (Nat.card G).totient | null | true |
AddMonoidHom.toAddEquiv.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f f_1 : M →+ N) (e_f : f = f_1)
(g g_1 : N →+ M) (e_g : g = g_1) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N),
f.toAddEquiv g h₁ h₂ = f_1.toAddEquiv g_1 ⋯ ⋯ | null | true |
_private.Std.Tactic.BVDecide.Normalize.BitVec.0.Std.Tactic.BVDecide.Normalize.BitVec.le_ult._simp_1_1 | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {n : ℕ} {x y : BitVec n}, (x ≤ y) = (x.toNat ≤ y.toNat) | null | false |
Lean.Meta.Grind.Arith.Linear.EqCnstr.collectDecVars._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Meta.Grind.Arith.CollectDecVarsM Unit | null | false |
Std.Time.Nanosecond.instLEOffset._aux_1 | Std.Time.Time.Unit.Nanosecond | Std.Time.Nanosecond.Offset → Std.Time.Nanosecond.Offset → Prop | null | false |
Module.Presentation.CokernelData.mk.noConfusion | Mathlib.Algebra.Module.Presentation.Cokernel | {A : Type u} →
{inst : Ring A} →
{M₁ : Type v₁} →
{M₂ : Type v₂} →
{inst_1 : AddCommGroup M₁} →
{inst_2 : Module A M₁} →
{inst_3 : AddCommGroup M₂} →
{inst_4 : Module A M₂} →
{pres₂ : Module.Presentation A M₂} →
{f : M₁ →ₗ[A] M₂} ... | null | false |
Finsupp.equivFunOnFinite_single | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] [inst_2 : Finite α] (x : α) (m : M),
(Finsupp.equivFunOnFinite fun₀ | x => m) = Pi.single x m | null | true |
Finsupp.subtypeDomain_extendDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_12} [inst : Zero M] {P : α → Prop} [inst_1 : DecidablePred P] (f : Subtype P →₀ M),
Finsupp.subtypeDomain P f.extendDomain = f | null | true |
CategoryTheory.Functor.ranCounit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{u_2, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasRightKanExtension F] {F₁ F₂ : CategoryThe... | null | false |
ContinuousAlternatingMap.bounds_nonempty | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] {f : E [⋀^ι]→L[𝕜] F},
∃ c, c ∈ {c | 0 ≤ c ∧ ∀ (m : ι → E), ‖f m‖ ≤ c * ... | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₁.f S.L₁.g = CategoryTheory.CategoryStruct.comp 0 S.v₀₁.τ₃ | null | false |
ENNReal.instCompleteLinearOrder._aux_1 | Mathlib.Data.ENNReal.Basic | Set ENNReal → ENNReal | null | false |
_private.Mathlib.Tactic.MinImports.0.Mathlib.Command.MinImports.previousInstName.match_5 | Mathlib.Tactic.MinImports | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((nm init : Lean.Name) → (tail : String) → (h : nm = init.str tail) → motive (namedPattern nm (init.str tail) h)) →
((nm : Lean.Name) → motive nm) → motive x | null | false |
Std.Internal.List.minKey_insertEntryIfNew_le_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k} {he : l.isEmpty = false},
(compare (Std.Internal.List.minKey (Std.Internal.List.insertEntryIfNew k v l) ⋯)
(S... | null | true |
AddSubgroup.instMeasurableVAdd | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : AddGroup G]
[inst_3 : AddAction G α] [MeasurableVAdd G α] (s : AddSubgroup G), MeasurableVAdd (↥s) α | null | true |
FirstOrder.Language.Structure.noConfusionType | Mathlib.ModelTheory.Basic | Sort u_1 →
{L : FirstOrder.Language} →
{M : Type w} → L.Structure M → {L' : FirstOrder.Language} → {M' : Type w} → L'.Structure M' → Sort u_1 | null | false |
Complex.ofReal_exp._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), Complex.exp ↑x = ↑(Real.exp x) | null | false |
CategoryTheory.Limits.prod.lift' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y : C} →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] →
(f : W ⟶ X) →
(g : W ⟶ Y) →
{ l //
CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.prod.fst = f ∧
CategoryTh... | If the product of `X` and `Y` exists, then every pair of morphisms `f : W ⟶ X` and `g : W ⟶ Y`
induces a morphism `l : W ⟶ X ⨯ Y` satisfying `l ≫ Prod.fst = f` and `l ≫ Prod.snd = g`. | true |
ContravariantClass.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop}, Contravariant M N μ r → ContravariantClass M N μ r | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_9 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (hs : table.size < pat.utf8ByteSize),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun table ht₀ =>
PSigma.casesOn ht₀ fun ht₀ ht =... | null | false |
Subalgebra.prod_toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (S : Subalgebra R A) (S₁ : Subalgebra R B),
Subalgebra.toSubmodule (S.prod S₁) = (Subalgebra.toSubmodule S).prod (Subalgebra.toSubmodule S₁) | null | true |
CategoryTheory.bifunctorComp₁₂ | Mathlib.CategoryTheory.Functor.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{C₁₂ : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_... | Given two bifunctors `F₁₂ : C₁ ⥤ C₂ ⥤ C₁₂` and `G : C₁₂ ⥤ C₃ ⥤ C₄`, this is
the trifunctor `C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` obtained by composition. | true |
Std.Tactic.BVDecide.BVUnOp.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} →
(t : Std.Tactic.BVDecide.BVUnOp) →
motive Std.Tactic.BVDecide.BVUnOp.not →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateLeft n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateRight n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.... | null | false |
RBTree.RBMap.size | BatteriesRecycling.RBTree.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → RBTree.RBMap α β cmp → ℕ | `O(n)`. The number of items in the RBMap. | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState.mk | Lean.Elab.DocString | Lean.Doc.State →
Array (Lean.ScopedEnvExtension Lean.EnvExtensionEntry Lean.EnvExtensionEntry Lean.EnvExtensionState) →
Lean.Doc.ModuleDocstringState✝ | null | true |
_private.Mathlib.Data.Real.ConjExponents.0.ENNReal.HolderTriple.toNNReal_iff._simp_1_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, p.HolderTriple q r = (↑p).HolderTriple ↑q ↑r | null | false |
SubmonoidClass.coe_multiset_prod | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
(m : Multiset ↥S), ↑m.prod = (Multiset.map Subtype.val m).prod | null | true |
MeasureTheory.measure_biUnion_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {ι : Type u_2} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α]
{I : Set ι} (μ : F), I.Countable → ∀ (s : ι → Set α), μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i) | null | true |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_15 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), x_1 ⊔ xᶜ = x_1 ⊔ xᶜ | null | false |
Bool.eq_true_of_true_le | Init.Data.Bool | ∀ {x : Bool}, true ≤ x → x = true | null | true |
Std.Async.MaybeTask.get | Std.Async.Basic | {α : Type} → Std.Async.MaybeTask α → α | Gets the value of the `MaybeTask` by blocking.
| true |
Monoid.Coprod.mk | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} →
{N : Type u_2} → [inst : MulOneClass M] → [inst_1 : MulOneClass N] → FreeMonoid (M ⊕ N) →* Monoid.Coprod M N | The natural projection `FreeMonoid (M ⊕ N) →* M ∗ N`. | true |
MeasurableSMul₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [SMul M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop | We say that the action of `M` on `α` has `Measurable_SMul₂` if the map
`(c, x) ↦ c • x` is a measurable function. | true |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | null | false |
_private.Lean.Meta.Sym.Canon.0.Lean.Meta.Sym.Canon.canon.postReduce.match_1 | Lean.Meta.Sym.Canon | (motive : Option (Lean.Expr × ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × ℕ)) →
((e : Lean.Expr) → (k : ℕ) → motive (some (e, k))) → ((x : Option (Lean.Expr × ℕ)) → motive x) → motive __do_lift | null | false |
TensorProduct.instRepr | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Type u_7} →
{N : Type u_8} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → [Repr M] → [Repr N] → Repr (TensorProduct R M N) | Produces an arbitrary representation of the form `mₒ ⊗ₜ n₀ + ...`. | true |
CategoryTheory.ShortComplex.Hom.mk.sizeOf_spec | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : SizeOf C] (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂)
(τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ :
autoParam (CategoryTheory.CategoryStruct.comp τ₁ S₂.f = Catego... | null | true |
Lean.Grind.AC.Seq.isVar | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Bool | Returns `true` if `s` is a variable. | true |
Aesop.GoalStats.forwardStateStats | Aesop.Stats.Basic | Aesop.GoalStats → Aesop.ForwardStateStats | null | true |
Polynomial.eval_le_zero_of_roots_le_of_leadingCoeff_nonpos | Mathlib.Analysis.Polynomial.Order | ∀ {P : Polynomial ℝ} {x : ℝ}, (∀ (y : ℝ), P.IsRoot y → y ≤ x) → P.leadingCoeff ≤ 0 → Polynomial.eval x P ≤ 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.