name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Meta.Grind.isCastLikeFn | Lean.Meta.Tactic.Grind.CastLike | Lean.Expr → Bool |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_neg_of_msb_true._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w},
2 * x.toNat ≥ 2 ^ w → ¬(if 2 * x.toNat < 2 ^ w then ↑x.toNat else ↑x.toNat - ↑(2 ^ w)) < 0 → False |
CategoryTheory.MonoidalCategory.monoidalOfLawfulDayConvolutionMonoidalCategoryStruct._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_6, u_3} C] (V : Type u_5)
[inst_1 : CategoryTheory.Category.{u_4, u_5} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCategoryStruct D]
[CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct C V D] (x y : D),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id x)
(CategoryTheory.CategoryStruct.id y) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj x y) |
Std.TreeMap.minKey_insert_of_isEmpty | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → (t.insert k v).minKey ⋯ = k |
Invertible.ofLeftInverse | Mathlib.Algebra.Group.Invertible.Basic | {R : Type u_1} →
{S : Type u_2} →
{G : Type u_3} →
[inst : MulOneClass R] →
[inst_1 : MulOneClass S] →
[inst_2 : FunLike G S R] →
[MonoidHomClass G S R] →
(f : R → S) → (g : G) → (r : R) → Function.LeftInverse (⇑g) f → [Invertible (f r)] → Invertible r |
QuadraticAlgebra.coe_eq_one_iff | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Zero R] [inst_1 : One R] {r : R}, QuadraticAlgebra.C r = 1 ↔ r = 1 |
Lean.Parser.Term.termUnless._regBuiltin.Lean.Parser.Term.termUnless.declRange_5 | Lean.Parser.Do | IO Unit |
Lean.Omega.LinearCombo.noConfusion | Init.Omega.LinearCombo | {P : Sort u} → {t t' : Lean.Omega.LinearCombo} → t = t' → Lean.Omega.LinearCombo.noConfusionType P t t' |
Classical.propDecidable._proof_1 | Init.Classical | ∀ (a : Prop), Nonempty (Decidable a) |
Prod.nonUnitalSeminormedRing._proof_6 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalSeminormedRing α] [inst_1 : NonUnitalSeminormedRing β] (a : α × β),
0 * a = 0 |
BitVec.reduceGetMsb._regBuiltin.BitVec.reduceGetMsb.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4252493603._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
SeparationQuotient.instCommGroup._proof_2 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [IsTopologicalGroup G], ContinuousInv G |
Lean.Compiler.LCNF.Pass.shouldAlwaysRunCheck._default | Lean.Compiler.LCNF.PassManager | Bool |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.erase_le_erase_min'._simp_1_3 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s t : Finset α},
(Finset.filter p s = Finset.filter p t) = ∀ ⦃a : α⦄, p a → (a ∈ s ↔ a ∈ t) |
ValuativeExtension.vle_iff_vle | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {A : Type u_1} {B : Type u_2} {inst : CommRing A} {inst_1 : CommRing B} {inst_2 : ValuativeRel A}
{inst_3 : ValuativeRel B} {inst_4 : Algebra A B} [self : ValuativeExtension A B] (a b : A),
(algebraMap A B) a ≤ᵥ (algebraMap A B) b ↔ a ≤ᵥ b |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.instPartialOrderDiagramWithUniqueTerminal._proof_2 | Mathlib.CategoryTheory.Presentable.Directed | ∀ (J : Type u_1) [inst : CategoryTheory.SmallCategory J] (κ : Cardinal.{u_1})
(x : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ), x.P ≤ x.P |
Array.count.eq_1 | Init.Data.Array.Count | ∀ {α : Type u} [inst : BEq α] (a : α) (as : Array α), Array.count a as = Array.countP (fun x => x == a) as |
AlgebraicGeometry.Scheme.Hom.quasiFiniteLocus_eq_top_iff | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.LocallyOfFiniteType f],
AlgebraicGeometry.Scheme.Hom.quasiFiniteLocus f = ⊤ ↔ AlgebraicGeometry.LocallyQuasiFinite f |
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 |
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
(CategoryTheory.Limits.prod.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst CategoryTheory.Limits.prod.snd f)
CategoryTheory.Limits.prod.fst)
(CategoryTheory.Limits.pullback.snd CategoryTheory.Limits.prod.snd f))
(CategoryTheory.Limits.pullback.lift (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id Z) f)
CategoryTheory.Limits.prod.snd ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback CategoryTheory.Limits.prod.snd f) |
_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 |
Finpartition.indiscrete_parts | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (ha : a ≠ ⊥), (Finpartition.indiscrete ha).parts = {a} |
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 |
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] [SecondCountableTopology F]
[inst_9 : CompleteSpace F] [inst_10 : CompleteSpace E] [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.MemLp id 2 μ →
∀ (L : E →L[ℝ] F) (u v : F),
((ProbabilityTheory.covarianceBilin (MeasureTheory.Measure.map (⇑L) μ)) u) v =
((ProbabilityTheory.covarianceBilin μ) ((ContinuousLinearMap.adjoint L) u)) ((ContinuousLinearMap.adjoint L) v) |
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' := ⋯ } } |
CompHaus.lift | Mathlib.Topology.Category.Stonean.Basic | {X Y : CompHaus} → {Z : Stonean} → (Z.compHaus ⟶ Y) → (f : X ⟶ Y) → [CategoryTheory.Epi f] → Z.compHaus ⟶ X |
Real.hasDerivAt_tan | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ {x : ℝ}, Real.cos x ≠ 0 → HasDerivAt Real.tan (1 / Real.cos x ^ 2) x |
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) → motive t |
Real.smoothTransition.zero_of_nonpos | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, x ≤ 0 → x.smoothTransition = 0 |
Lean.Server.ServerTask.hasFinished | Lean.Server.ServerTask | {α : Type u_1} → Lean.Server.ServerTask α → BaseIO Bool |
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) |
_private.Lean.Elab.DocString.Builtin.Parsing.0.Lean.Doc.parseQuotedStrLit.reposition | Lean.Elab.DocString.Builtin.Parsing | Lean.FileMap → String.Pos.Raw → String → String.Pos.Raw → String.Pos.Raw |
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_8 : EquivLike F M M₂]
[inst_9 : SemilinearEquivClass F σ M M₂] (f : F), Function.RightInverse (↑f).invFun (↑f).toFun |
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 Std.DTreeMap.Internal.Impl.empty l ⋯)) k h =
() |
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 |
_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 |
Int.ofAdd_mul | Mathlib.Algebra.Group.Int.TypeTags | ∀ (a b : ℤ), Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b |
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 |
Int32.eq_sub_iff_add_eq | Init.Data.SInt.Lemmas | ∀ {a b c : Int32}, a = c - b ↔ a + b = c |
_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) |
_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 |
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 |
_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 |
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.StronglyAdapted (ProbabilityTheory.countableFiltration γ) fun n x => κ.densityProcess ν n a x s |
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 : TensorProduct R A B),
(a + b) * c = a * c + b * c |
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 : RingHomInvPair σ₁₂ σ₂₁] [inst_7 : RingHomInvPair σ₂₁ σ₁₂] (e : E ≃SL[σ₁₂] F) [RingHomIsometric σ₁₂]
(l : Filter E) (x : E), (fun x' => e (x' - x)) =O[l] fun x' => x' - x |
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 |
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 |
Batteries.UnionFind.arr_empty | Batteries.Data.UnionFind.Lemmas | Batteries.UnionFind.empty.arr = #[] |
Lean.Compiler.LCNF.Simp.JpCasesAlt.default | Lean.Compiler.LCNF.Simp.JpCases | Lean.Compiler.LCNF.Simp.JpCasesAlt → Bool |
_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) →
(__discr : Mathlib.Tactic.BicategoryLike.Eval.Result) →
((ι : Mathlib.Tactic.BicategoryLike.NormalExpr) → (e_ι : Lean.Expr) → motive { expr := ι, proof := e_ι }) →
motive __discr |
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 := ⋯ } |
Aesop.TreeSpec.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.TreeSpec} → t = t' → Aesop.TreeSpec.noConfusionType P t t' |
_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 |
_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 } |
_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 |
IO.AsyncList._sizeOf_1 | Lean.Server.AsyncList | {ε : Type u} → {α : Type v} → [SizeOf ε] → [SizeOf α] → IO.AsyncList ε α → ℕ |
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) |
_private.Mathlib.MeasureTheory.Measure.Regular.0.Set.measure_eq_iInf_isOpen._simp_1_1 | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a |
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 |
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 |
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 |
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' φ h₁ h₂ - CategoryTheory.ShortComplex.cyclesMap' φ' h₁ h₂ |
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.decompose ℳ) (f i) |
SimpleGraph.Walk.edgeSet_nil | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} (u : V), SimpleGraph.Walk.nil.edgeSet = ∅ |
Int.ofNat_dvd._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ}, (↑m ∣ ↑n) = (m ∣ n) |
Mathlib.StacksTag.Database.recOn | Mathlib.Tactic.StacksAttribute | {motive : Mathlib.StacksTag.Database → Sort u} →
(t : Mathlib.StacksTag.Database) →
motive Mathlib.StacksTag.Database.kerodon → motive Mathlib.StacksTag.Database.stacks → motive t |
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 |
_private.Mathlib.Algebra.MvPolynomial.Basic.0.MvPolynomial.coeff_X_mul'._simp_1_4 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (0 < a) = (a ≠ 0) |
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 |
essInf_const_top | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
essInf (fun x => ⊤) μ = ⊤ |
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 |
Set.ncard_le_ncard_diff_add_ncard._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax |
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 ⋯ |
Aesop.ForwardInstantiationStats.recOn | Aesop.Stats.Basic | {motive : Aesop.ForwardInstantiationStats → Sort u} →
(t : Aesop.ForwardInstantiationStats) →
((«matches» hyps : ℕ) → motive { «matches» := «matches», hyps := hyps }) → motive t |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt32.reduceDiv.declare_184._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.97 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
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) |
Lean.Compiler.LCNF.instTraverseFVarParam | Lean.Compiler.LCNF.FVarUtil | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.TraverseFVar (Lean.Compiler.LCNF.Param pu) |
DyckWord.denest | Mathlib.Combinatorics.Enumerative.DyckWord | (p : DyckWord) → p.IsNested → DyckWord |
SimplicialObject.Split.forget | Mathlib.AlgebraicTopology.SimplicialObject.Split | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.Functor (SimplicialObject.Split C) (CategoryTheory.SimplicialObject C) |
Lean.Lsp.instFromJsonReferenceParams | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.ReferenceParams |
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 |
AddCommGrpCat.uliftFunctor.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddCommGrpCat.uliftFunctor =
{ obj := fun X => AddCommGrpCat.of (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 := ⋯ } |
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 () |
Lean.Meta.DiscrTree.Trie._sizeOf_1 | Lean.Meta.DiscrTree.Types | {α : Type} → [SizeOf α] → Lean.Meta.DiscrTree.Trie α → ℕ |
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) μ |
Fin.partialSum_zero | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddMonoid M] {n : ℕ} (f : Fin n → M), Fin.partialSum f 0 = 0 |
_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 |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.preprocessDeclPattern | Lean.Meta.Sym.Pattern | Lean.Name → Lean.MetaM (List Lean.Name × Lean.Expr) |
groupHomology.H1ToTensorOfIsTrivial._proof_6 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G),
AddMonoidHomClass (↑(groupHomology.H1 A) →ₗ[k] ↑(groupHomology.shortComplexH1 A).moduleCatLeftHomologyData.H)
↑(groupHomology.H1 A) ↑(groupHomology.shortComplexH1 A).moduleCatLeftHomologyData.H |
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 |
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 |
Filter.NeBot.of_sub_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Sub α] {f g : Filter α}, (f - g).NeBot → g.NeBot |
_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 |
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.IsPointwiseRightKanExtensionAt Y), L.HasPointwiseRightKanExtensionAt F Y |
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 } =
{ toTopologicalSpace := toTopologicalSpace_1, toIsTopologicalRing := toIsTopologicalRing_1 }) =
(toTopologicalSpace = toTopologicalSpace_1) |
_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 |
_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) |
_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 |
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₂ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.