name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_3 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), Module.Finite ℝ (WithLp 2 (Fin d → ℝ)) | null | false |
Asymptotics.SuperpolynomialDecay.add | Mathlib.Analysis.Asymptotics.SuperpolynomialDecay | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f g : α → β} [inst : TopologicalSpace β] [inst_1 : CommSemiring β]
[ContinuousAdd β],
Asymptotics.SuperpolynomialDecay l k f →
Asymptotics.SuperpolynomialDecay l k g → Asymptotics.SuperpolynomialDecay l k (f + g) | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letMVar._regBuiltin.Lean.Parser.Term.letMVar_1 | Lean.Parser.Term | IO Unit | null | false |
Subgroup.quotientiInfSubgroupOfEmbedding._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (i : ι), iInf f ≤ f i | null | false |
_private.Init.Data.Order.Lemmas.0.Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax._simp_1 | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : Max α] [inst_1 : LE α] [Std.LawfulOrderSup α] {a b c : α}, (a ⊔ b ≤ c) = (a ≤ c ∧ b ≤ c) | null | false |
LinearMap.BilinForm.baseChange_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₂] [inst_3 : Algebra R A] [inst_4 : Module R M₂] [FaithfulSMul R A]
(B : LinearMap.BilinForm R M₂), (LinearMap.BilinForm.baseChange A B = 0) = (B = 0) | null | false |
le_mul_of_one_le_left' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : LE α] [MulRightMono α], 1 ≤ b → a ≤ b * a | null | true |
Std.LawfulEqOrd.compare_eq_iff_eq._simp_1 | Init.Data.Order.Ord | ∀ {α : Type u} [inst : Ord α] [Std.LawfulEqOrd α] {a b : α}, (compare a b = Ordering.eq) = (a = b) | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.IsCut.congr.match_1_1 | Batteries.Recycling.RBTree.Lemmas | ∀ (motive : Ordering.eq = Ordering.lt → Prop) (x : Ordering.eq = Ordering.lt), motive x | null | false |
Std.HashSet.Raw.WF.casesOn | Std.Data.HashSet.Raw | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{m : Std.HashSet.Raw α} → {motive : m.WF → Sort u_1} → (t : m.WF) → ((out : m.inner.WF) → motive ⋯) → motive t | null | false |
Configuration.HasPoints.lineCount_eq_pointCount | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasPoints P L] [inst_2 : Fintype P]
[inst_3 : Fintype L],
Fintype.card P = Fintype.card L →
∀ {p : P} {l : L}, p ∉ l → Configuration.lineCount L p = Configuration.pointCount P l | null | true |
Set.FiniteExhaustion._sizeOf_inst | Mathlib.Data.Set.FiniteExhaustion | {α : Type u_1} → (s : Set α) → [SizeOf α] → [(a : α) → SizeOf (s a)] → SizeOf s.FiniteExhaustion | null | false |
_private.Std.Data.TreeSet.Lemmas.0.Std.TreeSet.contains_toArray._simp_1_1 | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp}, t.toArray = t.toList.toArray | null | false |
IntermediateField.induction_on_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E]
{motive : IntermediateField F E → Prop},
motive ⊥ →
(∀ (K : IntermediateField F E) (x : E), motive K → motive (IntermediateField.restrictScalars F (↥K)⟮x⟯)) →
∀ (K : IntermediateField F E), m... | null | true |
Lean.Sym.UInt16.lt_eq_true | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = true → (a < b) = True | null | true |
Std.HashMap.Raw.getKey_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α} (h' : k ∈ m), m.getKey k h' = k | null | true |
AlgebraicGeometry.Scheme.basicOpen_restrict | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {V U : X.Opens} (i : V ⟶ U) (f : ↑(X.presheaf.obj (Opposite.op U))),
X.basicOpen (TopCat.Presheaf.restrict f i) ≤ X.basicOpen f | null | true |
String.eq_append_of_dropPrefix?_prop_eq_some | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String} {res : String.Slice},
s.dropPrefix? P = some res → ∃ c, s = String.singleton c ++ res.copy ∧ P c | null | true |
CategoryTheory.Pretriangulated.instHasFiniteCoproducts | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.Limits.H... | null | true |
QuadraticAlgebra.trace_omega | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommRing R], QuadraticAlgebra.trace QuadraticAlgebra.omega = b | null | true |
Std.DTreeMap.Const.getKey?_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Const.insertMany t l).getKey? k' = some k | null | true |
ProbabilityTheory.complexMGF_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (z : ℂ),
ProbabilityTheory.complexMGF id (ProbabilityTheory.gaussianReal μ v) z = Complex.exp (z * ↑μ + ↑↑v * z ^ 2 / 2) | The complex moment-generating function of a Gaussian distribution with mean `μ` and variance `v`
is given by `z ↦ exp (z * μ + v * z ^ 2 / 2)`. | true |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a : ℝ} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ]
[CompleteSpace E] [intervalIntegral.FTCFilter a l l'],
StronglyMeasurableAtFil... | **Fundamental theorem of calculus-1**, local version for any measure.
Let filters `l` and `l'` be related by `[intervalIntegral.FTCFilter a l l']`; let `μ` be a locally
finite measure. If `f` has a finite limit `c` at `l' ⊓ ae μ`, then
`∫ x in u..v, f x ∂μ = μ (Ioc u v) • c + o(μ(Ioc u v))` as both `u` and `v` tend t... | true |
CategoryTheory.LocalizerMorphism.inv_functor | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂)
[inst_2 : Φ.functor.IsEquivalence] [inst_3 : Φ.IsInduced] [in... | null | true |
TopCat.Presheaf.EtaleSpace.homeomorph._proof_5 | Mathlib.Topology.Sheaves.EtaleSpace | ∀ {X : TopCat} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {CC : C → Type u_1} {FC : C → C → Type u_3}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.Limits.HasColimits C] {F : TopCat.Presheaf C X} (U : TopologicalSpace... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isValidRevSearchFrom_iff_isValidRevSearchFrom_beq._simp_1_3 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice}
{l : List (String.Slice.Pattern.SearchStep s)} {startPos endPos : s.Pos},
startPos < endPos →
(∀ (pos : s.Pos), startPos < pos → pos ≤ endPos → ¬String.Slice.Pattern.Model.RevMatchesAt pat pos) →
String.Slice.Pa... | null | false |
Matroid.freeOn.eq_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (E : Set α), Matroid.freeOn E = (Matroid.loopyOn E)✶ | null | true |
Ring.instAddCommMonoidDirectLimit._aux_1 | Mathlib.Algebra.Colimit.Ring | {ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → CommRing (G i)] →
(f : (i j : ι) → i ≤ j → G i → G j) → Ring.DirectLimit G f → Ring.DirectLimit G f → Ring.DirectLimit G f | null | false |
PSigma.Lex.preorder._proof_4 | Mathlib.Order.PSigma | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : Preorder ι] [inst_1 : (i : ι) → Preorder (α i)] (a b : Σₗ' (i : ι), α i),
a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceLog2.declare_29._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.1090884023._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
«command#long_names_» | Mathlib.Util.LongNames | Lean.ParserDescr | Lists all declarations with a long name, gathered according to the module they are defined in.
Use as `#long_names` or `#long_names 100` to specify the length.
| true |
OrderedFinpartition.eraseMiddle._proof_11 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) ≠ {0}) (i j : Fin c.length),
i < j →
(fun m =>
if h : m = c.index 0 then
(c.emb m
(Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩.succ)).pred
⋯
... | null | false |
Sub.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Sub α} → {α' : Type u} → {t' : Sub α'} → α = α' → t ≍ t' → Sub.noConfusionType P t t' | null | false |
BooleanAlgebra.recOn | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} →
{motive : BooleanAlgebra α → Sort u_1} →
(t : BooleanAlgebra α) →
([toDistribLattice : DistribLattice α] →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
[toTop : Top α] →
[toBot : Bot α] →
... | null | false |
RingHom.liftOfRightInverse_comp | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (g : { g // RingHom.ker f ≤ RingHom.ker g }),
((f.liftOfRightInverse f_inv hf) g).comp f = ↑g | null | true |
LinearMap.extendScalarsOfIsLocalizationEquiv._proof_8 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
{N : Type u_2} [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [IsScalarTower R A M]
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : Module A N] [IsScalarTower R ... | null | false |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae.match_1_1 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {α : Type} [inst : Finite α] {B : CompHaus} (X : α → CompHaus) (π : (a : α) → X a ⟶ B)
(motive : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π) → Prop)
(x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)),
(∀ (x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)), motive x) → motive x | null | false |
CategoryTheory.instIsIsoComp | Mathlib.CategoryTheory.IsoCat | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsIso] [G.IsIso], (F.comp G).IsIso | null | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (M : Matroid α), M.3 ∅ = True | null | false |
CategoryTheory.shrinkYonedaMonObjObjEquiv._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.ShrinkYoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] {M : CategoryTheory.Mon C} {Y : Cᵒᵖ},
Small.{u_1, u_2} ↑((CategoryTheory.yonedaMon.obj M).obj Y) | null | false |
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.σ_comp_P_eq_zero._simp_1_5 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
IsZGroup.isCyclic_commutator | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ (G : Type u_1) [inst : Group G] [Finite G] [IsZGroup G], IsCyclic ↥(commutator G) | A finite Z-group has cyclic commutator subgroup. | true |
CategoryTheory.Limits.limit.isLimit | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.cone F) | Evidence that the arbitrary choice of cone provided by `limit.cone F` is a limit cone. | true |
LinearMap.compMultilinearMap_add | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃]
[inst_4 : (i : ι) → Module R (M₁ i)] [inst_5 : Module R M₂] [inst_6 : Module R M₃] (g : M₂ →ₗ[R] M₃)
(f₁ f₂ : Multili... | null | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIio.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (a_1 : ↑(Set.Iio a)) (motive : (∃ b, b < ↑a_1) → Prop) (x : ∃ b, b < ↑a_1),
(∀ (b : α) (hb : b < ↑a_1), motive ⋯) → motive x | null | false |
BitVec.ushiftRight_and_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x &&& y) >>> n = x >>> n &&& y >>> n | null | true |
ENNReal.toReal_eq_toReal_iff' | Mathlib.Basic.ENNReal.Basic | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → (x.toReal = y.toReal ↔ x = y) | null | true |
List.zipWithM.loop | Init.Data.List.Control | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → Array γ → m (List γ) | null | true |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegrable_sub_inv_iff._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
GradedRing.projZeroRingHom'_surjective | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [inst_4 : CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜], Function.Surjective ⇑(GradedRing.projZero... | The ring homomorphism `GradedRing.projZeroRingHom' 𝒜` is surjective. | true |
Int.Internal.Linear.Expr.brecOn | Init.Data.Int.Linear | {motive : Int.Internal.Linear.Expr → Sort u} →
(t : Int.Internal.Linear.Expr) →
((t : Int.Internal.Linear.Expr) → Int.Internal.Linear.Expr.below t → motive t) → motive t | null | false |
factorPowSucc.isUnit_of_isUnit_image | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_3} [inst : CommRing R] {I : Ideal R} {n : ℕ},
n > 0 → ∀ {a : R ⧸ I ^ (n + 1)}, IsUnit ((Ideal.Quotient.factorPow I ⋯) a) → IsUnit a | null | true |
Filter.tendstoIxxClass_principal | Mathlib.Order.Filter.Interval | ∀ {α : Type u_1} {s t : Set α} {Ixx : α → α → Set α},
Filter.TendstoIxxClass Ixx (Filter.principal s) (Filter.principal t) ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t | null | true |
optParam | Init.Prelude | (α : Sort u) → α → Sort u | Gadget for optional parameter support.
A binder like `(x : α := default)` in a declaration is syntax sugar for
`x : optParam α default`, and triggers the elaborator to attempt to use
`default` to supply the argument if it is not supplied.
| true |
WithTop.LE.rec | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {motive : (a a_1 : WithTop α) → a.LE a_1 → Prop},
(∀ (x : WithTop α), motive x ⊤ ⋯) →
(∀ {a b : α} (a_1 : a ≤ b), motive ↑a ↑b ⋯) → ∀ {a a_1 : WithTop α} (t : a.LE a_1), motive a a_1 t | null | false |
Std.Slice.Internal.SubarrayData.stop_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u} (self : Std.Slice.Internal.SubarrayData α), self.stop ≤ self.array.size | The stopping index is no later than the end of the array.
The ending index is exclusive. If it is equal to the size of the array, then the last element of
the array is in the subarray.
| true |
analyticOrderAt_eq_nat_iff_iteratedDeriv_eq_zero | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CharZero 𝕜] [CompleteSpace E] {z₀ : 𝕜} {f : 𝕜 → E},
AnalyticAt 𝕜 f z₀ →
∀ {n : ℕ}, analyticOrderAt f z₀ = ↑n ↔ (∀ k < n, iteratedDeriv k f z₀ = 0) ∧ iteratedDeriv n f z₀ ≠ 0 | An analytic function `f` has finite analytic order `n` at `z₀` if and only if its first
`n` iterated derivatives (including `f` itself) vanish at `z₀` and the `n`-th iterated derivative is
non-zero. | true |
CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms | Mathlib.CategoryTheory.Sites.Localization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_2) [inst_1 : CategoryTheory.Category.{v_2, u_2} A] [inst_2 : CategoryTheory.HasWeakSheafify J A],
J.W =
(CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage
... | null | true |
_private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv._simp_1_8 | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
OrthogonalIdempotents.mul_sum_of_mem | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} {e : I → R},
OrthogonalIdempotents e → ∀ {i : I} {s : Finset I}, i ∈ s → e i * ∑ j ∈ s, e j = e i | null | true |
CategoryTheory.Enriched.HasConicalLimitsOfSize.hasConicalLimitsOfShape._autoParam | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | Lean.Syntax | null | false |
Mathlib.Tactic.BicategoryLike.NormalExpr.nodesAux | Mathlib.Tactic.Widget.StringDiagram | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
ℕ →
Mathlib.Tactic.BicategoryLike.NormalExpr →
Mathlib.Tactic.BicategoryLike.CoherenceM ρ (List (List Mathlib.Tactic.Widget.StringDiagram.Node)) | The list of nodes at the top of a string diagram. The position is counted from the
specified natural number. | true |
Mathlib.Tactic.GCongr.GCongrKey.recOn | Mathlib.Tactic.GCongr.Core | {motive : Mathlib.Tactic.GCongr.GCongrKey → Sort u} →
(t : Mathlib.Tactic.GCongr.GCongrKey) →
((relName head : Lean.Name) → (arity : ℕ) → motive { relName := relName, head := head, arity := arity }) → motive t | null | false |
ImportGraph.Shake.instUnionNeeds | ImportGraph.Shake.Core | Union ImportGraph.Shake.Needs | null | true |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getNumParams | Lean.Meta.RecursorInfo | Array Lean.Expr → Lean.Expr → ℕ → ℕ | Compute number of parameters for (user-defined) recursor.
We assume a parameter is anything that occurs before the motive | true |
CategoryTheory.Arrow.equivSigma | Mathlib.CategoryTheory.Comma.Arrow | (T : Type u) → [inst : CategoryTheory.Category.{v, u} T] → CategoryTheory.Arrow T ≃ (X : T) × (Y : T) × (X ⟶ Y) | `Arrow T` is equivalent to a sigma type. | true |
AlgebraNorm.mk.inj | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} {inst : SeminormedCommRing R} {S : Type u_2} {inst_1 : Ring S} {inst_2 : Algebra R S}
{toRingNorm : RingNorm S} {smul' : ∀ (a : R) (x : S), toRingNorm.toFun (a • x) = ‖a‖ * toRingNorm.toFun x}
{toRingNorm_1 : RingNorm S} {smul'_1 : ∀ (a : R) (x : S), toRingNorm_1.toFun (a • x) = ‖a‖ * toRingNorm_1.... | null | true |
Algebra.Presentation.instCommRingCore._aux_36 | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → {P : Algebra.Presentation R S ι σ} → ℤ → P.Core → P.Core | null | false |
ContinuousAlternatingMap.curryLeft_add | Mathlib.Analysis.Normed.Module.Alternating.Curry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f g : E [⋀^Fin (n + 1)]→L[𝕜] F), (f + g).curryLeft = f.curryLeft + g.curryLeft | null | true |
cantorToTernary | Mathlib.Topology.Instances.CantorSet | ℝ → Stream' (Fin 3) | Given `x` in the Cantor set, return its ternary representation `(d₀, d₁, …)`
using only digits `0` and `2`, such that `x = 0.d₀d₁...` in base-3. | true |
Vector.extract_eq_pop | Init.Data.Vector.Extract | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {stop : ℕ} (h : stop = n - 1), xs.extract 0 stop = Vector.cast ⋯ xs.pop | null | true |
TensorPower.gmonoid._proof_2 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ)
(a : GradedMonoid fun i => TensorPower R i M),
GradedMonoid.mk (n.succ • a.fst) (GradedMonoid.GMonoid.gnpowRec n.succ a.snd) =
⟨n • a.fst, GradedMonoid.GMonoid.gnpowRec n a.snd⟩ * a | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.mergeFailures.match_1 | Lean.Elab.App | (motive : Option Lean.Elab.InfoTree → Sort u_1) →
(x : Option Lean.Elab.InfoTree) →
((tree : Lean.Elab.InfoTree) → motive (some tree)) → ((x : Option Lean.Elab.InfoTree) → motive x) → motive x | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.h | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof | null | true |
TensorProduct.tmul_neg | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {P : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup P] [inst_3 : Module R M] [inst_4 : Module R P] (m : M) (p : P), m ⊗ₜ[R] (-p) = -m ⊗ₜ[R] p | null | true |
Graph.induce._proof_3 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_2} {β : Type u_1} (G : Graph α β) (X : Set α) (e : β),
e ∈ {e | ∃ x y, (fun e x y => G.IsLink e x y ∧ x ∈ X ∧ y ∈ X) e x y} ↔ ∃ x y, G.IsLink e x y ∧ x ∈ X ∧ y ∈ X | null | false |
Stream'.WSeq.seq_destruct_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α), Stream'.Seq.destruct s.think = some (none, s) | null | true |
Polynomial.trinomial | Mathlib.Algebra.Polynomial.UnitTrinomial | {R : Type u_1} → [inst : Semiring R] → ℕ → ℕ → ℕ → R → R → R → Polynomial R | Shorthand for a trinomial | true |
MeasureTheory.setLAverage_congr_fun | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f g : α → ENNReal},
MeasurableSet s → Set.EqOn f g s → ⨍⁻ (x : α) in s, f x ∂μ = ⨍⁻ (x : α) in s, g x ∂μ | null | true |
TopCat.instCategory._proof_2 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (f : X.Hom Y), { hom' := { hom' := ContinuousMap.id ↑Y }.hom'.comp f.hom' } = f | null | false |
Inclusion.IntervalDyadicReal.instRefineIntervalDyadicReal | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Init | Inclusion.Refine (Inclusion.Interval Dyadic) ℝ | null | true |
List.sym2_eq_nil_iff | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, xs.sym2 = [] ↔ xs = [] | null | true |
Fix.mk._flat_ctor | Mathlib.Control.Fix | {α : Type u_3} → ((α → α) → α) → Fix α | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.diff.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β),
m₁.diff m₂ =
if (↑m₁).size ≤ (↑m₂).size then Std.DHashMap.Internal.Raw₀.filter (fun k x => !m₂.contains k) m₁
else ↑(m₁.eraseManyEntries ↑m₂) | null | true |
Primrec.list_head? | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.head? | null | true |
Std.TreeMap.getElem!_modify_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β] {f : β → β}, (t.modify k f)[k]! = (Option.map f t[k]?).get! | null | true |
Polynomial.le_trailingDegree_C | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {a : R} [inst : Semiring R], 0 ≤ (Polynomial.C a).trailingDegree | null | true |
RootPairing.finrank_rootSpan_map_polarization_eq_finrank_corootSpan | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [IsDomain R] [inst_5 : Module R M] [inst_6 : Module R N]
(P : RootPairing ι R M N) [P.IsAnisotropic],
Module.finrank R ↥(Submodule.map P.Polarization (P.rootSp... | null | true |
ImportGraph.WorkspaceModel.ctorIdx | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel → ℕ | null | false |
Nat.forM | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → m Unit | Executes a monadic action on all the numbers less than some bound, in increasing order.
Example:
````lean example
#eval Nat.forM 5 fun i _ => IO.println i
````
````output
0
1
2
3
4
````
| true |
IsPGroup.of_surjective | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G],
IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G →* H), Function.Surjective ⇑ϕ → IsPGroup p H | null | true |
Std.TreeMap.forIn_eq_forIn_keys | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ},
(forIn t init fun a d => f a.1 d) = forIn t.keys init f | null | true |
Std.Http.Status.paymentRequired.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 25 → motive Std.Http.Status.paymentRequired → motive t | null | false |
Asymptotics.isTheta_const_const_iff | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{l : Filter α} [l.NeBot] {c₁ : E''} {c₂ : F''}, ((fun x => c₁) =Θ[l] fun x => c₂) ↔ (c₁ = 0 ↔ c₂ = 0) | null | true |
Vector.mem_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n) (x : { x // x ∈ xs }), x ∈ xs.attach | null | true |
CategoryTheory.NatTrans.rightDerivedFunctorPlus_comp | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
[inst_6 : CategoryTheory.EnoughInjectives C] {F₁ F₂ ... | null | true |
Lean.Elab.Tactic.iterateExactly' | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit | `iterateExactly' n t` executes `t` `n` times. If any iteration fails, the whole tactic fails.
| true |
BoundedLatticeHom.dual._proof_2 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β],
Function.RightInverse (fun f => { toLatticeHom := LatticeHom.dual.symm f.toLatticeHom, map_top' := ⋯, map_bot' := ⋯ })
fun f => { toLatticeHom := LatticeHom.dual f.toLatticeHom, map_top' ... | null | false |
Std.DTreeMap.head?_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.keys.head? = t.minKey? | null | true |
Set.encard_pos | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 0 < s.encard ↔ s.Nonempty | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.