name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.getD_surjective_iff | Mathlib.Data.List.GetD | ∀ {α : Type u} {l : List α} {d : α}, (Function.Surjective fun x => l.getD x d) ↔ ∀ (x : α), x = d ∨ x ∈ l | null | true |
CategoryTheory.Limits.pullbackProdSndIsoProd._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y) (Z : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProduct Z Y] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Z X]
[inst_3 : CategoryTheory.Limits.HasPullback CategoryTheory.Limits.prod.snd f],
CategoryTheory.CategoryStruct.comp... | null | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.Set.0.MeasureTheory.setIntegral_eq_of_subset_of_ae_sdiff_eq_zero_aux._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {a b : Prop}, (a = b) = (a ↔ b) | null | false |
_private.Std.Data.HashMap.IteratorLemmas.0.Std.HashMap.toArray_valuesIter._simp_1_1 | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray | null | false |
Finpartition.indiscrete_parts | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (ha : a ≠ ⊥), (Finpartition.indiscrete ha).parts = {a} | null | true |
CategoryTheory.Functor.weightedLimObjMap_id | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
(W : CategoryTheory.Functor J (Type w)) (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasWeightedLimit W F],
W.weightedLimObjMap (CategoryTheory.CategoryStruct.id F) = CategoryTh... | null | true |
Lean.Expr.sort.noConfusion | Lean.Expr | {P : Sort u} → {u u' : Lean.Level} → Lean.Expr.sort u = Lean.Expr.sort u' → (u = u' → P) → P | null | false |
ProbabilityTheory.covarianceBilin_map | Mathlib.Probability.Moments.CovarianceBilin | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : MeasurableSpace E]
[inst_3 : BorelSpace E] {μ : MeasureTheory.Measure E} {F : Type u_2} [inst_4 : NormedAddCommGroup F]
[inst_5 : InnerProductSpace ℝ F] [inst_6 : MeasurableSpace F] [inst_7 : BorelSpace F] [SecondCountableTopo... | null | true |
AddGroupNorm.instMax.eq_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E],
AddGroupNorm.instMax =
{
max := fun p q =>
let __src := p.toAddGroupSeminorm ⊔ q.toAddGroupSeminorm;
{ toAddGroupSeminorm := __src, eq_zero_of_map_eq_zero' := ⋯ } } | null | true |
CompHaus.lift | Mathlib.Topology.Category.Stonean.Basic | {X Y : CompHaus} → {Z : Stonean} → (Z.compHaus ⟶ Y) → (f : X ⟶ Y) → [CategoryTheory.Epi f] → Z.compHaus ⟶ X | ```
X
|
(f)
|
\/
Z ---(e)---> Y
```
If `Z` is a Stonean space, `f : X ⟶ Y` an epi in `CompHaus` and `e : Z ⟶ Y` is arbitrary, then
`lift e f` is a fixed (but arbitrary) lift of `e` to a morphism `Z ⟶ X`. It exists because
`Z` is a projective ob... | true |
Real.hasDerivAt_tan | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ {x : ℝ}, Real.cos x ≠ 0 → HasDerivAt Real.tan (1 / Real.cos x ^ 2) x | null | true |
CategoryTheory.ObjectProperty.IsMonoidal.rec | Mathlib.CategoryTheory.Monoidal.Subcategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsMonoidal → Sort u_1} →
([toContainsUnit : P.ContainsUnit] → [toTensorLE : P.TensorLE P P] → motive ⋯) → (t : P.IsMonoidal) → motiv... | null | false |
Real.smoothTransition.zero_of_nonpos | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, x ≤ 0 → x.smoothTransition = 0 | null | true |
MeasureTheory.memLp_add_measure | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {m0 : MeasurableSpace α} {p : ENNReal} {μ ν : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] {f : α → F},
MeasureTheory.MemLp f p (μ + ν) ↔ MeasureTheory.MemLp f p μ ∧ MeasureTheory.MemLp f p ν | null | true |
Lean.Server.ServerTask.hasFinished | Lean.Server.ServerTask | {α : Type u_1} → Lean.Server.ServerTask α → BaseIO Bool | null | true |
Finset.Icc_mul_Ico_subset' | Mathlib.Algebra.Group.Pointwise.Finset.Interval | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : PartialOrder α] [inst_2 : DecidableEq α] [MulLeftStrictMono α]
[MulRightStrictMono α] [inst_5 : LocallyFiniteOrder α] (a b c d : α),
Finset.Icc a b * Finset.Ico c d ⊆ Finset.Ico (a * c) (b * d) | null | true |
_private.Mathlib.InformationTheory.Coding.PrefixFree.0.InformationTheory.IsPrefixFree.isUniquelyDecodable._proof_1_1 | Mathlib.InformationTheory.Coding.PrefixFree | ∀ {α : Type u_1} {S : Set (List α)},
[] ∉ S → ∀ (w : List α) (L : List (List α)), (∀ w_1 ∈ w :: L, w_1 ∈ S) → (w = [] ∧ ∀ l ∈ L, l = []) → [] = w :: L | null | false |
SemilinearEquivClass.semilinearEquiv._proof_3 | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_4} {S : Type u_5} {M : Type u_1} {M₂ : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] {σ : R →+* S}
{σ' : S →+* R} [inst_6 : RingHomInvPair σ σ'] [inst_7 : RingHomInvPair σ' σ] [inst... | null | false |
Std.DTreeMap.Internal.Impl.Const.get_insertManyIfNewUnit_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {l : List α} {k : α}
{h :
Std.DTreeMap.Internal.Impl.contains k
↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit Std.DTreeMap.Internal.Impl.empty l ⋯) =
true},
Std.DTreeMap.Internal.Impl.Const.get
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit ... | null | true |
CategoryTheory.Arrow.homMk'_left | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y : T} {f : X ⟶ Y} {P Q : T} {g : P ⟶ Q} (u : X ⟶ P)
(v : Y ⟶ Q)
(w :
autoParam (CategoryTheory.CategoryStruct.comp u g = CategoryTheory.CategoryStruct.comp f v)
CategoryTheory.Arrow.homMk'._auto_1),
(CategoryTheory.Arrow.homMk' u v w).left = u | null | true |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.BoundedFormula.realize_iSup._simp_1_2 | Mathlib.ModelTheory.Semantics | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
Int.ofAdd_mul | Mathlib.Algebra.Group.Int.TypeTags | ∀ (a b : ℤ), Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b | null | true |
Finset.Colex.instLinearOrder._proof_6 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : Colex (Finset α)), (if a ≤ b then b else a) = if a ≤ b then b else a | null | false |
Int32.eq_sub_iff_add_eq | Init.Data.SInt.Lemmas | ∀ {a b c : Int32}, a = c - b ↔ a + b = c | null | true |
_private.Mathlib.RingTheory.LocalProperties.Exactness.0.exact_of_isLocalized_span._simp_1_1 | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P}, Function.Exact ⇑f ⇑g = (g.ker = f.range) | null | false |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.add._simp_1_7 | Mathlib.Probability.Moments.SubGaussian | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
IsAddQuotientCoveringMap.toContinuousConstVAdd | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_4}
[inst_2 : AddGroup G] [inst_3 : AddAction G E], IsAddQuotientCoveringMap f G → ContinuousConstVAdd G E | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.isFragment_smul_finset._simp_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G} {a : G},
Finset.IsFragment✝ K S (a • A) = Finset.IsFragment✝ K S A | null | false |
ProbabilityTheory.Kernel.stronglyAdapted_densityProcess | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β))
(ν : ProbabilityTheory.Kernel α γ) (a : α) {s : Set β},
MeasurableSet s →
MeasureTheory.StronglyAdapt... | null | true |
Algebra.TensorProduct.instNonUnitalRing._proof_2 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] [inst_5 : NonUnitalSemiring B] [inst_6 : Module R B]
[inst_7 : SMulCommClass R B B] [inst_8 : IsScalarTower R B B] (a b c : TensorProd... | null | false |
ContinuousLinearEquiv.isBigO_sub | Mathlib.Analysis.Normed.Operator.Asymptotics | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} {σ₂₁ : 𝕜₂ →+* 𝕜}
[inst_6... | null | true |
ContinuousMultilinearMap.norm_mkPiAlgebraFin_le_of_pos | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {A : Type u_1} [inst_1 : SeminormedRing A]
[inst_2 : NormedAlgebra 𝕜 A], 0 < n → ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ ≤ 1 | null | true |
WittVector.ghostComponent_teichmuller | Mathlib.RingTheory.WittVector.Teichmuller | ∀ (p : ℕ) {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (r : R) (n : ℕ),
(WittVector.ghostComponent n) ((WittVector.teichmuller p) r) = r ^ p ^ n | The `n`-th ghost component of `teichmuller p r` is `r ^ p ^ n`. | true |
Batteries.UnionFind.arr_empty | Batteries.Data.UnionFind.Lemmas | Batteries.UnionFind.empty.arr = #[] | null | true |
Lean.Compiler.LCNF.Simp.JpCasesAlt.default | Lean.Compiler.LCNF.Simp.JpCases | Lean.Compiler.LCNF.Simp.JpCasesAlt → Bool | null | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalComp.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.Eval.Result → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.Eval.Result) →
((ι : Mathlib.Tactic.BicategoryLike.NormalExpr) → (e_ι : Lean.Expr) → motive { expr := ι, proof := e_ι }) → motive x | null | false |
InfHom.dual.eq_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β],
InfHom.dual =
{ toFun := fun f => { toFun := ⇑f, map_sup' := ⋯ }, invFun := fun f => { toFun := ⇑f, map_inf' := ⋯ },
left_inv := ⋯, right_inv := ⋯ } | null | true |
Aesop.TreeSpec.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.TreeSpec} → t = t' → Aesop.TreeSpec.noConfusionType P t t' | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rio_add_add_eq_append._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m : ℕ}, ¬0 ≤ m → False | null | false |
_private.Mathlib.Algebra.Polynomial.Basic.0.Polynomial.monomial._simp_1 | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a b : AddMonoidAlgebra R ℕ},
{ toFinsupp := a } + { toFinsupp := b } = { toFinsupp := a + b } | null | false |
ProfiniteAddGrp.ProfiniteCompletion.etaFn_injective_iff_residuallyFinite | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ (G : AddGrpCat), Function.Injective (ProfiniteAddGrp.ProfiniteCompletion.etaFn G) ↔ AddGroup.ResiduallyFinite ↑G | null | true |
_private.Lean.Data.Name.0.Lean.Name.eqStr.match_1 | Lean.Data.Name | (motive : Lean.Name → String → Sort u_1) →
(x : Lean.Name) →
(x_1 : String) →
((s s' : String) → motive (Lean.Name.anonymous.str s) s') →
((x : Lean.Name) → (x_2 : String) → motive x x_2) → motive x x_1 | null | false |
Std.HashSet.Raw.contains_union | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂).contains k = (m₁.contains k || m₂.contains k) | null | true |
_private.Mathlib.MeasureTheory.Measure.Regular.0.Set.measure_eq_iInf_isOpen._simp_1_1 | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {ι : Sort u_3} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a | null | false |
NonUnitalStarAlgebra.mem_inf | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {S T : NonUnitalStarSubalgebra R A} {x : A}, x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T | null | true |
Submodule.exists_le_ker_of_lt_top | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
∀ p < ⊤, ∃ f, f ≠ 0 ∧ p ≤ f.ker | If `p < ⊤` is a subspace of a vector space `V`, then there exists a nonzero linear map
`f : V →ₗ[K] K` such that `p ≤ ker f`. | true |
DirectLimit.instStar | Mathlib.Algebra.Colimit.DirectLimit | {ι : Type u_2} →
[inst : Preorder ι] →
{G : ι → Type u_3} →
{T : ⦃i j : ι⦄ → i ≤ j → Type u_6} →
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} →
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] →
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] →
... | null | true |
ValuationSubring.primeSpectrumEquiv._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (S : { S // A ≤ S }),
(fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) S) = S | null | false |
CategoryTheory.ShortComplex.cyclesMap'_sub | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.ShortComplex.cyclesMap' (φ - φ') h₁ h₂ =
CategoryTheory.ShortComplex.cyclesMap' φ ... | null | true |
DirectSum.decompose_sum | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike σ M]
[inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ] {ι' : Type u_5} (s : Finset ι')
(f : ι' → M), (DirectSum.decompose ℳ) (∑ i ∈ s, f i) = ∑ i ∈ s, (DirectSum.decompo... | null | true |
SimpleGraph.Walk.edgeSet_nil | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} (u : V), SimpleGraph.Walk.nil.edgeSet = ∅ | null | true |
Int.ofNat_dvd._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ}, (↑m ∣ ↑n) = (m ∣ n) | null | false |
CategoryTheory.id_of_comp_left_id | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (f : X ⟶ X),
(∀ {Y : C} (g : X ⟶ Y), CategoryTheory.CategoryStruct.comp f g = g) → f = CategoryTheory.CategoryStruct.id X | null | true |
_private.Mathlib.Algebra.MvPolynomial.Basic.0.MvPolynomial.coeff_X_mul'._simp_1_4 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
LipschitzOnWith.ae_differentiableWithinAt_of_mem_of_real | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{C : NNReal} {f : E → ℝ} {s : Set E} {μ : MeasureTheory.Measure E} [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure],
LipschitzOnWith C f s → ∀ᵐ (x : E) ∂μ, x ∈ s → DifferentiableWithinAt ℝ f s x | A real-valued function on a finite-dimensional space which is Lipschitz on a set is
differentiable almost everywhere in this set. Superseded by
`LipschitzOnWith.ae_differentiableWithinAt_of_mem` which works for functions taking value in any
finite-dimensional space. | true |
essInf_const_top | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
essInf (fun x => ⊤) μ = ⊤ | null | true |
Lean.Elab.Tactic.Omega.Justification.combine | Lean.Elab.Tactic.Omega.Core | {s t : Lean.Omega.Constraint} →
{c : Lean.Omega.Coeffs} →
Lean.Elab.Tactic.Omega.Justification s c →
Lean.Elab.Tactic.Omega.Justification t c → Lean.Elab.Tactic.Omega.Justification (s.combine t) c | The result of `combine` on two `Justifications`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceToNat._regBuiltin.Int.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.3578908840._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
_private.Mathlib.CategoryTheory.Limits.Types.PreservesLimit.0.CategoryTheory.Presheaf.nonempty_isLimit_mapCone_iff._simp_1_1 | Mathlib.CategoryTheory.Limits.Types.PreservesLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} J]
[inst_2 : CategoryTheory.LocallySmall.{w, v, u} C] {F : CategoryTheory.Functor J Cᵒᵖ}
(c : CategoryTheory.Limits.Cone F)
{c' : CategoryTheory.Limits.Cocone (F.leftOp.comp CategoryTheory.shrinkYoned... | null | false |
String.Pos.eq_prev_of_prev?_eq_some | Init.Data.String.Termination | ∀ {s : String} {p q : s.Pos} (h : p.prev? = some q), q = p.prev ⋯ | null | true |
Aesop.ForwardInstantiationStats.recOn | Aesop.Stats.Basic | {motive : Aesop.ForwardInstantiationStats → Sort u} →
(t : Aesop.ForwardInstantiationStats) →
((«matches» hyps : ℕ) → motive { «matches» := «matches», hyps := hyps }) → motive t | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_355 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
CategoryTheory.GrothendieckTopology.Cover.Relation | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → J.Cover X → Type (max u v) | An auxiliary structure, used to define `S.index`. | true |
Lean.Compiler.LCNF.instTraverseFVarParam | Lean.Compiler.LCNF.FVarUtil | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.TraverseFVar (Lean.Compiler.LCNF.Param pu) | null | true |
DyckWord.denest | Mathlib.Combinatorics.Enumerative.DyckWord | (p : DyckWord) → p.IsNested → DyckWord | Denest `p`, i.e. `(x)` becomes `x`, given that `p.IsNested`. | true |
Lean.Lsp.instFromJsonReferenceParams | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.ReferenceParams | null | true |
OmegaCompletePartialOrder.ωScottContinuous.of_map_ωSup_of_orderHom | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
{f : α →o β},
(∀ (c : OmegaCompletePartialOrder.Chain α),
f (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSup (c.map f)) →
OmegaCompletePartialOrder.ωScottContinuous ⇑f | **Alias** of the reverse direction of `OmegaCompletePartialOrder.ωScottContinuous_iff_map_ωSup_of_orderHom`.
---
A monotone function `f : α →o β` is ωScott continuous if and only if it distributes over ωSup. | true |
Subgroup.Commensurable.bot_left_iff._simp_2 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, ⊥.Commensurable H = Finite ↥H | null | false |
AddCommGrpCat.uliftFunctor.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddCommGrpCat.uliftFunctor =
{ obj := fun X => ↧(ULift.{u, v} ↑X),
map := fun {x x_1} f =>
AddCommGrpCat.ofHom
(AddEquiv.ulift.symm.toAddMonoidHom.comp ((AddCommGrpCat.Hom.hom f).comp AddEquiv.ulift.toAddMonoidHom)),
map_id := ⋯, map_comp := ⋯ } | null | true |
Std.DHashMap.Const.insertManyIfNewUnit_list_singleton | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} {k : α},
Std.DHashMap.Const.insertManyIfNewUnit m [k] = m.insertIfNew k () | null | true |
Lean.Meta.DiscrTree.Trie._sizeOf_1 | Lean.Meta.DiscrTree.Types | {α : Type} → [SizeOf α] → Lean.Meta.DiscrTree.Trie α → ℕ | null | false |
MeasureTheory.NullMeasurableSet.union | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet t μ → MeasureTheory.NullMeasurableSet (s ∪ t) μ | null | true |
Fin.partialSum_zero | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddMonoid M] {n : ℕ} (f : Fin n → M), Fin.partialSum f 0 = 0 | null | true |
_private.Mathlib.Algebra.Group.Irreducible.Lemmas.0.irreducible_mul_isUnit.match_1_1 | Mathlib.Algebra.Group.Irreducible.Lemmas | ∀ {M : Type u_1} [inst : Monoid M] {x : M} (motive : IsUnit x → Prop) (h : IsUnit x),
(∀ (x_1 : Mˣ) (hx : ↑x_1 = x), motive ⋯) → motive h | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.preprocessDeclPattern | Lean.Meta.Sym.Pattern | Lean.Name → optParam Bool false → Lean.MetaM (List Lean.Name × Lean.Expr) | Helper function for implementing `mkPatternFromDecl` and `mkEqPatternFromDecl` | true |
groupHomology.H1ToTensorOfIsTrivial._proof_6 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
AddMonoidHomClass (↑(groupHomology.H1 A) →ₗ[k] ↑(groupHomology.shortComplexH1 A).moduleCatLeftHomologyData.H)
↑(groupHomology.H1 A) ↑(groupHomology.shortComplexH1 A).moduleCatLeftHomologyData.H | null | false |
Std.Time.Second.Ordinal.ofNat | Std.Time.Time.Unit.Second | {leap : Bool} → (data : ℕ) → (data ≤ if leap = true then 60 else 59) → Std.Time.Second.Ordinal leap | Creates an `Ordinal` from a natural number, ensuring the value is within bounds.
| true |
IsAntichain.to_dual | Mathlib.Order.Antichain | ∀ {α : Type u_1} {s : Set α} [inst : LE α], IsAntichain (fun x1 x2 => x1 ≤ x2) s → IsAntichain (fun x1 x2 => x1 ≤ x2) s | null | true |
Nat.Internal.SOM.Poly.insertSorted._sunfold | Init.Data.Nat.Internal.SOM | ℕ → Nat.Internal.SOM.Mon → Nat.Internal.SOM.Poly → Nat.Internal.SOM.Poly | null | false |
Filter.NeBot.of_sub_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Sub α] {f g : Filter α}, (f - g).NeBot → g.NeBot | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_neg_iff_sign_neg._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal < 0 ↔ Real.sin θ.toReal < 0 | null | false |
CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtensionAt.hasPointwiseRightKanExtensionAt | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.RightExtension F} {Y : D}
(h : E.IsPointwiseRightKan... | null | true |
RingTopology.mk.injEq | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u} [inst : Ring R] (toTopologicalSpace : TopologicalSpace R) (toIsTopologicalRing : IsTopologicalRing R)
(toTopologicalSpace_1 : TopologicalSpace R) (toIsTopologicalRing_1 : IsTopologicalRing R),
({ toTopologicalSpace := toTopologicalSpace, toIsTopologicalRing := toIsTopologicalRing } =
{ toTopolo... | null | true |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq._sparseCasesOn_1 | Aesop.Forward.State | {motive : Aesop.RawHyp → Sort u} →
(t : Aesop.RawHyp) →
((fvarId : Lean.FVarId) → motive (Aesop.RawHyp.fvarId fvarId)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Topology.Connected.PathConnected.0.IsPathConnected.exists_path_through_family._simp_1_3 | Mathlib.Topology.Connected.PathConnected | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
_private.Mathlib.RingTheory.Nilpotent.Basic.0.Commute.isNilpotent_finsum._simp_1_1 | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R], IsNilpotent 0 = True | null | false |
Set.sups_inter_subset_right | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] {s t₁ t₂ : Set α}, s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂ | null | true |
map_eq_zero_iff_eq_zero | Mathlib.Algebra.Order.Hom.GroupNorm | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : AddGroup α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [AddGroupNormClass F α β] (f : F) {x : α}, f x = 0 ↔ x = 0 | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Quotient.0._aux_Mathlib_MeasureTheory_Measure_Haar_Quotient___macroRules__private_Mathlib_MeasureTheory_Measure_Haar_Quotient_0_termπ_1 | Mathlib.MeasureTheory.Measure.Haar.Quotient | Lean.Macro | null | false |
AddHom.fst._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : Add M] [inst_1 : Add N] (x x_1 : M × N), (x + x_1).1 = (x + x_1).1 | null | false |
CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃... | null | true |
AddMonoidAlgebra.semiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddMonoid M],
AddMonoidAlgebra.semiring =
{ toAddCommMonoid := AddMonoidAlgebra.instAddCommMonoid, toOne := AddMonoidAlgebra.nonAssocSemiring.toOne,
toMul := AddMonoidAlgebra.nonUnitalSemiring.toMul, mul_assoc := ⋯, one_mul := ⋯, mul_one := ⋯,
... | null | true |
NormedRing.toNonUnitalNormedRing._proof_9 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedRing α] (a : α), 0 * a = 0 | null | false |
lcm_dvd_lcm_mul_left | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] (m n k : α), lcm m n ∣ lcm (k * m) n | null | true |
RCLike.mk.noConfusion | Mathlib.Analysis.RCLike.Basic | {K : semiOutParam (Type u_1)} →
{P : Sort u} →
{toDenselyNormedField : DenselyNormedField K} →
{toStarRing : StarRing K} →
{toNormedAlgebra : NormedAlgebra ℝ K} →
{toCompleteSpace : CompleteSpace K} →
{re im : K →+ ℝ} →
{I : K} →
{I_re_ax : re I = ... | null | false |
Std.IterM.Total.rec | Init.Data.Iterators.Consumers.Monadic.Total | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.IterM.Total m β → Sort u} →
((it : Std.IterM m β) → motive { it := it }) → (t : Std.IterM.Total m β) → motive t | null | false |
CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} (J' : Type u_2) (h : J ≃ J'),
(CategoryTheory.Functor.id (CategoryTheory.Limits.WidePullbackShape J)).obj none =
((CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h j)).comp
(CategoryT... | null | false |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.insertExtractMax.match_1.splitter | Batteries.Data.BinaryHeap.Lemmas | {α : Type u_1} →
(motive : Option α → Sort u_2) →
(x : Option α) → (x = none → motive none) → ((m : α) → x = some m → motive (some m)) → motive x | null | true |
CategoryTheory.CartesianMonoidalCategory.fullSubcategory_tensorObj_obj | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{P : CategoryTheory.ObjectProperty C} [inst_2 : P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete PEmpty.{1})]
[inst_3 : P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.Walk... | null | true |
Quiver.Path.instDecidableEq._proof_3 | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (v w : V) (p q : Quiver.Path v w), ⟨p, ⋯⟩ = ⟨q, ⋯⟩ ↔ ↑⟨p, ⋯⟩ = ↑⟨q, ⋯⟩ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.