name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false
|
Std.Data.DTreeMap.Internal.Lemmas
|
∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [inst : BEq α] [Std.LawfulBEqOrd α]
[Std.TransOrd α] [inst_3 : Inhabited α] (h : t.WF) {l : List α} {k : α},
k ∉ t → l.contains k = false → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey! k = default
|
MulOpposite.unop_inj
|
Mathlib.Algebra.Opposites
|
∀ {α : Type u_1} {x y : αᵐᵒᵖ}, MulOpposite.unop x = MulOpposite.unop y ↔ x = y
|
SimpleGraph.Walk.IsPath.transfer
|
Mathlib.Combinatorics.SimpleGraph.Paths
|
∀ {V : Type u} {G : SimpleGraph V} {u v : V} {H : SimpleGraph V} {p : G.Walk u v} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet),
p.IsPath → (p.transfer H hp).IsPath
|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic.0.Mathlib.Meta.Positivity.evalRealPi.match_1
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
|
(motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
((α : Q(Type)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive Lean.Level.zero _zα _pα e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive x _zα _pα e __alt __alt_2) →
motive u _zα _pα e __alt __alt_1
|
HahnSeries.instNonUnitalCommSemiring
|
Mathlib.RingTheory.HahnSeries.Multiplication
|
{Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[IsOrderedCancelAddMonoid Γ] → [inst : NonUnitalCommSemiring R] → NonUnitalCommSemiring (HahnSeries Γ R)
|
CategoryTheory.leftAdjointMate
|
Mathlib.CategoryTheory.Monoidal.Rigid.Basic
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : C} →
[inst_2 : CategoryTheory.HasLeftDual X] → [inst_3 : CategoryTheory.HasLeftDual Y] → (X ⟶ Y) → (ᘁY ⟶ ᘁX)
|
Lean.Elab.Term.elabValueOf._regBuiltin.Lean.Elab.Term.elabValueOf_1
|
Lean.Elab.BuiltinTerm
|
IO Unit
|
BitVec.reduceNe
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec
|
Lean.Meta.Simp.Simproc
|
LightCondensed.locallyConstantIsoFinYoneda
|
Mathlib.Condensed.Discrete.Colimit
|
(F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)) →
FintypeCat.toLightProfinite.op.comp
(LightCondensed.locallyConstantPresheaf
(F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op { carrier := PUnit.{u + 1}, str := PUnit.fintype })))) ≅
LightCondensed.finYoneda F
|
QuotientGroup.quotientQuotientIsometryEquivQuotient.eq_1
|
Mathlib.Analysis.Normed.Group.Quotient
|
∀ {M : Type u_1} [inst : SeminormedCommGroup M] {S T : Subgroup M} (h : S ≤ T),
QuotientGroup.quotientQuotientIsometryEquivQuotient h =
{ toEquiv := (QuotientGroup.quotientQuotientEquivQuotient S T h).toEquiv, isometry_toFun := ⋯ }
|
finAddFlip.eq_1
|
Mathlib.Logic.Equiv.Fin.Basic
|
∀ {m n : ℕ}, finAddFlip = (finSumFinEquiv.symm.trans (Equiv.sumComm (Fin m) (Fin n))).trans finSumFinEquiv
|
Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt.injEq
|
Lean.Meta.Tactic.Grind.EMatchTheorem
|
∀ (lhs n lhs_1 n_1 : ℕ),
(Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs n = Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs_1 n_1) =
(lhs = lhs_1 ∧ n = n_1)
|
LinearEquiv.conj_exact_iff_exact
|
Mathlib.Algebra.Exact
|
∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {N' : Type u_5} {P : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid N'] [inst_4 : AddCommMonoid P]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R N'] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g : N →ₗ[R] P) (e : N ≃ₗ[R] N'), Function.Exact ⇑(↑e ∘ₗ f) ⇑(g ∘ₗ ↑e.symm) ↔ Function.Exact ⇑f ⇑g
|
ValuativeRel.srel_iff
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (x y : R), x <ᵥ y ↔ ¬y ≤ᵥ x
|
AffineMap.lineMap_eq_right_iff
|
Mathlib.LinearAlgebra.AffineSpace.AffineMap
|
∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] [NoZeroSMulDivisors k V1] {p₀ p₁ : P1} {c : k},
(AffineMap.lineMap p₀ p₁) c = p₁ ↔ p₀ = p₁ ∨ c = 1
|
_private.Mathlib.Data.List.Basic.0.List.getLast_append_of_right_ne_nil._proof_1_12
|
Mathlib.Data.List.Basic
|
∀ {α : Type u_1} (l₂ : List α) (head : α) (tail : List α),
(head :: tail ++ l₂).length - 1 + 1 ≤ (head :: tail).length → (head :: tail ++ l₂).length - 1 < (head :: tail).length
|
NumberField.FinitePlace.mk._proof_1
|
Mathlib.NumberTheory.NumberField.FinitePlaces
|
∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
∃ v_1,
NumberField.place (NumberField.FinitePlace.embedding v_1) = NumberField.place (NumberField.FinitePlace.embedding v)
|
Std.ExtDTreeMap.getKeyD_maxKey?
|
Std.Data.ExtDTreeMap.Lemmas
|
∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km fallback : α}, t.maxKey? = some km → t.getKeyD km fallback = km
|
interior_inter
|
Mathlib.Topology.Closure
|
∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, interior (s ∩ t) = interior s ∩ interior t
|
NumberField.IsCMField.of_forall_isConj
|
Mathlib.NumberTheory.NumberField.CMField
|
∀ (K : Type u_2) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K] [NumberField.IsTotallyComplex K]
[IsGalois ℚ K] {σ : Gal(K/ℚ)}, (∀ (φ : K →+* ℂ), NumberField.ComplexEmbedding.IsConj φ σ) → NumberField.IsCMField K
|
SymmetricPower.Rel.recOn
|
Mathlib.LinearAlgebra.TensorPower.Symmetric
|
∀ {R ι : Type u} [inst : CommSemiring R] {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{motive : (a a_1 : PiTensorProduct R fun x => M) → SymmetricPower.Rel R ι M a a_1 → Prop}
{a a_1 : PiTensorProduct R fun x => M} (t : SymmetricPower.Rel R ι M a a_1),
(∀ (e : Equiv.Perm ι) (f : ι → M),
motive ((PiTensorProduct.tprod R) fun i => f i) ((PiTensorProduct.tprod R) fun i => f (e i)) ⋯) →
motive a a_1 t
|
_private.Lean.Parser.Extension.0.Lean.Parser.isParserAlias.match_1
|
Lean.Parser.Extension
|
(motive : Option (Lean.Parser.AliasValue Lean.Parser.Parser) → Sort u_1) →
(__do_lift : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) →
((val : Lean.Parser.AliasValue Lean.Parser.Parser) → motive (some val)) →
((x : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) → motive x) → motive __do_lift
|
CategoryTheory.Bicategory.InducedBicategory.Hom₂.rec
|
Mathlib.CategoryTheory.Bicategory.InducedBicategory
|
{B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
((hom : f.hom ⟶ g.hom) → motive { hom := hom }) →
(t : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g) → motive t
|
Std.Packages.LinearOrderOfOrdArgs.max_eq._autoParam
|
Init.Data.Order.PackageFactories
|
Lean.Syntax
|
IsLocallyConstant.apply_eq_of_preconnectedSpace
|
Mathlib.Topology.LocallyConstant.Basic
|
∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f → ∀ (x y : X), f x = f y
|
_private.Mathlib.Data.ENat.Basic.0.ENat.top_ne_one.match_1_1
|
Mathlib.Data.ENat.Basic
|
∀ (motive : ⊤ = 1 → Prop) (a : ⊤ = 1), motive a
|
Module.Relations.Solution.ofπ'._proof_1
|
Mathlib.Algebra.Module.Presentation.Basic
|
∀ {A : Type u_2} [inst : Ring A] {relations : Module.Relations A} {M : Type u_1} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π : (relations.G →₀ A) →ₗ[A] M),
π ∘ₗ relations.map = 0 → ∀ (r : relations.R), π (relations.relation r) = 0
|
_private.Mathlib.GroupTheory.RegularWreathProduct.0.RegularWreathProduct.instFaithfulSMulProdOfNonempty._simp_5
|
Mathlib.GroupTheory.RegularWreathProduct
|
∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1)
|
_private.Mathlib.Algebra.BigOperators.Expect.0.Finset.expect_ite_mem._simp_1_2
|
Mathlib.Algebra.BigOperators.Expect
|
∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b / a = a⁻¹ * b
|
CategoryTheory.hoFunctor.isIso_prodComparison
|
Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction
|
∀ (X Y : SSet), CategoryTheory.IsIso (CategoryTheory.Limits.prodComparison SSet.hoFunctor X Y)
|
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.posFittingComp_map_incl_sup_of_codisjoint._simp_1_2
|
Mathlib.Algebra.Lie.Weights.Basic
|
∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsNoetherian R M] [IsArtinian R M],
LieModule.posFittingComp R L M = ⨅ k, LieModule.lowerCentralSeries R L M k
|
ValuationSubring.integer_valuation
|
Mathlib.RingTheory.Valuation.ValuationSubring
|
∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), A.valuation.integer = A.toSubring
|
CircleDeg1Lift.lt_map_of_int_lt_translationNumber
|
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber
|
∀ (f : CircleDeg1Lift) {n : ℤ}, ↑n < f.translationNumber → ∀ (x : ℝ), x + ↑n < f x
|
Lean.Order.PartialOrder.noConfusion
|
Init.Internal.Order.Basic
|
{P : Sort u_1} →
{α : Sort u} →
{t : Lean.Order.PartialOrder α} →
{α' : Sort u} →
{t' : Lean.Order.PartialOrder α'} → α = α' → t ≍ t' → Lean.Order.PartialOrder.noConfusionType P t t'
|
_private.Mathlib.Algebra.Homology.ShortComplex.Preadditive.0.CategoryTheory.ShortComplex.Homotopy.ext.match_1
|
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₂} (motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Prop)
(h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
(∀ (h₀ : S₁.X₁ ⟶ S₂.X₁)
(h₀_f :
autoParam (CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0) CategoryTheory.ShortComplex.Homotopy.h₀_f._autoParam)
(h₁ : S₁.X₂ ⟶ S₂.X₁) (h₂ : S₁.X₃ ⟶ S₂.X₂) (h₃ : S₁.X₃ ⟶ S₂.X₃)
(g_h₃ :
autoParam (CategoryTheory.CategoryStruct.comp S₁.g h₃ = 0) CategoryTheory.ShortComplex.Homotopy.g_h₃._autoParam)
(comm₁ :
autoParam (φ₁.τ₁ = CategoryTheory.CategoryStruct.comp S₁.f h₁ + h₀ + φ₂.τ₁)
CategoryTheory.ShortComplex.Homotopy.comm₁._autoParam)
(comm₂ :
autoParam
(φ₁.τ₂ = CategoryTheory.CategoryStruct.comp S₁.g h₂ + CategoryTheory.CategoryStruct.comp h₁ S₂.f + φ₂.τ₂)
CategoryTheory.ShortComplex.Homotopy.comm₂._autoParam)
(comm₃ :
autoParam (φ₁.τ₃ = h₃ + CategoryTheory.CategoryStruct.comp h₂ S₂.g + φ₂.τ₃)
CategoryTheory.ShortComplex.Homotopy.comm₃._autoParam),
motive
{ h₀ := h₀, h₀_f := h₀_f, h₁ := h₁, h₂ := h₂, h₃ := h₃, g_h₃ := g_h₃, comm₁ := comm₁, comm₂ := comm₂,
comm₃ := comm₃ }) →
motive h
|
measurable_from_top
|
Mathlib.MeasureTheory.MeasurableSpace.Basic
|
∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace β] {f : α → β}, Measurable f
|
Denumerable.lower.eq_2
|
Mathlib.Logic.Equiv.Multiset
|
∀ (x m : ℕ) (l : List ℕ), Denumerable.lower (m :: l) x = (m - x) :: Denumerable.lower l m
|
compl_sSup'
|
Mathlib.Order.CompleteBooleanAlgebra
|
∀ {α : Type u} [inst : CompleteBooleanAlgebra α] {s : Set α}, (sSup s)ᶜ = sInf (compl '' s)
|
LightCondMod.instReflectsEpimorphismsLightCondSetForget
|
Mathlib.Condensed.Light.Epi
|
∀ (R : Type u) [inst : Ring R], (LightCondensed.forget R).ReflectsEpimorphisms
|
groupCohomology.dArrowIso₀₁._proof_1
|
Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree
|
IsRightCancelAdd ℕ
|
HomologicalComplex₂.ofGradedObject_d_f
|
Mathlib.Algebra.Homology.HomologicalBicomplex
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(X : CategoryTheory.GradedObject (I₁ × I₂) C) (d₁ : (i₁ i₁' : I₁) → (i₂ : I₂) → X (i₁, i₂) ⟶ X (i₁', i₂))
(d₂ : (i₁ : I₁) → (i₂ i₂' : I₂) → X (i₁, i₂) ⟶ X (i₁, i₂'))
(shape₁ : ∀ (i₁ i₁' : I₁), ¬c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), d₁ i₁ i₁' i₂ = 0)
(shape₂ : ∀ (i₁ : I₁) (i₂ i₂' : I₂), ¬c₂.Rel i₂ i₂' → d₂ i₁ i₂ i₂' = 0)
(d₁_comp_d₁ : ∀ (i₁ i₁' i₁'' : I₁) (i₂ : I₂), CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₁ i₁' i₁'' i₂) = 0)
(d₂_comp_d₂ : ∀ (i₁ : I₁) (i₂ i₂' i₂'' : I₂), CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₂ i₁ i₂' i₂'') = 0)
(comm :
∀ (i₁ i₁' : I₁) (i₂ i₂' : I₂),
CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₂ i₁' i₂ i₂') =
CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₁ i₁ i₁' i₂'))
(i₁ i₁' : I₁) (i₂ : I₂),
((HomologicalComplex₂.ofGradedObject c₁ c₂ X d₁ d₂ shape₁ shape₂ d₁_comp_d₁ d₂_comp_d₂ comm).d i₁ i₁').f i₂ =
d₁ i₁ i₁' i₂
|
ContinuousAddEquiv.mk.inj
|
Mathlib.Topology.Algebra.ContinuousMonoidHom
|
∀ {G : Type u} {inst : TopologicalSpace G} {H : Type v} {inst_1 : TopologicalSpace H} {inst_2 : Add G} {inst_3 : Add H}
{toAddEquiv : G ≃+ H}
{continuous_toFun : autoParam (Continuous toAddEquiv.toFun) Homeomorph.continuous_toFun._autoParam}
{continuous_invFun : autoParam (Continuous toAddEquiv.invFun) Homeomorph.continuous_invFun._autoParam}
{toAddEquiv_1 : G ≃+ H}
{continuous_toFun_1 : autoParam (Continuous toAddEquiv_1.toFun) Homeomorph.continuous_toFun._autoParam}
{continuous_invFun_1 : autoParam (Continuous toAddEquiv_1.invFun) Homeomorph.continuous_invFun._autoParam},
{ toAddEquiv := toAddEquiv, continuous_toFun := continuous_toFun, continuous_invFun := continuous_invFun } =
{ toAddEquiv := toAddEquiv_1, continuous_toFun := continuous_toFun_1, continuous_invFun := continuous_invFun_1 } →
toAddEquiv = toAddEquiv_1
|
CategoryTheory.Limits.FormalCoproduct.category._proof_6
|
Mathlib.CategoryTheory.Limits.FormalCoproducts
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {W X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ f := h.f ∘ { f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.f,
φ := fun x =>
CategoryTheory.CategoryStruct.comp
({ f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.φ x)
(h.φ ({ f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.f x)) } =
{ f := { f := h.f ∘ g.f, φ := fun x => CategoryTheory.CategoryStruct.comp (g.φ x) (h.φ (g.f x)) }.f ∘ f.f,
φ := fun x =>
CategoryTheory.CategoryStruct.comp (f.φ x)
({ f := h.f ∘ g.f, φ := fun x => CategoryTheory.CategoryStruct.comp (g.φ x) (h.φ (g.f x)) }.φ (f.f x)) }
|
Int8.shiftRight_and
|
Init.Data.SInt.Bitwise
|
∀ {a b c : Int8}, (a &&& b) >>> c = a >>> c &&& b >>> c
|
BoxIntegral.unitPartition.mem_box_iff_index
|
Mathlib.Analysis.BoxIntegral.UnitPartition
|
∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] {x : ι → ℝ} {ν : ι → ℤ},
x ∈ BoxIntegral.unitPartition.box n ν ↔ BoxIntegral.unitPartition.index n x = ν
|
CategoryTheory.Limits.preservesColimitsOfSize_shrink
|
Mathlib.CategoryTheory.Limits.Preserves.Basic
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesColimitsOfSize.{max w w₂, max w' w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F
|
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.instCompleteSpace._simp_2
|
Mathlib.Topology.UniformSpace.UniformConvergenceTopology
|
∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f)
|
Std.TreeSet.Raw.max?_eq_some_maxD
|
Std.Data.TreeSet.Raw.Lemmas
|
∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.max? = some (t.maxD fallback)
|
HomologicalComplex.opFunctor._proof_2
|
Mathlib.Algebra.Homology.Opposite
|
∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y : (HomologicalComplex V c)ᵒᵖ} (f : X ⟶ Y) (i j : ι),
(CategoryTheory.CategoryStruct.comp ((Opposite.unop Y).d j i) (f.unop.f i)).op =
(CategoryTheory.CategoryStruct.comp (f.unop.f j) ((Opposite.unop X).d j i)).op
|
ValuativeRel.IsNontrivial.condition
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
∀ {R : Type u_1} {inst : CommRing R} {inst_1 : ValuativeRel R} [self : ValuativeRel.IsNontrivial R], ∃ γ, γ ≠ 0 ∧ γ ≠ 1
|
_private.Lean.Compiler.LCNF.FixedParams.0.Lean.Compiler.LCNF.FixedParams.isEquivalentFunDecl?.match_3
|
Lean.Compiler.LCNF.FixedParams
|
(motive : Option Lean.Compiler.LCNF.FixedParams.AbsValue → Sort u_1) →
(x : Option Lean.Compiler.LCNF.FixedParams.AbsValue) →
((funIdx : ℕ) → motive (some (Lean.Compiler.LCNF.FixedParams.AbsValue.val funIdx))) →
((x : Option Lean.Compiler.LCNF.FixedParams.AbsValue) → motive x) → motive x
|
_private.Init.Data.Iterators.Lemmas.Combinators.Take.0.Std.Iterators.Iter.atIdxSlow?.match_3.eq_1
|
Init.Data.Iterators.Lemmas.Combinators.Take
|
∀ {α β : Type u_1} [inst : Std.Iterators.Iterator α Id β] (it : Std.Iter β) (motive : it.Step → Sort u_2)
(it' : Std.Iter β) (out : β) (property : it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out))
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(property : it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out)) →
motive ⟨Std.Iterators.IterStep.yield it' out, property⟩)
(h_2 :
(it' : Std.Iter β) →
(property : it.IsPlausibleStep (Std.Iterators.IterStep.skip it')) →
motive ⟨Std.Iterators.IterStep.skip it', property⟩)
(h_3 : (property : it.IsPlausibleStep Std.Iterators.IterStep.done) → motive ⟨Std.Iterators.IterStep.done, property⟩),
(match ⟨Std.Iterators.IterStep.yield it' out, property⟩ with
| ⟨Std.Iterators.IterStep.yield it' out, property⟩ => h_1 it' out property
| ⟨Std.Iterators.IterStep.skip it', property⟩ => h_2 it' property
| ⟨Std.Iterators.IterStep.done, property⟩ => h_3 property) =
h_1 it' out property
|
LinearMap.IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self
|
Mathlib.LinearAlgebra.SesquilinearForm.Basic
|
∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} {n : Type u_19} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup M₁] [inst_4 : Module R M₁] [NoZeroSMulDivisors R M₁]
{B : M →ₗ[R] M →ₗ[R] M₁} (v : Module.Basis n R M),
B.IsOrthoᵢ ⇑v → (∀ (i : n), ¬B.IsOrtho (v i) (v i)) → B.Nondegenerate
|
MonoidHom.transfer._proof_2
|
Mathlib.GroupTheory.Transfer
|
∀ {G : Type u_2} [inst : Group G] {H : Subgroup G} {A : Type u_1} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
[inst_2 : H.FiniteIndex] (g h : G),
Subgroup.leftTransversals.diff ϕ default ((g * h) • default) =
Subgroup.leftTransversals.diff ϕ default (g • default) * Subgroup.leftTransversals.diff ϕ default (h • default)
|
_private.Mathlib.Order.Monotone.Basic.0.StrictMono.isMin_of_apply.match_1_1
|
Mathlib.Order.Monotone.Basic
|
∀ {α : Type u_1} [inst : Preorder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hb : w < a), motive ⋯) → motive x
|
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.map.go_get_aux._proof_1_1
|
Std.Sat.AIG.RefVecOperator.Map
|
∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig : Std.Sat.AIG α} (curr : ℕ)
(s : aig.RefVec curr) (input : aig.RefVec len) (f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [Std.Sat.AIG.RefVec.LawfulMapOperator α f],
∀ idx < curr, curr < len → ¬idx < curr + 1 → False
|
MeasureTheory.AEEqFun.coeFn_smul
|
Mathlib.MeasureTheory.Function.AEEqFun
|
∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
{𝕜 : Type u_5} [inst_2 : SMul 𝕜 γ] [inst_3 : ContinuousConstSMul 𝕜 γ] (c : 𝕜) (f : α →ₘ[μ] γ), ↑(c • f) =ᵐ[μ] c • ↑f
|
Orientation.oangle.eq_1
|
Mathlib.Geometry.Euclidean.Angle.Oriented.Basic
|
∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), o.oangle x y = ↑((o.kahler x) y).arg
|
nonempty_commRing_iff
|
Mathlib.SetTheory.Cardinal.Free
|
∀ (α : Type u), Nonempty (CommRing α) ↔ Nonempty α
|
Polynomial.eval₂RingHom'._proof_1
|
Mathlib.Algebra.Polynomial.Eval.Defs
|
∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
(∀ (a : R), Commute (f a) x) →
∀ (_p q : Polynomial R), Polynomial.eval₂ f x (_p * q) = Polynomial.eval₂ f x _p * Polynomial.eval₂ f x q
|
Dynamics.netMaxcard_zero
|
Mathlib.Dynamics.TopologicalEntropy.NetEntropy
|
∀ {X : Type u_1} {F : Set X} (T : X → X), F.Nonempty → ∀ (U : SetRel X X), Dynamics.netMaxcard T F U 0 = 1
|
DistLat.casesOn
|
Mathlib.Order.Category.DistLat
|
{motive : DistLat → Sort u} →
(t : DistLat) →
((carrier : Type u_1) → [str : DistribLattice carrier] → motive { carrier := carrier, str := str }) → motive t
|
MeasureTheory.innerRegularWRT_isCompact_isClosed
|
Mathlib.MeasureTheory.Measure.RegularityCompacts
|
∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) IsClosed
|
Int8.casesOn
|
Init.Data.SInt.Basic
|
{motive : Int8 → Sort u} → (t : Int8) → ((toUInt8 : UInt8) → motive { toUInt8 := toUInt8 }) → motive t
|
AffineSubspace.card_pos_of_affineSpan_eq_top
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs
|
∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_5} [inst_3 : Fintype ι] {p : ι → P},
affineSpan k (Set.range p) = ⊤ → 0 < Fintype.card ι
|
CategoryTheory.Functor.Monoidal.whiskerLeft_δ_μ
|
Mathlib.CategoryTheory.Monoidal.Functor
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft T (CategoryTheory.Functor.OplaxMonoidal.δ F X Y))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft T (CategoryTheory.Functor.LaxMonoidal.μ F X Y)) =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj T (F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)))
|
LightDiagram.instCategory
|
Mathlib.Topology.Category.LightProfinite.Basic
|
CategoryTheory.Category.{u_1, u_1 + 1} LightDiagram
|
Lean.IR.ExpandResetReuse.ProjMap
|
Lean.Compiler.IR.ExpandResetReuse
|
Type
|
Lean.Meta.Grind.Order.Cnstr.rec
|
Lean.Meta.Tactic.Grind.Order.Types
|
{α : Type} →
{motive : Lean.Meta.Grind.Order.Cnstr α → Sort u} →
((kind : Lean.Meta.Grind.Order.CnstrKind) →
(u v : α) →
(k : ℤ) →
(e : Lean.Expr) →
(h? : Option Lean.Expr) → motive { kind := kind, u := u, v := v, k := k, e := e, h? := h? }) →
(t : Lean.Meta.Grind.Order.Cnstr α) → motive t
|
ContinuousMap.liftCover'
|
Mathlib.Topology.ContinuousMap.Basic
|
{α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(A : Set (Set α)) →
(F : (s : Set α) → s ∈ A → C(↑s, β)) →
(∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩) →
(∀ (x : α), ∃ i ∈ A, i ∈ nhds x) → C(α, β)
|
FreeGroup.of_ne_one
|
Mathlib.GroupTheory.FreeGroup.Reduce
|
∀ {α : Type u_1} (a : α), FreeGroup.of a ≠ 1
|
_private.Mathlib.Order.Interval.Set.Pi.0.Set.pi_univ_Ioc_update_left._simp_1_1
|
Mathlib.Order.Interval.Set.Pi
|
∀ {α : Type u} (a b c : Set α), a ∩ (b ∩ c) = a ∩ b ∩ c
|
EuclideanGeometry.Sphere.IsDiameter.wbtw
|
Mathlib.Geometry.Euclidean.Sphere.Basic
|
∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → Wbtw ℝ p₁ s.center p₂
|
_private.Plausible.Sampleable.0.Plausible.mkGenerator.match_1
|
Plausible.Sampleable
|
(motive : Lean.Level → Sort u_1) →
(u : Lean.Level) → ((u : Lean.Level) → motive u.succ) → ((x : Lean.Level) → motive x) → motive u
|
Array.count_empty
|
Init.Data.Array.Count
|
∀ {α : Type u_1} [inst : BEq α] {a : α}, Array.count a #[] = 0
|
HomotopicalAlgebra.ModelCategory.categoryWithCofibrations._autoParam
|
Mathlib.AlgebraicTopology.ModelCategory.Basic
|
Lean.Syntax
|
AddHom.noncommCoprod._proof_1
|
Mathlib.GroupTheory.NoncommCoprod
|
∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Add M] [inst_1 : Add N] [inst_2 : AddSemigroup P] (f : M →ₙ+ P)
(g : N →ₙ+ P),
(∀ (m : M) (n : N), AddCommute (f m) (g n)) →
∀ (mn mn' : M × N), f (mn + mn').1 + g (mn + mn').2 = f mn.1 + g mn.2 + (f mn'.1 + g mn'.2)
|
Polynomial.rootsExpandPowEquivRoots_apply
|
Mathlib.FieldTheory.Perfect
|
∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R] [inst_4 : PerfectRing R p] (n : ℕ) (x : ↥((Polynomial.expand R (p ^ n)) f).roots.toFinset),
↑((Polynomial.rootsExpandPowEquivRoots p f n) x) = ↑x ^ p ^ n
|
Subsemiring.centralizer_univ
|
Mathlib.Algebra.Ring.Subsemiring.Basic
|
∀ {R : Type u_1} [inst : Semiring R], Subsemiring.centralizer Set.univ = Subsemiring.center R
|
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.rewrite?.diagnoseWhenNoIndex
|
Lean.Meta.Tactic.Simp.Rewrite
|
Lean.Expr → Lean.Meta.SimpTheoremTree → Lean.Meta.SimpTheorem → Lean.Meta.SimpM Unit
|
EReal.mul_div_cancel
|
Mathlib.Data.EReal.Inv
|
∀ {a b : EReal}, b ≠ ⊥ → b ≠ ⊤ → b ≠ 0 → b * (a / b) = a
|
Function.infinite_of_left
|
Mathlib.Data.Fintype.Prod
|
∀ {ι : Sort u_4} {π : Type u_5} [Nontrivial π] [Infinite ι], Infinite (ι → π)
|
Submodule.toConvexCone_top
|
Mathlib.Geometry.Convex.Cone.Basic
|
∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], ⊤.toConvexCone = ⊤
|
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit._proof_1_8
|
Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult
|
∀ {n : ℕ} (units : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
assignments.size = n →
∀ (foundContradiction : Bool) (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
¬Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment l.2 assignments[↑l.1]! = true →
↑i = ↑l.1 → ↑l.1 < assignments.size
|
Real.arsinh_sinh
|
Mathlib.Analysis.SpecialFunctions.Arsinh
|
∀ (x : ℝ), Real.arsinh (Real.sinh x) = x
|
OrderBot.recOn
|
Mathlib.Order.BoundedOrder.Basic
|
{α : Type u} →
[inst : LE α] →
{motive : OrderBot α → Sort u_1} →
(t : OrderBot α) →
([toBot : Bot α] → (bot_le : ∀ (a : α), ⊥ ≤ a) → motive { toBot := toBot, bot_le := bot_le }) → motive t
|
mul_lt_of_lt_one_left
|
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic
|
∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Zero α] {a b : α} [inst_2 : Preorder α] [MulPosStrictMono α],
0 < b → a < 1 → a * b < b
|
IsFreeGroupoid.noConfusion
|
Mathlib.GroupTheory.FreeGroup.NielsenSchreier
|
{P : Sort u} →
{G : Type u_1} →
{inst : CategoryTheory.Groupoid G} →
{t : IsFreeGroupoid G} →
{G' : Type u_1} →
{inst' : CategoryTheory.Groupoid G'} →
{t' : IsFreeGroupoid G'} → G = G' → inst ≍ inst' → t ≍ t' → IsFreeGroupoid.noConfusionType P t t'
|
_private.Mathlib.Probability.Distributions.Beta.0.ProbabilityTheory.lintegral_betaPDF_eq_one._simp_1_3
|
Mathlib.Probability.Distributions.Beta
|
∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False
|
Batteries.RBNode.reverse_balRight
|
Batteries.Data.RBMap.WF
|
∀ {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α),
(l.balRight v r).reverse = r.reverse.balLeft v l.reverse
|
Ordinal.monoid._proof_1
|
Mathlib.SetTheory.Ordinal.Arithmetic
|
∀ (α : Type u_1) (r : α → α → Prop),
IsWellOrder α r → ∀ (β : Type u_1) (s : β → β → Prop), IsWellOrder β s → IsWellOrder (β × α) (Prod.Lex s r)
|
fderivWithin_ccosh
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x
|
Nat.exists_prime_lt_and_le_two_mul_eventually
|
Mathlib.NumberTheory.Bertrand
|
∀ (n : ℕ), 512 ≤ n → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n
|
Std.DTreeMap.Raw.isSome_minKey?_eq_not_isEmpty
|
Std.Data.DTreeMap.Raw.Lemmas
|
∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.minKey?.isSome = !t.isEmpty
|
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.recOn
|
Mathlib.CategoryTheory.Monoidal.Action.Basic
|
{C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategoryStruct C] →
{motive : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct C D → Sort u} →
(t : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct C D) →
((actionObj : C → D → D) →
(actionHomLeft : {c c' : C} → (c ⟶ c') → (d : D) → actionObj c d ⟶ actionObj c' d) →
(actionHomRight : (c : C) → {d d' : D} → (d ⟶ d') → (actionObj c d ⟶ actionObj c d')) →
(actionHom : {c c' : C} → {d d' : D} → (c ⟶ c') → (d ⟶ d') → (actionObj c d ⟶ actionObj c' d')) →
(actionAssocIso :
(c c' : C) →
(d : D) →
actionObj (CategoryTheory.MonoidalCategoryStruct.tensorObj c c') d ≅
actionObj c (actionObj c' d)) →
(actionUnitIso :
(d : D) → actionObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) d ≅ d) →
motive
{ actionObj := actionObj, actionHomLeft := actionHomLeft,
actionHomRight := actionHomRight, actionHom := actionHom,
actionAssocIso := actionAssocIso, actionUnitIso := actionUnitIso }) →
motive t
|
Lean.Lsp.FileIdent.ctorElim
|
Lean.Server.FileSource
|
{motive : Lean.Lsp.FileIdent → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Lsp.FileIdent) → ctorIdx = t.ctorIdx → Lean.Lsp.FileIdent.ctorElimType ctorIdx → motive t
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.getToIntId?.toIntInterval?
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt
|
Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval)
|
AddSubsemigroup.coe_copy
|
Mathlib.Algebra.Group.Subsemigroup.Defs
|
∀ {M : Type u_1} [inst : Add M] {S : AddSubsemigroup M} {s : Set M} (hs : s = ↑S), ↑(S.copy s hs) = s
|
Lean.Lsp.ChangeAnnotation.mk._flat_ctor
|
Lean.Data.Lsp.Basic
|
String → Bool → Option String → Lean.Lsp.ChangeAnnotation
|
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator
|
Lean.PrettyPrinter.Delaborator.SubExpr
|
Type
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.