name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.SyntaxDeprecationEntry.since? | Lean.Elab.DeprecatedSyntax | Lean.Elab.SyntaxDeprecationEntry → Option String | Optional version or date at which the syntax was deprecated. | true |
Filter.instSDiv.eq_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SDiv α β],
Filter.instSDiv =
{
sdiv := fun f g =>
let __src := Filter.map₂ (fun x1 x2 => x1 /ₛ x2) f g;
{ sets := {s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ /ₛ t₂ ⊆ s}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ } } | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.lt_one_iff._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ↑x.toNat < 1 → ¬x.toNat = 0 → False | null | false |
AddGrpCat.casesOn | Mathlib.Algebra.Category.Grp.Basic | {motive : AddGrpCat → Sort u_1} →
(t : AddGrpCat) →
((carrier : Type u) → [str : AddGroup carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._f | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedState →
Lean.Syntax →
Option Lean.Expr →
Bool →
(x : List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Term.TermElab)) →
List.below x → Lean.Elab.TermElabM Lean.Expr | null | false |
GromovHausdorff.IsometryRel.setoid | Mathlib.Topology.MetricSpace.GromovHausdorff | Setoid (TopologicalSpace.NonemptyCompacts ↥(lp (fun n => ℝ) ⊤)) | setoid instance identifying two isometric nonempty compact subspaces of ℓ^∞(ℝ) | true |
Matrix.det_eq_detp_sub_detp | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n R),
M.det = Matrix.detp 1 M - Matrix.detp (-1) M | null | true |
instNonUnitalCommCStarAlgebraSubtypePreLpMemAddSubgroupLpTopENNReal._proof_6 | Mathlib.Analysis.CStarAlgebra.lpSpace | ∀ {I : Type u_1} {A : I → Type u_2} [inst : (i : I) → NonUnitalCommCStarAlgebra (A i)] (a b c : ↥(lp A ⊤)),
a * (b + c) = a * b + a * c | null | false |
_private.Init.Data.List.Basic.0.List.zipWith.match_1.eq_1 | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Sort u_3) (x : α) (xs : List α) (y : β) (ys : List β)
(h_1 : (x : α) → (xs : List α) → (y : β) → (ys : List β) → motive (x :: xs) (y :: ys))
(h_2 : (x : List α) → (x_1 : List β) → motive x x_1),
(match x :: xs, y :: ys with
| x :: xs, y :: ys => h_1 ... | null | true |
AlgebraicGeometry.PresheafedSpace.ColimitCoconeIsColimit.descCApp._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J TopCat]
[CategoryTheory.Limits.HasLimitsOfShape Jᵒᵖ C] (F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C))
(s : Catego... | null | false |
HomogeneousLocalization.NumDenSameDeg._sizeOf_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
{inst : CommRing A} →
{inst_1 : SetLike σ A} →
{𝒜 : ι → σ} →
{x : Submonoid A} → [SizeOf ι] → [SizeOf A] → [SizeOf σ] → HomogeneousLocalization.NumDenSameDeg 𝒜 x → ℕ | null | false |
CategoryTheory.Limits.pointwiseBinaryBicone_inr_app | Mathlib.CategoryTheory.Limits.FunctorCategory.BinaryBiproducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{v_2, u_2} D]
(F G : CategoryTheory.Functor D C) (X : D),
(CategoryTheory.Limits.pointwiseBinar... | null | true |
RingCon.instNonUnitalRingQuotient._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonUnitalRing R] (c : RingCon R) (a b c_1 : c.Quotient), a * b * c_1 = a * (b * c_1) | null | false |
HahnSeries.ofPowerSeries_C | Mathlib.RingTheory.HahnSeries.PowerSeries | ∀ {Γ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : Semiring Γ] [inst_2 : PartialOrder Γ]
[inst_3 : IsStrictOrderedRing Γ] (r : R), (HahnSeries.ofPowerSeries Γ R) (PowerSeries.C r) = HahnSeries.C r | null | true |
Set.union_sdiv | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SDiv α β] {s₁ s₂ t : Set β}, s₁ ∪ s₂ /ₛ t = s₁ /ₛ t ∪ (s₂ /ₛ t) | null | true |
mkFactorOrderIsoOfFactorDvdEquiv._proof_4 | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_2} [inst : CommMonoidWithZero M] {N : Type u_1} [inst_1 : CommMonoidWithZero N] [inst_2 : Subsingleton Mˣ]
[inst_3 : Subsingleton Nˣ] {m : M} {n : N} {d : { l // l ∣ m } ≃ { l // l ∣ n }} (x : ↑(Set.Iic (Associates.mk m))),
associatesEquivOfUniqueUnits ↑⟨Associates.mk ↑(d ⟨associatesEquivOfUniqueUnits... | null | false |
OrderedFinpartition.emb_injective | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n), Function.Injective fun p => c.emb p.fst p.snd | null | true |
Std.TreeMap.Raw.getElem!_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst : Inhabited β], k ∉ t₁ → (t₁ ∪ t₂)[k]! = t₂[k]! | null | true |
_private.Mathlib.Algebra.BigOperators.Group.List.Lemmas.0.List.ranges_flatten._simp_1_3 | Mathlib.Algebra.BigOperators.Group.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {L : List (List α)},
(List.map (List.map f) L).flatten = List.map f L.flatten | null | false |
BinaryTree.numNodes._unsafe_rec | Mathlib.Data.Tree.Basic | {α : Type u} → BinaryTree α → ℕ | null | false |
_private.Mathlib.Order.SetAccumulate.0.Set.mem_accumulate._simp_1_2 | Mathlib.Order.SetAccumulate | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.core | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Expr → Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof | null | true |
Encodable.encode_sigma_val | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {γ : α → Type u_3} [inst : Encodable α] [inst_1 : (a : α) → Encodable (γ a)] (a : α) (b : γ a),
Encodable.encode ⟨a, b⟩ = Nat.pair (Encodable.encode a) (Encodable.encode b) | null | true |
AlgEquiv.ofLinearEquiv_toLinearEquiv | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (map_mul : ↑e 1 = 1)
(map_one : ∀ (x y : A₁), ↑e (x * y) = ↑e x * ↑e y), AlgEquiv.ofLinearEquiv (↑e) map_mul map_one = e | null | true |
ConvexOn.subset | 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 : PartialOrder β] [inst_5 : SMul 𝕜 E] [inst_6 : SMul 𝕜 β] {s : Set E} {f : E → β}
{t : Set E}, ConvexOn 𝕜 t f → s ⊆ t → Convex 𝕜 s → ConvexOn 𝕜 s f | null | true |
Lean.Elab.PartialFixpoint.term? | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpoint → Option Lean.Term | null | true |
GaloisInsertion.u_le_u_iff | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β] (gi : GaloisInsertion l u)
{a b : β}, u a ≤ u b ↔ a ≤ b | null | true |
Subsemiring.map_iInf | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {ι : Sort u_1} [Nonempty ι]
(f : R →+* S),
Function.Injective ⇑f → ∀ (s : ι → Subsemiring R), Subsemiring.map f (iInf s) = ⨅ i, Subsemiring.map f (s i) | null | true |
GenLoop.fromLoop._proof_4 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} (i : N),
ContinuousMapClass ((N → ↑unitInterval) ≃ₜ ↑unitInterval × ({ j // j ≠ i } → ↑unitInterval)) (N → ↑unitInterval)
(↑unitInterval × ({ j // j ≠ i } → ↑unitInterval)) | null | false |
CategoryTheory.InjectiveResolution.desc_commutes_zero | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (J.ι.f 0) ((CategoryTheory.InjectiveResolution.desc f I J).f 0) =
CategoryT... | null | true |
_private.Plausible.DeriveShrinkable.0.Plausible.mkCtorShrinkExpr._proof_5 | Plausible.DeriveShrinkable | ∀ (freshIdents : Array Lean.Ident) (i j : ℕ), 0 ≤ j ∧ j < freshIdents.size → ¬j < freshIdents.size → False | null | false |
Std.TreeSet.instDecidableEquivOfTransCmpOfLawfulEqCmp | Std.Data.TreeSet.DecidableEquiv | {α : Type u} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → [Std.LawfulEqCmp cmp] → {t₁ t₂ : Std.TreeSet α cmp} → Decidable (t₁.Equiv t₂) | null | true |
_private.Lean.Structure.0.Lean.computeStructureResolutionOrder.match_1 | Lean.Structure | (motive : Option (Array Lean.Name) → Sort u_1) →
(x : Option (Array Lean.Name)) →
((resOrder : Array Lean.Name) → motive (some resOrder)) → ((x : Option (Array Lean.Name)) → motive x) → motive x | null | false |
Std.ExtDTreeMap.minKey!_insertIfNew_of_isEmpty | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey! = k | null | true |
MeasureTheory.MemLp.eLpNorm_ne_top | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f p μ → MeasureTheory.eLpNorm f p μ ≠ ⊤ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.filterMap_equiv_filter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Mathlib.TacticAnalysis.Entry.casesOn | Mathlib.Tactic.TacticAnalysis | {motive : Mathlib.TacticAnalysis.Entry → Sort u} →
(t : Mathlib.TacticAnalysis.Entry) →
((declName optionName : Lean.Name) → motive { declName := declName, optionName := optionName }) → motive t | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSlice_ne_startPos._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {q r : (s.slice p₀ p₁ h).Pos},
(q < r) = (String.Slice.Pos.ofSlice q < String.Slice.Pos.ofSlice r) | null | false |
FirstOrder.Language.ElementarySubstructure.mk.sizeOf_spec | Mathlib.ModelTheory.ElementarySubstructures | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] [inst_1 : SizeOf M]
(toSubstructure : L.Substructure M) (isElementary' : toSubstructure.IsElementary),
sizeOf { toSubstructure := toSubstructure, isElementary' := isElementary' } = 1 + sizeOf toSubstructure | null | true |
_private.Mathlib.Algebra.Field.Subfield.Basic.0.Subfield.mem_iSup_of_directed.match_1_1 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] {ι : Sort u_1} {S : ι → Subfield K} (x : K)
(motive : (∃ i, x ∈ ↑(S i).toSubring) → Prop) (x_1 : ∃ i, x ∈ ↑(S i).toSubring),
(∀ (i : ι) (hi : x ∈ ↑(S i).toSubring), motive ⋯) → motive x_1 | null | false |
AddMonoidHom.isStrictMap_iff_isEmbedding_kerLift | Mathlib.Topology.Maps.Strict.Group | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {f : G →+ H} [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace H], Topology.IsStrictMap ⇑f ↔ Topology.IsEmbedding ⇑(QuotientAddGroup.kerLift f) | An additive group homomorphism is strict if and only if its
`QuotientAddGroup.kerLift` is an embedding. | true |
integralClosure_idem | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
integralClosure (↥(integralClosure R A)) A = ⊥ | null | true |
CategoryTheory.ConcreteCategory.congr_hom | Mathlib.CategoryTheory.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
{f g : X ⟶ Y},
f = g →
∀ (x : CategoryTheory.ToType X),
(CategoryTheory.ConcreteCategory.hom ... | Analogue of `congr_fun h x`,
when `h : f = g` is an equality between morphisms in a concrete category.
| true |
isOfFinAddOrder_nsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {a : G} {n : ℕ}, IsOfFinAddOrder (n • a) ↔ IsOfFinAddOrder a ∨ n = 0 | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.isEmpty_filter_eq_false._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
LeftCancelMonoid.toMonoid_injective | Mathlib.Algebra.Group.Ext | ∀ {M : Type u}, Function.Injective (@LeftCancelMonoid.toMonoid M) | null | true |
_private.Mathlib.Analysis.Complex.Liouville.0.Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le._simp_1_1 | Mathlib.Analysis.Complex.Liouville | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
Lean.Meta.Grind.instInhabitedSplitStatus.default | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitStatus | null | true |
Lean.Parser.Term.stateRefT.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Std.LawfulOrderMin.toMinEqOr | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Min α} {inst_1 : LE α} [self : Std.LawfulOrderMin α], Std.MinEqOr α | null | true |
Finsupp.embSigma_apply | Mathlib.Data.Finsupp.Sigma | ∀ {κ : Type u_1} {ι : κ → Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : DecidableEq κ] {k : κ} (f : ι k →₀ M)
(i : (k : κ) × ι k), f.embSigma i = if h : i.fst = k then f (h ▸ i.snd) else 0 | null | true |
Sbtw.oangle_eq_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ p₃' : P}, Sbtw ℝ p₂ p₃ p₃' → EuclideanGeometry.oangle p₁ p₂ p₃ = EuclideanGeom... | An oriented angle is unchanged by replacing the third point by one strictly further away on
the same ray. | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.isJpCases?.go._sunfold | Lean.Compiler.LCNF.Simp.JpCases | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure →
ℕ → Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → ℕ → Option ℕ | null | false |
instLocallyPathConnectedSpace | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [StronglyLocallyContractibleSpace X], LocallyPathConnectedSpace X | Strongly locally contractible spaces are locally path-connected. | true |
String.push_ne_empty | Init.Data.String.Lemmas.Basic | ∀ {s : String} {c : Char}, s.push c ≠ "" | null | true |
Differential.logDeriv_mul | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : Field R] [inst_1 : Differential R] (a b : R),
a ≠ 0 → b ≠ 0 → Differential.logDeriv (a * b) = Differential.logDeriv a + Differential.logDeriv b | null | true |
LinearMap.range_toAddSubmonoid | Mathlib.Algebra.Module.Submodule.Range | ∀ {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.toAddSubmonoid = AddMonoidHom... | null | true |
Lean.Lsp.LeanModule.mk.sizeOf_spec | Lean.Data.Lsp.Extra | ∀ (name : String) (uri : Lean.Lsp.DocumentUri) (data? : Option Lean.Json),
sizeOf { name := name, uri := uri, data? := data? } = 1 + sizeOf name + sizeOf uri + sizeOf data? | null | true |
SSet.stdSimplex.homOfLE_faceSingletonComplIso_inv_eq_facePairComplIso_inv_δ_castPred | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (i j : Fin (n + 3)) (h : i < j),
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.homOfLE ⋯) (SSet.stdSimplex.faceSingletonComplIso j).inv =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.facePairComplIso i j h).inv (SSet.stdSimplex.δ (i.castPred ⋯)) | null | true |
Real.instConditionallyCompleteLinearOrder._proof_3 | Mathlib.Algebra.Order.Archimedean.Real.Basic | ∀ (a b : ℝ), a ≤ SemilatticeSup.sup a b | null | false |
Ergodic.mem_extremePoints | Mathlib.Dynamics.Ergodic.Extreme | ∀ {X : Type u_1} {m : MeasurableSpace X} {μ : MeasureTheory.Measure X} {f : X → X}
[MeasureTheory.IsProbabilityMeasure μ],
Ergodic f μ →
μ ∈ Set.extremePoints ENNReal {ν | MeasureTheory.MeasurePreserving f ν ν ∧ MeasureTheory.IsProbabilityMeasure ν} | null | true |
MeasurableEquiv.shearSubRight | Mathlib.MeasureTheory.Group.Prod | (G : Type u_1) →
[inst : MeasurableSpace G] → [inst_1 : AddGroup G] → [MeasurableAdd₂ G] → [MeasurableNeg G] → G × G ≃ᵐ G × G | The map `(x, y) ↦ (x, y - x)` as a `MeasurableEquiv` with inverse `(x, y) ↦ (x, y + x)`. | true |
ContinuousMap.restrict_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (s : Set α)
(x : ↑s), (ContinuousMap.restrict s f) x = f ↑x | null | true |
Int64.ofIntLE_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : ℤ} (ha₁ : Int64.minValue.toInt ≤ a) (ha₂ : a ≤ Int64.maxValue.toInt) (hb₁ : Int64.minValue.toInt ≤ b)
(hb₂ : b ≤ Int64.maxValue.toInt), Int64.ofIntLE a ha₁ ha₂ ≤ Int64.ofIntLE b hb₁ hb₂ ↔ a ≤ b | null | true |
EMetric.isUniformEmbedding_iff' | Mathlib.Topology.EMetricSpace.Basic | ∀ {β : Type v} {γ : Type w} [inst : EMetricSpace γ] [inst_1 : PseudoEMetricSpace β] {f : γ → β},
IsUniformEmbedding f ↔
(∀ ε > 0, ∃ δ > 0, ∀ {a b : γ}, edist a b < δ → edist (f a) (f b) < ε) ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : γ}, edist (f a) (f b) < ε → edist a b < δ | A map between emetric spaces is a uniform embedding if and only if the edistance between `f x`
and `f y` is controlled in terms of the distance between `x` and `y` and conversely. | true |
instSMulWeakSpaceOfModule._aux_1 | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | {𝕜 : Type u_3} →
{𝕝 : Type u_1} →
{E : Type u_2} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
... | null | false |
nnnorm_fderiv_norm_rpow_le | Mathlib.Analysis.InnerProductSpace.NormPow | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {f : F → E},
Differentiable ℝ f →
∀ {x : F} {p : NNReal}, 1 < p → ‖fderiv ℝ (fun x => ‖f x‖ ^ ↑p) x‖₊ ≤ p * ‖f x‖₊ ^ (↑p - 1) * ‖fderiv ℝ f x‖₊ | null | true |
Lean.Meta.Grind.AttrKind.ext.elim | Lean.Meta.Tactic.Grind.Attr | {motive : Lean.Meta.Grind.AttrKind → Sort u} →
(t : Lean.Meta.Grind.AttrKind) → t.ctorIdx = 4 → motive Lean.Meta.Grind.AttrKind.ext → motive t | null | false |
LinearEquiv.snd_comp_prodComm | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂],
LinearMap.snd R M₂ M ∘ₗ ↑(LinearEquiv.prodComm R M M₂) = LinearMap.fst R M M₂ | null | true |
FiniteIndexNormalAddSubgroup.mk.sizeOf_spec | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : SizeOf G] (toAddSubgroup : AddSubgroup G)
(isNormal' : autoParam toAddSubgroup.Normal FiniteIndexNormalAddSubgroup.isNormal'._autoParam)
(isFiniteIndex' : autoParam toAddSubgroup.FiniteIndex FiniteIndexNormalAddSubgroup.isFiniteIndex'._autoParam),
sizeOf { toAddSubgr... | null | true |
IsPrimitiveRoot.prod_one_sub_pow_eq_order | Mathlib.RingTheory.RootsOfUnity.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] {n : ℕ} {μ : R},
IsPrimitiveRoot μ (n + 1) → ∏ k ∈ Finset.range n, (1 - μ ^ (k + 1)) = ↑n + 1 | If `μ` is a primitive `n`th root of unity in `R`, then `∏(1≤k<n) (1-μ^k) = n`.
(Stated with `n+1` in place of `n` to avoid the condition `n ≠ 0`.) | true |
Lean.AssocList.empty | Lean.Data.AssocList | {α : Type u} → {β : Type v} → Lean.AssocList α β | null | true |
ZMod.natCast_val | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] [NeZero n] (i : ZMod n), ↑i.val = i.cast | null | true |
FirstOrder.Language.BoundedFormula.toPrenex.eq_5 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (f : L.BoundedFormula α (x + 1)), f.all.toPrenex = f.toPrenex.all | null | true |
Algebra.TensorProduct.prodRight._proof_3 | Mathlib.RingTheory.TensorProduct.Pi | ∀ (S : Type u_1) [inst : CommSemiring S], RingHomInvPair (RingHom.id S) (RingHom.id S) | null | false |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.mk._flat_ctor | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} → {s : String.Slice} → s.Pos → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s | null | false |
Std.DTreeMap.Raw.Const.get.congr_simp | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} (t t_1 : Std.DTreeMap.Raw α (fun x => β) cmp) (e_t : t = t_1)
(a a_1 : α) (e_a : a = a_1) (h : a ∈ t), Std.DTreeMap.Raw.Const.get t a h = Std.DTreeMap.Raw.Const.get t_1 a_1 ⋯ | null | true |
Matrix.fromBlocks_mul_fromRows | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} {n₁ : Type u_6} {n₂ : Type u_7} [inst : Semiring R]
[inst_1 : Fintype n₁] [inst_2 : Fintype n₂] (A₁ : Matrix n₁ n R) (A₂ : Matrix n₂ n R) (B₁₁ : Matrix m₁ n₁ R)
(B₁₂ : Matrix m₁ n₂ R) (B₂₁ : Matrix m₂ n₁ R) (B₂₂ : Matrix m₂ n₂ R),
Matrix.fromBlocks B... | A block matrix multiplied by a row partitioned matrix gives a row partitioned matrix. | true |
Fin.contractNth_apply_of_gt | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {α : Sort u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n),
↑j < ↑k → j.contractNth op g k = g k.succ | null | true |
Lean.Elab.Tactic.mkSimpContext | Lean.Elab.Tactic.Simp | Lean.Syntax →
Bool →
optParam Lean.Elab.Tactic.SimpKind Lean.Elab.Tactic.SimpKind.simp →
optParam Bool false →
optParam (Lean.CoreM Lean.Meta.SimpTheorems) Lean.Meta.getSimpTheorems →
Lean.Elab.Tactic.TacticM Lean.Elab.Tactic.MkSimpContextResult | Create the `Simp.Context` for the `simp`, `dsimp`, and `simp_all` tactics.
If `kind != SimpKind.simp`, the `discharge` option must be `none`
TODO: generate error message if non `rfl` theorems are provided as arguments to `dsimp`.
The argument `simpTheorems` defaults to `getSimpTheorems`,
but allows overriding with an... | true |
NonarchAddGroupSeminorm.instSemilatticeSup._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] {x y : NonarchAddGroupSeminorm E}, ⇑x ≤ ⇑y ↔ ⇑x ≤ ⇑y | null | false |
ContinuousOn.image_uIcc_of_monotoneOn | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
ContinuousOn f (Set.uIcc a b) → MonotoneOn f (Set.uIcc a b) → f '' Set.... | null | true |
ProbabilityTheory.condIndep_iSup_of_antitone | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' m₁ mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] [inst_2 : SemilatticeInf ι]
{m : ι → MeasurableSpace Ω},
(∀ (i : ι), ProbabilityTheory.CondIndep m' (m i) m₁ hm' μ) →
(∀ (i : ι)... | null | true |
Function.Injective.preimage_pullbackDiagonal._proof_1 | Mathlib.Data.Set.Prod | ∀ {X : Type u_3} {Y : Sort u_2} {Z : Type u_1} {f : X → Y} {g : Z → X}, f ∘ g = id ∘ f ∘ g | null | false |
_private.Lean.Elab.PreDefinition.TerminationHint.0.Lean.Elab.TerminationHints.ensureNone._sparseCasesOn_3 | Lean.Elab.PreDefinition.TerminationHint | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Topology.Algebra.Group.SubmonoidClosure.0.mapClusterPt_self_zpow_atTop_pow._simp_1_1 | Mathlib.Topology.Algebra.Group.SubmonoidClosure | ∀ {G : Type u_3} [inst : Group G] (a : G) (m n : ℤ), a ^ m * (a ^ n)⁻¹ = a ^ (m - n) | null | false |
CategoryTheory.InjectiveResolution.extMk.congr_simp | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(f f_1 : X ⟶ R.cocomplex.X n) (e_f : f = f_1) (m m_1 : ℕ) (e_m : m = m_1) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruc... | null | true |
eq_zero_of_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroOneClass M₀], 0 = 1 → ∀ (a : M₀), a = 0 | In a monoid with zero, if zero equals one, then zero is the only element. | true |
MonoidAlgebra.coeff_mapAlgHom | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (f : A →ₐ[R] B)
(x : MonoidAlgebra A M) (m : M), ((MonoidAlgebra.mapAlgHom M f) x).coeff m = f (x.coeff m) | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_696 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Mathlib.Topology.Separation.Basic.0.t1Space_TFAE._simp_1_5 | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_1} {s : Set α} {a : α}, (a ∉ s) = (s ⊆ {a}ᶜ) | null | false |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Under.isLeftAdjoint_post.match_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor T D) (motive : F.IsLeftAdjoint → Prop)
(x : F.IsLeftAdjoint), (∀ (G : CategoryTheory.Functor D T) (a : F ⊣ G), motive ⋯) → motive x | null | false |
FirstOrder.Language.ElementarySubstructure.subtype_injective | Mathlib.ModelTheory.ElementarySubstructures | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] (S : L.ElementarySubstructure M),
Function.Injective ⇑S.subtype | null | true |
List.nil_eq | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, [] = xs ↔ xs = [] | null | true |
Lean.LLVM.constInt32 | Lean.Compiler.IR.LLVMBindings | (ctx : Lean.LLVM.Context) → UInt64 → optParam Bool false → BaseIO (Lean.LLVM.Value ctx) | null | true |
Module.AEval.instAddCommGroup._aux_3 | Mathlib.Algebra.Polynomial.Module.AEval | {R : Type u_2} →
{A : Type u_3} →
{M : Type u_1} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
(a : A) →
[inst_2 : Algebra R A] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module A M] →
[inst_5 : Module R M] → [inst_6 : IsScalar... | null | false |
Std.PRange.UpwardEnumerable.Map.mk.noConfusion | Init.Data.Range.Polymorphic.Map | {α : Type u} →
{β : Type v} →
{inst : Std.PRange.UpwardEnumerable α} →
{inst_1 : Std.PRange.UpwardEnumerable β} →
{P : Sort u_1} →
{toFun : α → β} →
{injective : Function.Injective toFun} →
{succ?_toFun : ∀ (a : α), Std.PRange.succ? (toFun a) = Option.map toFun (S... | null | false |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.eq_one_or_neg_one_of_mem_fdo_mem_fd._simp_1_2 | Mathlib.NumberTheory.Modular | ∀ (z : UpperHalfPlane), z.re = (↑z).re | null | false |
Std.DTreeMap.isEmpty_eq_size_eq_zero | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.isEmpty = (t.size == 0) | null | true |
LinearMap.smulRightₗ._proof_3 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (f f' : M₂ →ₗ[R] R),
{ toFun := (f + f').smulRight, map_add' := ⋯, map_smul' := ⋯ } =
{ toFun := f.smulRight, map_add' := ⋯, map_smul' := ⋯ ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.