name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddZero | Mathlib.Algebra.Group.Defs | Type u_2 → Type u_2 | Bundling an `Add` and `Zero` structure together without any axioms about their
compatibility. See `AddZeroClass` for the additional assumption that 0 is an identity. | true |
ConvexOn.le_left_of_right_le' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s f ... | null | true |
String.utf8InductionOn._sunfold | Batteries.Data.String.Lemmas | {motive : List Char → String.Pos.Raw → Sort u} →
(s : List Char) →
(i p : String.Pos.Raw) →
((i : String.Pos.Raw) → motive [] i) →
((c : Char) → (cs : List Char) → motive (c :: cs) p) →
((c : Char) → (cs : List Char) → (i : String.Pos.Raw) → i ≠ p → motive cs (i + c) → motive (c :: cs) i) ... | null | false |
AlgCat.instRingElemForallObjCompForgetAlgHomCarrierSections._proof_23 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_1} [inst_1 : CategoryTheory.Category.{u_3, u_1} J]
(F : CategoryTheory.Functor J (AlgCat R)),
autoParam
(∀ (n : ℕ) (x : ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections),
AlgCat.instRingElemForallObjCompForgetAlgHomCarrierSections._aux_20 F (n + 1) x =... | null | false |
RatFunc.valuedRatFunc | Mathlib.FieldTheory.RatFunc.AsPolynomial | (K : Type u_1) → [inst : Field K] → Valued (RatFunc K) (WithZero (Multiplicative ℤ)) | We give this instance a name so that it can be locally disabled when defining `FqtInfty`.
Something similar might be needed after the refactor from `Valued` to `ValuativeRel`. | true |
Equiv.prodSubtypeFstEquivSubtypeProd._proof_4 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (x : { a // p a } × β), p ↑x.1 | null | false |
Std.Rxc.Iterator.toList_eq_toList_rxoIterator | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : LT α] [inst_3 : DecidableLT α]
[inst_4 : Std.PRange.UpwardEnumerable α] [Std.Rxc.IsAlwaysFinite α] [Std.Rxo.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_... | null | true |
Cardinal.mk_list_eq_max_mk_aleph0 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) [Nonempty α], Cardinal.mk (List α) = max (Cardinal.mk α) Cardinal.aleph0 | null | true |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_83 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | null | false |
CategoryTheory.Iso.cancel_iso_hom_left._simp_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.comp f.hom g') = (g = g') | null | false |
DerivedCategory.instHasZeroObject | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.Limits.HasZeroObject (DerivedCategory C) | null | true |
Part._sizeOf_inst | Mathlib.Data.Part | (α : Type u) → [SizeOf α] → SizeOf (Part α) | null | false |
_private.Mathlib.Data.Finset.Card.0.Finset.exists_of_one_lt_card_pi._simp_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s : Finset α}, (1 < s.card) = ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b | null | false |
List.Perm.all_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α} {f : α → Bool}, l₁.Perm l₂ → l₁.all f = l₂.all f | null | true |
unitary.match_1 | Mathlib.Algebra.Star.Unitary | ∀ (R : Type u_1) [inst : Monoid R] [inst_1 : StarMul R] (B : R)
(motive : B ∈ {U | star U * U = 1 ∧ U * star U = 1} → Prop) (x : B ∈ {U | star U * U = 1 ∧ U * star U = 1}),
(∀ (hB₁ : star B * B = 1) (hB₂ : B * star B = 1), motive ⋯) → motive x | null | false |
String.Pos.prev_le | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p ≠ s.startPos}, p.prev h ≤ p | null | true |
LinearOrderedAddCommGroupWithTop.sub_self_eq_zero_iff_ne_top._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α] {a : α}, (a - a = 0) = (a ≠ ⊤) | null | false |
OrderMonoidIso.symm._proof_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β) {a b : β}, f.toOrderIso.symm a ≤ f.toOrderIso.symm b ↔ a ≤ b | null | false |
TensorProduct.map_comp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring R₂]
[inst_2 : CommSemiring R₃] {σ₁₂ : R →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R →+* R₃} {M : Type u_7} {N : Type u_8}
{M₂ : Type u_12} {M₃ : Type u_13} {N₂ : Type u_14} {N₃ : Type u_15} [inst_3 : AddCommMonoid M]
[inst_4 : ... | null | true |
IsUnit.mul_eq_right | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit b → (a * b = b ↔ a = 1) | null | true |
TannakaDuality.FiniteGroup.equivHom._proof_3 | Mathlib.RepresentationTheory.Tannaka | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G],
CategoryTheory.LaxMonoidalFunctor.isoOfComponents (TannakaDuality.FiniteGroup.equivApp 1) ⋯ ⋯ ⋯ = 1 | null | false |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___delab_app__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termT_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
MeasureTheory.MeasuredSets.continuous_measure | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α}, Continuous fun s => μ ↑s | null | true |
HahnModule.instAddCommMonoid._proof_8 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommMonoid V],
autoParam (∀ (x : HahnModule Γ R V), HahnModule.instAddCommMonoid._aux_6 0 x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
_private.Batteries.Util.ExtendedBinder.0.Batteries.ExtendedBinder.«_aux_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∃ᵉ_,__1».match_1 | Batteries.Util.ExtendedBinder | (motive : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder))) →
((ps : Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → motive (some ps)) →
(Unit → motive none) → motive x | null | false |
Lean.Elab.checkSyntaxNodeKindAtNamespaces._sunfold | Lean.Elab.Util | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [Lean.MonadError m] → Lean.Name → Lean.Name → m Lean.Name | null | false |
groupHomology.chainsMap_f_hom | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (i : ℕ),
ModuleCat.Hom.hom ((groupHomology.chainsMap f φ).f i) =
Finsupp.mapRange.linearMap (Rep.Hom.hom φ).toLinearMap ∘ₗ Finsupp.lmapDomain (↑A) k fun... | null | true |
_private.Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic.0.ValueDistribution.proximity_mul_top_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ | null | false |
HopfAlgCat.instMonoidalCategoryStruct._proof_1 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), IsScalarTower R R X.carrier | null | false |
Subtype.coe_le_coe._gcongr_2 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, x ≤ y → ↑x ≤ ↑y | null | false |
Rat.instUniqueInfinitePlace._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ (x : NumberField.InfinitePlace ℚ), x = Rat.infinitePlace | null | false |
Turing.ToPartrec.Cont.eval.eq_4 | Mathlib.Computability.TuringMachine.Config | ∀ (f : Turing.ToPartrec.Code) (k : Turing.ToPartrec.Cont),
(Turing.ToPartrec.Cont.comp f k).eval = fun v => f.eval v >>= k.eval | null | true |
LSeries.positive_of_differentiable_of_eqOn | Mathlib.NumberTheory.LSeries.Positivity | ∀ {a : ℕ → ℂ},
0 ≤ a →
0 < a 1 →
∀ {f : ℂ → ℂ},
Differentiable ℂ f →
∀ {x : ℝ}, LSeries.abscissaOfAbsConv a ≤ ↑x → Set.EqOn f (LSeries a) {s | x < s.re} → ∀ (y : ℝ), 0 < f ↑y | If all values of `a : ℕ → ℂ` are nonnegative reals and `a 1`
is positive, and the L-series of `a` agrees with an entire function `f` on some open
right half-plane where it converges, then `f` is real and positive on `ℝ`. | true |
Real.two_mul_cos_mul_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), 2 * Real.cos x * Real.cos y = Real.cos (x - y) + Real.cos (x + y) | null | true |
Fin.exists_succAbove_eq_iff._simp_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {x y : Fin (n + 1)}, (∃ z, x.succAbove z = y) = (y ≠ x) | null | false |
Multiset.pairwise_zero._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop), Multiset.Pairwise r 0 = True | null | false |
Module.Relations.Solution.IsPresentationCore | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] → relations.Solution M → Type (max (max (max u v) (w' + 1)) w₀) | Helper structure in order to prove `Module.Relations.Solutions.IsPresentation`
by showing the universal property of the module defined by generators and relations.
The universal property is restricted to modules that are in `Type w'` for
an auxiliary universe `w'`. See `IsPresentationCore.isPresentation`. | true |
continuous_multiset_sum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M} (s : Multiset ι),
(∀ i ∈ s, Continuous (f i)) → Continuous fun a => (Multiset.map (fun i => f i a) s).sum | null | true |
LinearIsometryEquiv.toHomeomorph_trans | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} {E : Type u_5} {E₂ : Type u_6} {E₃ : Type u_7} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {σ₁₃ : R →+* R₃} {σ₃₁ : R₃ →+* R}
{σ₂₃ : R₂ →+* R₃} {σ₃₂ : R₃ →+* R₂} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHo... | null | true |
WithLp.idemSnd | Mathlib.Analysis.Normed.Lp.ProdLp | {α : Type u_2} →
{β : Type u_3} →
[inst : SeminormedAddCommGroup α] →
[inst_1 : SeminormedAddCommGroup β] → {p : ENNReal} → AddMonoid.End (WithLp p (α × β)) | Projection on `WithLp p (α × β)` with range `β` and kernel `α` | true |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_ι | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.RightHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
(Category... | null | true |
Set.compl_cIoo | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularOrder α] {a b : α}, (Set.cIoo a b)ᶜ = Set.cIcc b a | null | true |
LieAlgebra.SemiDirectSum.recOn | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
{x : L →ₗ⁅R⁆ LieDerivation R K K} →
{motive : K ⋊⁅x⁆ L ... | null | false |
unitInterval.symm_bijective | Mathlib.Topology.UnitInterval | Function.Bijective unitInterval.symm | null | true |
Lean.MessageData.ofFormatWithInfos.noConfusion | Lean.Message | {P : Sort u} →
{a a' : Lean.FormatWithInfos} →
Lean.MessageData.ofFormatWithInfos a = Lean.MessageData.ofFormatWithInfos a' → (a = a' → P) → P | null | false |
ZeroAtInftyContinuousMap.compNonUnitalAlgHom._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {β : Type u_2} {γ : Type u_3} {δ : Type u_1} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
[inst_2 : TopologicalSpace δ] [inst_3 : NonUnitalNonAssocSemiring δ] [inst_4 : IsTopologicalSemiring δ]
(g : CocompactMap β γ), ZeroAtInftyContinuousMap.comp 0 g = ZeroAtInftyContinuousMap.comp 0 g | null | false |
MDifferentiableAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | null | true |
Primrec.eq_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] (f : α → β),
Primrec f = Nat.Primrec fun n => Encodable.encode (Option.map f (Encodable.decode n)) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Internalize.0.Lean.Meta.Grind.Arith.Linear.internalize.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.Internalize | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((natStructId : ℕ) → motive (some natStructId)) → ((x : Option ℕ) → motive x) → motive __do_lift | null | false |
Lean.PrintImportsResult._sizeOf_1 | Lean.Elab.ParseImportsFast | Lean.PrintImportsResult → ℕ | null | false |
ShowMessageRequestParams.noConfusion | Lean.Data.Lsp.Window | {P : Sort u} → {t t' : ShowMessageRequestParams} → t = t' → ShowMessageRequestParams.noConfusionType P t t' | null | false |
Lean.Lsp.instFromJsonDefinitionParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.DefinitionParams | null | true |
Std.Http.URI.Port.value.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} →
{port port' : UInt16} → Std.Http.URI.Port.value port = Std.Http.URI.Port.value port' → (port = port' → P) → P | null | false |
Std.Http.URI.Host.ipv6 | Std.Http.Data.URI.Basic | Std.Net.IPv6Addr → Std.Http.URI.Host | An IPv6 address.
| true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_21 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α) (ha : a ∈ x :: y :: tail),
a ≠ (x :: y :: tail).head ⋯ → 0 < (y :: tail).length | null | false |
IsOpen.locallyCompactSpace | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyCompactSpace X] {s : Set X}, IsOpen s → LocallyCompactSpace ↑s | null | true |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.bojanic_mahler_step1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoidWithOne M] [inst_1 : AddCommGroup G] (f : M → G) (n : ℕ) {R : ℕ},
1 ≤ R →
(fwdDiff 1)^[n + R] f 0 =
-∑ j ∈ Finset.range (R - 1), R.choose (j + 1) • (fwdDiff 1)^[n + (j + 1)] f 0 +
∑ k ∈ Finset.range (n + 1), ((-1) ^ (n - k) * ↑(n.choose k)) • (f (... | First step in Bojanić's proof of Mahler's theorem (equation (10) of [bojanic74]): rewrite
`Δ^[n + R] f 0` in a shape that makes it easy to bound `p`-adically. | true |
Lean.Meta.Simp.SimprocExtension | Lean.Meta.Tactic.Simp.Simproc | Type | null | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Composition_CompNotation___macroRules_ProbabilityTheory_term_∘ₘ__1» | Mathlib.Probability.Kernel.Composition.CompNotation | Lean.Macro | null | false |
StieltjesFunction.instAddZeroClass._proof_2 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : StieltjesFunction R), x + 0 = x | null | false |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_4 | Mathlib.Topology.Metrizable.Uniformity | ∀ {a : Prop}, (¬¬a) = a | null | false |
_private.Lean.Meta.Tactic.Symm.0.Lean.Meta.Symm.initFn._sparseCasesOn_4._@.Lean.Meta.Tactic.Symm.3447505512._hygCtx._hyg.2 | Lean.Meta.Tactic.Symm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
UniformSpace.toCore_toTopologicalSpace | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α), u.toCore.toTopologicalSpace = u.toTopologicalSpace | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparison_fst_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (A B : C) {Z : D} (h : F.obj A ⟶ Z),
CategoryTheory.Cate... | null | true |
sameRay_neg_iff._simp_1 | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x y : M}, SameRay R (-x) (-y) = SameRay R x y | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_390 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
ModuleCat.free_hom_ext | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ {R : Type u} [inst : Ring R] {X : Type u} {M : ModuleCat R} {f g : (ModuleCat.free R).obj X ⟶ M},
(∀ (x : X),
(CategoryTheory.ConcreteCategory.hom f) (ModuleCat.freeMk x) =
(CategoryTheory.ConcreteCategory.hom g) (ModuleCat.freeMk x)) →
f = g | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_8 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5 → r₀ ≤ r | null | false |
Filter.germSetoid | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → Filter α → (β : Type u_5) → Setoid (α → β) | Setoid used to define the space of germs. | true |
CategoryTheory.Under.mapId_eq | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (Y : T),
CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y) | Mapping by the identity morphism is just the identity functor. | true |
Lean.Meta.Grind.Arith.CommRing.State.typeIdOf | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ) | Mapping from types to its "ring id". We cache failures using `none`.
`typeIdOf[type]` is `some id`, then `id < rings.size`. | true |
Std.Net.SocketAddress.v6.inj | Std.Net.Addr | ∀ {addr addr_1 : Std.Net.SocketAddressV6},
Std.Net.SocketAddress.v6 addr = Std.Net.SocketAddress.v6 addr_1 → addr = addr_1 | null | true |
Submodule.submodule_torsionBy_orderIso._proof_5 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_le_of_lt._proof_1_11 | Init.Data.String.Basic | ∀ {s : String.Slice} {p q : s.Pos} {h : p ≠ s.endPos},
q.offset.byteIdx = p.offset.byteIdx + (q.offset.byteIdx - p.offset.byteIdx) →
q.offset.byteIdx - p.offset.byteIdx = 0 → p.offset.byteIdx < q.offset.byteIdx → False | null | false |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.reduceCoefficientwise.match_9 | Mathlib.Tactic.Module | {u v : Lean.Level} →
{M : Q(Type v)} →
{R : Q(Type u)} →
{x : Q(AddCommMonoid «$M»)} →
{x_1 : Q(Semiring «$R»)} →
(iRM : Q(Module «$R» «$M»)) →
(l₁ : Mathlib.Tactic.Module.qNF R M) →
(L₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) →
(motive :... | null | false |
Std.DTreeMap.Internal.Const.toList_ric | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] (t : Std.DTreeMap.Internal.Impl α fun x => β),
t.Ordered →
∀ (bound : α),
Std.Slice.toList (Std.Ric.Sliceable.mkSlice t *...=bound) =
List.filter (fun e => (compare e.1 bound).isLE) (Std.DTreeMap.Internal.Impl.Const.toList t) | null | true |
LinearPMap.instAddAction._proof_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_3} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_4} [inst_4 : AddCommGroup F] [inst_5 : Module S F] (_f₁ _f₂ : E →ₛₗ[σ] F)
(x : E →ₛₗ.[σ] F), (_f₁ + _f₂) +ᵥ x = _f₁ +ᵥ _f₂ +ᵥ x | null | false |
CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
(hf : CategoryTheory.Limits.IsColimit cc) (cc' : CategoryTheory.Limits.CokernelCofork f')
(φ : CategoryTheory.... | null | true |
Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ {fallback : α}, t₁.minKeyD fallback = t₂.minKeyD fallback | null | true |
Std.TreeSet.le_min | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α} {he : t.isEmpty = false},
(cmp k (t.min he)).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
Array.replace_extract | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α} {xs : Array α} {i : ℕ},
(xs.extract 0 i).replace a b = (xs.replace a b).extract 0 i | null | true |
CategoryTheory.Comma.post | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{C : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C] →
... | The functor `(L, R) ⥤ (L ⋙ F, R ⋙ F)` | true |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.Affine.Simplex.sum_reflectionCircumcenterWeightsWithCircumcenter._simp_1_4 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit_functor | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit.functor =
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon C | null | true |
HOr.mk._flat_ctor | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HOr α β γ | null | false |
_private.Init.Data.String.Lemmas.Iterate.0.Std.Iter.toArray_eq_match_step.match_1.splitter | Init.Data.String.Lemmas.Iterate | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x | null | true |
Vector.forall_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {p : β → Prop} {xs : Vector α n} {f : α → Vector β m},
(∀ x ∈ xs.flatMap f, p x) ↔ ∀ a ∈ xs, ∀ b ∈ f a, p b | null | true |
Aesop.GoalUnsafe.rec_6 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
CategoryTheory.TransfiniteCompositionOfShape.F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
CategoryTheory.Transfinit... | a well order continuous functor `F : J ⥤ C` | true |
AbsoluteValue.coe_toMonoidWithZeroHom | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : PartialOrder S]
(abv : AbsoluteValue R S) [inst_3 : IsDomain S] [inst_4 : Nontrivial R], ⇑abv.toMonoidWithZeroHom = ⇑abv | null | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctor._proof_3 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk (n.negOnePow • (Ca... | null | false |
SchwartzMap.toBoundedContinuousFunctionCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | (𝕜 : Type u_2) →
(E : Type u_5) →
(F : Type u_6) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
[inst_4 : RCLike 𝕜] →
[inst_5 : NormedSpace 𝕜 F] →
[... | The inclusion map from Schwartz functions to bounded continuous functions as a continuous linear
map. | true |
CategoryTheory.RegularEpi.ofIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y)
(s : CategoryTheory.Limits.Cofork (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.ofπ e.hom ⋯).π
(CategoryTheory.CategoryStruct.comp... | null | false |
CategoryTheory.Limits.ChosenEnds | Mathlib.CategoryTheory.Limits.Chosen.End | (C : Type u_3) →
[CategoryTheory.Category.{v_3, u_3} C] → Type (max (max (max (max (max (max (u + 1) (v + 1)) u) u_3) v_3) u) v) | The data of chosen ends in `C`. | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → ℕ | null | false |
FloatArray.mk | Init.Data.FloatArray.Basic | Array Float → FloatArray | null | true |
PartialEquiv.IsImage.of_symm_preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t → e.IsImage s t | **Alias** of the reverse direction of `PartialEquiv.IsImage.iff_symm_preimage_eq`. | true |
_private.Mathlib.RingTheory.Localization.Finiteness.0.Submodule.of_localizationSpan'._simp_1_1 | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M}, N.FG = Module.Finite R ↥N | null | false |
FractionalIdeal.den.eq_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I : FractionalIdeal S P), I.den = ⟨Exists.choose ⋯, ⋯⟩ | null | true |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_4 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.