name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Aesop.traceSimpTheoremTreeContents
|
Aesop.Tracing
|
Lean.Meta.SimpTheoremTree → Aesop.TraceOption → Lean.CoreM Unit
|
OnePoint.not_specializes_infty_coe
|
Mathlib.Topology.Compactification.OnePoint.Basic
|
∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, ¬OnePoint.infty ⤳ ↑x
|
IsFreeGroupoid.SpanningTree.treeHom.eq_1
|
Mathlib.GroupTheory.FreeGroup.NielsenSchreier
|
∀ {G : Type u} [inst : CategoryTheory.Groupoid G] [inst_1 : IsFreeGroupoid G]
(T : WideSubquiver (Quiver.Symmetrify (IsFreeGroupoid.Generators G)))
[inst_2 : Quiver.Arborescence (WideSubquiver.toType (Quiver.Symmetrify (IsFreeGroupoid.Generators G)) T)] (a : G),
IsFreeGroupoid.SpanningTree.treeHom T a = IsFreeGroupoid.SpanningTree.homOfPath T default
|
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp_inv_app_fst_app
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
|
∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A₁] [inst_4 : CategoryTheory.Category.{v₅, u₅} B₁]
[inst_5 : CategoryTheory.Category.{v₆, u₆} C₁] {F₁ : CategoryTheory.Functor A₁ B₁} {G₁ : CategoryTheory.Functor C₁ B₁}
{A₂ : Type u₇} {B₂ : Type u₈} {C₂ : Type u₉} [inst_6 : CategoryTheory.Category.{v₇, u₇} A₂]
[inst_7 : CategoryTheory.Category.{v₈, u₈} B₂] [inst_8 : CategoryTheory.Category.{v₉, u₉} C₂]
{F₂ : CategoryTheory.Functor A₂ B₂} {G₂ : CategoryTheory.Functor C₂ B₂} (X : Type u₁₀)
[inst_9 : CategoryTheory.Category.{v₁₀, u₁₀} X] (ψ : CategoryTheory.Limits.CatCospanTransform F G F₁ G₁)
(ψ' : CategoryTheory.Limits.CatCospanTransform F₁ G₁ F₂ G₂)
(X_1 : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X) (x : X),
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp X ψ ψ').inv.app X_1).fst.app x =
CategoryTheory.CategoryStruct.id (ψ'.left.obj (ψ.left.obj (X_1.fst.obj x)))
|
HopfAlgCat.tensorUnit_carrier
|
Mathlib.Algebra.Category.HopfAlgCat.Monoidal
|
∀ (R : Type u) [inst : CommRing R], (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier = R
|
LawfulFix.mk._flat_ctor
|
Mathlib.Control.LawfulFix
|
{α : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
(fix : (α → α) → α) →
(∀ {f : α → α}, OmegaCompletePartialOrder.ωScottContinuous f → fix f = f (fix f)) → LawfulFix α
|
CategoryTheory.Limits.coequalizer.isoTargetOfSelf_inv
|
Mathlib.CategoryTheory.Limits.Shapes.Equalizers
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
(CategoryTheory.Limits.coequalizer.isoTargetOfSelf f).inv = CategoryTheory.Limits.coequalizer.π f f
|
Real.le_sqrt'
|
Mathlib.Data.Real.Sqrt
|
∀ {x y : ℝ}, 0 < x → (x ≤ √y ↔ x ^ 2 ≤ y)
|
Set.disjoint_of_subset_iff_left_eq_empty
|
Mathlib.Order.BooleanAlgebra.Set
|
∀ {α : Type u_1} {s t : Set α}, s ⊆ t → (Disjoint s t ↔ s = ∅)
|
MeasureTheory.Lp.instLattice
|
Mathlib.MeasureTheory.Function.LpOrder
|
{α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst : NormedAddCommGroup E] →
[inst_1 : Lattice E] → [HasSolidNorm E] → [IsOrderedAddMonoid E] → Lattice ↥(MeasureTheory.Lp E p μ)
|
CauSeq.Completion.Cauchy.field._proof_6
|
Mathlib.Algebra.Order.CauSeq.Completion
|
∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_1}
[inst_3 : Field β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], Nontrivial (CauSeq.Completion.Cauchy abv)
|
groupCohomology.functor
|
Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality
|
(k G : Type u) → [inst : CommRing k] → [inst_1 : Group G] → ℕ → CategoryTheory.Functor (Rep k G) (ModuleCat k)
|
Equiv.apply_eq_iff_eq_symm_apply
|
Mathlib.Logic.Equiv.Defs
|
∀ {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β), f x = y ↔ x = f.symm y
|
_private.Mathlib.SetTheory.PGame.Algebra.0.SetTheory.PGame.addAssocRelabelling.match_1._arg_pusher
|
Mathlib.SetTheory.PGame.Algebra
|
∀ (motive : SetTheory.PGame → SetTheory.PGame → SetTheory.PGame → Sort u_2) (α : Sort u✝) (β : α → Sort v✝)
(f : (x : α) → β x) (rel : SetTheory.PGame → SetTheory.PGame → SetTheory.PGame → α → Prop)
(x x_1 x_2 : SetTheory.PGame)
(h_1 :
(xl xr : Type u_1) →
(xL : xl → SetTheory.PGame) →
(xR : xr → SetTheory.PGame) →
(yl yr : Type u_1) →
(yL : yl → SetTheory.PGame) →
(yR : yr → SetTheory.PGame) →
(zl zr : Type u_1) →
(zL : zl → SetTheory.PGame) →
(zR : zr → SetTheory.PGame) →
((y : α) →
rel (SetTheory.PGame.mk xl xr xL xR) (SetTheory.PGame.mk yl yr yL yR)
(SetTheory.PGame.mk zl zr zL zR) y →
β y) →
motive (SetTheory.PGame.mk xl xr xL xR) (SetTheory.PGame.mk yl yr yL yR)
(SetTheory.PGame.mk zl zr zL zR)),
((match (motive := (x x_3 x_4 : SetTheory.PGame) → ((y : α) → rel x x_3 x_4 y → β y) → motive x x_3 x_4) x, x_1,
x_2 with
| SetTheory.PGame.mk xl xr xL xR, SetTheory.PGame.mk yl yr yL yR, SetTheory.PGame.mk zl zr zL zR => fun x =>
h_1 xl xr xL xR yl yr yL yR zl zr zL zR x)
fun y h => f y) =
match x, x_1, x_2 with
| SetTheory.PGame.mk xl xr xL xR, SetTheory.PGame.mk yl yr yL yR, SetTheory.PGame.mk zl zr zL zR =>
h_1 xl xr xL xR yl yr yL yR zl zr zL zR fun y h => f y
|
contractRight_apply
|
Mathlib.LinearAlgebra.Contraction
|
∀ {R : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f : Module.Dual R M) (m : M), (contractRight R M) (m ⊗ₜ[R] f) = f m
|
MeromorphicAt.order_inv
|
Mathlib.Analysis.Meromorphic.Order
|
∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {f : 𝕜 → 𝕜},
meromorphicOrderAt f⁻¹ x = -meromorphicOrderAt f x
|
Lean.Elab.Do.ContVarInfo.tunneledVars
|
Lean.Elab.Do.Basic
|
Lean.Elab.Do.ContVarInfo → Std.HashSet Lean.Name
|
WithZero.instDivisionMonoid.match_1
|
Mathlib.Algebra.GroupWithZero.WithZero
|
∀ {α : Type u_1} (motive : WithZero α → WithZero α → Prop) (x x_1 : WithZero α),
(∀ (a : Unit), motive none none) →
(∀ (val : α), motive none (some val)) →
(∀ (val : α), motive (some val) none) → (∀ (val val_1 : α), motive (some val) (some val_1)) → motive x x_1
|
Lean.ClassState._sizeOf_inst
|
Lean.Class
|
SizeOf Lean.ClassState
|
SemilatInfCat.instConcreteCategoryInfTopHomX._proof_3
|
Mathlib.Order.Category.Semilat
|
∀ {X : SemilatInfCat} (x : X.X), (CategoryTheory.CategoryStruct.id X) x = x
|
UniformSpace.Completion.completionSeparationQuotientEquiv._proof_2
|
Mathlib.Topology.UniformSpace.Completion
|
∀ (α : Type u_1) [inst : UniformSpace α] (a : UniformSpace.Completion α),
UniformSpace.Completion.extension (SeparationQuotient.lift' UniformSpace.Completion.coe')
(UniformSpace.Completion.map SeparationQuotient.mk a) =
a
|
of_eq_false
|
Init.SimpLemmas
|
∀ {p : Prop}, p = False → ¬p
|
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_mul._simp_1_2
|
Mathlib.NumberTheory.ZetaValues
|
∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c
|
ContinuousLinearMapWOT.instAddCommGroup
|
Mathlib.Analysis.LocallyConvex.WeakOperatorTopology
|
{𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
{σ : 𝕜₁ →+* 𝕜₂} →
{E : Type u_3} →
{F : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E] →
[inst_5 : AddCommGroup F] →
[inst_6 : TopologicalSpace F] →
[inst_7 : Module 𝕜₂ F] → [IsTopologicalAddGroup F] → AddCommGroup (E →SWOT[σ] F)
|
Pi.instLTLexForall
|
Mathlib.Order.PiLex
|
{ι : Type u_1} → {β : ι → Type u_2} → [LT ι] → [(a : ι) → LT (β a)] → LT (Lex ((i : ι) → β i))
|
AlternatingMap.domLCongr._proof_1
|
Mathlib.LinearAlgebra.Alternating.Basic
|
∀ (R : Type u_1) [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (N : Type u_3)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ι : Type u_4) {M₂ : Type u_5} [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] (e : M ≃ₗ[R] M₂) (x x_1 : M [⋀^ι]→ₗ[R] N),
(x + x_1).compLinearMap ↑e.symm = (x + x_1).compLinearMap ↑e.symm
|
Lean.Parser.Command.export._regBuiltin.Lean.Parser.Command.export.parenthesizer_13
|
Lean.Parser.Command
|
IO Unit
|
Real.cos_add
|
Mathlib.Analysis.Complex.Trigonometric
|
∀ (x y : ℝ), Real.cos (x + y) = Real.cos x * Real.cos y - Real.sin x * Real.sin y
|
pointedToTwoPSndForgetCompBipointedToPointedSndAdjunction._proof_5
|
Mathlib.CategoryTheory.Category.TwoP
|
∀ (X : Pointed) (Y : TwoP) (f : pointedToTwoPSnd.obj X ⟶ Y),
f.toFun (pointedToTwoPSnd.obj X).toBipointed.toProd.2 = Y.toBipointed.toProd.2
|
ArithmeticFunction.vonMangoldt_sum
|
Mathlib.NumberTheory.ArithmeticFunction.VonMangoldt
|
∀ {n : ℕ}, ∑ i ∈ n.divisors, ArithmeticFunction.vonMangoldt i = Real.log ↑n
|
IsEvenlyCovered.subtypeVal_comp
|
Mathlib.Topology.Covering.Basic
|
∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] (s : Set X) {I : Type u_3}
[inst_2 : TopologicalSpace I],
IsOpen s → ∀ {x : ↑s} {f : E → ↑s}, IsEvenlyCovered f x I → IsEvenlyCovered (Subtype.val ∘ f) (↑x) I
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ext
|
Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation
|
∀ {numVarsSucc : ℕ} {x y : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula numVarsSucc},
x.clauses = y.clauses → x.rupUnits = y.rupUnits → x.ratUnits = y.ratUnits → x.assignments = y.assignments → x = y
|
Matrix.blockDiag'_transpose
|
Mathlib.Data.Matrix.Block
|
∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12}
(M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o), M.transpose.blockDiag' k = (M.blockDiag' k).transpose
|
Finmap.union_toFinmap
|
Mathlib.Data.Finmap
|
∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : AList β), s₁.toFinmap ∪ s₂.toFinmap = (s₁ ∪ s₂).toFinmap
|
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.registerFailedToInferDefTypeInfo._sparseCasesOn_7
|
Lean.Elab.MutualDef
|
{motive : Lean.Elab.DefKind → Sort u} →
(t : Lean.Elab.DefKind) →
motive Lean.Elab.DefKind.example →
motive Lean.Elab.DefKind.instance →
motive Lean.Elab.DefKind.theorem → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t
|
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorBinaryRefVecBlastUmod
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod
|
∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.BinaryRefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastUmod
|
CategoryTheory.Abelian.LeftResolution.chainComplexMap_f_succ_succ
|
Mathlib.Algebra.Homology.LeftResolution.Basic
|
∀ {A : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} (f : X ⟶ Y) [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5 : CategoryTheory.Abelian A] (n : ℕ),
(Λ.chainComplexMap f).f (n + 2) =
CategoryTheory.CategoryStruct.comp (Λ.chainComplexXIso X n).hom
(CategoryTheory.CategoryStruct.comp
(Λ.F.map
(CategoryTheory.Limits.kernel.map (ι.map ((Λ.chainComplex X).d (n + 1) n))
(ι.map ((Λ.chainComplex Y).d (n + 1) n)) (ι.map ((Λ.chainComplexMap f).f (n + 1)))
(ι.map ((Λ.chainComplexMap f).f n)) ⋯))
(Λ.chainComplexXIso Y n).inv)
|
instMulActionRayVector._proof_1
|
Mathlib.LinearAlgebra.Ray
|
∀ {M : Type u_1} [inst : AddCommMonoid M] {G : Type u_2} [inst_1 : Group G] [inst_2 : DistribMulAction G M] (r : G)
(x : M), x ≠ 0 → r • x ≠ 0
|
AntivaryOn.card_mul_sum_le_sum_mul_sum
|
Mathlib.Algebra.Order.Chebyshev
|
∀ {ι : Type u_1} {α : Type u_2} [inst : Semiring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
{s : Finset ι} {f g : ι → α}, AntivaryOn f g ↑s → ↑s.card * ∑ i ∈ s, f i * g i ≤ (∑ i ∈ s, f i) * ∑ i ∈ s, g i
|
PSigma.fintypePropRight.match_5
|
Mathlib.Data.Fintype.Basic
|
∀ {α : Type u_1} {β : α → Prop} (motive : { a // β a } → Prop) (x : { a // β a }),
(∀ (val : α) (property : β val), motive ⟨val, property⟩) → motive x
|
AlgebraicGeometry.IsClosedImmersion.lift_fac
|
Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion
|
∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g H) f = g
|
Aesop.CoreRuleBuilderOutput.noConfusion
|
Aesop.Builder.Basic
|
{P : Sort u} → {t t' : Aesop.CoreRuleBuilderOutput} → t = t' → Aesop.CoreRuleBuilderOutput.noConfusionType P t t'
|
Continuous.compCM
|
Mathlib.Topology.CompactOpen
|
∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [LocallyCompactPair Y Z] {X' : Type u_6} [inst_4 : TopologicalSpace X']
{g : X' → C(Y, Z)} {f : X' → C(X, Y)}, Continuous g → Continuous f → Continuous fun x => (g x).comp (f x)
|
Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom
|
Mathlib.GroupTheory.Perm.Centralizer
|
∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α},
Nat.card ↥(Equiv.Perm.OnCycleFactors.toPermHom g).range =
∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial
|
NonUnitalStarAlgebra.elemental.isClosedEmbedding_coe
|
Mathlib.Topology.Algebra.NonUnitalStarAlgebra
|
∀ (R : Type u_1) {A : Type u_2} [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] [inst_8 : TopologicalSpace A] [inst_9 : IsTopologicalSemiring A]
[inst_10 : ContinuousConstSMul R A] [inst_11 : ContinuousStar A] (x : A), Topology.IsClosedEmbedding Subtype.val
|
CategoryTheory.Conv.instMul
|
Mathlib.CategoryTheory.Monoidal.Conv
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : C} → [CategoryTheory.ComonObj M] → [CategoryTheory.MonObj N] → Mul (CategoryTheory.Conv M N)
|
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.getElem?_toList._simp_1_4
|
Mathlib.Data.Seq.Basic
|
∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a)
|
LaurentPolynomial.degree_T_le
|
Mathlib.Algebra.Polynomial.Laurent
|
∀ {R : Type u_1} [inst : Semiring R] (n : ℤ), (LaurentPolynomial.T n).degree ≤ ↑n
|
Real.fderiv_fourier
|
Mathlib.Analysis.Fourier.FourierTransformDeriv
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E},
MeasureTheory.Integrable f MeasureTheory.volume →
MeasureTheory.Integrable (fun v => ‖v‖ * ‖f v‖) MeasureTheory.volume →
fderiv ℝ (FourierTransform.fourier f) = FourierTransform.fourier (VectorFourier.fourierSMulRight (innerSL ℝ) f)
|
CategoryTheory.FinCategory.mk
|
Mathlib.CategoryTheory.FinCategory.Basic
|
{J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
autoParam (Fintype J) CategoryTheory.FinCategory.fintypeObj._autoParam →
autoParam ((j j' : J) → Fintype (j ⟶ j')) CategoryTheory.FinCategory.fintypeHom._autoParam →
CategoryTheory.FinCategory J
|
AddSubgroup.index
|
Mathlib.GroupTheory.Index
|
{G : Type u_1} → [inst : AddGroup G] → AddSubgroup G → ℕ
|
NumberField.mixedEmbedding.convexBodyLT'_volume
|
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody
|
∀ (K : Type u_1) [inst : Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex })
[inst_1 : NumberField K],
MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀) =
↑(NumberField.mixedEmbedding.convexBodyLT'Factor K) * ↑(∏ w, f w ^ w.mult)
|
Std.ExtTreeMap.toList_inj
|
Std.Data.ExtTreeMap.Lemmas
|
∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α β cmp},
t₁.toList = t₂.toList ↔ t₁ = t₂
|
Num.commSemiring._proof_4
|
Mathlib.Data.Num.Lemmas
|
∀ (x x_1 x_2 : Num), (x + x_1) * x_2 = x * x_2 + x_1 * x_2
|
CategoryTheory.HasClassifier.comm
|
Mathlib.CategoryTheory.Topos.Classifier
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasClassifier C] {U X : C} (m : U ⟶ X)
[inst_2 : CategoryTheory.Mono m],
CategoryTheory.CategoryStruct.comp m (CategoryTheory.HasClassifier.χ m) =
CategoryTheory.CategoryStruct.comp (⋯.some.χ₀ U) (CategoryTheory.HasClassifier.truth C)
|
Lean.PersistentHashMap.findAux
|
Lean.Data.PersistentHashMap
|
{α : Type u_1} → {β : Type u_2} → [BEq α] → Lean.PersistentHashMap.Node α β → USize → α → Option β
|
MeasureTheory.integrable_stoppedValue_of_mem_finset
|
Mathlib.Probability.Process.Stopping
|
∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Nonempty ι] {μ : MeasureTheory.Measure Ω}
{τ : Ω → WithTop ι} {E : Type u_4} {u : ι → Ω → E} [inst_1 : PartialOrder ι] {ℱ : MeasureTheory.Filtration ι m}
[inst_2 : NormedAddCommGroup E],
MeasureTheory.IsStoppingTime ℱ τ →
(∀ (n : ι), MeasureTheory.Integrable (u n) μ) →
∀ {s : Finset ι},
(∀ (ω : Ω), τ ω ∈ WithTop.some '' ↑s) → MeasureTheory.Integrable (MeasureTheory.stoppedValue u τ) μ
|
_private.Mathlib.Tactic.CC.Addition.0.Mathlib.Tactic.CC.CCM.pushSubsingletonEq.match_1
|
Mathlib.Tactic.CC.Addition
|
(motive : Option Lean.Expr → Sort u_1) →
(__discr : Option Lean.Expr) →
((AEqB : Lean.Expr) → motive (some AEqB)) → ((x : Option Lean.Expr) → motive x) → motive __discr
|
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_top_eq_maxUnifEigenspaceIndex._simp_1_2
|
Mathlib.LinearAlgebra.Eigenspace.Basic
|
∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True
|
Bialgebra.toLinearMap_counitAlgHom
|
Mathlib.RingTheory.Bialgebra.Basic
|
∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Bialgebra.counitAlgHom R A).toLinearMap = CoalgebraStruct.counit
|
MeasureTheory.L1.SimpleFunc.setToL1S_add_left
|
Mathlib.MeasureTheory.Integral.SetToL1
|
∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(T T' : Set α → E →L[ℝ] F) (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
MeasureTheory.L1.SimpleFunc.setToL1S (T + T') f =
MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T' f
|
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.comap_mem_associatedPrimes_of_mem_associatedPrimes_of_isLocalizedModule_of_fg._simp_1_1
|
Mathlib.RingTheory.Ideal.AssociatedPrime.Localization
|
∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (f x ∈ K) = (x ∈ Ideal.comap f K)
|
CategoryTheory.PreZeroHypercoverFamily.noConfusionType
|
Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily
|
Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.PreZeroHypercoverFamily C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.PreZeroHypercoverFamily C' → Sort u_1
|
PLift.instLawfulFunctor_mathlib
|
Mathlib.Control.ULift
|
LawfulFunctor PLift
|
[email protected]._hygCtx._hyg.2
|
Lean.Compiler.NoncomputableAttr
|
IO Lean.TagDeclarationExtension
|
RatFunc.X.eq_1
|
Mathlib.FieldTheory.RatFunc.AsPolynomial
|
∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.X = (algebraMap (Polynomial K) (RatFunc K)) Polynomial.X
|
RingCone.mem_mk
|
Mathlib.Algebra.Order.Ring.Cone
|
∀ {R : Type u_1} [inst : Ring R] {toSubsemiring : Subsemiring R}
(eq_zero_of_mem_of_neg_mem : ∀ {a : R}, a ∈ toSubsemiring.carrier → -a ∈ toSubsemiring.carrier → a = 0) {x : R},
x ∈ { toSubsemiring := toSubsemiring, eq_zero_of_mem_of_neg_mem' := eq_zero_of_mem_of_neg_mem } ↔ x ∈ toSubsemiring
|
List.lookmap
|
Batteries.Data.List.Basic
|
{α : Type u_1} → (α → Option α) → List α → List α
|
NormedSpace.invertibleExpOfMemBall._proof_1
|
Mathlib.Analysis.Normed.Algebra.Exponential
|
∀ {𝕂 : Type u_2} {𝔸 : Type u_1} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸]
[CompleteSpace 𝔸] [CharZero 𝕂] {x : 𝔸},
x ∈ EMetric.ball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → NormedSpace.exp 𝕂 (-x) * NormedSpace.exp 𝕂 x = 1
|
Array.map_eq_empty_iff._simp_1
|
Init.Data.Array.Lemmas
|
∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α}, (Array.map f xs = #[]) = (xs = #[])
|
Associates.prime_mk
|
Mathlib.Algebra.GroupWithZero.Associated
|
∀ {M : Type u_1} [inst : CommMonoidWithZero M] {p : M}, Prime (Associates.mk p) ↔ Prime p
|
bne_eq_false_iff_eq._simp_1
|
Init.SimpLemmas
|
∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a != b) = false) = (a = b)
|
AkraBazziRecurrence.recOn
|
Mathlib.Computability.AkraBazzi.SumTransform
|
{α : Type u_1} →
[inst : Fintype α] →
[inst_1 : Nonempty α] →
{T : ℕ → ℝ} →
{g : ℝ → ℝ} →
{a b : α → ℝ} →
{r : α → ℕ → ℕ} →
{motive : AkraBazziRecurrence T g a b r → Sort u} →
(t : AkraBazziRecurrence T g a b r) →
((n₀ : ℕ) →
(n₀_gt_zero : 0 < n₀) →
(a_pos : ∀ (i : α), 0 < a i) →
(b_pos : ∀ (i : α), 0 < b i) →
(b_lt_one : ∀ (i : α), b i < 1) →
(g_nonneg : ∀ x ≥ 0, 0 ≤ g x) →
(g_grows_poly : AkraBazziRecurrence.GrowsPolynomially g) →
(h_rec : ∀ (n : ℕ), n₀ ≤ n → T n = ∑ i, a i * T (r i n) + g ↑n) →
(T_gt_zero' : ∀ n < n₀, 0 < T n) →
(r_lt_n : ∀ (i : α) (n : ℕ), n₀ ≤ n → r i n < n) →
(dist_r_b :
∀ (i : α),
(fun n => ↑(r i n) - b i * ↑n) =o[Filter.atTop] fun n =>
↑n / Real.log ↑n ^ 2) →
motive
{ n₀ := n₀, n₀_gt_zero := n₀_gt_zero, a_pos := a_pos, b_pos := b_pos,
b_lt_one := b_lt_one, g_nonneg := g_nonneg, g_grows_poly := g_grows_poly,
h_rec := h_rec, T_gt_zero' := T_gt_zero', r_lt_n := r_lt_n,
dist_r_b := dist_r_b }) →
motive t
|
Equiv.trans_toEmbedding
|
Mathlib.Logic.Embedding.Basic
|
∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ),
(e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding
|
HomologicalComplex₂.totalShift₁Iso._proof_1
|
Mathlib.Algebra.Homology.TotalComplexShift
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n n' : ℤ),
CategoryTheory.CategoryStruct.comp (K.totalShift₁XIso x n (n + x) ⋯).hom
(((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) x).obj (K.total (ComplexShape.up ℤ))).d
n n') =
CategoryTheory.CategoryStruct.comp
((((HomologicalComplex₂.shiftFunctor₁ C x).obj K).total (ComplexShape.up ℤ)).d n n')
(K.totalShift₁XIso x n' (n' + x) ⋯).hom
|
CategoryTheory.NatIso.removeOp_hom
|
Mathlib.CategoryTheory.Opposites
|
∀ {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} (α : F.op ≅ G.op),
(CategoryTheory.NatIso.removeOp α).hom = CategoryTheory.NatTrans.removeOp α.hom
|
Lean.Elab.Tactic.Do.State.mk.sizeOf_spec
|
Lean.Elab.Tactic.Do.VCGen.Basic
|
∀ (fuel : Lean.Elab.Tactic.Do.Fuel) (simpState : Lean.Meta.Simp.State) (invariants vcs : Array Lean.MVarId),
sizeOf { fuel := fuel, simpState := simpState, invariants := invariants, vcs := vcs } =
1 + sizeOf fuel + sizeOf simpState + sizeOf invariants + sizeOf vcs
|
CategoryTheory.Limits.IsColimit.map
|
Mathlib.CategoryTheory.Limits.IsLimit
|
{J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F G : CategoryTheory.Functor J C} →
{s : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsColimit s → (t : CategoryTheory.Limits.Cocone G) → (F ⟶ G) → (s.pt ⟶ t.pt)
|
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_11
|
Mathlib.Algebra.Lie.Semisimple.Basic
|
∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p)
|
Prod.instDivInvMonoid._proof_4
|
Mathlib.Algebra.Group.Prod
|
∀ {G : Type u_1} {H : Type u_2} [inst : DivInvMonoid G] [inst_1 : DivInvMonoid H] (x : ℕ) (x_1 : G × H),
(DivInvMonoid.zpow (Int.negSucc x) x_1.1, DivInvMonoid.zpow (Int.negSucc x) x_1.2) =
(DivInvMonoid.zpow (↑x.succ) x_1.1, DivInvMonoid.zpow (↑x.succ) x_1.2)⁻¹
|
exists_quadratic_eq_zero
|
Mathlib.Algebra.QuadraticDiscriminant
|
∀ {K : Type u_1} [inst : Field K] [NeZero 2] {a b c : K},
a ≠ 0 → (∃ s, discrim a b c = s * s) → ∃ x, a * (x * x) + b * x + c = 0
|
CategoryTheory.Adjunction.whiskerRight_counit_app_app
|
Mathlib.CategoryTheory.Adjunction.Whiskering
|
∀ (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 D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor C E)
(X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).counit.app X).app X_1 = adj.counit.app (X.obj X_1)
|
_private.Mathlib.Data.Nat.Cast.Order.Ring.0.Nat.neg_cast_eq_cast._simp_1_1
|
Mathlib.Data.Nat.Cast.Order.Ring
|
∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (-a = b) = (a + b = 0)
|
CategoryTheory.Limits.IsTerminal.strict_hom_ext
|
Mathlib.CategoryTheory.Limits.Shapes.StrictInitial
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C}
(hI : CategoryTheory.Limits.IsTerminal I) {A : C} (f g : I ⟶ A), f = g
|
Function.const_neg'
|
Mathlib.Algebra.Order.Pi
|
∀ {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : Preorder α] {a : α} [Nonempty β],
Function.const β a < 0 ↔ a < 0
|
LinearMap.compMultilinearMap_compLinearMap
|
Mathlib.LinearAlgebra.Multilinear.Basic
|
∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₁' : ι → Type v₁'} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → AddCommMonoid (M₁' i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : AddCommMonoid M₃] [inst_5 : (i : ι) → Module R (M₁ i)] [inst_6 : (i : ι) → Module R (M₁' i)]
[inst_7 : Module R M₂] [inst_8 : Module R M₃] (g : M₂ →ₗ[R] M₃) (f : MultilinearMap R M₁ M₂)
(f' : (i : ι) → M₁' i →ₗ[R] M₁ i),
g.compMultilinearMap (f.compLinearMap f') = (g.compMultilinearMap f).compLinearMap f'
|
Option.instMembership
|
Init.Data.Option.Instances
|
{α : Type u_1} → Membership α (Option α)
|
mulMulHom._proof_1
|
Mathlib.Algebra.Group.Prod
|
∀ {α : Type u_1} [inst : CommSemigroup α] (x x_1 : α × α), x.1 * x_1.1 * (x.2 * x_1.2) = x.1 * x.2 * (x_1.1 * x_1.2)
|
CategoryTheory.StrictPseudofunctor.mk'._proof_7
|
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor
|
∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictPseudofunctorCore B C) {a b : B} (f : a ⟶ b),
S.map₂ (CategoryTheory.CategoryStruct.id f) = CategoryTheory.CategoryStruct.id (S.map f)
|
Std.Tactic.BVDecide.Normalize.BitVec.not_neg'
|
Std.Tactic.BVDecide.Normalize.BitVec
|
∀ {w : ℕ} (x : BitVec w), ~~~(x + 1#w) = ~~~x + -1#w
|
BoundedContinuousFunction.norm_const_eq
|
Mathlib.Topology.ContinuousMap.Bounded.Normed
|
∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β] [h : Nonempty α] (b : β),
‖BoundedContinuousFunction.const α b‖ = ‖b‖
|
Set.projIci_of_mem
|
Mathlib.Order.Interval.Set.ProjIcc
|
∀ {α : Type u_1} [inst : LinearOrder α] {a x : α} (hx : x ∈ Set.Ici a), Set.projIci a x = ⟨x, hx⟩
|
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_add_succ_right_eq_push'._proof_1_2
|
Init.Data.Range.Polymorphic.NatLemmas
|
∀ {m n : ℕ}, ¬m ≤ m + n → False
|
Std.DHashMap.Raw.Const.get?_insertIfNew
|
Std.Data.DHashMap.RawLemmas
|
∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a : α} {v : β},
Std.DHashMap.Raw.Const.get? (m.insertIfNew k v) a =
if (k == a) = true ∧ k ∉ m then some v else Std.DHashMap.Raw.Const.get? m a
|
_private.Mathlib.Computability.Primrec.0.PrimrecPred.exists_mem_list.match_1_1
|
Mathlib.Computability.Primrec
|
∀ {α : Type u_1} {p : α → Prop} [inst : Primcodable α] (motive : PrimrecPred p → Prop) (x : PrimrecPred p),
(∀ (w : DecidablePred p) (hf : Primrec fun a => decide (p a)), motive ⋯) → motive x
|
Std.Internal.IO.Async.System.OSInfo.mk.sizeOf_spec
|
Std.Internal.Async.System
|
∀ (name release version machine : String),
sizeOf { name := name, release := release, version := version, machine := machine } =
1 + sizeOf name + sizeOf release + sizeOf version + sizeOf machine
|
Lean.Meta.Grind.BuiltinPropagators.recOn
|
Lean.Meta.Tactic.Grind.PropagatorAttr
|
{motive : Lean.Meta.Grind.BuiltinPropagators → Sort u} →
(t : Lean.Meta.Grind.BuiltinPropagators) →
((up down : Lean.Meta.Grind.PropagatorMap) → motive { up := up, down := down }) → motive t
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_eq_false_right._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)
|
_private.Mathlib.SetTheory.Cardinal.Order.0.Cardinal.le_mk_iff_exists_set.match_1_1
|
Mathlib.SetTheory.Cardinal.Order
|
∀ {α : Type u_1} (x : Type u_1) (motive : Cardinal.mk x ≤ Cardinal.mk α → Prop) (x_1 : Cardinal.mk x ≤ Cardinal.mk α),
(∀ (f : x → α) (hf : Function.Injective f), motive ⋯) → motive x_1
|
Std.ExtHashMap.isSome_getKey?_iff_mem._simp_1
|
Std.Data.ExtHashMap.Lemmas
|
∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.