name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PadicInt.mahlerEquiv._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], RingHomInvPair (RingHom.id ℤ_[p]) (RingHom.id ℤ_[p]) | null | false |
Std.Roo.isSome_succMany?_of_lt_size_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {i : ℕ}, i < r.toArray.size → (Std.PRange.succMany? (i + 1) r.lower).isSome = true | null | true |
Finset.sum_bij | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : AddCommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ),
(∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) →
(∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) →
(∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s)... | Reorder a sum.
The difference with `Finset.sum_bij'` is that the bijection is specified as a surjective injection,
rather than by an inverse function.
The difference with `Finset.sum_nbij` is that the bijection is allowed to use membership of the
domain of the sum, rather than being a non-dependent function. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Degenerate.0.SSet.unique_nonDegenerate.map_g_op_y₂ | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := n })} {m₁ m₂ : ℕ} {f₁ : { len := n } ⟶ { len := m₁ }}
(hf₁ : CategoryTheory.SplitEpi f₁) {y₁ : ↑(X.nonDegenerate m₁)},
x = (CategoryTheory.ConcreteCategory.hom (X.map f₁.op)) ↑y₁ →
∀ {f₂ : { len := n } ⟶ { len := m₂ }} {y₂ : X.obj (Opposite.op { len := m₂ })... | null | true |
Std.Http.URI.EncodedString.recOn | Std.Http.Data.URI.Encoding | {r : UInt8 → Bool} →
{motive : Std.Http.URI.EncodedString r → Sort u} →
(t : Std.Http.URI.EncodedString r) →
((toByteArray : ByteArray) →
(valid : Std.Http.URI.IsAllowedEncodedChars r toByteArray) →
motive { toByteArray := toByteArray, valid := valid }) →
motive t | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int32.reduceSub.declare_210._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.110 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
SSet.Subcomplex.Pairing.RankFunction.casesOn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{α : Type v} →
[inst : PartialOrder α] →
{motive : P.RankFunction α → Sort u_1} →
(t : P.RankFunction α) →
((rank : ↑P.II → α) →
(lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y) → mo... | null | false |
Pi.smulWithZero' | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
{g : I → Type u_1} →
[inst : (i : I) → Zero (g i)] →
[inst_1 : (i : I) → Zero (f i)] →
[(i : I) → SMulWithZero (g i) (f i)] → SMulWithZero ((i : I) → g i) ((i : I) → f i) | null | true |
Std.DTreeMap.Internal.Unit.RicSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{inst : Ord α} →
{P : Sort u_1} →
{treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit} →
{range : Std.Ric α} →
{treeMap' : Std.DTreeMap.Internal.Impl α fun x => Unit} →
{range' : Std.Ric α} →
{ treeMap := treeMap, range := range } = { treeMap := t... | null | false |
IsLocalRing.instModuleResidueFieldCotangentSpace | Mathlib.RingTheory.Ideal.Cotangent | (R : Type u_1) →
[inst : CommRing R] → [inst_1 : IsLocalRing R] → Module (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) | null | true |
CategoryTheory.Pseudofunctor.isoMapOfCommSq_eq._proof_1 | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {X₁ Y₁ Y₂ : B} {t : X₁ ⟶ Y₁} {r : Y₁ ⟶ Y₂} (φ : X₁ ⟶ Y₂),
CategoryTheory.CategoryStruct.comp t r = φ → CategoryTheory.CategoryStruct.comp t r = φ | null | false |
Equiv.lt_def | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : LT β] (a b : α), e a < e b ↔ a < b | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Path.0.SSet.spine_δ₀._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {m : ℕ}, 1 + m ≤ m + 1 | null | false |
Int.induct_roo_left | Init.Data.Range.Polymorphic.IntLemmas | ∀ (motive : ℤ → ℤ → Prop),
(∀ (a b : ℤ), b ≤ a + 1 → motive a b) →
(∀ (a b : ℤ), a + 1 < b → motive (a + 1) b → motive a b) → ∀ (a b : ℤ), motive a b | Induction principle for proving properties of `Int`-based ranges of the form `a<...b` by
varying the lower bound.
In the `base` case, one proves that for any `a : Int` and `b : Int` with
`b ≤ a + 1`, the statement holds for the empty range `a<...b`.
In the `step` case, one proves that for any `a : Int` and `b : Int`,... | true |
Lean.DeclNameGenerator.ctorIdx | Lean.CoreM | Lean.DeclNameGenerator → ℕ | null | false |
Int.negSucc_dvd | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℕ} {b : ℤ}, Int.negSucc a ∣ b ↔ ↑(a + 1) ∣ b | null | true |
SSet.Augmented.stdSimplex._proof_8 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {X Y Z : SimplexCategory} (f : X ⟶ Y) (g : Y ⟶ Z),
{ left := SSet.stdSimplex.map (CategoryTheory.CategoryStruct.comp f g),
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x... | null | false |
SignType.instHasDistribNeg | Mathlib.Basic.Sign.Defs | HasDistribNeg SignType | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {n s : ℕ}, n + 1 ≤ (List.findIdxs p [] s).length → n < (List.findIdxs p [] s).length | null | false |
Finpartition.mk_mem_sparsePairs._simp_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
(P : Finpartition A) (G : SimpleGraph α) [inst_3 : DecidableRel G.Adj] (u v : Finset α) (ε : 𝕜),
((u, v) ∈ P.sparsePairs G ε) = (u ∈ P.parts ∧ v ∈ P.parts ∧ u ≠ v ∧ ↑(G.edgeDensity u v) < ε) | null | false |
ConjAct.unitsSMulCommClass' | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (α : Type u_1) {M : Type u_2} [inst : Monoid M] [inst_1 : SMul α M] [SMulCommClass M α M] [IsScalarTower α M M],
SMulCommClass (ConjAct Mˣ) α M | null | true |
FractionRing.instNontrivial | Mathlib.RingTheory.Localization.FractionRing | ∀ (R : Type u_1) [inst : CommRing R] [Nontrivial R], Nontrivial (FractionRing R) | null | true |
CategoryTheory.CostructuredArrow.essentiallySmall | Mathlib.CategoryTheory.Comma.StructuredArrow.Small | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [CategoryTheory.EssentiallySmall.{w, v₁, u₁} C]
[CategoryTheory.LocallySmall.{w, v₂, u₂} D],
CategoryTheory.EssentiallySmall.{w, v₁, max u₁ v₂} (Category... | null | true |
Complex.liftAux | Mathlib.LinearAlgebra.Complex.Module | {A : Type u_1} → [inst : Ring A] → [inst_1 : Algebra ℝ A] → (I' : A) → I' * I' = -1 → ℂ →ₐ[ℝ] A | There is an `AlgHom` from `ℂ` to any `ℝ`-algebra with an element that squares to `-1`.
See `Complex.lift` for this as an equiv. | true |
AddSubmonoid.toAddMonoid | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_5} → [inst : AddMonoid M] → (S : AddSubmonoid M) → AddMonoid ↥S | An `AddSubmonoid` of an `AddMonoid` inherits an `AddMonoid` structure. | true |
TopModuleCat.mk._flat_ctor | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | {R : Type u} →
[inst : Ring R] →
[inst_1 : TopologicalSpace R] →
(carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
[topologicalSpace : TopologicalSpace carrier] →
[isTopologicalAddGroup : IsTopologicalAddGroup carrier] ... | null | false |
quadraticChar._proof_1 | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ (F : Type u_1) [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (a : F),
¬IsUnit a → quadraticCharFun F a = 0 | null | false |
CategoryTheory.Limits.Types.instHasColimitConstPUnitFunctor | Mathlib.CategoryTheory.Limits.IsConnected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsConnected C],
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.Types.constPUnitFunctor C) | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Module.Defs.0.CStarModule.inner_zero_right._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [inst_10 : StarModule ℂ A] {x y : E},
inner A x y = (CSt... | null | false |
Set.prod_image_right | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → γ) (s : Set α) (t : Set β),
t ×ˢ (f '' s) = (fun x => (x.1, f x.2)) '' t ×ˢ s | null | true |
Int64.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | ∀ (n : BitVec 64), Int64.minValue.toInt ≤ n.toInt | null | false |
_private.Mathlib.Topology.Instances.Matrix.0.Continuous.matrix_blockDiagonal.match_1_1 | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_1} {p : Type u_2} (motive : n × p → Prop) (x : n × p), (∀ (j₁ : n) (_j₂ : p), motive (j₁, _j₂)) → motive x | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs._proof_1 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool}, i < (List.filter p xs).length → i < (List.findIdxs p xs).length | null | false |
Finset.Nat.prod_antidiagonal_eq_prod_range_succ | Mathlib.Algebra.BigOperators.NatAntidiagonal | ∀ {M : Type u_2} [inst : CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ),
∏ ij ∈ Finset.HasAntidiagonal.antidiagonal n, f ij.1 ij.2 = ∏ k ∈ Finset.range n.succ, f k (n - k) | This lemma matches more generally than `Finset.Nat.prod_antidiagonal_eq_prod_range_succ_mk` when
using `rw ← `. | true |
classifyingSpaceUniversalCover.compForgetAugmented.toModule.eq_1 | Mathlib.RepresentationTheory.Homological.Resolution | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Monoid G],
classifyingSpaceUniversalCover.compForgetAugmented.toModule k G =
((CategoryTheory.SimplicialObject.Augmented.whiskering (Type u) (ModuleCat k)).obj
(ModuleCat.monoidAlgebraFree k)).obj
(classifyingSpaceUniversalCover.compForgetAugmented G) | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.invariantCardinalRank_of_finitary.match_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u_1} ⦃B B' : Set α⦄ ⦃N : Matroid α⦄ (U : Set α)
(motive : (∃ e ∈ B' \ (B ∩ B' ∪ U), N.Indep (insert e (B ∩ B' ∪ U))) → Prop)
(x : ∃ e ∈ B' \ (B ∩ B' ∪ U), N.Indep (insert e (B ∩ B' ∪ U))),
(∀ (a : α) (ha : a ∈ B' \ (B ∩ B' ∪ U)) (ind : N.Indep (insert a (B ∩ B' ∪ U))), motive ⋯) → motive x | null | false |
intervalIntegral.integrableOn_deriv_of_nonneg | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {g' g : ℝ → ℝ} {a b : ℝ},
ContinuousOn g (Set.Icc a b) →
(∀ x ∈ Set.Ioo a b, HasDerivAt g (g' x) x) →
(∀ x ∈ Set.Ioo a b, 0 ≤ g' x) → MeasureTheory.IntegrableOn g' (Set.Ioc a b) MeasureTheory.volume | When the derivative of a function is nonnegative, then it is automatically integrable,
Ioc version. | true |
_private.Mathlib.CategoryTheory.Presentable.SharplyLT.Basic.0.Cardinal.SharplyLT.IsCardinalFilteredAndHasCardinalLT.pair._proof_1 | Mathlib.CategoryTheory.Presentable.SharplyLT.Basic | ∀ (κ₁ κ₂ : Cardinal.{u_1}) [inst : Fact κ₁.IsRegular] [Fact κ₂.IsRegular] {J : Type u_1} [inst_2 : PartialOrder J]
{j j' : J}, j ≤ j' → CategoryTheory.IsCardinalFiltered (↑{j, j'}) κ₁ ∧ HasCardinalLT (↑{j, j'}) κ₂ | null | false |
CategoryTheory.CommMon.mkIso | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{M N : CategoryTheory.CommMon C} →
(e : M.X ≅ N.X) →
autoParam (CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.on... | Construct an isomorphism of commutative monoid objects by giving an isomorphism between the
underlying objects and checking compatibility with unit and multiplication only in the forward
direction. | true |
_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.addEqStep.updateRoots.match_1 | Lean.Meta.Tactic.Grind.Core | (__do_lift : Lean.Meta.Grind.Goal) →
(motive : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap) → Sort u_1) →
(x : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap)) →
((e : Lean.Expr) → motive (some { e := e })) →
((x : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap)) → motive x) → moti... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Rank.0.Matrix.rank_mul_ge._proof_1_9 | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_1} [inst : Fintype n] [inst_1 : Fintype o]
[inst_2 : CommRing R] (A : Matrix m n R) (B : Matrix n o R),
Module.finrank R ↥(A.mulVecLin ∘ₗ B.mulVecLin).ker ≤
Module.finrank R ↥A.mulVecLin.ker + Module.finrank R ↥B.mulVecLin.ker →
Module.finrank R ↥... | null | false |
CategoryTheory.PreOneHypercover.sieve₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
{i₁ i₂ : E.I₀} → {W : C} → (W ⟶ E.X i₁) → (W ⟶ E.X i₂) → CategoryTheory.Sieve W | Given an object `W` equipped with morphisms `p₁ : W ⟶ E.X i₁`, `p₂ : W ⟶ E.X i₂`,
this is the sieve of `W` which consists of morphisms `g : Z ⟶ W` such that there exists `j`
and `h : Z ⟶ E.Y j` such that `g ≫ p₁ = h ≫ E.p₁ j` and `g ≫ p₂ = h ≫ E.p₂ j`.
See lemmas `sieve₁_eq_pullback_sieve₁'` and `sieve₁'_eq_sieve₁` for... | true |
LowerSet.coe_iSup | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → LowerSet α), ↑(⨆ i, f i) = ⋃ i, ↑(f i) | null | true |
_private.Mathlib.Algebra.Group.Opposite.0.MulOpposite.semiconjBy_op._simp_1_2 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} {x y : α}, (MulOpposite.op x = MulOpposite.op y) = (x = y) | null | false |
Int8._sizeOf_1 | Init.Data.SInt.Basic | Int8 → ℕ | null | false |
_private.Mathlib.Algebra.Order.Group.MinMax.0.max_sub_max_le_max._proof_1_1 | Mathlib.Algebra.Order.Group.MinMax | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c d : α),
max a b - max c d ≤ max (a - c) (b - d) | null | false |
Aesop.Safety.safe.elim | Aesop.Rule | {motive : Aesop.Safety → Sort u} → (t : Aesop.Safety) → t.ctorIdx = 0 → motive Aesop.Safety.safe → motive t | null | false |
tendsto_integral_mul_one_add_inv_smul_sq_pow | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSqIntegral | ∀ {E : Type u_1} [inst : TopologicalSpace E] [inst_1 : MeasurableSpace E] [BorelSpace E] {P : MeasureTheory.Measure E}
[MeasureTheory.IsFiniteMeasure P] {ε : ℝ} (g : BoundedContinuousFunction E ℝ),
0 < ε →
Filter.Tendsto (fun n => ∫ (x : E), (g * (1 + (↑n)⁻¹ • -(ε • g * g)) ^ n) x ∂P) Filter.atTop
(nhds (... | The integral of `mulExpNegMulSq ε ∘ g` with respect to a finite measure `P` can be
approximated by the integral of the sequence approximating the exponential function. | true |
Nat._aux_Mathlib_Data_Nat_Totient___macroRules_Nat_termφ_1 | Mathlib.Data.Nat.Totient | Lean.Macro | null | false |
Std.ExtDHashMap.size_add_size_eq_size_union_add_size_inter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.size + m₂.size = (m₁ ∪ m₂).size + (m₁ ∩ m₂).size | null | true |
CategoryTheory.Endofunctor.Algebra.Initial.left_inv | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A : CategoryTheory.Endofunctor.Algebra F} (h : CategoryTheory.Limits.IsInitial A),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Endofunctor.Algebra.Initial.strInv h) A.str =
CategoryTheory.CategoryStruct.id A.a | null | true |
Lean.PrettyPrinter.Delaborator.annotateTermInfo | Lean.PrettyPrinter.Delaborator.Basic | Lean.Term → Lean.PrettyPrinter.Delaborator.Delab | Annotates the term with the current expression position and registers `TermInfo`
to associate the term to the current expression.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.takeUntil_eq_take._proof_1_12 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {w : V} [inst : DecidableEq V] {u_1 v_1 w_1 : V} (hadj : G.Adj u_1 v_1)
(p : G.Walk v_1 w_1),
w ∈ (SimpleGraph.Walk.cons hadj p).support →
G.Walk u_1 ((SimpleGraph.Walk.cons hadj p).getVert (List.idxOf w (SimpleGraph.Walk.cons hadj p).support)) =
G.Walk u_1 w | null | false |
Isometry.euclideanHausdorffMeasure_preimage | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ {X : Type u_1} {Y : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X]
[inst_3 : EMetricSpace Y] [inst_4 : MeasurableSpace Y] [inst_5 : BorelSpace Y] {f : X → Y} {d : ℕ},
Isometry f →
∀ (s : Set Y),
(MeasureTheory.Measure.euclideanHausdorffMeasure d) (f ⁻¹' s) =
... | null | true |
Lean.Omega.Constraint.combo | Init.Omega.Constraint | ℤ → Lean.Omega.Constraint → ℤ → Lean.Omega.Constraint → Lean.Omega.Constraint | A linear combination of two constraints. | true |
Nat.bitwise_eq_binaryRec | Mathlib.Data.Nat.Bitwise | ∀ (f : Bool → Bool → Bool),
Nat.bitwise f = fun n =>
Nat.binaryRec (motive := fun x => ℕ → ℕ) (fun n => bif f false true then n else 0)
(fun a m Ia n => Nat.binaryRec (bif f true false then Nat.bit a m else 0) (fun b n x => Nat.bit (f a b) (Ia n)) n)
n | null | true |
Int.abs_modEq_two | Mathlib.Data.Int.ModEq | ∀ {a : ℤ}, |a| ≡ a [ZMOD 2] | null | true |
Mathlib.Tactic.Echelon.DecompositionCert.mul_eq | Mathlib.Tactic.Echelon.Cert | {u : Lean.Level} →
{m n : ℕ} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{A : Q(Matrix (Fin «$m») (Fin «$n») «$α»)} →
(self : Mathlib.Tactic.Echelon.DecompositionCert rα A) →
let a := self.U.matrix;
let a_1 := self.L.matrix;
Q(unknown_1 * «$A».submatri... | The product equation. | true |
SSet.horn₃₂.ι₁_desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | ∀ {X : SSet} (f₀ f₁ f₃ : SSet.stdSimplex.obj { len := 2 } ⟶ X)
(h₀₂ :
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₁ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₃)
(h₁₂ :
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp... | null | true |
Ordnode.All.imp | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {P Q : α → Prop}, (∀ (a : α), P a → Q a) → ∀ {t : Ordnode α}, Ordnode.All P t → Ordnode.All Q t | null | true |
AddMonoidHom.coe_finset_sum | Mathlib.Algebra.BigOperators.Group.Finset.Lemmas | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (f : ι → M →+ N)
(s : Finset ι), ⇑(∑ x ∈ s, f x) = ∑ x ∈ s, ⇑(f x) | **Alias** of `AddMonoidHom.coe_finsetSum`. | true |
groupHomology.indIso._proof_9 | Mathlib.RepresentationTheory.Homological.GroupHomology.Shapiro | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G),
(Rep.resFunctor S.subtype).PreservesZeroMorphisms | null | false |
Pi.instAddTorsor._proof_3 | Mathlib.Algebra.Torsor.Basic | ∀ {I : Type u_1} {fg : I → Type u_2} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type u_3}
[inst_1 : (i : I) → AddTorsor (fg i) (fp i)] (g : (i : I) → fg i) (p : (i : I) → fp i),
(fun i => (g +ᵥ p) i -ᵥ p i) = g | null | false |
_private.Mathlib.NumberTheory.FrobeniusNumber.0.Nat.exists_mem_span_nat_finset_of_ge._simp_1_9 | Mathlib.NumberTheory.FrobeniusNumber | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c | null | false |
IntermediateField.isAlgebraic_adjoin_simple | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L] {x : L},
IsIntegral K x → Algebra.IsAlgebraic K ↥K⟮x⟯ | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.instRxiHasSize | Init.Data.Range.Polymorphic.SInt | {α : Type u} →
[inst : LE α] →
[inst_1 : LT α] →
{β : Type v} →
[inst_2 : LE β] →
[inst_3 : LT β] →
[inst_4 : Std.PRange.UpwardEnumerable β] →
[inst_5 : Std.PRange.LawfulUpwardEnumerable β] →
[inst_6 : Std.PRange.LawfulUpwardEnumerableLE β] →
... | null | true |
Holor.instAddMonoid._proof_6 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : AddMonoid α],
autoParam (∀ (x : Holor α ds), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
AddChar.compAddMonoidHom_injective_left | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(f : A →+ B), Function.Surjective ⇑f → Function.Injective fun ψ => ψ.compAddMonoidHom f | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.structInstFieldEqns._regBuiltin.Lean.Parser.Term.structInstFieldEqns.parenthesizer_9 | Lean.Parser.Term | IO Unit | null | false |
ContinuousLinearEquiv.toNonlinearRightInverse._proof_1 | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_4} {𝕜' : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜'] {σ : 𝕜 →+* 𝕜'}
{E : Type u_1} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {F : Type u_2}
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜' F] {σ' : 𝕜' →+* 𝕜} [inst_6 : RingHomInv... | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.finish | Lean.Elab.Tactic.RCases | optParam (Array (Lean.Ident × Lean.FVarId)) #[] →
Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → Array Lean.MVarId → Lean.Elab.TermElabM (Array Lean.MVarId) | The terminating continuation used in `rcasesCore` and `rcasesContinue`. We specialize the type
`α` to `Array MVarId` to collect the list of goals, and given the list of `clears`, it attempts to
clear them from the goal and adds the goal to the list.
| true |
CategoryTheory.DifferentialObject.d_squared_apply | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_1} [inst : AddCommGroup β] {b : β} {V : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V]
(X : CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V)) {x : β},
CategoryTheory.CategoryStruct.comp (X.d x) (X.d ((fun b_... | null | true |
Bornology.isVonNBounded_pi_iff | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_6} {ι : Type u_7} {E : ι → Type u_8} [inst : NormedDivisionRing 𝕜] [inst_1 : (i : ι) → AddCommGroup (E i)]
[inst_2 : (i : ι) → Module 𝕜 (E i)] [inst_3 : (i : ι) → TopologicalSpace (E i)] {S : Set ((i : ι) → E i)},
Bornology.IsVonNBounded 𝕜 S ↔ ∀ (i : ι), Bornology.IsVonNBounded 𝕜 (Function.eval i... | null | true |
CategoryTheory.Functor.FullyFaithful.unop | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} → F.FullyFaithful → F.unop.FullyFaithful | A functor is fully faithful when its opposite is fully faithful. | true |
Submonoid.commMonoidTopologicalClosure | Mathlib.Topology.Algebra.Monoid | {M : Type u_3} →
[inst : TopologicalSpace M] →
[inst_1 : Monoid M] →
[inst_2 : SeparatelyContinuousMul M] →
[T2Space M] → (s : Submonoid M) → (∀ (x y : ↥s), x * y = y * x) → CommMonoid ↥s.topologicalClosure | If a submonoid of a topological monoid is commutative, then so is its topological closure. | true |
Lean.Compiler.LCNF.DeclValue.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive : Lean.Compiler.LCNF.DeclValue pu → Sort u} → ℕ → Sort (max 1 u) | null | false |
ProbabilityTheory.IsGaussian.integrable_fun_id | Mathlib.Probability.Distributions.Gaussian.Fernique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{μ : MeasureTheory.Measure E} [ProbabilityTheory.IsGaussian μ] [CompleteSpace E] [SecondCountableTopology E],
MeasureTheory.Integrable (fun x => x) μ | Eta-expanded form of `ProbabilityTheory.IsGaussian.integrable_id` | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxs_eq_nil_iff._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {s : ℕ}, List.findIdxs p [] s = [] ↔ ∀ x ∈ [], p x = false | null | false |
Inclusion.IntervalDyadicReal.abs_mem._inclusionExt_1 | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | Inclusion.InclusionExt | null | false |
MeasureTheory.Measure.instCompleteLattice._proof_2 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} ⦃f : ℕ → Set α⦄,
(∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Function.onFun Disjoint f) → ⊤ (⋃ i, f i) = ∑' (i : ℕ), ⊤ (f i) | null | false |
Lean.Elab.Command.elabSyntax | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Command.CommandElabM Lean.Name | Elaborates the given `syntax` command and returns the new node kind. | true |
_private.Mathlib.Topology.EMetricSpace.Weak.0.Option.edist_self'.match_1_1 | Mathlib.Topology.EMetricSpace.Weak | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(∀ (val : α), motive (some val)) → (∀ (_ : Unit), motive none) → motive x | null | false |
IsPGroup.orderOf_coprime | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], IsPGroup p G → ∀ {n : ℕ}, p.Coprime n → ∀ (g : G), (orderOf g).Coprime n | null | true |
Finset.notMem_subset | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s | **Alias** of `Finset.notMem_mono`. | true |
Complex.IsConservativeOn.isExactOn_ball | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {c : ℂ} {r : ℝ} {f : ℂ → E} [CompleteSpace E],
ContinuousOn f (Metric.ball c r) →
Complex.IsConservativeOn f (Metric.ball c r) → Complex.IsExactOn f (Metric.ball c r) | **Morera's theorem for a disk** On a disk, a continuous function whose integrals on rectangles
vanish, has primitives. | true |
Representation.asAlgebraHom._proof_1 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {V : Type u_2} [inst : CommSemiring k] [inst_1 : AddCommMonoid V] [inst_2 : Module k V],
SMulCommClass k k V | null | false |
neg_dotProduct_neg | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocRing α] (v w : m → α), -v ⬝ᵥ -w = v ⬝ᵥ w | null | true |
CommRingCat.isLimitForkPushoutSelfOfFaithfullyFlat._proof_11 | Mathlib.Algebra.Category.Ring.EqualizerPushout | ∀ {R S : CommRingCat} (f : R ⟶ S),
CategoryTheory.Limits.pushout.inl (CommRingCat.ofHom (algebraMap ↑R ↑S)) (CommRingCat.ofHom (algebraMap ↑R ↑S)) =
CategoryTheory.CategoryStruct.comp (CommRingCat.pushoutCocone ↑R ↑S ↑S).inl ⋯.isoPushout.hom | null | false |
Topology.CWComplex.mkFiniteType_cell | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i)) (Me... | null | true |
Fintype.balance_zero | Mathlib.Algebra.BigOperators.Balance | ∀ {ι : Type u_1} {G : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup G] [inst_2 : Module ℚ≥0 G],
Fintype.balance 0 = 0 | null | true |
eq_mul_inv_of_mul_eq | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a * c = b → a = b * c⁻¹ | null | true |
Sum.not_inl_lt_inr | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a : α} {b : β}, ¬Sum.inl b < Sum.inr a | null | true |
IsLocalization.localizationLocalizationSubmodule.eq_1 | Mathlib.RingTheory.Localization.LocalizationLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] (N : Submonoid S),
IsLocalization.localizationLocalizationSubmodule M N =
Submonoid.comap (algebraMap R S) (N ⊔ Submonoid.map (algebraMap R S) M) | null | true |
Set.diff_subset_diff_left | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s₁ s₂ t : Set α}, s₁ ⊆ s₂ → s₁ \ t ⊆ s₂ \ t | **Alias** of `Set.sdiff_subset_sdiff_left`. | true |
_private.Mathlib.Topology.ContinuousMap.Units.0.ContinuousMap.spectrum_eq_preimage_range._simp_1_1 | Mathlib.Topology.ContinuousMap.Units | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
(r ∈ spectrum R a) = ¬IsUnit ((algebraMap R A) r - a) | null | false |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_expand_left._proof_1_1 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R],
∀ t₁ ∈ Set.Icc 0 1, ∀ (t₂ : R), t₁ * t₂ ≤ 1 - t₁ + t₁ * t₂ | null | false |
Lean.IR.LogEntry.instToFormat | Lean.Compiler.IR.CompilerM | Std.ToFormat Lean.IR.LogEntry | null | true |
Lean.Lsp.TextEditBatch | Lean.Data.Lsp.Basic | Type | An array of `TextEdit`s to be performed in sequence. | true |
CategoryTheory.Coreflective.mk | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
[toFull : L.Full] →
[toFaithful : L.Faithful] → (R : CategoryTheory.Functor D C) → (L ⊣ R) → CategoryTheory.Coreflect... | null | true |
MeasureTheory.lintegral_strict_mono_of_ae_le_of_frequently_ae_lt | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
AEMeasurable g μ →
∫⁻ (x : α), f x ∂μ ≠ ⊤ → f ≤ᵐ[μ] g → (∃ᵐ (x : α) ∂μ, f x ≠ g x) → ∫⁻ (x : α), f x ∂μ < ∫⁻ (x : α), g x ∂μ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.