name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Parser.Command.tactic_extension | Lean.Parser.Command | Lean.Parser.Parser | Adds more documentation as an extension of the documentation for a given tactic.
The extended documentation is placed in the command's docstring. It is shown as part of a bulleted
list, so it should be brief.
| true |
_private.Mathlib.Algebra.FreeAlgebra.0.FreeAlgebra.liftAux._proof_1 | Mathlib.Algebra.FreeAlgebra | ∀ (R : Type u_1) {X : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(f : X → A) (a b : FreeAlgebra.Pre R X),
FreeAlgebra.Rel R X a b → FreeAlgebra.liftFun R X f a = FreeAlgebra.liftFun R X f b | null | false |
Stream'.Seq.zipWith_map_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {β' : Type v'} (s₁ : Stream'.Seq α) (s₂ : Stream'.Seq β) (f : β → β')
(g : α → β' → γ), Stream'.Seq.zipWith g s₁ (Stream'.Seq.map f s₂) = Stream'.Seq.zipWith (fun a b => g a (f b)) s₁ s₂ | null | true |
_private.Init.Data.List.Erase.0.List.filterMap.match_1.eq_1 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
HasStrictDerivAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ},
HasStrictDerivAt f f' x → f x ∈ Complex.slitPlane → HasStrictDerivAt (fun t => Complex.log (f t)) (f' / f x) x | null | true |
BooleanSubalgebra.val_bot | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α}, ↑⊥ = ⊥ | null | true |
LinearMap.tracePositiveLinearMap._proof_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
SMulCommClass 𝕜 𝕜 E | null | false |
PFun.preimage_eq | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s : Set β), f.preimage s = f.core s ∩ f.Dom | null | true |
Ideal.normalizedFactorsEquivSpanNormalizedFactors.eq_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsPrincipalIdealRing R]
[inst_3 : NormalizationMonoid R] {r : R} (hr : r ≠ 0),
Ideal.normalizedFactorsEquivSpanNormalizedFactors hr = Equiv.ofBijective (fun d => ⟨Ideal.span {↑d}, ⋯⟩) ⋯ | null | true |
Codisjoint.sup_right' | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (c ⊔ b) | null | true |
Lean.Meta.Sym.ProofInstArgInfo.noConfusion | Lean.Meta.Sym.SymM | {P : Sort u} → {t t' : Lean.Meta.Sym.ProofInstArgInfo} → t = t' → Lean.Meta.Sym.ProofInstArgInfo.noConfusionType P t t' | null | false |
OrderIso.dualAntisymmetrization._proof_6 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : (Antisymmetrization α fun x1 x2 => x1 ≤ x2)ᵒᵈ),
Quotient.map' id ⋯ (Quotient.map' id ⋯ a) = a | null | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.prod_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} (motive : (x : ℕ) → (Fin x → α) → Prop) (x : ℕ) (x_1 : Fin x → α),
(∀ (x : Fin 0 → α), motive 0 x) →
(∀ (a : Fin 1 → α), motive 1 a) → (∀ (n : ℕ) (a : Fin (n + 2) → α), motive n.succ.succ a) → motive x x_1 | null | false |
HomotopicalAlgebra.CofibrantObject.ι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] → CategoryTheory.Functor (HomotopicalAlgebra.CofibrantObject C) C | The inclusion functor `CofibrantObject C ⥤ C`. | true |
RingHom.ENatMap._proof_1 | Mathlib.Data.ENat.Basic | ∀ {S : Type u_1} [inst : CommSemiring S] [inst_1 : DecidableEq S] [inst_2 : Nontrivial S] (f : ℕ →+* S)
(hf : Function.Injective ⇑f), (↑(f.toMonoidWithZeroHom.ENatMap hf)).toFun 1 = 1 | null | false |
CompactExhaustion.iUnion_eq | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X), ⋃ n, K n = Set.univ | null | true |
SimpleGraph.Walk.getVert_eq_support_getElem? | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {n : ℕ} (p : G.Walk u v), n ≤ p.length → some (p.getVert n) = p.support[n]? | null | true |
Bipointed.swap._proof_1 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Bipointed),
{ toFun := (CategoryTheory.CategoryStruct.id X).toFun, map_fst := ⋯, map_snd := ⋯ } =
CategoryTheory.CategoryStruct.id { X := X.X, toProd := X.toProd.swap } | null | false |
TopologicalSpace.PositiveCompacts.locallyCompactSpace_of_addGroup | Mathlib.Topology.Algebra.Group.Compact | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G]
(K : TopologicalSpace.PositiveCompacts G), LocallyCompactSpace G | Every topological additive group
in which there exists a compact set with nonempty interior is locally compact. | true |
_private.Lean.Meta.Transform.0.Lean.Meta.transformWithCache.visit.visitPost._unsafe_rec | Lean.Meta.Transform | {m : Type → Type} →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Lean.TransformStep) →
(Lean.Expr → m Lean.TransformStep) →
Bool →
Bool →
Bool →
(x : STWorld IO.RealWorld m) →
... | null | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Refine.0.Lean.Elab.Tactic.Do.ProofMode.patAsTerm.match_1 | Lean.Elab.Tactic.Do.ProofMode.Refine | (motive : Lean.Parser.Tactic.MRefinePat → Sort u_1) →
(pat : Lean.Parser.Tactic.MRefinePat) →
((t : Lean.TSyntax `term) → motive (Lean.Parser.Tactic.MRefinePat.pure t)) →
((name : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MRefinePat.one name)) →
((x : Lean.Parser.Tactic.MRefinePat... | null | false |
Metric.ediam_pos_iff' | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : EMetricSpace X], 0 < Metric.ediam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y | null | true |
Std.ExtDHashMap.get?_eq_none_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α},
m.contains a = false → m.get? a = none | null | true |
Pi.distrib | Mathlib.Algebra.Ring.Pi | {I : Type u} → {f : I → Type v} → [(i : I) → Distrib (f i)] → Distrib ((i : I) → f i) | null | true |
Order.cof_ne_one._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality.Basic | ∀ {α : Type u} [inst : Preorder α] [h : NoTopOrder α], (Order.cof α = 1) = False | null | false |
Subsemiring.mem_unop | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {x : R} {S : Subsemiring Rᵐᵒᵖ}, x ∈ S.unop ↔ MulOpposite.op x ∈ S | null | true |
_private.Mathlib.FieldTheory.Finite.Basic.0._aux_Mathlib_FieldTheory_Finite_Basic___macroRules__private_Mathlib_FieldTheory_Finite_Basic_0_termQ_1 | Mathlib.FieldTheory.Finite.Basic | Lean.Macro | null | false |
LieAlgebra.Extension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing N] →
[inst_2 : LieAlgebra R N] →
[inst_3 : LieRing M] →
[inst_4 : LieAlgebra R M] →
{motive : LieAlgebra.Extension R N M → Sort u} →
(t : L... | null | false |
MeasureTheory.Filtration.mk.inj | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {inst : Preorder ι} {m : MeasurableSpace Ω} {seq : ι → MeasurableSpace Ω}
{mono' : Monotone seq} {le' : ∀ (i : ι), seq i ≤ m} {seq_1 : ι → MeasurableSpace Ω} {mono'_1 : Monotone seq_1}
{le'_1 : ∀ (i : ι), seq_1 i ≤ m},
{ seq := seq, mono' := mono', le' := le' } = { seq := seq_1, mo... | null | true |
String.Slice.Pattern.Model.CharPred.not_matchesAt_of_get | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Bool} {s : String.Slice} {pos : s.Pos} {h : pos ≠ s.endPos},
p (pos.get h) = false → ¬String.Slice.Pattern.Model.MatchesAt p pos | null | true |
AddSubgroup.isComplement'_bot_top | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G], ⊥.IsComplement' ⊤ | null | true |
SSet.Truncated.HomotopyCategory.homToNerveMk_app_edge | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u} [inst : CategoryTheory.SmallCategory C]
(F : CategoryTheory.Functor X.HomotopyCategory C)
{x y : X.obj (Opposite.op { obj := { len := 0 }, property := _proof_11✝ })} (e : SSet.Truncated.Edge x y),
(CategoryTheory.ConcreteCategory.hom
((SSet.Truncated.HomotopyCategory.... | null | true |
NonUnitalAlgHom.rec | Mathlib.Algebra.Algebra.NonUnitalHom | {R : Type u} →
{S : Type u₁} →
[inst : Monoid R] →
[inst_1 : Monoid S] →
{φ : R →* S} →
{A : Type v} →
{B : Type w} →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : DistribMulAction R A] →
[inst_4 : NonUnitalNonAssocSemiring B... | null | false |
PFunctor.M.IsPath.cons | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (xs : PFunctor.Approx.Path F) {a : F.A} (x : F.M) (f : F.B a → F.M) (i : F.B a),
x = PFunctor.M.mk ⟨a, f⟩ → PFunctor.M.IsPath xs (f i) → PFunctor.M.IsPath (⟨a, i⟩ :: xs) x | null | true |
String.Slice.copy_slice_next._proof_1 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {p : s.Pos} {h : p ≠ s.endPos}, p ≤ p.next h | null | false |
Std.ExtDHashMap.Const.size_alter_le_size | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β}, (Std.ExtDHashMap.Const.alter m k f).size ≤ m.size + 1 | null | true |
RingEquiv.map_sub | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R ≃+* S)
(x y : R), f (x - y) = f x - f y | null | true |
Set.mul_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z₁ z₂ : M}, z₁ ∈ Set.center M → z₂ ∈ Set.center M → z₁ * z₂ ∈ Set.center M | null | true |
Std.Internal.List.getKey?_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getKey? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) =
Std.Internal.List.getKe... | null | true |
Nat.xor_mod_two_eq_one._simp_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, ((a ^^^ b) % 2 = 1) = ¬(a % 2 = 1 ↔ b % 2 = 1) | null | false |
Function.IsPeriodicPt.piMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i} {n : ℕ},
(∀ (i : ι), Function.IsPeriodicPt (f i) n (x i)) → Function.IsPeriodicPt (Pi.map f) n x | null | true |
Std.ExtTreeSet.get_min? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α}
{hc : t.contains km = true}, t.min?.get ⋯ = km → t.get km hc = km | null | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {Y : C}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp P.i₀ (CategoryTheory.CategoryStruct.comp P.π f) = f | null | false |
Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.noConfusionType P t t' | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_twoPow._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Std.Async.Selector.casesOn | Std.Async.Select | {α : Type} →
{motive : Std.Async.Selector α → Sort u} →
(t : Std.Async.Selector α) →
((tryFn : Std.Async.Async (Option α)) →
(registerFn : Std.Async.Waiter α → Std.Async.Async Unit) →
(unregisterFn : Std.Async.Async Unit) →
motive { tryFn := tryFn, registerFn := registerF... | null | false |
CategoryTheory.yoneda_preservesLimits | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (CategoryTheory.yoneda.obj X) | The yoneda embedding `yoneda.obj X : Cᵒᵖ ⥤ Type v` for `X : C` preserves limits. | true |
CategoryTheory.Limits.limit.hom_ext_iff | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] {X : C}
{f f' : X ⟶ CategoryTheory.Limits.limit F},
f = f' ↔
∀ (j : J),
CategoryTheory.CategoryStruct.comp f (... | null | true |
ZFSet.mem_pairSep._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {p : ZFSet.{u} → ZFSet.{u} → Prop} {x y z : ZFSet.{u}},
(z ∈ ZFSet.pairSep p x y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b | null | false |
Finpartition.mem_part_self | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a : α}, a ∈ P.part a ↔ a ∈ s | null | true |
Lean.ModuleDoc.mk._flat_ctor | Lean.DocString.Extension | String → Lean.DeclarationRange → Lean.ModuleDoc | null | false |
ConvexCone.hull_min | 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 : SMul R M] {C : ConvexCone R M} {s : Set M}, s ⊆ ↑C → ConvexCone.hull R s ≤ C | null | true |
AddUnits.recOn | Mathlib.Algebra.Group.Units.Defs | {α : Type u} →
[inst : AddMonoid α] →
{motive : AddUnits α → Sort u_1} →
(t : AddUnits α) →
((val neg : α) →
(val_neg : val + neg = 0) →
(neg_val : neg + val = 0) → motive { val := val, neg := neg, val_neg := val_neg, neg_val := neg_val }) →
motive t | null | false |
InverseSystem.piEquivLim | Mathlib.Order.DirectedInverseSystem | {ι : Type u_6} →
{F : ι → Type u_7} →
{X : ι → Type u_8} →
{i : ι} →
[inst : LinearOrder ι] →
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} →
{equiv : (j : ↑(Set.Iio i)) → F ↑j ≃ InverseSystem.piLT X ↑j} →
InverseSystem.IsNatEquiv f equiv →
F i ≃ ↑(InverseSy... | Extend a natural family of bijections to a limit ordinal. | true |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | null | false |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_iSup._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (s ∈ f) = (f ≤ Filter.principal s) | null | false |
Homeomorph.sumArrowHomeomorphProdArrow._proof_4 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Type u_2} {ι' : Type u_3} (i : ι),
Continuous fun a => (Equiv.sumArrowEquivProdArrow ι ι' X).invFun a (Sum.inl i) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → quasispectrum ℝ a ⊆ Set.Ici 0 | null | false |
CategoryTheory.Functor.ext_of_iso | Mathlib.CategoryTheory.EqToHom | ∀ {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) (hobj : ∀ (X : C), F.obj X = G.obj X),
autoParam (∀ (X : C), e.hom.app X = CategoryTheory.eqToHom ⋯) CategoryTheory.Functor.ext_of_iso._auto_1 → F = ... | null | true |
Equiv.prodEmpty | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → α × Empty ≃ Empty | `Empty` type is a right absorbing element for type product up to an equivalence. | true |
ContRepresentation.Equiv.coe_toContinuousLinearMap | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Monoid G] [inst_1 : Ring R]
[inst_2 : AddCommGroup V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V]
[inst_6 : AddCommGroup W] [inst_7 : TopologicalSpace W] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Modu... | null | true |
CategoryTheory.instCategoryComonad._proof_4 | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (M : CategoryTheory.Comonad C) (X : C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.id M.toFunctor).app X) (M.δ.app X) =
CategoryTheory.CategoryStruct.comp (M.δ.app X)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.C... | null | false |
CategoryTheory.ReflQuiv.isoOfQuivIso._proof_1 | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {V W : Type u_2} [inst : CategoryTheory.ReflQuiver V] [inst_1 : CategoryTheory.ReflQuiver W]
(e : CategoryTheory.Quiv.of V ≅ CategoryTheory.Quiv.of W),
(∀ (X : V), e.hom.map (CategoryTheory.ReflQuiver.id X) = CategoryTheory.ReflQuiver.id (e.hom.obj X)) →
∀ (Y : ↑(CategoryTheory.ReflQuiv.of W)),
(Categor... | null | false |
AddSemigroupAction.casesOn | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} →
{P : Type u_10} →
[inst : AddSemigroup G] →
{motive : AddSemigroupAction G P → Sort u} →
(t : AddSemigroupAction G P) →
([toVAdd : VAdd G P] →
(add_vadd : ∀ (g₁ g₂ : G) (p : P), (g₁ + g₂) +ᵥ p = g₁ +ᵥ g₂ +ᵥ p) →
motive { toVAdd := toVAdd, add_... | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.subset_union_prime._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Polynomial.expand_pow | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (f : Polynomial R),
(Polynomial.expand R (p ^ q)) f = (⇑(Polynomial.expand R p))^[q] f | null | true |
MeasureTheory.OuterMeasure.comap_iInf | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {ι : Sort u_2} {β : Type u_3} (f : α → β) (m : ι → MeasureTheory.OuterMeasure β),
(MeasureTheory.OuterMeasure.comap f) (⨅ i, m i) = ⨅ i, (MeasureTheory.OuterMeasure.comap f) (m i) | null | true |
Configuration.HasLines.toNondegenerate | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.HasLines P L],
Configuration.Nondegenerate P L | null | true |
CategoryTheory.uliftCategory._proof_4 | Mathlib.CategoryTheory.Category.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C] {X Y : ULift.{u_1, u_2} C} (f : X.down ⟶ Y.down),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y.down) = f | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_12 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
CompHausLike.LocallyConstant.counitApp.eq_1 | Mathlib.Condensed.Discrete.Colimit | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
(Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w)))
[inst_3 : CategoryTheory.Limits.Pre... | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.synthesizeInstMVarCore._sparseCasesOn_4 | Lean.Elab.Term.TermElabM | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
PolynomialLaw.instSMul | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_2} → [inst_3 : AddCommMonoid N] → [inst_4 : Module R N] → SMul R (M →ₚₗ[R] N) | null | true |
Subfield.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relrank C = B.relrank C | null | true |
TannakaDuality.FiniteGroup.rightFDRep._proof_1 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k] [Finite G], Module.Finite k (G → k) | null | false |
CategoryTheory.OplaxFunctor.PseudoCore.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F : CategoryTheory.OplaxFunctor B C} →
(mapIdIso :
(a : B) → F.map (CategoryTheory.CategoryStruct.id a) ≅ CategoryTheory.CategoryStruct.id (F.obj a)) →
... | null | false |
Std.TreeMap.Equiv.maxKey_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{h' : t₁.isEmpty = false} (h : t₁.Equiv t₂), t₁.maxKey h' = t₂.maxKey ⋯ | null | true |
NNRat.instMetricSpace._aux_14 | Mathlib.Topology.Instances.Rat | Filter (ℚ≥0 × ℚ≥0) | null | false |
String.Slice.toNat?_eq_none_iff | Std.Data.String.ToNat | ∀ {s : String.Slice}, s.toNat? = none ↔ s.isNat = false | null | true |
RBTree.RBNode.All.append._unary | BatteriesRecycling.RBTree.WF | ∀ {α : Type u_1} {p : α → Prop}
(_x : (l : RBTree.RBNode α) ×' (r : RBTree.RBNode α) ×' (_ : RBTree.RBNode.All p l) ×' RBTree.RBNode.All p r),
RBTree.RBNode.All p (_x.1.append _x.2.1) | null | false |
_private.Init.Data.Ord.Vector.0.Vector.instLawfulBEqOrd._proof_1 | Init.Data.Ord.Vector | ∀ {α : Type u_1} [inst : Ord α] [inst_1 : BEq α] [Std.LawfulBEqOrd α] {n : ℕ}, Std.LawfulBEqOrd (Vector α n) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality.0.Polynomial.Chebyshev.integral_eval_T_real_mul_self_measureT_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality | ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R} {x : R},
Polynomial.eval x p * Polynomial.eval x q = Polynomial.eval x (p * q) | null | false |
Matrix.instLieRingToLieAlgebra._proof_27 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x y z : Matrix.ToLieAlgebra R CM), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆ | null | false |
CategoryTheory.Limits.Trident.app_zero_assoc | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)}
(s : CategoryTheory.Limits.Trident f) (j : J) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (s.π.app CategoryTheory.Limits.WalkingParallelFamily.zero)
(CategoryTheory.CategoryStruct.comp (f j) h) =
... | null | true |
SignType.pos | Mathlib.Data.Sign.Defs | SignType | null | true |
IterateMulAct.instCommMonoid._proof_5 | Mathlib.GroupTheory.GroupAction.IterateAct | ∀ {α : Type u_1} {f : α → α} (x x_1 : IterateMulAct f), x * x_1 = x_1 * x | null | false |
CategoryTheory.Pretriangulated.contractibleTriangleFunctor._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.contractibleTriangle ... | null | false |
OrderedFinpartition.compAlongOrderedFinpartitionₗ._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_2}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | null | false |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.mk._flat_ctor | Lean.Meta.Tactic.Backtrack | ℕ →
(List Lean.MVarId → List Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId))) →
(Lean.MVarId → Lean.MetaM Bool) →
(Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId))) → Bool → Lean.Meta.Tactic.Backtrack.BacktrackConfig | null | false |
IsCompact.exists_infEdist_eq_edist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α},
IsCompact s → s.Nonempty → ∀ (x : α), ∃ y ∈ s, Metric.infEDist x s = edist x y | **Alias** of `IsCompact.exists_infEDist_eq_edist`. | true |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_3 | Mathlib.Topology.LocallyFinite | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
_private.Init.Control.Lawful.Instances.0.EStateM.bind.match_1.eq_1 | Init.Control.Lawful.Instances | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (a : α) (s : σ)
(h_1 : (a : α) → (s : σ) → motive (EStateM.Result.ok a s))
(h_2 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)),
(match EStateM.Result.ok a s with
| EStateM.Result.ok a s => h_1 a s
| EStateM.Result.error e s => h_2 e... | null | true |
TopHom._sizeOf_inst | Mathlib.Order.Hom.Bounded | (α : Type u_6) → (β : Type u_7) → {inst : Top α} → {inst_1 : Top β} → [SizeOf α] → [SizeOf β] → SizeOf (TopHom α β) | null | false |
LowerSet.ctorIdx | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → {inst : LE α} → LowerSet α → ℕ | null | false |
εNFA.εClosure.below.step | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {S : Set σ} {motive : (a : σ) → M.εClosure S a → Prop} (s t : σ)
(a : t ∈ M.step s none) (a_1 : M.εClosure S s), εNFA.εClosure.below a_1 → motive s a_1 → εNFA.εClosure.below ⋯ | null | true |
ModularGroup.one_lt_normSq_T_zpow_smul | Mathlib.NumberTheory.Modular | ∀ {z : UpperHalfPlane}, z ∈ ModularGroup.fdo → ∀ (n : ℤ), 1 < Complex.normSq ↑(ModularGroup.T ^ n • z) | If `z ∈ 𝒟ᵒ`, and `n : ℤ`, then `|z + n| > 1`. | true |
not_addDissociated | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : AddCommGroup α] {s : Set α},
¬AddDissociated s ↔ ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ t ≠ u ∧ ∑ x ∈ t, x = ∑ x ∈ u, x | null | true |
Std.Internal.List.List.getValueD_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValueD k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) fallback =
Std... | null | true |
CategoryTheory.Limits.isLimitConeOfAdj | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{L : CategoryTheory.Functor (CategoryTheory.Functor J C) C} →
(adj : CategoryTheory.Functor.const J ⊣ L) →
(F : CategoryTheory.Functor J C) → CategoryTheor... | The cones defined by `coneOfAdj` are limit cones. | true |
Std.Internal.List.getValueCast?_filter_not_contains_of_contains_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α},
Std.Internal.List.DistinctKeys l₁ →
l₂.contains k = false →
Std.Internal.List.getValueCast? k (List.filter (fun p => !l₂.contains p.fst) l₁) =
Std.Internal.List.getValueCast? k l₁ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.