name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConvSeq1Indented._regBuiltin.Lean.Elab.Tactic.Conv.evalConvSeq1Indented_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Lean.Environment.0.Lean.Environment.RealizeConstKey.noConfusionType | Lean.Environment | Sort u → Lean.Environment.RealizeConstKey✝ → Lean.Environment.RealizeConstKey✝ → Sort u | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.2270162977._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO Unit | Dependent arrow
* `def foo : (unused : Nat) → Nat := id`
| false |
CategoryTheory.Quotient.linear_functor | Mathlib.CategoryTheory.Quotient.Linear | ∀ (R : Type u_1) {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (r : HomRel C)
[inst_4 : CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂))
[inst_5 :... | null | true |
CategoryTheory.yonedaAddMon_map_app | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X Y : CategoryTheory.AddMon C} (ψ : X ⟶ Y) (x : Cᵒᵖ),
(CategoryTheory.yonedaAddMon.map ψ).app x =
AddMonCat.ofHom (CategoryTheory.IsAddMonHom.addMonoidHom ψ.hom (Opposite.unop x)) | null | true |
_private.Mathlib.Combinatorics.Hall.Finite.0.HallMarriageTheorem.hall_hard_inductive_step_B._proof_1_6 | Mathlib.Combinatorics.Hall.Finite | ∀ {ι : Type u_1} {α : Type u_2} [inst : DecidableEq α] {t : ι → Finset α} (s : Finset ι) (f' : ↥s → α),
Function.Injective f' →
(∀ (x : ↥s), f' x ∈ (fun x' => t ↑x') x) →
∀ (f'' : ↑(↑s)ᶜ → α),
(∀ (x'' : ι) (hx'' : x'' ∉ s), f'' ⟨x'', hx''⟩ ∉ s.biUnion t) →
∀ (x' x'' : ι) (hx' : x' ∈ s) (hx... | null | false |
Qq.Impl.MVarSynth.type.elim | Qq.Macro | {motive : Qq.Impl.MVarSynth → Sort u} →
(t : Qq.Impl.MVarSynth) →
t.ctorIdx = 1 → ((unquotedMVar : Lean.MVarId) → motive (Qq.Impl.MVarSynth.type unquotedMVar)) → motive t | null | false |
MulAut.applyMulAction._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_1} [inst : Monoid M] (x : M), 1 • x = 1 • x | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {outWidth : ℕ} {aig : Std.Sat.AIG α} {w len : ℕ} (iterNum : ℕ)
(oldLayer : aig.RefVec (len * w)) (newLayer : aig.RefVec (iterNum * w)) (hold : 2 * (iterNum - 1) < len)
(hout : outWidth = (len + 1) / 2 * w),
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLaye... | null | true |
_private.Mathlib.Data.Set.Sigma.0.Set.empty_sigma._proof_1_1 | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)}, ∅.sigma t = ∅ | null | false |
NNReal.not_toReal_neg | Mathlib.Basic.NNReal.Defs | ∀ {r : NNReal}, ¬↑r < 0 | null | true |
FractionalIdeal.eq_spanSingleton_mul | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] {x : P} {I J : FractionalIdeal S P},
I = (FractionalIdeal.spanSingleton S) x * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I | null | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.leftUnitorInvM | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m] →
[Mathlib.Tactic.BicategoryLike.MonadNormalExpr m] →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.NormalExpr | The inverse of the left unitor as a term of `normalExpr`. | true |
AList.insert_singleton_eq | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b b' : β a},
AList.insert a b (AList.singleton a b') = AList.singleton a b | null | true |
RootPairing.Base.cartanMatrix_apply_eq_zero_iff_pairing | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : P.IsCrystallographic] [CharZero R] {i j : ↥b.support}, b.cartanMatrix i j = 0 ↔ P.pairing... | null | true |
DividedPowers.SubDPIdeal.instCompleteLattice._simp_5 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
ApplicativeTransformation.instCoeFunForallForall | Mathlib.Control.Traversable.Basic | (F : Type u → Type v) →
[inst : Applicative F] →
(G : Type u → Type w) →
[inst_1 : Applicative G] → CoeFun (ApplicativeTransformation F G) fun x => {α : Type u} → F α → G α | null | true |
CategoryTheory.Limits.WalkingPair.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | {motive : CategoryTheory.Limits.WalkingPair → Sort u} →
(ctorIdx : ℕ) →
(t : CategoryTheory.Limits.WalkingPair) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingPair.ctorElimType ctorIdx → motive t | null | false |
Concept.isUpperSet_intent_le | Mathlib.Order.Concept | ∀ {α : Type u_5} [inst : Preorder α] (c : Concept α α fun x1 x2 => x1 ≤ x2), IsUpperSet c.intent | null | true |
MonomialOrder.leadingTerm_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι},
(∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.leadingTerm (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingTerm (P i) | null | true |
TestFunction.instModuleOfSMulCommClassRealOfContinuousConstSMul | Mathlib.Analysis.Distribution.TestFunction | {E : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_4} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{R : Type u_6} →
[inst_4 : S... | null | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.elabTranslationAttr.match_9 | Mathlib.Tactic.Translate.Core | (motive : Option (Array (Lean.TSyntax `Mathlib.Tactic.Translate.bracketedOption)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `Mathlib.Tactic.Translate.bracketedOption))) →
((opts : Array (Lean.TSyntax `Mathlib.Tactic.Translate.bracketedOption)) → motive (some opts)) →
(Unit → motive none) → motive x | null | false |
ProbabilityTheory.aestronglyMeasurable_integral_condDistrib | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | null | true |
CategoryTheory.MorphismProperty.MapFactorizationData.op._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W₁ W₂ : CategoryTheory.MorphismProperty C) {X Y : C}
{f : X ⟶ Y} (hf : W₁.MapFactorizationData W₂ f), (CategoryTheory.CategoryStruct.comp hf.p.op hf.i.op).unop = f.op.unop | null | false |
LinearIsometryEquiv.withLpProdAssoc._proof_2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_4) (α : Type u_3) (β : Type u_2) (γ : Type u_1) [hp : Fact (1 ≤ p)] [inst : Semiring 𝕜]
[inst_1 : SeminormedAddCommGroup α] [inst_2 : Module 𝕜 α] [inst_3 : SeminormedAddCommGroup β] [inst_4 : Module 𝕜 β]
[inst_5 : SeminormedAddCommGroup γ] [inst_6 : Module 𝕜 γ] (x : 𝕜) (x_1 : WithL... | null | false |
MonoidAlgebra.symm_mapDomainLinearEquiv | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : Module R S] (e : M ≃ N),
(MonoidAlgebra.mapDomainLinearEquiv R S e).symm = MonoidAlgebra.mapDomainLinearEquiv R S e.symm | null | true |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabImport._regBuiltin.Lean.Elab.Command.elabImport.declRange_3 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
instDecidableEqAdditive | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [h : DecidableEq α] → DecidableEq (Additive α) | null | true |
MeasureTheory.Lp.simpleFunc.stronglyMeasurable | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {p : ENNReal}
{μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp.simpleFunc E p μ)),
MeasureTheory.StronglyMeasurable ⇑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f) | null | true |
UniformSpace.Completion.ring._proof_5 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [IsUniformAddGroup α],
Continuous fun x => x.1 * x.2.1 * x.2.2 | null | false |
Fin.castSucc_lt_or_lt_succ | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), i.castSucc < p ∨ p < i.succ | null | true |
CategoryTheory.ShortComplex.instSubHom._proof_4 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ φ' : S₁ ⟶ S₂),
CategoryTheory.CategoryStruct.comp (φ.τ₂ - φ'.τ₂) S₂.g = CategoryTheory.CategoryStruct.comp S₁.g (φ.τ₃ - φ'.τ₃) | null | false |
String.Slice.Pos.instLawfulOrderLT | Init.Data.String.OrderInstances | ∀ {s : String.Slice}, Std.LawfulOrderLT s.Pos | null | true |
Submodule.reflection_orthogonal_apply | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (v : E), Kᗮ.reflection v = -K.reflection v | null | true |
CategoryTheory.PreOneHypercover.sigmaOfIsColimit_Y | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S)
{c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan E.Y'}
(hd : CategoryTheory.Limits.IsColimit d) (x x_1 : (E.sigmaOfIsColimit hc).I₀) (x_2 : PUnit.{w... | null | true |
ZFSet.image.mk | Mathlib.SetTheory.ZFC.Basic | ∀ (f : ZFSet.{u} → ZFSet.{u}) [inst : ZFSet.Definable₁ f] (x : ZFSet.{u}) {y : ZFSet.{u}}, y ∈ x → f y ∈ ZFSet.image f x | null | true |
Lean.Meta.Simp.ConfigCtx.memoize._inherited_default | Init.MetaTypes | Bool | null | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.exists_kerSquareLift_comp_eq_id | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_1) [inst : CommRing R] {A : Type u} {B : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B),
∃ σ₀,
(Ideal.Quotient.mkₐ (↥(Algebra.Smooth.DescentAux.subalgebra✝ R D))
(Ideal.span
(Set... | null | true |
Mathlib.Tactic.ExtendDocs.commandExtend_docs__Before__After_ | Mathlib.Tactic.ExtendDoc | Lean.ParserDescr | `extend_docs <declName> before <prefix_string> after <suffix_string>` extends the
docs of `<declName>` by adding `<prefix_string>` before and `<suffix_string>` after. | true |
_private.Mathlib.Data.Finset.Image.0.Finset.image_singleton._proof_1_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (f : α → β) (a : α), Finset.image f {a} = {f a} | null | false |
Std.Time.Hour.instDecidableLtOrdinal._aux_1 | Std.Time.Time.Unit.Hour | {x y : Std.Time.Hour.Ordinal} → Decidable (x < y) | null | false |
ENNReal.exists_inv_nat_lt | Mathlib.Basic.ENNReal.Inv | ∀ {a : ENNReal}, a ≠ 0 → ∃ n, (↑n)⁻¹ < a | null | true |
Lean.LLVM.Value.noConfusionType | Lean.Compiler.IR.LLVMBindings | Sort u → {ctx : Lean.LLVM.Context} → Lean.LLVM.Value ctx → {ctx' : Lean.LLVM.Context} → Lean.LLVM.Value ctx' → Sort u | null | false |
instCommCStarAlgebraForall._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → CommCStarAlgebra (A i)] (a : (i : ι) → A i),
0 * a = 0 | null | false |
CategoryTheory.Cokleisli.Hom.noConfusion | Mathlib.CategoryTheory.Monad.Kleisli | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{U : CategoryTheory.Comonad C} →
{c c' : CategoryTheory.Cokleisli U} →
{t : c.Hom c'} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{U' : CategoryTheory.C... | null | false |
Algebra.Extension.self_σ | Mathlib.RingTheory.Extension.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (a : S),
(Algebra.Extension.self R S).σ a = id a | null | true |
Valuation.RankOne.rec | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} →
{motive : v.RankOne → Sort u} →
([toRankLeOne : v.RankLeOne] →
[toIsNontrivial : v.IsNontrivial] →
motive { toRankLeOne :... | null | false |
ProbabilityTheory.Kernel.iIndepFun.indepFun_sub_left | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β} [inst : Sub β]
[MeasurableSub₂ β] {f : ι → Ω → β},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), Mea... | null | true |
Eq.propIntro | Init.Core | ∀ {a b : Prop}, (a → b) → (b → a) → a = b | null | true |
_private.Mathlib.CategoryTheory.Galois.EssSurj.0.CategoryTheory.PreGaloisCategory.coconeQuotientDiagIsColimit | Mathlib.CategoryTheory.Galois.EssSurj | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
[inst_1 : CategoryTheory.GaloisCategory C] →
[inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F] →
{V U : OpenSubgroup (CategoryTheory.Aut F)} →
(h : (↑U).Normal) →
... | The constructed cocone `coconeQuotientDiag` on the diagram `quotientDiag` is colimiting. | true |
Int.lcm_one_left | Init.Data.Int.Gcd | ∀ (a : ℤ), Int.lcm 1 a = a.natAbs | null | true |
Finset.inf_one | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : One α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β] (f : α → β),
Finset.inf 1 f = f 1 | null | true |
CategoryTheory.WithTerminal.noConfusion | Mathlib.CategoryTheory.WithTerminal.Basic | {P : Sort u_1} →
{C : Type u} →
{t : CategoryTheory.WithTerminal C} →
{C' : Type u} →
{t' : CategoryTheory.WithTerminal C'} → C = C' → t ≍ t' → CategoryTheory.WithTerminal.noConfusionType P t t' | null | false |
Nat.mul_add_mod_of_lt | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, c < b → (a * b + c) % b = c | null | true |
regularSpace_induced | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [RegularSpace X] (f : Y → X), RegularSpace Y | null | true |
IntermediateField.coe_inf | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
(S T : IntermediateField F E), ↑(S ⊓ T) = ↑S ∩ ↑T | null | true |
_private.Std.Http.Transport.0.Std.Http.Internal.Mock.Client.mk.inj | Std.Http.Transport | ∀ {shared shared_1 : Std.Http.Internal.Mock.SharedState✝},
{ shared := shared } = { shared := shared_1 } → shared = shared_1 | null | true |
Batteries.UFNode._sizeOf_1 | Batteries.Data.UnionFind.Basic | Batteries.UFNode → ℕ | null | false |
OptionT.orElse.match_1 | Init.Control.Option | {α : Type u_1} →
(motive : Option α → Sort u_2) →
(__do_lift : Option α) → ((a : α) → motive (some a)) → ((x : Option α) → motive x) → motive __do_lift | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_415 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.rightUnitor._proof_5 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
AhlswedeZhang.infSum_eq_one | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {𝒜 : Finset (Finset α)} [Nonempty α],
𝒜.Nonempty → ∅ ∉ 𝒜 → AhlswedeZhang.infSum 𝒜 = 1 | The **Ahlswede-Zhang Identity**. | true |
ContinuousMap.HomotopyEquiv.refl_apply | Mathlib.Topology.Homotopy.Equiv | ∀ (X : Type u) [inst : TopologicalSpace X] (a : X), (ContinuousMap.HomotopyEquiv.refl X).toFun a = a | null | true |
Polynomial.IsSplittingField.instIsTorsionFreeSplittingField | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K), Module.IsTorsionFree K f.SplittingField | null | true |
CommRingCat.adj._proof_3 | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ {X : Type u_1} {Y Y' : CommRingCat} (f : CommRingCat.free.obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => TypeCat.ofHom (MvPolynomial.homEquiv (CommRingCat.Hom.hom f)),
invFun := fun f => CommRingCat.ofHom (MvPolynomial.homEquiv.symm ⇑(CategoryTheory.ConcreteCategory.hom f)),
left_inv := ⋯, right_inv :... | null | false |
Std.DTreeMap.Internal.Impl.erase.induct | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α)
(motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Prop),
(∀ (hr : Std.DTreeMap.Internal.Impl.leaf.Balanced), motive Std.DTreeMap.Internal.Impl.leaf hr) →
(∀ (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hr : (St... | null | true |
List.Nodup.sdiff_eq_filter | Mathlib.Data.List.Nodup | ∀ {α : Type u} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ l₂ : List α},
l₁.Nodup → l₁.diff l₂ = List.filter (fun x => decide (x ∉ l₂)) l₁ | null | true |
Filter.EventuallyConst.mulIndicator_const_iff | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : One β] {s : Set α} {c : β},
Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ c = 1 ∨ Filter.EventuallyConst s l | null | true |
CategoryTheory.ChosenPullbacksAlong.lift_snd_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z X : C} {f : Y ⟶ X} {g : Z ⟶ X}
[inst_1 : CategoryTheory.ChosenPullbacksAlong g] {W : C} (a : W ⟶ Y) (b : W ⟶ Z)
(h : autoParam (CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g) _auto_83✝) {Z_1 : C}
(h_1 : Z ⟶ Z_1),
... | null | true |
Turing.TM2to1.addBottom.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} (L : Turing.ListBlank ((k : K) → Option (Γ k))),
Turing.TM2to1.addBottom L =
Turing.ListBlank.cons (true, L.head) (Turing.ListBlank.map { f := Prod.mk false, map_pt' := ⋯ } L.tail) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.mkAddNat | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Expr → Lean.Expr → Lean.Expr | null | true |
RestrictScalars.module | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) →
(S : Type u_2) →
(M : Type u_3) →
[inst : Semiring S] →
[inst_1 : AddCommMonoid M] →
[inst_2 : CommSemiring R] → [Algebra R S] → [Module S M] → Module R (RestrictScalars R S M) | When `M` is a module over a ring `S`, and `S` is an algebra over `R`, then `M` inherits a
module structure over `R`.
The preferred way of setting this up is `[Module R M] [Module S M] [IsScalarTower R S M]`.
| true |
_private.Mathlib.CategoryTheory.Monoidal.Comon_.0.CategoryTheory.Comon.Hom.ext.match_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{M N : CategoryTheory.Comon C} (motive : M.Hom N → Prop) (h : M.Hom N),
(∀ (hom : M.X ⟶ N.X) (isComonHom_hom : CategoryTheory.IsComonHom hom),
motive { hom := hom, isComonHom_hom := isComonHom_hom }) →
... | null | false |
Std.DHashMap.Raw.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α] {l : List α}
{k : α}, l.contains k = false → (Std.DHashMap.Raw.Const.unitOfList l).getKey! k = default | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.le_maxKey_of_contains._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Std.Tactic.BVDecide.Reflect.BitVec.clz_congr | Std.Tactic.BVDecide.Reflect | ∀ (w : ℕ) (x x' : BitVec w), x = x' → x'.clz = x.clz | null | true |
_private.Mathlib.MeasureTheory.OuterMeasure.Basic.0.MeasureTheory.OuterMeasure.iUnion_nat_of_monotone_of_tsum_ne_top._simp_1_2 | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.proj._regBuiltin.Lean.Parser.Term.proj.parenthesizer_13 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.Data.List.Permutation.0.List.nodup_permutations'Aux_of_notMem._simp_1_5 | Mathlib.Data.List.Permutation | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | null | false |
_private.Mathlib.Tactic.NormNum.Inv.0.Mathlib.Meta.NormNum.isNat_inv_one.match_1_1 | Mathlib.Tactic.NormNum.Inv | ∀ {α : Type u_1} [inst : DivisionSemiring α] (motive : (x : α) → Mathlib.Meta.NormNum.IsNat x 1 → Prop) (x : α)
(x_1 : Mathlib.Meta.NormNum.IsNat x 1), (∀ (_ : Unit), motive ↑1 ⋯) → motive x x_1 | null | false |
CategoryTheory.instCompleteLatticeSubfunctor._proof_11 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F : CategoryTheory.Functor C (Type u_1)}
(x : Set (CategoryTheory.Subfunctor F)),
∀ x_1 ∈ x,
∀ (x_3 : C), ∀ x_4 ∈ x_1.obj x_3, x_4 ∈ { obj := fun U => sSup ((fun T => T.obj U) '' x), map := ⋯ }.obj x_3 | null | false |
Cardinal.sum_le_mk_mul_iSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι : Type u} (f : ι → Cardinal.{u}), Cardinal.sum f ≤ Cardinal.mk ι * ⨆ i, f i | null | true |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.getHaveTelescopeInfo.collect.match_1 | Lean.Meta.HaveTelescope | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (t v b : Lean.Expr) → motive (Lean.Expr.letE n t v b true)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
OrderIso.equivalence | Mathlib.CategoryTheory.Category.Preorder | {X : Type u} → {Y : Type v} → [inst : Preorder X] → [inst_1 : Preorder Y] → X ≃o Y → (X ≌ Y) | The equivalence of categories `X ≌ Y` induced by `e : X ≃o Y`. | true |
Matrix.IsFiniteCartan.mk._flat_ctor | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {M : Matrix ι ι ℤ},
(∀ (i : ι), M i i = 2) →
(∀ (i j : ι), i ≠ j → M i j ≤ 0) →
(∀ (i j : ι), M i j = 0 ↔ M j i = 0) →
(∃ d, (∀ (i : ι), 0 < d i) ∧ (Matrix.diagonal d * M).PosDef) → M.IsFiniteCartan | null | false |
Set.MapsTo.image_subset | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.MapsTo f s t → f '' s ⊆ t | null | true |
MonTypeEquivalenceMon.functor._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ {X Y : CategoryTheory.Mon (Type u_1)} (f : X ⟶ Y),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one f.hom))
PUnit.unit =
(CategoryTheory.ConcreteCategory.hom CategoryTheory.MonObj.one) PUnit.unit | null | false |
CategoryTheory.Bicategory.Equivalence.adj_unit | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {a b : B} (e : CategoryTheory.Bicategory.Equivalence a b),
e.adj.unit = e.unit.hom | null | true |
Wbtw.dist_add_dist | Mathlib.Analysis.Normed.Affine.Convex | ∀ {E : Type u_1} {P : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : PseudoMetricSpace P] [inst_3 : NormedAddTorsor E P] {x y z : P},
Wbtw ℝ x y z → dist x y + dist y z = dist x z | null | true |
spectrum_star_mul_self_nonneg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A] {b : A}, ∀ x ∈ spectrum ℝ (star b * b), 0 ≤ x | The `ℝ`-spectrum of an element of the form `star b * b` in a C⋆-algebra is nonnegative.
This is the key result used to establish `CStarAlgebra.instNonnegSpectrumClass`. | true |
AlgebraicGeometry.Scheme.Hom.smooth_appLE | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [self : AlgebraicGeometry.Smooth f] {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ {V : X.Opens},
AlgebraicGeometry.IsAffineOpen V →
∀ (e : V ≤ (TopologicalSpace.Opens.map f.base).obj U),
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom... | **Alias** of `AlgebraicGeometry.Smooth.smooth_appLE`. | true |
Valuation.restrict_pos_iff | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
(x : R), 0 < v.restrict x ↔ 0 < v x | null | true |
String.Slice.Pattern.BackwardPattern.skipSuffix?_prop_eq_skipSuffix?_decide | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice},
String.Slice.Pattern.BackwardPattern.skipSuffix? p s =
String.Slice.Pattern.BackwardPattern.skipSuffix? (fun x => decide (p x)) s | null | true |
CategoryTheory.Limits.PreservesColimit₂ | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | {J₁ : Type u_1} →
{J₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] →
{C₁ : Type u_3} →
{C₂ : Type u_4} →
{C : Type u_5} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] →
[inst_3 ... | A functor `PreservesColimit₂ K₁ K₂` if whenever `c₁` is a colimit cocone and `c₂` is a colimit
cocone then `G.mapCocone₂ c₁ c₂` is a colimit cocone. This can be thought of as the data of an
isomorphism
$\mathrm{colim}_{(j_1,j_2)} G(K_1(j_1),K_2(j_2)) \simeq G(\mathrm{colim} K_1,\mathrm{colim} K_2)$.
| true |
CategoryTheory.Abelian.Ext.mapExactFunctor₀ | Mathlib.Algebra.Homology.DerivedCategory.Ext.Map | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
[inst_4 : F.Additive] [inst_5 : CategoryTheory.Limits.PreservesFiniteLimits F]
[ins... | null | true |
CategoryTheory.NatIso.inv_inv_app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G) (X : C), CategoryTheory.inv (e.inv.app X) = e.hom.app X | null | true |
CategoryTheory.Localization.Monoidal.curriedTensorPreIsoPost | Mathlib.CategoryTheory.Localization.Monoidal.Functor | {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] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[inst_4 : Category... | The natural isomorphism of bifunctors `F - ⊗ F - ≅ F (- ⊗ -)`, given that `F` lifts along `L`
to a monoidal functor `G`, where `L` is a monoidal localization functor.
| true |
System.Platform.System.Platform.numBits_dvd._simp_1 | Init.System.Platform | (System.Platform.numBits ∣ 64) = True | null | false |
_private.Mathlib.LinearAlgebra.Vandermonde.0.Matrix.det_vandermonde_sub._simp_1_1 | Mathlib.LinearAlgebra.Vandermonde | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
_private.Std.Sync.Broadcast.0.Std.Bounded.Receiver.unsubscribe.match_3 | Std.Sync.Broadcast | (motive : Except Std.Broadcast.Error Unit → Sort u_1) →
(id : Except Std.Broadcast.Error Unit) →
((res : Std.Broadcast.Error) → motive (Except.error res)) → ((a : Unit) → motive (Except.ok a)) → motive id | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.