name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HomologicalComplex.Hom.comm | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {A B : HomologicalComplex V c} (f : A.Hom B)
(i j : ι), CategoryTheory.CategoryStruct.comp (f.f i) (B.d i j) = CategoryTheory.CategoryStruct.comp (A.d i j) (f.f j) | null | true |
PiTensorProduct.constantBaseRingEquiv_symm | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ι] (r : R),
(PiTensorProduct.constantBaseRingEquiv ι R).symm r = (algebraMap R (PiTensorProduct R fun x => R)) r | null | true |
Plausible.Shrinkable.shrink | Plausible.Shrinkable | {α : Type u} → [self : Plausible.Shrinkable α] → α → List α | null | true |
Std.Time.PlainTime.toHours | Std.Time.Time.PlainTime | Std.Time.PlainTime → Std.Time.Hour.Offset | Converts a `PlainTime` value to the total number of hours.
| true |
instAddCommMonoidPrimeMultiset._proof_3 | Mathlib.Data.PNat.Factors | ∀ (a b c : PrimeMultiset), a + b + c = a + (b + c) | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._unsafe_rec | Lean.Util.Diff | {α : Type u_1} → [BEq α] → Subarray α → Subarray α → ℕ → Subarray α × Subarray α × Array α | null | false |
AddSubgroup.comap_map_eq | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
AddSubgroup.comap f (AddSubgroup.map f H) = H ⊔ f.ker | null | true |
instNonUnitalCStarAlgebraForall._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_2} {A : ι → Type u_1} [inst : (i : ι) → NonUnitalCStarAlgebra (A i)], CompleteSpace ((i : ι) → A i) | null | false |
FormalMultilinearSeries.iteratedFDerivSeries._proof_1 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
_aux_Mathlib_Algebra_Group_Hom_Defs___unexpand_MonoidHom_1 | Mathlib.Algebra.Group.Hom.Defs | Lean.PrettyPrinter.Unexpander | null | false |
WithBot.bot_mul_bot | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α], ⊥ * ⊥ = ⊥ | null | true |
AddValuation.map_eq_of_lt_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R}, v x < v (y - x) → v y = v x | null | true |
instShiftLeftUSize | Init.Data.UInt.Basic | ShiftLeft USize | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.adjoin_simple_isCompactElement._simp_1_2 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E}
{K : IntermediateField F E}, (F⟮α⟯ ≤ K) = (α ∈ K) | null | false |
_private.Mathlib.Data.Multiset.Filter.0.Multiset.filter_attach'._simp_1_2 | Mathlib.Data.Multiset.Filter | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
_private.Mathlib.Order.Filter.Pi.0.Filter.tendsto_pi._simp_1_2 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) | null | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.mapCompIso._proof_2 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H)
{X Y : F.CoGrothendieck} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pseudofunctor.CoGrothendieck.map ... | null | false |
LieAlgebra.maxNilpotentIdeal_le_radical | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.maxNilpotentIdeal R L ≤ LieAlgebra.radical R L | null | true |
Lean.Doc.builtinDocDirectives | Lean.Elab.DocString | IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocDirectiveExpander))) | Built-in docstring directives, for bootstrapping.
| true |
Finsupp.DegLex.single_antitone | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Antitone fun a => toDegLex fun₀ | a => 1 | null | true |
toAdd_div | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} [inst : Sub α] (x y : Multiplicative α),
Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y | null | true |
powMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_6} [inst : CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0) (a : M₀), (powMonoidWithZeroHom hn) a = a ^ n | null | true |
_private.Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo.0.CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_hom._simp_1_2 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(f = CategoryTheory.CategoryStruct.comp g α) = (CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.instPreservesFiniteBiproductsTensorLeft._simp_3 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | null | false |
Module.FaithfullyFlat.subsingleton_tensorProduct_iff_right | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] [Module.FaithfullyFlat R M],
Subsingleton (TensorProduct R M N) ↔ Subsingleton N | null | true |
MonomialOrder.coeff_degree_ne_zero_iff | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R},
MvPolynomial.coeff (m.degree f) f ≠ 0 ↔ f ≠ 0 | null | true |
SchwartzMap._aux_Mathlib_Analysis_Distribution_TemperedDistribution___unexpand_TemperedDistribution_1 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.PrettyPrinter.Unexpander | null | false |
Lean.Doc.State.openDecls | Lean.Elab.DocString | Lean.Doc.State → List Lean.OpenDecl | The set of open declarations presently in force.
The `MonadLift TermElabM DocM` instance runs the lifted action in a context where these open
declarations are used, so elaboration commands that mutate this state cause it to take effect in
subsequent commands.
| true |
aeSeq.measurable | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} (hf : ∀ (i : ι), AEMeasurable (f i) μ) (p : α → (ι → β) → Prop) (i : ι),
Measurable (aeSeq hf p i) | null | true |
Function.argmin._proof_1 | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [WellFoundedLT β],
WellFounded (InvImage (fun x1 x2 => x1 < x2) f) | null | false |
Finset.le_card_mul_mul_mulEnergy | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α),
s.card ^ 2 * t.card ^ 2 ≤ (s * t).card * s.mulEnergy t | null | true |
Submodule.Quotient.restrictScalarsEquiv_symm_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : Ring S] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (P : Submodule R M)
(x : M), (Submodule.Quotient.restrictScalarsEquiv S P).symm (Submodule.Quotient.mk x) = Submod... | null | true |
ValueDistribution.characteristic | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℂ E] → (ℂ → E) → WithTop E → ℝ → ℝ | The Characteristic Function of Value Distribution Theory
If `f : ℂ → E` is meromorphic and `a : WithTop E` is any value, the characteristic function of `f`
is defined as the sum of two terms: the proximity function, which quantifies how close `f` gets to
`a` on the circle `∣z∣ = r`, and the logarithmic counting functi... | true |
chartAt | Mathlib.Geometry.Manifold.ChartedSpace | (H : Type u_5) →
[inst : TopologicalSpace H] →
{M : Type u_6} → [inst_1 : TopologicalSpace M] → [ChartedSpace H M] → M → OpenPartialHomeomorph M H | The preferred chart at a point `x` in a charted space `M`. | true |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → Monoid (R i)] [∀ (i : ι), SubmonoidClass (S i) (R i)] (i : ι), MulMemClass (S i) (R i) | null | false |
IsMulTorsionFree.zpow_eq_one_iff | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : Group G] [IsMulTorsionFree G] {n : ℤ} {a : G}, a ^ n = 1 ↔ a = 1 ∨ n = 0 | null | true |
Multiset.Icc_eq_zero_iff._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, (Multiset.Icc a b = 0) = ¬a ≤ b | null | false |
StructureGroupoid.noConfusion | Mathlib.Geometry.Manifold.StructureGroupoid | {P : Sort u} →
{H : Type u_2} →
{inst : TopologicalSpace H} →
{t : StructureGroupoid H} →
{H' : Type u_2} →
{inst' : TopologicalSpace H'} →
{t' : StructureGroupoid H'} → H = H' → inst ≍ inst' → t ≍ t' → StructureGroupoid.noConfusionType P t t' | null | false |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.FiniteMeasure.limsup_measure_closed_le_of_tendsto._simp_1_1 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj_hom_ext.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀
(motive :
(x y z : AugmentedSimplexCategory) →
(f g : CategoryTheory.MonoidalCategoryStruct.tensorObj x y ⟶ z) →
CategoryTheory.CategoryStruct.comp (x.inl y) f = CategoryTheory.CategoryStruct.comp (x.inl y) g →
CategoryTheory.CategoryStruct.comp (x.inr y) f = CategoryTheory.CategoryStruc... | null | false |
_private.Mathlib.Data.Part.0.Part.mem_unique.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (motive : (x x_1 : α) → (x_2 : Part α) → x ∈ x_2 → x_1 ∈ x_2 → Prop) (x x_1 : α) (x_2 : Part α)
(x_3 : x ∈ x_2) (x_4 : x_1 ∈ x_2),
(∀ (Dom : Prop) (get : Dom → α) (w w_1 : { Dom := Dom, get := get }.Dom),
motive ({ Dom := Dom, get := get }.get w) ({ Dom := Dom, get := get }.get w_1) { Dom := ... | null | false |
AddUnits.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddMonoid M]
[inst_3 : AddAction M X] [ContinuousVAdd M X], ContinuousVAdd (AddUnits M) X | null | true |
FixedDetMatrices.instMulActionSpecialLinearGroupFixedDetMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ (n : Type u_1) [inst : DecidableEq n] [inst_1 : Fintype n] (R : Type u_2) [inst_2 : CommRing R] (m : R)
(b : FixedDetMatrix n R m), 1 • b = b | null | false |
Subring.toAddSubgroup_strictMono | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R], StrictMono Subring.toAddSubgroup | null | true |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Functor_Oplax___unexpand_CategoryTheory_OplaxFunctor_1 | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | Lean.PrettyPrinter.Unexpander | null | false |
convex_iff_pairwise_pos | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E},
Convex 𝕜 s ↔ s.Pairwise fun x y => ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.continuous_map_iff._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_3} [inst_1 : TopologicalSpace Y] (f : OnePoint X → Y),
Continuous f =
(Filter.Tendsto (fun x => f ↑x) (Filter.coclosedCompact X) (nhds (f OnePoint.infty)) ∧ Continuous fun x => f ↑x) | null | false |
CategoryTheory.Idempotents.split_imp_of_iso | Mathlib.CategoryTheory.Idempotents.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X X' : C} (φ : X ≅ X') (p : X ⟶ X) (p' : X' ⟶ X'),
CategoryTheory.CategoryStruct.comp p φ.hom = CategoryTheory.CategoryStruct.comp φ.hom p' →
(∃ Y i e,
CategoryTheory.CategoryStruct.comp i e = CategoryTheory.CategoryStruct.id Y ∧
Ca... | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.IterM.step_filterM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := false })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false }... | null | true |
Interval.lattice._proof_2 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DecidableLE α] (s t : Interval α),
(match s, t with
| none, x => ⊥
| x, none => ⊥
| some s, some t =>
if h : s.toProd.1 ≤ t.toProd.2 ∧ t.toProd.1 ≤ s.toProd.2 then
↑{ fst := s.toProd.1 ⊔ t.toProd.1, snd := s.toProd.2 ⊓ t.toProd.2, fst_le_snd := ⋯... | null | false |
Algebra.IsAlgebraic.algHomEmbeddingOfSplits._proof_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_1} [inst : Field F] (L' : Type u_2) [inst_1 : Field L'] [inst_2 : Algebra F L'], IsScalarTower F F L' | null | false |
isCyclic_tfae | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L],
(primitiveRoots (Module.finrank K L) K).Nonempty →
[IsGalois K L ∧ IsCyclic Gal(L/K),
∃ a,
Irreducible (Polynomial.X ^ Module.finrank K L - Polynomial.C a) ∧
Polynomial... | Suppose `L/K` is a finite extension of dimension `n`,
and `K` contains a primitive`n`-th root of unity.
Then `L/K` is cyclic iff
`L` is a splitting field of some irreducible polynomial of the form `Xⁿ - a : K[X]` iff
`L = K[α]` for some `αⁿ ∈ K`.
| true |
MeasureTheory.SimpleFunc.pow_apply | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Monoid β] (n : ℕ)
(f : MeasureTheory.SimpleFunc α β) (a : α), (f ^ n) a = f a ^ n | null | true |
continuousSMul_closedBall_ball | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ}, ContinuousSMul ↑(Metric.closedBall 0 1) ↑(Metric.ball 0 r) | null | true |
DivisibleHull.instSMulRat._proof_1 | Mathlib.GroupTheory.DivisibleHull | ∀ (a : ℚ), 0 ≤ |a| | null | false |
Set.sUnion_sub | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} [inst : Sub α] (S : Set (Set α)) (t : Set α), ⋃₀ S - t = ⋃ s ∈ S, s - t | null | true |
Lean.HeadIndex.sort.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.sort = 1 | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_Ico_le_integral_of_le._simp_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
_private.Init.PropLemmas.0.and_or_left.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : a ∧ (b ∨ c) → Prop) (x : a ∧ (b ∨ c)), (∀ (ha : a) (hbc : b ∨ c), motive ⋯) → motive x | null | false |
Array.map_set | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size} {a : α},
Array.map f (xs.set i a h) = (Array.map f xs).set i (f a) ⋯ | null | true |
Cardinal.commSemiring._proof_10 | Mathlib.SetTheory.Cardinal.Order | ∀ (a : Cardinal.{u_1}), a * 1 = a | null | false |
StateTransition.EvalsToInTime.noConfusion | Mathlib.Computability.StateTransition | {P : Sort u} →
{σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} →
{b : Option σ} →
{m : ℕ} →
{t : StateTransition.EvalsToInTime f a b m} →
{σ' : Type u_1} →
{f' : σ' → Option σ'} →
{a' : σ'} →
{b' : Option σ'} →
... | null | false |
BitVec.getMsbD_rotateLeft | Init.Data.BitVec.Lemmas | ∀ {r n w : ℕ} {x : BitVec w}, (x.rotateLeft r).getMsbD n = (decide (n < w) && x.getMsbD ((r + n) % w)) | null | true |
DilationEquivClass.mk | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {F : Type u_1} {X : outParam (Type u_2)} {Y : outParam (Type u_3)} [inst : PseudoEMetricSpace X]
[inst_1 : PseudoEMetricSpace Y] [inst_2 : EquivLike F X Y],
(∀ (f : F), ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (f x) (f y) = ↑r * edist x y) → DilationEquivClass F X Y | null | true |
CommSemiRingCat.Hom.hom | Mathlib.Algebra.Category.Ring.Basic | {R S : CommSemiRingCat} → R.Hom S → ↑R →+* ↑S | Turn a morphism in `CommSemiRingCat` back into a `RingHom`. | true |
Submodule.Quotient.equiv._proof_1 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : Submodule R M) (Q : Submodule R N) (f : M ≃ₗ[R] N),
Submodule.map (↑f) P = Q → ∀ x ∈ Q, x ∈ Submodule.comap (↑f.symm) P | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.EvalNum.0.Lean.Meta.Grind.Arith.evalNatCore | Lean.Meta.Tactic.Grind.Arith.EvalNum | Lean.Expr → OptionT Lean.Meta.Grind.GrindM ℕ | null | true |
Ring.DimensionLEOne.localization | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ {R : Type u_2} (Rₘ : Type u_3) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing Rₘ] [inst_3 : Algebra R Rₘ]
{M : Submonoid R} [IsLocalization M Rₘ], M ≤ nonZeroDivisors R → ∀ [h : Ring.DimensionLEOne R], Ring.DimensionLEOne Rₘ | Localizing a domain of Krull dimension `≤ 1` gives another ring of Krull dimension `≤ 1`.
Note that the same proof can/should be generalized to preserving any Krull dimension,
once we have a suitable definition.
| true |
CategoryTheory.Limits.createsFiniteLimitsOfCreatesFiniteLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
((J : Type w) →
{x : CategoryTheory.SmallCategory J} →
CategoryTheory.FinCategory J → CategoryTheor... | If `F` creates finite limits in any universe, then it creates finite limits. | true |
Lean.CodeAction.CommandCodeActions.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActions} → t = t' → Lean.CodeAction.CommandCodeActions.noConfusionType P t t' | null | false |
NNReal.coe_sub_of_lt._simp_1 | Mathlib.Data.NNReal.Basic | ∀ {a b : NNReal}, a < b → ↑b - ↑a = ↑(b - a) | null | false |
UniformSpace.Completion.coe_vadd._simp_1 | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X] [UniformContinuousConstVAdd M X] (c : M)
(x : X), c +ᵥ ↑x = ↑(c +ᵥ x) | null | false |
CategoryTheory.Equivalence.enoughProjectives_iff | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : C ≌ D), CategoryTheory.EnoughProjectives C ↔ CategoryTheory.EnoughProjectives D | null | true |
_private.Mathlib.CategoryTheory.Shift.ShiftedHomOpposite.0.CategoryTheory.ShiftedHom.opEquiv_symm_comp._proof_1 | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ {a b c : ℤ}, b + a = c → a + b = c | null | false |
Nat.getElem_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...=n).toArray.size), (m<...=n).toArray[i] = m + 1 + i | null | true |
_private.Mathlib.GroupTheory.DivisibleHull.0.«term↑ⁿ» | Mathlib.GroupTheory.DivisibleHull | Lean.ParserDescr | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.quot._regBuiltin.Lean.Parser.Command.quot.formatter_9 | Lean.Parser.Command | IO Unit | null | false |
CategoryTheory.SimplicialObject.Splitting.homotopyEquivNondegComplex_inv | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C], s.homotopyEquivNondegComplex.inv = s.fromNondegComplex | null | true |
OrderDual.instDivisionRing._proof_6 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (a : Kᵒᵈ), a ≠ 0 → a * a⁻¹ = 1 | null | false |
ContMDiffWithinAt.prodMap' | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. | true |
MeasureTheory.Measure.MutuallySingular.zero_left._simp_1 | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.Measure.MutuallySingular 0 μ = True | null | false |
ComplexShape.Embedding.πTruncGENatTrans | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
(e : c.Embedding c') →
[inst : e.IsTruncGE] →
(C : Type u_4) →
[inst_1 : CategoryTheory.Category.{v_2, u_4} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] ... | The natural transformation `K.πTruncGE e : K ⟶ K.truncGE e` for all `K`. | true |
AddMonoid.addOrderOf_le_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.ExponentExists G → ∀ (g : G), addOrderOf g ≤ AddMonoid.exponent G | null | true |
Std.ExtTreeSet.min!_eq_iff_mem_and_forall | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst_2 : Inhabited α], t ≠ ∅ → ∀ {km : α}, t.min! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestSeq1Tac | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TryTactic | null | true |
Left.one_lt_mul | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftStrictMono α] {a b : α}, 1 < a → 1 < b → 1 < a * b | Assumes left covariance.
The lemma assuming right covariance is `Right.one_lt_mul`. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_eq_nextFast._proof_1_7 | Init.Data.String.Basic | ∀ (s : String.Slice) (pos : s.Pos) (h : pos ≠ s.endPos),
¬pos.offset.byteIdx + (pos.str.get ⋯).utf8Size =
s.startInclusive.offset.byteIdx + pos.offset.byteIdx + (pos.str.get ⋯).utf8Size -
s.startInclusive.offset.byteIdx →
False | null | false |
TensorProduct.dualDistribEquivOfBasis_apply_apply | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} {κ : Type u_6} [inst : DecidableEq ι]
[inst_1 : DecidableEq κ] [inst_2 : Fintype ι] [inst_3 : Fintype κ] [inst_4 : CommSemiring R]
[inst_5 : AddCommMonoid M] [inst_6 : AddCommMonoid N] [inst_7 : Module R M] [inst_8 : Module R N]
(b : Module.Basis ι R M... | null | true |
NormedField.toNormedSpace._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] (a b : 𝕜), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
USize.ofNatLT_sub | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (ha : a < 2 ^ System.Platform.numBits) (hab : b ≤ a),
USize.ofNatLT (a - b) ⋯ = USize.ofNatLT a ha - USize.ofNatLT b ⋯ | null | true |
NNReal.sqrt_le_sqrt | Mathlib.Analysis.Real.Sqrt | ∀ {x y : NNReal}, NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y | null | true |
Batteries.CodeAction.matchExpand.match_6 | Batteries.CodeAction.Match | (motive : Option (Lean.Elab.TermInfo × Lean.Elab.ContextInfo) → Sort u_1) →
(x : Option (Lean.Elab.TermInfo × Lean.Elab.ContextInfo)) →
((info : Lean.Elab.TermInfo) → (updatedCtx : Lean.Elab.ContextInfo) → motive (some (info, updatedCtx))) →
((x : Option (Lean.Elab.TermInfo × Lean.Elab.ContextInfo)) → motiv... | null | false |
SimpleGraph.Walk.take_spec | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support),
(p.takeUntil u h).append (p.dropUntil u h) = p | The `takeUntil` and `dropUntil` functions split a walk into two pieces.
The lemma `SimpleGraph.Walk.count_support_takeUntil_eq_one` specifies where this split occurs. | true |
SimpleGraph.Subgraph.instDecidableRel_deleteVerts_adj._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (u : Set V) (x : ↑(⊤.deleteVerts u).verts), ↑x ∈ ⊤.verts | null | false |
Lean.Grind.AC.SubseqResult.false.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Seq | sizeOf Lean.Grind.AC.SubseqResult.false = 1 | null | true |
Homotopy.compLeft | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D E : HomologicalComplex V c} →
{f g : D ⟶ E} →
Homotopy f g →
(e : C ⟶ D) → Homotopy (CategoryTheory.Ca... | homotopy is closed under composition (on the left) | true |
Sym2.inf | Mathlib.Data.Sym.Sym2.Order | {α : Type u_1} → [SemilatticeInf α] → Sym2 α → α | The infimum of the two elements. | true |
Aesop.RuleTerm.const.elim | Aesop.RuleTac.RuleTerm | {motive : Aesop.RuleTerm → Sort u} →
(t : Aesop.RuleTerm) → t.ctorIdx = 0 → ((decl : Lean.Name) → motive (Aesop.RuleTerm.const decl)) → motive t | null | false |
Algebra.SubmersivePresentation.jacobianRelationsOfHasCoeffs._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_2} {S : Type u_4} {ι : Type u_1} {σ : Type u_5} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_3)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[P.... | null | false |
Std.DHashMap.Internal.Raw₀.getKey?_insert_self | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.