name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.NatTrans.mk.injEq | Mathlib.CategoryTheory.NatTrans | ∀ {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} (app : (X : C) → F.obj X ⟶ G.obj X)
(naturality :
autoParam
(∀ ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app Y) = Ca... | null | true |
fwdDiff_const | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (g : G),
(fwdDiff h fun x => g) = fun x => 0 | null | true |
Nat.sSup_mem | Mathlib.Order.Lattice.Nat | ∀ {s : Set ℕ}, s.Nonempty → BddAbove s → sSup s ∈ s | null | true |
RelSeries.head_append | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p q : RelSeries r) (connect : (p.last, q.head) ∈ r),
(p.append q connect).head = p.head | null | true |
Lean.Elab.Term.Do.attachJPs | Lean.Elab.Do.Legacy | Array Lean.Elab.Term.Do.JPDecl → Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.Code | null | true |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.strictOccursMax | Lean.Meta.LevelDefEq | Lean.Level → Lean.Level → Bool | Return true iff `lvl` occurs in `max u_1 ... u_n` and `lvl != u_i` for all `i in [1, n]`.
That is, `lvl` is a proper level subterm of some `u_i`. | true |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_4 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)], ⇑1 = ⇑1 | null | false |
Subsingleton.measurable | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [Subsingleton α],
Measurable f | null | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage._proof_2 | Mathlib.RingTheory.AdicCompletion.Exactness | ∀ {R : Type u_3} [inst : CommRing R] {I : Ideal R} {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_1} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (hf : Function.Surjective ⇑f)
(x : AdicCompletion.AdicCauchySequence I N), f ⋯.choose = ↑x 0 | null | false |
_private.Init.Grind.Ordered.Module.0.Lean.Grind.OrderedAdd.zsmul_le_zsmul._simp_1_1 | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M]
{a b : M}, (0 ≤ a - b) = (b ≤ a) | null | false |
Ideal.isPrime_map_of_isLocalizationAtPrime | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (q : Ideal R) [inst_1 : q.IsPrime] {S : Type u_4} [inst_2 : CommSemiring S]
[inst_3 : Algebra R S] [IsLocalization.AtPrime S q] {p : Ideal R} [p.IsPrime],
p ≤ q → (Ideal.map (algebraMap R S) p).IsPrime | null | true |
CategoryTheory.ShortComplex.isoMk._auto_3 | Mathlib.Algebra.Homology.ShortComplex.Basic | Lean.Syntax | null | false |
TensorProduct.ext' | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_7}
{N : Type u_8} {P₂ : Type u_17} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂] {g h : TensorProdu... | null | true |
CategoryTheory.Limits.hasFiniteProducts_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteProducts C | If `C` has finite limits then it has finite products. | true |
_private.Mathlib.Topology.MetricSpace.Bounded.0.IsComplete.nonempty_iInter_of_nonempty_biInter._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
_private.Mathlib.RepresentationTheory.Coinvariants.0.Representation.Coinvariants.instFinite._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_3} {V : Type u_2} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) [Module.Finite k V], Module.Finite k ρ.Coinvariants | null | false |
SubAddAction.instInhabited.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : VAdd R M], SubAddAction.instInhabited = { default := ⊥ } | null | true |
ModularForm.const_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ) (τ : UpperHalfPlane), (ModularForm.const x) τ = x | null | true |
Std.DTreeMap.Raw.Const.ofList._auto_1 | Std.Data.DTreeMap.Raw.Basic | Lean.Syntax | null | false |
LieIdeal.map_sup_ker_eq_map' | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L},
LieIdeal.map f I ⊔ LieIdeal.map f f.ker = LieIdeal.map f I | null | true |
Set.vadd_empty | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set α}, s +ᵥ ∅ = ∅ | null | true |
RingHom.map_iterate_frobenius | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p] (x : R) (n : ℕ),
g ((⇑(frobenius R p))^[n] x) = (⇑(frobenius S p))^[n] (g x) | null | true |
MeasureTheory.VectorMeasure.Integrable._proof_1 | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {E : Type u_2} {G : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup G]
[inst_3 : NormedSpace ℝ G], T2Space (E →L[ℝ] G) | null | false |
PFunctor.Idx | Mathlib.Data.PFunctor.Univariate.Basic | PFunctor.{uA, uB} → Type (max uA uB) | `Idx` identifies a location inside the application of a polynomial functor. For `F : PFunctor`,
`x : F α` and `i : F.Idx`, `i` can designate one part of `x` or is invalid, if `i.1 ≠ x.1`. | true |
ProofWidgets.CheckRequestResponse.ctorElimType | ProofWidgets.Cancellable | {motive : ProofWidgets.CheckRequestResponse → Sort u} → ℕ → Sort (max 1 u) | null | false |
CategoryTheory.MorphismProperty.HasQuotient.iff_of_eqvGen | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] [W.HasQuotient homRel] {X Y : C} {f g : X ⟶ Y},
Relation.EqvGen homR... | null | true |
Lean.Meta.Try.Collector.OrdSet.insert | Lean.Meta.Tactic.Try.Collect | {α : Type} → {x : Hashable α} → {x_1 : BEq α} → Lean.Meta.Try.Collector.OrdSet α → α → Lean.Meta.Try.Collector.OrdSet α | null | true |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.transGen_oneStep_of_isDershowitzMannaLT._simp_1_1 | Mathlib.Data.Multiset.DershowitzManna | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
(a ∈ Multiset.filter p s) = (a ∈ s ∧ p a) | null | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.discharge?.match_1 | Lean.Meta.Tactic.Grind.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((p : Lean.Expr) → motive (some p)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | null | false |
Lean.Lsp.instFromJsonDiagnosticCode.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((i : ℤ) → motive (Lean.Json.num { mantissa := i, exponent := 0 })) →
((s : String) → motive (Lean.Json.str s)) → ((j : Lean.Json) → motive j) → motive x | null | false |
ContinuousMap.instNonUnitalCommCStarAlgebra._proof_6 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : NonUnitalCommCStarAlgebra A] (a b c : C(α, A)), a * (b + c) = a * b + a * c | null | false |
Std.ExtTreeSet.contains_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.contains km = true | null | true |
CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₃ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : Ca... | null | true |
instDecidableEqDihedralGroup.decEq._proof_1 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (a : ZMod n), DihedralGroup.r a = DihedralGroup.r a | null | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDimension.0.hausdorffMeasure_of_lt_dimH._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (a < iSup f) = ∃ i, a < f i | null | false |
Int16.toInt_div_of_ne_left | Init.Data.SInt.Lemmas | ∀ (a b : Int16), a ≠ Int16.minValue → (a / b).toInt = a.toInt.tdiv b.toInt | null | true |
Filter.TendstoCofinite.mk | Mathlib.Order.Filter.TendstoCofinite | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Filter.Tendsto f Filter.cofinite Filter.cofinite → Filter.TendstoCofinite f | null | true |
Mathlib.Tactic.Monoidal.instMkEvalWhiskerLeftMonoidalM.match_1 | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | (ctx : Mathlib.Tactic.Monoidal.Context) →
(motive : Option Q(CategoryTheory.MonoidalCategory unknown_1) → Sort u_1) →
(x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) →
((_monoidal : Q(CategoryTheory.MonoidalCategory unknown_1)) → motive (some _monoidal)) →
((x : Option Q(CategoryTheory.Mon... | null | false |
isClosed_Ioo_iff | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsClosed (Set.Ioo a b) ↔ b ≤ a | `Set.Ioo a b` is only closed if it is empty. | true |
_private.Mathlib.Algebra.Module.Submodule.Union.0.Submodule.iUnion_ssubset_of_forall_ne_top_of_card_lt._simp_1_1 | Mathlib.Algebra.Module.Submodule.Union | ∀ {α : Type u} {s : Set α}, (s ⊂ Set.univ) = (s ≠ Set.univ) | null | false |
Submonoid.smulDistribClass | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_4} {S : Type u_5} [inst : SMul M' α] [inst_1 : SMul M' β]
[inst_2 : SMul α β] [inst_3 : SetLike S M'] [h : SMulDistribClass M' α β] (N' : S), SMulDistribClass (↥N') α β | null | true |
UInt8.mod_eq_of_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a < b → a % b = a | null | true |
Aesop.RuleBuilderInput.noConfusion | Aesop.Builder.Basic | {P : Sort u} → {t t' : Aesop.RuleBuilderInput} → t = t' → Aesop.RuleBuilderInput.noConfusionType P t t' | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.replace.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (b : β a) (a_1 : α) (b_1 : β a_1)
(es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.replace a b (Std.DHashMap.Internal.AssocList.cons a_1 b_1 es) =
bif a_1 == a then Std.DHashMap.Internal.AssocList.cons a b es
else Std.DHashMap... | null | true |
CategoryTheory.SimplicialObject.σ₀Iter_δ'._auto_5 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | Lean.Syntax | null | false |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ofHasDayConvolutions._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {D : Type u_6} [inst_4 : CategoryTheory.Category.{u_5, u_6} D]
(ι : CategoryTheory.Functor D (Cate... | null | false |
Std.Tactic.BVDecide.BVLogicalExpr.bitblast.go.match_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure | (motive : Std.Tactic.BVDecide.Gate → Sort u_1) →
(g : Std.Tactic.BVDecide.Gate) →
(Unit → motive Std.Tactic.BVDecide.Gate.and) →
(Unit → motive Std.Tactic.BVDecide.Gate.xor) →
(Unit → motive Std.Tactic.BVDecide.Gate.beq) → (Unit → motive Std.Tactic.BVDecide.Gate.or) → motive g | null | false |
CategoryTheory.Dial.rightUnitorImpl._proof_1 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X : CategoryTheory.Dial C),
(X.tensorObjImpl CategoryTheory.Dial.tensorUnitImpl).rel =
(CategoryTheory.Subobject.pullback
(CategoryTheory... | null | false |
CategoryTheory.Functor.LaxLeftLinear.μₗ | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
(F : CategoryTheory.Functor D D') →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{inst_3 : CategoryTheory.Mo... | The "μₗ" morphism. | true |
Colex.instLeftCancelSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [LeftCancelSemigroup α] → LeftCancelSemigroup (Colex α) | null | true |
NumberField.mixedEmbedding.convexBodySum_volume_eq_zero_of_le_zero | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {B : ℝ},
B ≤ 0 → MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) = 0 | null | true |
iUnion_Iic_eq_Iio_of_lt_of_tendsto | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {ι : Type u_1} {F : Filter ι} [F.NeBot] [inst : ConditionallyCompleteLinearOrder α]
[inst_1 : TopologicalSpace α] [ClosedIicTopology α] {a : α} {f : ι → α},
(∀ (i : ι), f i < a) → Filter.Tendsto f F (nhds a) → ⋃ i, Set.Iic (f i) = Set.Iio a | null | true |
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : CategoryTheory.Limits.HasBiproductsOfShape J C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete J) C),
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim.inv.app X =
Cat... | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.reportMatcherResultErrors.match_1 | Lean.Elab.Match | (motive : Array Lean.Meta.Match.CounterExample × Bool → Sort u_1) →
(x : Array Lean.Meta.Match.CounterExample × Bool) →
((shown : Array Lean.Meta.Match.CounterExample) → (truncated : Bool) → motive (shown, truncated)) → motive x | null | false |
MonadControlT | Init.Control.Basic | (Type u → Type v) → (Type u → Type w) → Type (max (max (u + 1) v) w) | A way to lift a computation from one monad to another while providing the lifted computation with a
means of interpreting computations from the outer monad. This provides a means of lifting
higher-order operations automatically.
Clients should typically use `control` or `controlAt`, which request an instance of `Monad... | true |
Function.Injective.groupWithZero | Mathlib.Algebra.GroupWithZero.InjSurj | {G₀ : Type u_2} →
{G₀' : Type u_4} →
[inst : GroupWithZero G₀] →
[inst_1 : Zero G₀'] →
[inst_2 : Mul G₀'] →
[inst_3 : One G₀'] →
[inst_4 : Inv G₀'] →
[inst_5 : Div G₀'] →
[inst_6 : Pow G₀' ℕ] →
[inst_7 : Pow G₀' ℤ] →
... | Pull back a `GroupWithZero` along an injective function.
See note [reducible non-instances]. | true |
Matrix.conjTranspose_reindex | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Star α] (eₘ : m ≃ l) (eₙ : n ≃ o)
(M : Matrix m n α), ((Matrix.reindex eₘ eₙ) M).conjTranspose = (Matrix.reindex eₙ eₘ) M.conjTranspose | null | true |
Lean.Parser.Attr.tactic_alt.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer | null | true |
ENat.floor_le_self | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal}, ↑⌊r⌋ₑ ≤ r | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.sum_ne_add_mod_eq_sub_one | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r c : ℕ}, (∑ w ∈ Finset.range r, if c % r ≠ (n + w) % r then 1 else 0) = r - 1 | null | true |
Sum.map_surjective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Surjective (Sum.map f g) ↔ Function.Surjective f ∧ Function.Surjective g | null | true |
LinearMap.BilinForm.Equivalent.symm | Mathlib.LinearAlgebra.BilinearForm.IsometryEquiv | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {B₁ : LinearMap.BilinForm R M₁}
{B₂ : LinearMap.BilinForm R M₂}, B₁.Equivalent B₂ → B₂.Equivalent B₁ | null | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ext.match_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} {inst : Semiring R} (motive : ValuativeRel R → Prop) (h : ValuativeRel R),
(∀ (vle : R → R → Prop) (vle_total : ∀ (x y : R), vle x y ∨ vle y x)
(vle_trans : ∀ {z y x : R}, vle x y → vle y z → vle x z)
(vle_add : ∀ {x y z : R}, vle x z → vle y z → vle (x + y) z)
(mul_vle_mul_left : ∀... | null | false |
Module.Basis.prod_apply_inl_fst | Mathlib.LinearAlgebra.Basis.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_5} {M' : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M']
(b : Module.Basis ι R M) (b' : Module.Basis ι' R M') (i : ι), ((b.prod b') (Sum.inl i)).1 = b i | null | true |
MLList.filterMap | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α β : Type u_1} → [Monad m] → (α → Option β) → MLList m α → MLList m β | Filter and transform a `MLList` using an `Option` valued function. | true |
Std.Http.Method.uncheckout.sizeOf_spec | Std.Http.Data.Method | sizeOf Std.Http.Method.uncheckout = 1 | null | true |
CFC.log_one | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : NormedAlgebra ℝ A]
[inst_3 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], CFC.log 1 = 0 | null | true |
Std.Internal.Do.PredTrans.apply_pushArg | Std.Internal.Do.PredTrans | ∀ {σ : Type u} {Pred : Type v} {EPred : Type w} {α : Type z} (x : σ → Std.Internal.Do.PredTrans Pred EPred (α × σ))
(post : α → σ → Pred) (epost : EPred) (s : σ),
(Std.Internal.Do.pushArg x).apply post epost s =
(x s).apply
(fun x =>
match x with
| (a, s) => post a s)
epost | Unfolding lemma for `pushArg`: applies the state-threaded transformer at state `s`. | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instUpwardEnumerable._proof_1 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int32), Int32.minValue.toInt ≤ i.toInt → ¬Int32.minValue.toInt ≤ i.toInt + ↑n → False | null | false |
FirstOrder.Language.HomClass.mk._flat_ctor | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
[inst : FunLike F M N] [inst_1 : L.Structure M] [inst_2 : L.Structure N],
(∀ (φ : F) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure... | null | false |
UInt8.toInt8_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (UInt8.ofNat n).toInt8 = Int8.ofNat n | null | true |
TendstoLocallyUniformlyOn.tendsto_at | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s → ∀ {a : α}, a ∈ s → Filter.Tendsto (fun i => F i a) p (nhds (f a)) | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk.injEq | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(toLaxFunctor : CategoryTheory.LaxFunctor B C)
(map_id :
autoParam
(∀ (X : B),
toLaxFunctor.map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (toLaxFunctor.obj X))
... | null | true |
GradeOrder.wellFoundedGT | Mathlib.Order.Grade | ∀ {α : Type u_3} [inst : Preorder α] (𝕆 : Type u_5) [inst_1 : Preorder 𝕆] [GradeOrder 𝕆 α] [WellFoundedGT 𝕆],
WellFoundedGT α | null | true |
WeierstrassCurve.Affine.instDecidableEqPoint.decEq._proof_6 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} (a a_1 : R) (a_2 : W'.Nonsingular a a_1)
(b b_1 : R) (b_2 : W'.Nonsingular b b_1),
¬a = b → ¬WeierstrassCurve.Affine.Point.some a a_1 a_2 = WeierstrassCurve.Affine.Point.some b b_1 b_2 | null | false |
padicValInt | Mathlib.NumberTheory.Padics.PadicVal.Basic | ℕ → ℤ → ℕ | For `p ≠ 1`, the `p`-adic valuation of an integer `z ≠ 0` is the largest natural number `k` such
that `p^k` divides `z`. If `x = 0` or `p = 1`, then `padicValInt p q` defaults to `0`. | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimageDiagram.eq_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))}
(hF : ∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (Categ... | null | true |
IsSimpleRing.of_surjective | Mathlib.RingTheory.SimpleRing.Congr | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] [Nontrivial S] (f : R →+* S),
IsSimpleRing R → Function.Surjective ⇑f → IsSimpleRing S | null | true |
Std.HashSet.getD_union_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ ∪ m₂).getD k fallback = m₂.getD k fallback | null | true |
Lean.Parser.Term.set_option.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
CircularPartialOrder.toCircularPreorder | Mathlib.Order.Circular | {α : Type u_1} → [self : CircularPartialOrder α] → CircularPreorder α | null | true |
ModuleCon.mk.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
{M : Type u_3} →
{inst : Add M} →
{inst_1 : SMul S M} →
{P : Sort u} →
{toAddCon : AddCon M} →
{smul : ∀ (s : S) {x y : M}, toAddCon.toSetoid x y → toAddCon.toSetoid (s • x) (s • y)} →
{toAddCon' : AddCon M} →
{smul' : ∀ (s : S) {x... | null | false |
Int.Linear.instBEqPoly.beq_spec | Init.Data.Int.Linear | ∀ (x x_1 : Int.Linear.Poly),
(x == x_1) =
match x, x_1 with
| Int.Linear.Poly.num a, Int.Linear.Poly.num b => a == b
| Int.Linear.Poly.add a a_1 a_2, Int.Linear.Poly.add b b_1 b_2 => a == b && (a_1 == b_1 && a_2 == b_2)
| x, x_2 => false | null | true |
MonoidHom.compLeftContinuousBounded_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type v} {γ : Type w} (α : Type u_3) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : Monoid β] [inst_3 : BoundedMul β] [inst_4 : ContinuousMul β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : Monoid γ] [inst_7 : BoundedMul γ] [inst_8 : ContinuousMul γ] (g : β →* γ) {C : NNReal}
(hg : Lipschi... | null | true |
LinearOrderedAddCommMonoidWithTop.toIsOrderedAddMonoid | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} [self : LinearOrderedAddCommMonoidWithTop α], IsOrderedAddMonoid α | null | true |
IsAntichain.sperner | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : Fintype α] {𝒜 : Finset (Finset α)},
IsAntichain (fun x1 x2 => x1 ⊆ x2) ↑𝒜 → 𝒜.card ≤ (Fintype.card α).choose (Fintype.card α / 2) | **Sperner's theorem**. The size of an antichain in `Finset α` is bounded by the size of the
maximal layer in `Finset α`. This precisely means that `Finset α` is a Sperner order. | true |
Partition.mem_removeBot | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {s x : α} [inst : CompleteLattice α] (P : Set α) (indep : sSupIndep P) (sSup_eq : sSup P = s),
x ∈ Partition.removeBot P indep sSup_eq ↔ x ∈ P ∧ x ≠ ⊥ | null | true |
Batteries.BinomialHeap.Imp.FindMin.WF.casesOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{res : Batteries.BinomialHeap.Imp.FindMin α} →
{motive : Batteries.BinomialHeap.Imp.FindMin.WF le res → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin.WF le res) →
((rank : ℕ) →
(before :
∀ {s : Batteries.BinomialHea... | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_2 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x z : V},
¬InnerProductGeometry.angle x z = Real.pi →
¬InnerProductGeometry.angle x z = 0 → ¬Real.sin (InnerProductGeometry.angle x z) = 0 | null | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Frame.0.Lean.Elab.Tactic.Do.ProofMode.transferHypNames.label.match_5 | Lean.Elab.Tactic.Do.ProofMode.Frame | (motive : List Lean.Elab.Tactic.Do.ProofMode.Hyp → Sort u_1) →
(Ps' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) →
((P : Lean.Elab.Tactic.Do.ProofMode.Hyp) → (Ps'' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive (P :: Ps'')) →
((x : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive x) → motive Ps' | null | false |
Std.ExtDHashMap.getD_ofList_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} [inst : LawfulBEq α] {l : List ((a : α) × β a)} {k : α}
{fallback : β k}, (List.map Sigma.fst l).contains k = false → (Std.ExtDHashMap.ofList l).getD k fallback = fallback | null | true |
Std.ExtDTreeMap.get_getKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{h : (t.getKey? a).isSome = true}, (t.getKey? a).get h = t.getKey a ⋯ | null | true |
MeasureTheory.Measure.singularPart_eq_zero | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ.singularPart ν = 0 ↔ μ.AbsolutelyContinuous ν | null | true |
Std.Iterators.Types.TakeWhile.PlausibleStep.recOn | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β]
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} {it : Std.IterM m β}
{motive : (step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.TakeWhile.PlausibleStep it step → Prop}
{step : Std.IterStep (Std.IterM m β) β} (... | null | false |
CliffordAlgebra.ofBaseChangeAux._proof_5 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_2 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
LinearMap.coe_equivOfIsUnitDet | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [inst_4 : Module.Finite R M] {f : M →ₗ[R] M} (h : IsUnit (LinearMap.det f)),
↑(LinearMap.equivOfIsUnitDet h) = f | null | true |
CategoryTheory.uliftFunctor | Mathlib.CategoryTheory.Types.Basic | CategoryTheory.Functor (Type u) (Type (max u v)) | The functor embedding `Type u` into `Type (max u v)`.
Write this as `uliftFunctor.{5, 2}` to get `Type 2 ⥤ Type 5`.
| true |
Std.Http.URI.Query.instEmptyCollection | Std.Http.Data.URI.Basic | EmptyCollection Std.Http.URI.Query | null | true |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.GetUnivsResult.casesOn | Lean.Meta.Sym.Simp.Have | {motive : Lean.Meta.Sym.Simp.GetUnivsResult✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.GetUnivsResult✝) →
((argUnivs fnUnivs : Array Lean.Level) → motive { argUnivs := argUnivs, fnUnivs := fnUnivs }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.