name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LieSubmodule.restr_toSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : LieAlgebra R L] (N : LieSubmodule R L M)
(H : LieSubalgebra R L), ↑(N.restr H) = ↑N | null | true |
List.isChain_of_isChain_map | Mathlib.Data.List.Chain | ∀ {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β),
(∀ (a b : α), S (f a) (f b) → R a b) → ∀ {l : List α}, List.IsChain S (List.map f l) → List.IsChain R l | null | true |
Matroid.isBase_restrict_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α},
autoParam (X ⊆ M.E) Matroid.isBase_restrict_iff._auto_1 → (M.restrict X).IsBase I = M.IsBasis I X | null | false |
Std.TreeMap.Raw.getElem_filterMap'._proof_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}
[inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α} {g : k ∈ Std.TreeMap.Raw.filterMap f t}
(h : t.WF), (f k t[k]).isSome = true | null | false |
Std.instAntisymmOfAsymm | Init.Data.Order.Lemmas | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Asymm r], Std.Antisymm r | null | true |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerLeft_naturality_naturality_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.Pseudofunctor B C} (θ : G ⟶ H) {a b : B} {a' : C} (f : a' ⟶ G.obj a) {g h : a ⟶ b} (β : g ⟶ h)
{Z : a' ⟶ H.obj b}
(h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStru... | null | true |
List.suffix_cons._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (a : α) (l : List α), (l <:+ a :: l) = True | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_alterKey_eq_self._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α}, (o.isNone = true) = (o = none) | null | false |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.one_mem_div_iff._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, (a / b = 1) = (a = b) | null | false |
Std.Internal.UV.UDP.Socket.bind | Std.Internal.UV.UDP | Std.Internal.UV.UDP.Socket → Std.Net.SocketAddress → IO Unit | Binds an UDP socket to a specific address. Address reuse is enabled to allow rebinding the
same address.
| true |
Turing.PartrecToTM2.unrev | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.Λ' → Turing.PartrecToTM2.Λ' | Move everything from the `rev` stack to the `main` stack (reversed). | true |
CategoryTheory.Limits.Sigma.isoColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }]
[inst_2 : CategoryTheory.Limits.HasColimit X],
CategoryTheory.Limits.Sigma.isoColimit X =
(CategoryTheory... | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk | Std.Time.Format.Basic | Option Std.Time.Year.Era →
Option Std.Time.Year.Offset →
Option Std.Time.Year.Offset →
Option Std.Time.Year.Offset →
Option (Sigma Std.Time.Day.Ordinal.OfYear) →
Option Std.Time.Month.Ordinal →
Option Std.Time.Day.Ordinal →
Option Std.Time.Month.Quarter →
... | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction.0.SSet.Truncated.liftOfStrictSegal_app_1._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | 1 ≤ 2 | null | false |
CategoryTheory.Abelian.LeftResolution.chainComplexMap_f_succ_succ._proof_1 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} (f : X ⟶ Y) [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphism... | null | false |
WeierstrassCurve.Projective.Point.toAffine | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {F : Type u} → [inst : Field F] → (W : WeierstrassCurve.Projective F) → (Fin 3 → F) → W.toAffine.Point | The natural map from a nonsingular projective point representative on a Weierstrass curve to its
corresponding nonsingular point in affine coordinates. | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.nf_repr_split'._simp_1_3 | Mathlib.SetTheory.Ordinal.Notation | ONote.NF 0 = True | null | false |
MeasureTheory.exists_lt_lowerSemicontinuous_lintegral_ge | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] (μ : MeasureTheory.Measure α)
[μ.WeaklyRegular] [MeasureTheory.SigmaFinite μ] (f : α → NNReal),
Measurable f →
∀ {ε : ENNReal},
ε ≠ 0 → ∃ g, (∀ (x : α), ↑(f x) < g x) ∧ LowerSemicontinuous g ∧ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ ... | Given a measurable function `f` with values in `ℝ≥0` in a sigma-finite space, there exists a
lower semicontinuous function `g > f` with integral arbitrarily close to that of `f`.
Formulation in terms of `lintegral`.
Auxiliary lemma for Vitali-Carathéodory theorem `exists_lt_lower_semicontinuous_integral_lt`. | true |
Lean.getStructureCtor | Lean.Structure | Lean.Environment → Lean.Name → Lean.ConstructorVal | Gets the constructor of an inductive type that has exactly one constructor.
This is meant to be used with types that have had been registered as a structure by `registerStructure`,
but this is not checked.
Warning: this does not check that the type has no indices.
| true |
AffineIsometryEquiv.linearIsometryEquiv._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
LinearMap.mulRight_inj._simp_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_6} {A : Type u_7} [inst : Semiring R] [inst_1 : NonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {a b : A}, (LinearMap.mulRight R a = LinearMap.mulRight R b) = (a = b) | null | false |
Continuous.cfcₙ_fun._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.seminormAux_le_bound | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F) {M : ℝ},
0 ≤ M → (∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ M) → SchwartzMap.seminormAux✝ k n f ≤ M | If one controls the norm of every `A x`, then one controls the norm of `A`. | true |
Topology.IsLocallyConstructible.isConstructible_of_subset_of_isCompact | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s t : Set X} [PrespectralSpace X] [QuasiSeparatedSpace X],
Topology.IsLocallyConstructible s → s ⊆ t → IsCompact t → Topology.IsConstructible s | null | true |
Task.spawn | Init.Core | {α : Type u} → (Unit → α) → optParam Task.Priority Task.Priority.default → Task α | `spawn fn : Task α` constructs and immediately launches a new task for
evaluating the function `fn () : α` asynchronously.
`prio`, if provided, is the priority of the task.
| true |
List.splitLengths_nil | Mathlib.Data.List.SplitLengths | ∀ {α : Type u_1} (l : List α), [].splitLengths l = [] | null | true |
Ultrafilter.mk.inj | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_2} {toFilter : Filter α} {neBot' : toFilter.NeBot}
{le_of_le : ∀ (g : Filter α), g.NeBot → g ≤ toFilter → toFilter ≤ g} {toFilter_1 : Filter α}
{neBot'_1 : toFilter_1.NeBot} {le_of_le_1 : ∀ (g : Filter α), g.NeBot → g ≤ toFilter_1 → toFilter_1 ≤ g},
{ toFilter := toFilter, neBot' := neBot', le_of_le... | null | true |
ContinuousLinearMap.flipₗᵢ._proof_7 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ (𝕜 : Type u_1) (E : Type u_2) (Fₗ : Type u_4) (Gₗ : Type u_3) [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup Fₗ] [inst_2 : SeminormedAddCommGroup Gₗ] [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 Fₗ] [inst_6 : NormedSpace 𝕜 Gₗ] (c : 𝕜) (f : E →L[... | null | false |
Valued.toUniformSpace | Mathlib.Topology.Algebra.Valued.ValuationTopology | {R : Type u} →
{inst : Ring R} →
{Γ₀ : outParam (Type v)} → {inst_1 : LinearOrderedCommGroupWithZero Γ₀} → [self : Valued R Γ₀] → UniformSpace R | null | true |
Nat.Partition.UniquePartitionZero._proof_2 | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (x : Nat.Partition 0), x = default | null | false |
Int.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {s : Finset ι} {f : ι → ℤ} {n : ℤ}, (∀ i ∈ s, n ∣ f i) → (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n | null | true |
Set.notMem_Ioc_of_le | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b c : α}, c ≤ a → c ∉ Set.Ioc a b | null | true |
Order.Coframe.recOn | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
{motive : Order.Coframe α → Sort u} →
(t : Order.Coframe α) →
([toCompleteLattice : CompleteLattice α] →
[toSDiff : SDiff α] →
(sdiff_le_iff : ∀ (a b c : α), a \ b ≤ c ↔ a ≤ b ⊔ c) →
[toHNot : HNot α] →
(top_sdiff : ∀ (a : α), ⊤ \ a = ￢a) ... | null | false |
CategoryTheory.SingleObj.inv_as_inv | Mathlib.CategoryTheory.SingleObj | ∀ (G : Type u) [inst : Group G] {x y : CategoryTheory.SingleObj G} (f : x ⟶ y), CategoryTheory.inv f = f⁻¹ | null | true |
OreLocalization.lift₂Expand_of | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_3}
[inst_2 : MulAction R X] {C : Sort u_2} {P : X → ↥S → X → ↥S → C}
{hP :
∀ (r₁ : X) (t₁ : R) (s₁ : ↥S) (ht₁ : t₁ * ↑s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : ↥S) (ht₂ : t₂ * ↑s₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨... | null | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_4 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂}, (f.range = ⊤) = Function.Surjective ⇑... | null | false |
iSupIndep.subtype_ne_bot_le_finrank | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {ι : Type w} {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsDomain R]
[Module.IsTorsionFree R M] [Module.Finite R M] [StrongRankCondition R] {p : ι → Submodule R M},
iSupIndep p → ∀ [inst_7 : Fintype { i // p i ≠ ⊥ }], Fintype.card { i // p i ≠ ⊥ } ≤ Module.finrank R ... | If `p` is an independent family of submodules of an `R`-finite module `M`, then the
number of nontrivial subspaces in the family `p` is bounded above by the dimension of `M`.
Note that the `Fintype` hypothesis required here can be provided by
`iSupIndep.fintypeNeBotOfFiniteDimensional`. | true |
LieDerivation.SMulBracketCommClass.rec | Mathlib.Algebra.Lie.Derivation.Basic | {S : Type u_4} →
{L : Type u_5} →
{α : Type u_6} →
[inst : SMul S α] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup α] →
[inst_3 : LieRingModule L α] →
{motive : LieDerivation.SMulBracketCommClass S L α → Sort u} →
((smul_bracket_comm : ∀ (s : S) ... | null | false |
Lean.Grind.IntModule.OfNatModule.instLTQOfOrderedAdd | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
[inst_1 : LE α] →
[inst_2 : Std.IsPreorder α] → [Lean.Grind.OrderedAdd α] → LT (Lean.Grind.IntModule.OfNatModule.Q α) | null | true |
WithLp.pseudoMetricSpaceToProd._proof_1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) [hp : Fact (1 ≤ p)] (α : Type u_1) (β : Type u_2) [inst : PseudoMetricSpace α]
[inst_1 : PseudoMetricSpace β], IsUniformInducing (WithLp.toLp p) | null | false |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.Lifts.nonempty_algHom_of_exist_lifts_finset._simp_1_5 | Mathlib.FieldTheory.Extension | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a < a ⊔ b) = ¬b ≤ a | null | false |
CategoryTheory.Limits.CokernelCofork.isColimitTensor._proof_2 | Mathlib.CategoryTheory.Monoidal.Limits.Cokernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C] {X₁ Y₁ : C} {f₁ : X₁ ⟶ Y₁}
{c₁ : CategoryTheory.Limits.CokernelCofork f₁},
((CategoryTheory.MonoidalCategory.curriedTensor C).o... | null | false |
nhdsWithin_restrict | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} (s : Set α) {t : Set α},
a ∈ t → IsOpen t → nhdsWithin a s = nhdsWithin a (s ∩ t) | null | true |
HahnSeries.instDistribMulAction._proof_4 | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] {V : Type u_2} [inst_1 : Monoid R] [inst_2 : AddMonoid V]
[inst_3 : DistribMulAction R V] (x : R) (x_1 x_2 : HahnSeries Γ V), x • (x_1 + x_2) = x • x_1 + x • x_2 | null | false |
_private.Init.Data.List.Impl.0.List.takeTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α | null | false |
Set.preimage_mul_const_Ico₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {c : G₀} (a b : G₀),
0 < c → (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c) | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_shift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ (a m p q : ℤ), p + m = q → p + a + m = q + a | null | false |
instCommSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : CommSemiring α] (a b : WithConv (Matrix m n α)), a * b = b * a | null | false |
AddCommGrpCat.kernelIsoKer._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {G H : AddCommGrpCat} (f : G ⟶ H), ⟨(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.kernel.ι f)) 0, ⋯⟩ = 0 | null | false |
Finsupp.sigmaFinsuppLEquivPiFinsupp_apply | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ (R : Type u_5) [inst : Semiring R] {η : Type u_7} [inst_1 : Fintype η] {M : Type u_9} {ιs : η → Type u_10}
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (f : (j : η) × ιs j →₀ M) (j : η) (i : ιs j),
((Finsupp.sigmaFinsuppLEquivPiFinsupp R) f j) i = f ⟨j, i⟩ | null | true |
PerfectClosure.instCommRing._proof_8 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(a : PerfectClosure K p), 1 * a = a | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofHasKernel_p | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.Limits.HasKernel S.g] (hf : S.f = 0),
(CategoryTheory.ShortComplex.RightHomologyData.ofHasKernel S hf).p = CategoryTheory.CategoryStruct.id ... | null | true |
_private.Mathlib.RingTheory.Smooth.Kaehler.0.derivationOfSectionOfKerSqZero._simp_6 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M)
{x : M} (h : x ∈ p), (⟨x, h⟩ = 0) = (x = 0) | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.ExprWithHoles.mk.inj | Lean.Elab.MutualDef | ∀ {ref : Lean.Syntax} {expr : Lean.Expr} {ref_1 : Lean.Syntax} {expr_1 : Lean.Expr},
{ ref := ref, expr := expr } = { ref := ref_1, expr := expr_1 } → ref = ref_1 ∧ expr = expr_1 | null | true |
Class.mem_wf | Mathlib.SetTheory.ZFC.Class | WellFounded fun x1 x2 => x1 ∈ x2 | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_X₃ | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
(r... | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.mk | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C},
(∀ {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y) → P.IsClosedUnderQuotients | null | true |
_private.Mathlib.GroupTheory.Solvable.0.isSolvable_of_subsingleton._simp_1 | Mathlib.GroupTheory.Solvable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
SimpleGraph.Subgraph.symm | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (self : G.Subgraph), Std.Symm self.Adj | null | true |
finTwoEquiv._proof_6 | Mathlib.Logic.Equiv.Defs | NeZero (1 + 1) | null | false |
Complex.instNormedField._proof_1 | Mathlib.Analysis.Complex.Basic | ∀ (x x_1 : ℂ), dist x x_1 = dist x x_1 | null | false |
TypeVec.repeatEq.match_1 | Mathlib.Data.TypeVec | (motive : (x : ℕ) → TypeVec.{u_1} x → Sort u_2) →
(x : ℕ) →
(x_1 : TypeVec.{u_1} x) →
((x : TypeVec.{u_1} 0) → motive 0 x) → ((n : ℕ) → (α : TypeVec.{u_1} n.succ) → motive n.succ α) → motive x x_1 | null | false |
NonUnitalSubsemiring.mem_map._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] {F : Type u_1}
[inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] {f : F} {s : NonUnitalSubsemiring R} {y : S},
(y ∈ NonUnitalSubsemiring.map f s) = ∃ x ∈ s, f x = y | null | false |
Dyadic.instHShiftRightInt | Init.Data.Dyadic.Basic | HShiftRight Dyadic ℤ Dyadic | null | true |
Lean.Meta.Grind.Arith.CommRing.ProofM.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | Lean.Meta.Grind.Arith.CommRing.ProofM.State → ℕ | null | false |
PartOrdEmb.Hom.noConfusionType | Mathlib.Order.Category.PartOrdEmb | Sort u_1 → {X Y : PartOrdEmb} → X.Hom Y → {X' Y' : PartOrdEmb} → X'.Hom Y' → Sort u_1 | null | false |
Prime.coprime_iff_not_dvd | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : CommRing R] [IsBezout R] [IsDomain R] {p n : R}, Prime p → (IsCoprime p n ↔ ¬p ∣ n) | null | true |
singleton_div_ball | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E), {x} / Metric.ball y δ = Metric.ball (x / y) δ | null | true |
ENNReal.rpow_add_rpow_le_add | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p : ℝ} (a b : ENNReal), 1 ≤ p → (a ^ p + b ^ p) ^ (1 / p) ≤ a + b | null | true |
Mathlib.Tactic.Choose.choose1WithInfo | Mathlib.Tactic.Choose | Lean.MVarId →
Bool →
Option Lean.Expr →
Mathlib.Tactic.Choose.ChooseArg → Lean.Elab.TermElabM (Mathlib.Tactic.Choose.ElimStatus × Lean.MVarId) | A wrapper around `choose1` that parses identifiers, adds variable info to new variables,
and optionally checks the type annotation. | true |
Equiv.prodCongr_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_9} {α₂ : Type u_10} {β₁ : Type u_11} {β₂ : Type u_12} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂),
⇑(e₁.prodCongr e₂) = Prod.map ⇑e₁ ⇑e₂ | null | true |
Std.DHashMap.containsThenInsertIfNew | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.DHashMap α β → (a : α) → β a → Bool × Std.DHashMap α β | Checks whether a key is present in a map and inserts a value for the key if it was not found.
If the returned `Bool` is `true`, then the returned map is unaltered. If the `Bool` is `false`, then
the returned map has a new value inserted.
Equivalent to (but potentially faster than) calling `contains` followed by `inse... | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.orthonormal_subsingleton_iff._simp_1_3 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a : M₀} {n : ℕ}
[ZeroLEOneClass M₀], 0 ≤ a → n ≠ 0 → (a ^ n = 1) = (a = 1) | null | false |
Filter.Realizer.comap | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {β : Type u_2} → (m : α → β) → {f : Filter β} → f.Realizer → (Filter.comap m f).Realizer | Construct a realizer for `comap m f` given a realizer for `f` | true |
Complex.sin_add_int_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℤ), Complex.sin (x + ↑n * (2 * ↑Real.pi)) = Complex.sin x | null | true |
Option.forM_some | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] (f : α → m PUnit.{u_1 + 1}) (a : α), forM (some a) f = f a | null | true |
_private.Init.Data.String.Lemmas.Pattern.Find.String.0.String.Slice.isInfix_toList_iff | Init.Data.String.Lemmas.Pattern.Find.String | ∀ {t s : String}, t.toList <:+: s.toList ↔ ∃ s₁ s₂, s = s₁ ++ t ++ s₂ | null | true |
PartialEquiv.symm_image_target_eq_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), ↑e.symm '' e.target = e.source | null | true |
Ctop.Realizer.isClosed_iff | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (F : Ctop.Realizer α) {s : Set α},
IsClosed s ↔ ∀ (a : α), (∀ (b : F.σ), a ∈ F.F.f b → ∃ z, z ∈ F.F.f b ∩ s) → a ∈ s | null | true |
Lean.Elab.Tactic.Do.BVarUses.rec | Lean.Elab.Tactic.Do.LetElim | {n : ℕ} →
{motive : Lean.Elab.Tactic.Do.BVarUses n → Sort u} →
motive Lean.Elab.Tactic.Do.BVarUses.none →
((uses : Vector Lean.Elab.Tactic.Do.Uses n) → motive (Lean.Elab.Tactic.Do.BVarUses.some uses)) →
(t : Lean.Elab.Tactic.Do.BVarUses n) → motive t | null | false |
Std.TreeMap.mem_union_iff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ ∪ t₂ ↔ k ∈ t₁ ∨ k ∈ t₂ | null | true |
Std.Time.GenericFormat.mk.injEq | Std.Time.Format.Basic | ∀ {awareness : Std.Time.Awareness} (config : Std.Time.FormatConfig) (string : Std.Time.FormatString)
(config_1 : Std.Time.FormatConfig) (string_1 : Std.Time.FormatString),
({ config := config, string := string } = { config := config_1, string := string_1 }) =
(config = config_1 ∧ string = string_1) | null | true |
_private.Mathlib.Topology.AlexandrovDiscrete.0.alexandrovDiscrete_iff_nhds._simp_1_2 | Mathlib.Topology.AlexandrovDiscrete | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed s = ∀ (a : X), ClusterPt a (Filter.principal s) → a ∈ s | null | false |
NonUnitalSubsemiring.mem_top | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (x : R), x ∈ ⊤ | null | true |
Std.Do.PredTrans.throw | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α ε : Type u} → ε → Std.Do.PredTrans (Std.Do.PostShape.except ε ps) α | The predicate transformer that asserts the first exception condition.
| true |
_private.Mathlib.Data.List.Defs.0.List.Forall.match_1.eq_2 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (motive : List α → Sort u_2) (x : α) (h_1 : Unit → motive []) (h_2 : (x : α) → motive [x])
(h_3 : (x : α) → (l : List α) → motive (x :: l)),
(match [x] with
| [] => h_1 ()
| [x] => h_2 x
| x :: l => h_3 x l) =
h_2 x | null | true |
CategoryTheory.Functor.mapSquare_obj | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) (sq : CategoryTheory.Square C), F.mapSquare.obj sq = sq.map F | null | true |
Lean.Core.prependError | Lean.CoreM | {m : Type → Type u_1} → {α : Type} → [MonadControlT Lean.CoreM m] → [Monad m] → Lean.MessageData → m α → m α | Execute `x`. If it throws an error, indent and prepend `msg` to it. | true |
ValueDistribution.logCounting_monotoneOn | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {f : 𝕜 → E} {e : WithTop E},
MonotoneOn (ValueDistribution.logCounting f e) (Set.Ioi 0) | The logarithmic counting function is monotonous.
| true |
Multiset.count_sum' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} [inst : DecidableEq α] {s : Finset ι} {a : α} {f : ι → Multiset α},
Multiset.count a (∑ x ∈ s, f x) = ∑ x ∈ s, Multiset.count a (f x) | null | true |
RCLike.add_conj | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (z : K), z + (starRingEnd K) z = 2 * ↑(RCLike.re z) | null | true |
ModuleCat.shortComplexOfConj_exact | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type v}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {L : Type v} [inst_5 : AddCommGroup L] [inst_6 : Module R L]
{M' : Type u_1} {N' : Type u_2} {L' : Type u_3} [inst_7 : AddCommGroup M'] [inst_8 : AddCommGroup N']
... | null | true |
Lean.Meta.Simp.Arith.Nat.toLinearExpr | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Expr → Lean.MetaM (Lean.Meta.Simp.Arith.Nat.LinearExpr × Array Lean.Expr) | null | true |
IsLocalization.adjoin_inv | Mathlib.RingTheory.Localization.Away.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (r : R), IsLocalization.Away r (AdjoinRoot (Polynomial.C r * Polynomial.X - 1)) | null | true |
WeierstrassCurve.Projective.baseChange_polynomialY | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R) {S : Type s} [inst_1 : CommRing S] {A : Type u}
[inst_2 : CommRing A] {B : Type v} [inst_3 : CommRing B] [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [I... | null | true |
Lean.Linter.MissingDocs.lintNamed | Lean.Linter.MissingDocs | Lean.Syntax → String → Lean.Elab.Command.CommandElabM Unit | null | true |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.asLinearComboImpl.handleNatCast.match_1 | Lean.Elab.Tactic.Omega.Frontend | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((v : Lean.Expr) → motive (some v)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | null | false |
Set.Ioo_subset_Iio_self | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b ⊆ Set.Iio b | null | true |
NonAssocCommSemiring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u} → (α → α → α) → α → α → ℕ → α | null | false |
Int64.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toISize = OfNat.ofNat n | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.