name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instNonemptyNormalizationMonoidOfNormalizedGCDMonoid | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [h : Nonempty (NormalizedGCDMonoid α)], Nonempty (NormalizationMonoid α) | null | true |
FormalMultilinearSeries.ofScalarsSum | Mathlib.Analysis.Analytic.OfScalars | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Field 𝕜] →
[inst_1 : Ring E] → [Algebra 𝕜 E] → [inst : TopologicalSpace E] → [IsTopologicalRing E] → (ℕ → 𝕜) → E → E | The sum of the formal power series. Takes the value `0` outside the radius of convergence. | true |
FP.Float.inf.inj | Mathlib.Data.FP.Basic | ∀ {C : FP.FloatCfg} {a a_1 : Bool}, FP.Float.inf a = FP.Float.inf a_1 → a = a_1 | null | true |
OrderEmbedding.birkhoffSet_sup | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred] (a b : α),
OrderEmbedding.birkhoffSet (a ⊔ b) = OrderEmbedding.birkhoffSet a ∪ OrderEmbedding.birkhoffSet b | null | true |
CategoryTheory.Functor.CorepresentableBy | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (Type v) → C → Type (max (max u₁ v) v₁) | The data which expresses that a functor `F : C ⥤ Type v` is corepresentable by `X : C`. | true |
fderivWithin_congr_set_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
s =ᶠ[nhdsWithin x {x}ᶜ] t → fderivWit... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.Equivalence.isAccessibleCategory | Mathlib.CategoryTheory.Presentable.Adjunction | ∀ {C : Type u} {D : Type u'} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v', u'} D]
(e : C ≌ D) [CategoryTheory.IsAccessibleCategory.{w, v, u} C], CategoryTheory.IsAccessibleCategory.{w, v', u'} D | null | true |
Set.Iic.coe_succ_of_not_isMax | Mathlib.Order.Interval.Set.SuccOrder | ∀ {J : Type u_1} [inst : PartialOrder J] [inst_1 : SuccOrder J] {j : J} {i : ↑(Set.Iic j)},
¬IsMax i → ↑(Order.succ i) = Order.succ ↑i | null | true |
instDistribLatticePrimeMultiset._proof_6 | Mathlib.Data.PNat.Factors | ∀ (x y z : PrimeMultiset), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
ValuativeRel.instTransVltVle | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] → [inst_1 : ValuativeRel R] → Trans ValuativeRel.vlt ValuativeRel.vle ValuativeRel.vlt | null | true |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepSet_iff._simp_1_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndepSet s μ = ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ | null | false |
TopologicalSpace.Opens.map_iSup | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑Y),
(TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U) | null | true |
Option.isSome.eq_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1}, none.isSome = false | null | true |
Chebyshev.psi.eq_1 | Mathlib.NumberTheory.Chebyshev | ∀ (x : ℝ), Chebyshev.psi x = ∑ n ∈ Finset.Ioc 0 ⌊x⌋₊, ArithmeticFunction.vonMangoldt n | null | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.instEvalExprCutsatConfig | Lean.Elab.Tactic.Grind.Config | Lean.Elab.ConfigEval.EvalExpr Lean.Grind.CutsatConfig | null | true |
WithLp.prod_continuous_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.ofLp | null | true |
_private.Mathlib.Tactic.Variable.0.Mathlib.Command.Variable.initFn._@.Mathlib.Tactic.Variable.1155143173._hygCtx._hyg.4 | Mathlib.Tactic.Variable | IO (Lean.Option Bool) | null | false |
exteriorPower.zeroEquiv_ιMulti | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Fin 0 → M),
(exteriorPower.zeroEquiv R M) ((exteriorPower.ιMulti R 0) f) = 1 | null | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.MetaM Bool | null | true |
CategoryTheory.IsKernelPair.equivalenceRelation | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
(f : X ⟶ Y) →
{R : C} →
(p₁ p₂ : R ⟶ X) →
{t : CategoryTheory.Limits.PullbackCone p₂ p₁} →
CategoryTheory.Limits.IsLimit t →
CategoryTheory.IsKernelPair f p₁ p₂ → Category... | A kernel pair gives rise to an equivalence relation. | true |
_private.Mathlib.LinearAlgebra.Isomorphisms.0.LinearMap.quotientInfEquivSupQuotient_surjective._simp_1_2 | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
LinearMap.polar_mem | Mathlib.Analysis.LocallyConvex.Polar | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedCommRing 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (s : Set E),
∀ y ∈ B.polar s, ∀ x ∈ s, ‖(B x) y‖ ≤ 1 | null | true |
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.OfLocalizationSpanTarget P →
RingHom.StableUnderCompositionWithLocalizationAwaySource P → RingHom.OfLocalizationSpan P | null | true |
ProofWidgets.ExprPresenter | ProofWidgets.Presentation.Expr | Type | An `Expr` presenter is similar to a delaborator but outputs HTML trees instead of syntax, and
the output HTML can contain elements which interact with the original `Expr` in some way. We call
interactive outputs with a reference to the original input *presentations*. | true |
CategoryTheory.Subobject.widePullbackι.eq_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
[inst_2 : CategoryTheory.WellPowered.{w, v₁, u₁} C] [inst_3 : CategoryTheory.Limits.HasWidePullbacks C] {A : C}
(s : Set (CategoryTheory.Subobject A)),
CategoryTheory.Subobject.widePullbackι s = Catego... | null | true |
_private.Mathlib.RingTheory.Coalgebra.Convolution.0.TensorProduct.map_convMul_map._simp_1_2 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
Prefunctor.map_reverse | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] [inst_2 : Quiver.HasReverse U]
[inst_3 : Quiver.HasReverse V] (φ : U ⥤q V) [φ.MapReverse] {u v : U} (e : u ⟶ v),
φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e) | null | true |
MulActionSemiHomClass.rec | Mathlib.GroupTheory.GroupAction.Hom | {F : Type u_8} →
{M : Type u_9} →
{N : Type u_10} →
{φ : M → N} →
{X : Type u_11} →
{Y : Type u_12} →
[inst : SMul M X] →
[inst_1 : SMul N Y] →
[inst_2 : FunLike F X Y] →
{motive : MulActionSemiHomClass F φ X Y → Sort u} →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_le_size._proof_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Std.DTreeMap.Internal.Impl α fun x => β}, ¬t.size - 1 ≤ t.size + 1 → False | null | false |
Irrational.eventually_forall_le_dist_cast_rat_of_den_le | Mathlib.Topology.Instances.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (n : ℕ), ∀ᶠ (ε : ℝ) in nhds 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r | null | true |
Lean.Meta.Sym.IntrosResult.failed.sizeOf_spec | Lean.Meta.Sym.Intro | sizeOf Lean.Meta.Sym.IntrosResult.failed = 1 | null | true |
CategoryTheory.yonedaAddGrpObj_obj_coe | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (G : C)
[inst_2 : CategoryTheory.AddGrpObj G] (X : Cᵒᵖ), ↑((CategoryTheory.yonedaAddGrpObj G).obj X) = (Opposite.unop X ⟶ G) | null | true |
CategoryTheory.Limits.ColimitPresentation.isColimit | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(self : CategoryTheory.Limits.ColimitPresentation J X) →
CategoryTheory.Limits.IsColimit { pt := X, ι := self.ι } | `X` is the colimit of the `Dᵢ` via `sᵢ`. | true |
Order.sub_one_wcovBy._simp_1 | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Sub α] [inst_2 : One α] [PredSubOrder α] (x : α), (x - 1 ⩿ x) = True | null | false |
MulAction.QuotientAction | Mathlib.GroupTheory.GroupAction.Quotient | {α : Type u} → (β : Type v) → [inst : Group α] → [inst_1 : Monoid β] → [MulAction β α] → Subgroup α → Prop | A typeclass for when a `MulAction β α` descends to the quotient `α ⧸ H`. | true |
tprod_setElem_eq_tprod_setElem_diff | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} (s t : Set β),
(∀ b ∈ t, f b = 1) → ∏' (a : ↑s), f ↑a = ∏' (a : ↑(s \ t)), f ↑a | **Alias** of `tprod_setElem_eq_tprod_setElem_sdiff`.
---
If `f b = 1` for all `b ∈ t`, then the product of `f a` with `a ∈ s` is the same as the
product of `f a` with `a ∈ s ∖ t`. | true |
AffineEquiv.ofLinearEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_10} →
{V : Type u_11} →
{P : Type u_12} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [inst_3 : AddTorsor V P] → (V ≃ₗ[k] V) → P → P → P ≃ᵃ[k] P | Construct an affine equivalence from a linear equivalence and two base points.
Given a linear equivalence `A : V ≃ₗ[k] V` and base points `p₀ p₁ : P`, this constructs
the affine equivalence `T x = A (x -ᵥ p₀) +ᵥ p₁`. This is the standard way to convert
a linear automorphism into an affine automorphism with specified b... | true |
QuadraticAlgebra.instField._proof_17 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {K : Type u_1} [inst : Field K] {a b : K} (q : ℚ) (x : QuadraticAlgebra K a b), q • x = ↑q * x | null | false |
Lean.Diff.Histogram.Entry | Lean.Util.Diff | Type u → ℕ → ℕ → Type | A histogram entry consists of the number of times the element occurs in the left and right input
arrays along with an index at which the element can be found, if applicable.
| true |
_private.Mathlib.GroupTheory.Nilpotent.0.Subgroup.upperCentralSeriesStep._simp_4 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
RelEmbedding.symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [Std.Symm s], Std.Symm r | null | true |
IntermediateField.fixingSubgroupEquiv._proof_3 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E)
(x x_1 : ↥K.fixingSubgroup),
(let __src := (↑(x * x_1)).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }) =
(let __src := (↑x).toRingEquiv;
{ to... | null | false |
ContinuousAlternatingMap.instAddCommGroup._proof_7 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {N : Type u_1} [inst : AddCommGroup N] [inst_1 : TopologicalSpace N] [IsTopologicalAddGroup N], ContinuousAdd N | null | false |
Rack.EnvelGroup | Mathlib.Algebra.Quandle | (R : Type u_1) → [Rack R] → Type u_1 | The universal enveloping group for the rack R.
| true |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instToJsonSemanticTokenModifier.toJson.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.SemanticTokenModifier → Sort u_1) →
(x : Lean.Lsp.SemanticTokenModifier) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.declaration) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.definition) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.readonly) →
(Unit → motive Le... | null | false |
SSet.stdSimplex.const | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n : ℕ) → Fin (n + 1) → (m : SimplexCategoryᵒᵖ) → (SSet.stdSimplex.obj { len := n }).obj m | The (degenerate) `m`-simplex in the standard simplex concentrated in vertex `k`. | true |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.gc_map_comap.match_1_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_2} {M₂ : Type u_4} [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₂]
(motive : Submodule R M → Submodule R₂ M₂ → Prop) (x : Submodule R M) (x_1 : Submodule R₂ M₂),
(∀ (x : Sub... | null | false |
UpperHalfPlane.instAddActionReal._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (x : ℝ) (z : UpperHalfPlane), 0 < (↑x + ↑z).im | null | false |
MeasureTheory.IsAddFundamentalDomain.mono | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ {ν : MeasureTheory.Measure α}, ν.AbsolutelyContinuous μ → MeasureTheory.IsAddFundamentalDomain G s ν | null | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
c.delete l = { clause := List.erase c.clause l, nodupkey := ⋯, nodup := ⋯ } | null | true |
Pi.negZeroClass.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → NegZeroClass (f i)],
Pi.negZeroClass = { toZero := Pi.instZero, toNeg := Pi.instNeg, neg_zero := ⋯ } | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_dvd_leadingCoeff_pow._simp_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime 0 x = IsUnit x | null | false |
MonoidAlgebra.map_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+ S) (r : R) (m : M),
MonoidAlgebra.map f (MonoidAlgebra.single m r) = MonoidAlgebra.single m (f r) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Symmetric.0.Matrix.isSymm_comp_iff_forall._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.IsSymm = ∀ (i j : n), A j i = A i j | null | false |
CategoryTheory.Mon.braiding_hom_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (M N : CategoryTheory.Mon C), (β_ M N).hom.hom = (β_ M.X N.X).hom | null | true |
AddCon.instInfSet.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M],
AddCon.instInfSet = { sInf := fun S => { r := fun x y => ∀ c ∈ S, c x y, iseqv := ⋯, add' := ⋯ } } | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_inv_app_hom_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Comon (CategoryTheory.Functor C D)) (x : C),
(CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso✝.inv.app X).hom.app x... | null | true |
CategoryTheory.BasedFunctor.w | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (self : CategoryTheory.BasedFunctor 𝒳 𝒴), self.comp 𝒴.p = 𝒳.p | null | true |
Equidecomp.refl | Mathlib.Algebra.Group.Action.Equidecomp | (X : Type u_1) → (G : Type u_2) → [inst : Monoid G] → [inst_1 : MulAction G X] → Equidecomp X G | The identity function is an equidecomposition of the space with itself. | true |
Std.HashMap.getElem!_ofList_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
∀ {v : β} [inst : Inhabited β],
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (k, v) ∈ l → (Std.HashMap.ofList l)[k']! = v | null | true |
MeasureTheory.SignedMeasure.eq_rnDeriv | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : MeasureTheory.SignedMeasure α}
(t : MeasureTheory.SignedMeasure α) (f : α → ℝ),
MeasureTheory.Integrable f μ →
MeasureTheory.VectorMeasure.MutuallySingular t μ.toENNRealVectorMeasure →
s = t + μ.withDensityᵥ f → f =ᵐ[μ] s.rnDeriv ... | Given a measure `μ`, signed measures `s` and `t`, and a function `f` such that `t` is
mutually singular with respect to `μ` and `s = t + μ.withDensityᵥ f`, we have
`f = rnDeriv s μ`, i.e. `f` is the Radon-Nikodym derivative of `s` and `μ`. | true |
PrimeSpectrum.BasicConstructibleSetData.rec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) →
(t : PrimeSpectrum.BasicConstructibleSetData R) → motive t | null | false |
Lean.Grind.Ring.ofNat_sub | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α] {x y : ℕ}, y ≤ x → OfNat.ofNat (x - y) = OfNat.ofNat x - OfNat.ofNat y | null | true |
Quot.lift.decidablePred | Mathlib.Data.Quot | {α : Sort u_1} →
(r : α → α → Prop) →
(f : α → Prop) → (h : ∀ (a b : α), r a b → f a = f b) → [hf : DecidablePred f] → DecidablePred (Quot.lift f h) | null | true |
SaturatedAddSubmonoid.ext_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {s₁ s₂ : SaturatedAddSubmonoid M},
s₁ = s₂ ↔ s₁.toAddSubmonoid = s₂.toAddSubmonoid | null | true |
Set.mem_prod | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t | null | true |
_private.Mathlib.Algebra.Order.Module.Basic.0.abs_smul._simp_1_3 | Mathlib.Algebra.Order.Module.Basic | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : Preorder α] [inst_4 : Preorder β] [SMulPosMono α β], a ≤ 0 → 0 ≤ b → (a • b ≤ 0) = True | null | false |
Lean.Elab.Tactic.evalRepeat' | Lean.Elab.Tactic.Repeat | Lean.Elab.Tactic.Tactic | null | true |
QPF.recF_eq | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] {α : Type u} (g : F α → α) (x : (QPF.P F).W),
QPF.recF g x = g (QPF.abs ((QPF.P F).map (QPF.recF g) x.dest)) | null | true |
ContDiffMapSupportedInClass.map_contDiff | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B), ContDiff ℝ ↑... | null | true |
Lean.Meta.RecursorUnivLevelPos._sizeOf_inst | Lean.Meta.RecursorInfo | SizeOf Lean.Meta.RecursorUnivLevelPos | null | false |
Mathlib.Tactic.BicategoryLike.IsoLift._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.IsoLift → ℕ | null | false |
_private.Mathlib.Data.Finset.Insert.0.Finset.ssubset_iff_exists_cons_subset._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α}, ∀ w ∉ s, w ∉ s | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.isAtomOrDerivable.match_5 | Mathlib.Tactic.Ring.Common | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
String.Slice.Pattern.Model.isMatch_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch pat pos ↔ String.Slice.Pattern.Model.PatternModel.Matches pat (s.sliceTo pos).copy | null | true |
Equiv.Perm.one_lt_card_support_of_ne_one | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α}, f ≠ 1 → 1 < f.support.card | null | true |
Representation.char_dual | Mathlib.RepresentationTheory.Character | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Group G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [FiniteDimensional k V] (ρ : Representation k G V) (g : G), ρ.dual.character g = ρ.character g⁻¹ | null | true |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.Subsemiring.prod_top._simp_1_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {s : Subsemiring R}
{t : Subsemiring S} {p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
OrderIso.image_symm_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set β), ⇑e '' ⇑e.symm '' s = s | null | true |
Congr!.Config.numArgsOk | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ → Bool | Whether the given number of arguments is allowed to be considered. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
IsSimpleOrder.equivBool.congr_simp | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : DecidableEq α] [inst_1 : LE α] [inst_2 : BoundedOrder α] [inst_3 : IsSimpleOrder α],
IsSimpleOrder.equivBool = IsSimpleOrder.equivBool | null | true |
RatCast.mk._flat_ctor | Batteries.Classes.RatCast | {K : Type u} → (ℚ → K) → RatCast K | null | false |
SemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : SemiRingCat} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | null | false |
Submodule.pointwiseNeg | Mathlib.Algebra.Module.Submodule.Pointwise | {R : Type u_2} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Neg (Submodule R M) | The submodule with every element negated. Note if `R` is a ring and not just a semiring, this
is a no-op, as shown by `Submodule.neg_eq_self`.
Recall that When `R` is the semiring corresponding to the nonnegative elements of `R'`,
`Submodule R' M` is the type of cones of `M`. This instance reflects such cones about `0... | true |
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : List (Lists α) → Sort u_2) (a : Lists α) (l : List (Lists α)) (h_1 : Unit → motive [])
(h_2 : (a : Lists α) → (l : List (Lists α)) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | null | true |
AddCommGrpCat.zero_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (G H : AddCommGrpCat) (g : ↑G), (CategoryTheory.ConcreteCategory.hom 0) g = 0 | null | true |
CategoryTheory.Equivalence.ctorIdx | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {inst_1 : CategoryTheory.Category.{v₂, u₂} D} → (C ≌ D) → ℕ | null | false |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.GenContFract.IntFractPair.exists_succ_nth_stream_of_fr_zero._simp_1_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Nat.factoredNumbers.map_prime_pow_mul | Mathlib.NumberTheory.SmoothNumbers | ∀ {F : Type u_1} [inst : Mul F] {f : ℕ → F},
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
∀ {s : Finset ℕ} {p : ℕ},
Nat.Prime p → p ∉ s → ∀ (e : ℕ) {m : ↑(Nat.factoredNumbers s)}, f (p ^ e * ↑m) = f (p ^ e) * f ↑m | If `f : ℕ → F` is multiplicative on coprime arguments, `p ∉ s` is a prime and `m`
is `s`-factored, then `f (p^e * m) = f (p^e) * f m`. | true |
StrictMono.injective | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
StrictMono f → Function.Injective f | null | true |
Polynomial.C_eq_intCast | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Ring R] (n : ℤ), Polynomial.C ↑n = ↑n | null | true |
MeasureTheory.ComplexMeasure.singularPart._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ContinuousAdd ℝ | null | false |
Lean.Meta.AbstractNestedProofs.Context._sizeOf_1 | Lean.Meta.AbstractNestedProofs | Lean.Meta.AbstractNestedProofs.Context → ℕ | null | false |
EquivLike.comp_surjective | Mathlib.Data.FunLike.Equiv | ∀ {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike F β γ] (f : α → β) (e : F),
Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f | null | true |
RBTree.RBNode.IsMonotone.rec | BatteriesRecycling.RBTree.WF | {α : Type u_1} →
{β : Type u_2} →
{cmpα : α → α → Ordering} →
{cmpβ : β → β → Ordering} →
{f : α → β} →
{motive : RBTree.RBNode.IsMonotone cmpα cmpβ f → Sort u} →
((lt_mono : ∀ {x y : α}, RBTree.RBNode.cmpLT cmpα x y → RBTree.RBNode.cmpLT cmpβ (f x) (f y)) → motive ⋯) →
... | null | false |
FiniteArchimedeanClass.closedBall | Mathlib.Algebra.Order.Module.Archimedean | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
(K : Type u_2) →
[inst_3 : Ring K] →
[inst_4 : LinearOrder K] →
[IsOrderedRing K] →
[Archimedean K] → [inst_7 : Module K M] → [PosSMulMono K M] ... | A closed ball defined by `ArchimedeanClass.submodule` of `UpperSet.Ici c`.
This has the same carrier as `ArchimedeanClass.closedBallAddSubgroup`'s. | true |
Submodule.piQuotientLift._proof_1 | Mathlib.LinearAlgebra.Quotient.Pi | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Int.Linear.Expr.denote.eq_7 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (e : Int.Linear.Expr) (k : ℤ),
Int.Linear.Expr.denote ctx (e.mulR k) = Int.Linear.Expr.denote ctx e * k | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.