name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.CoreHom.iso | Mathlib.CategoryTheory.Core | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : CategoryTheory.Core C} → CategoryTheory.CoreHom X Y → (X.of ≅ Y.of) | The isomorphism of objects of `C` underlying a morphism in `Core C`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey!_erase_eq_of_not_compare_maxKey!_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
MonCat.Colimits.Relation.below.rec | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] {F : CategoryTheory.Functor J MonCat}
{motive : (a a_1 : MonCat.Colimits.Prequotient F) → MonCat.Colimits.Relation F a a_1 → Prop}
{motive_1 :
{a a_1 : MonCat.Colimits.Prequotient F} →
(t : MonCat.Colimits.Relation F a a_1) → MonCat.Colimits.Relatio... | null | false |
Std.Time.ExtendedDayPeriod.midnight.sizeOf_spec | Std.Time.Format.Modifier | sizeOf Std.Time.ExtendedDayPeriod.midnight = 1 | null | true |
AlgCat.instRingObjForgetAlgHomCarrier | Mathlib.Algebra.Category.AlgCat.Basic | (R : Type u) → [inst : CommRing R] → {S : AlgCat R} → Ring ((CategoryTheory.forget (AlgCat R)).obj S) | null | true |
Mathlib.Tactic._aux_Mathlib_Tactic_Linarith_Frontend___elabRules_Mathlib_Tactic_linarith_1 | Mathlib.Tactic.Linarith.Frontend | Lean.Elab.Tactic.Tactic | null | false |
Std.ExtTreeMap.ext_getKey_getElem?_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α β cmp},
t₁ = t₂ ↔ (∀ (k : α) (hk : k ∈ t₁) (hk' : k ∈ t₂), t₁.getKey k hk = t₂.getKey k hk') ∧ ∀ (k : α), t₁[k]? = t₂[k]? | null | true |
Lean.Grind.CommRing.Poly.denote'.go.eq_def | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Poly)
(acc : α),
Lean.Grind.CommRing.Poly.denote'.go ctx p acc =
match p with
| Lean.Grind.CommRing.Poly.num 0 => acc
| Lean.Grind.CommRing.Poly.num k => acc + ↑k
| Lean.Grind.CommRing.Poly.add... | null | true |
WithBot.bot_add | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] (x : WithBot α), ⊥ + x = ⊥ | null | true |
subsetConditionallyCompleteLinearOrder._proof_4 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} (s : Set α) [inst : ConditionallyCompleteLinearOrder α] [inst_1 : Inhabited ↑s] (t : Set ↑s),
¬BddBelow t → sInf t = sInf ∅ | null | false |
instCommGroupClassGroup._proof_6 | Mathlib.RingTheory.ClassGroup.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] (a : ClassGroup R), 1 * a = a | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_comap_isInducing._simp_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] (Z : Set (PrimeSpectrum R)), IsClosed Z = ∃ s, Z = PrimeSpectrum.zeroLocus s | null | false |
_private.Mathlib.CategoryTheory.SmallRepresentatives.0.CategoryTheory.CoreSmallCategoryOfSet.arrowEquiv._simp_1 | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y X' Y' : T} (f : X ⟶ Y) (f' : X' ⟶ Y'),
(CategoryTheory.Arrow.mk f = CategoryTheory.Arrow.mk f') =
∃ (hX : X = X') (hY : Y = Y'),
f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom hX)
(CategoryTheory.CategoryStruct.c... | null | false |
CategoryTheory.FreeBicategory.Hom₂.noConfusion | Mathlib.CategoryTheory.Bicategory.Free | {P : Sort u_1} →
{B : Type u} →
{inst : Quiver B} →
{a b : CategoryTheory.FreeBicategory B} →
{a_1 a_2 : a ⟶ b} →
{t : CategoryTheory.FreeBicategory.Hom₂ a_1 a_2} →
{B' : Type u} →
{inst' : Quiver B'} →
{a' b' : CategoryTheory.FreeBicategory B'} →
... | null | false |
Lean.instFromJsonSubtypeOfDecidablePred_mathlib | Mathlib.Lean.Json | {α : Type u} → [Lean.FromJson α] → (p : α → Prop) → [DecidablePred p] → Lean.FromJson (Subtype p) | null | true |
Function.FromTypes.curry_apply_cons | Mathlib.Data.Fin.Tuple.Curry | ∀ {n : ℕ} {α : Type u} {p : Fin n → Type u} {τ : Type u} (f : ((i : Fin (n + 1)) → Matrix.vecCons α p i) → τ) (a : α),
Function.FromTypes.curry f a = Function.FromTypes.curry ((fun {x} => f) ∘' Fin.cons a) | null | true |
RCLike.copy_of_normedField._proof_5 | Mathlib.Analysis.RCLike.Basic | ∀ {𝕜 : Type u_1} (h : RCLike 𝕜) (hk : NormedField 𝕜), hk = h.toNormedField → (algebraMap ℝ 𝕜) 1 = 1 | null | false |
Traversable.map_traverse | Mathlib.Control.Traversable.Lemmas | ∀ {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {F : Type u → Type u} [inst_2 : Applicative F]
[LawfulApplicative F] {α β γ : Type u} (g : α → F β) (f : β → γ) (x : t α),
Functor.map f <$> traverse g x = traverse (Functor.map f ∘ g) x | null | true |
DistribMulActionHom.map_smulₑ | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B] (f : A →ₑ+[φ] B)
(m : M) (x : A), f (m • x) = φ m • f x | null | true |
Mathlib.Tactic.BicategoryLike.Mor₂.coherenceComp.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {P : Sort u} →
{e : Lean.Expr} →
{isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift} →
{f g h i : Mathlib.Tactic.BicategoryLike.Mor₁} →
{α : Mathlib.Tactic.BicategoryLike.CoherenceHom} →
{η θ : Mathlib.Tactic.BicategoryLike.Mor₂} →
{e' : Lean.Expr} →
{isoLif... | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction.0.UpperHalfPlane.linear_ne_zero_of_im._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.ball_two._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
MeasureTheory.Lp.instNNNorm._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), 0 ≤ (MeasureTheory.eLpNorm (↑↑f) p μ).toReal | null | false |
Colex.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
Colex.instCancelCommMonoid = { toCommMonoid := Colex.instCommMonoid, toIsLeftCancelMul := ⋯ } | null | true |
Lean.Parser.Tactic.rcasesPat.clear | Init.RCases | Lean.ParserDescr | `-` is a pattern which removes the value from the context | true |
CategoryTheory.Limits.FintypeCat.inclusionCreatesFiniteLimits._proof_1 | Mathlib.CategoryTheory.Limits.FintypeCat | ∀ {J : Type} [inst : CategoryTheory.SmallCategory J] {K : CategoryTheory.Functor J FintypeCat},
CategoryTheory.Limits.HasLimit (K.comp FintypeCat.incl) | null | false |
Polynomial.Monic.natDegree_mul | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
p.Monic → q.Monic → (p * q).natDegree = p.natDegree + q.natDegree | null | true |
Subgroup.unop_normalizer | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup Gᵐᵒᵖ), (Subgroup.normalizer ↑H).unop = Subgroup.normalizer ↑H.unop | null | true |
CategoryTheory.Limits.ChosenPullback.hp₂_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
(h : CategoryTheory.Limits.ChosenPullback f₁ f₂) {Z : C} (h_1 : S ⟶ Z),
CategoryTheory.CategoryStruct.comp h.p₂ (CategoryTheory.CategoryStruct.comp f₂ h_1) =
CategoryTheory.CategoryStruct.comp h.p h_1 | null | true |
FirstOrder.Language.orderLHom_leSymb | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered],
L.orderLHom.onRelation FirstOrder.Language.leSymb = FirstOrder.Language.leSymb | null | true |
_private.Lean.Meta.Injective.0.Lean.Meta.getCtorAppIndices?._sparseCasesOn_1 | Lean.Meta.Injective | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.PropInstances.0.Pi.isCompl_iff._simp_1_1 | Mathlib.Order.PropInstances | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a b : α},
IsCompl a b = (Disjoint a b ∧ Codisjoint a b) | null | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.matchConstAux.match_4 | Lean.Meta.WHNF | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((declName : Lean.Name) → (lvls : List Lean.Level) → motive (Lean.Expr.const declName lvls)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
Char.toLower_eq_of_isUpper | Batteries.Data.Char.AsciiCasing | ∀ {c : Char}, c.isUpper = true → c.toLower = Char.ofNat (c.toNat + 32) | null | true |
Set.pi_univ_Ioc_update_right | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] [inst_1 : DecidableEq ι] {x y : (i : ι) → α i}
{i₀ : ι} {m : α i₀},
m ≤ y i₀ →
(Set.univ.pi fun i => Set.Ioc (x i) (Function.update y i₀ m i)) =
{z | z i₀ ≤ m} ∩ Set.univ.pi fun i => Set.Ioc (x i) (y i) | null | true |
_private.Mathlib.Data.Nat.MaxPrimeFac.0.Nat.one_lt_maxPrimeFac_iff._proof_1_3 | Mathlib.Data.Nat.MaxPrimeFac | ∀ (n : ℕ), 1 < n + 2 | null | false |
UInt8.toFin_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a ^^^ b).toFin = a.toFin ^^^ b.toFin | null | true |
CliffordAlgebraComplex.reverse_eq_id | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | CliffordAlgebra.reverse = LinearMap.id | null | true |
MonoidHom.prod_comp_prodMap | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] {M' : Type u_6}
{N' : Type u_7} [inst_2 : MulOneClass M'] [inst_3 : MulOneClass N'] [inst_4 : MulOneClass P] (f : P →* M) (g : P →* N)
(f' : M →* M') (g' : N →* N'), (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reducePow._regBuiltin.Nat.reducePow.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.395276852._hygCtx._hyg.30 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
CategoryTheory.Bicategory.termΔ | Mathlib.CategoryTheory.Bicategory.Monad.Basic | Lean.ParserDescr | The comultiplication 2-morphism of the comonad. | true |
SimpleGraph.ConnectedComponent.adj_spanningCoe_toSimpleGraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (C : G.ConnectedComponent),
C.toSimpleGraph.spanningCoe.Adj v w ↔ v ∈ C.supp ∧ G.Adj v w | null | true |
UInt64.reduceLE | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.Simproc | null | true |
Lean.Elab.Command.ModuleLinter.mk | Lean.Elab.Command | (Array Lean.Syntax → Lean.Elab.Command.CommandElabM Unit) →
autoParam Lean.Name Lean.Elab.Command.ModuleLinter.name._autoParam → Lean.Elab.Command.ModuleLinter | null | true |
AddGrpCat.sectionsπAddMonoidHom | Mathlib.Algebra.Category.Grp.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J AddGrpCat) →
(j : J) → ↑(F.comp (CategoryTheory.forget AddGrpCat)).sections →+ ↑(F.obj j) | The projection from `Functor.sections` to a factor as an `AddMonoidHom`. | true |
AddMonoidHom.prodMap | Mathlib.Algebra.Group.Prod | {M : Type u_3} →
{N : Type u_4} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
{M' : Type u_6} →
{N' : Type u_7} →
[inst_2 : AddZeroClass M'] → [inst_3 : AddZeroClass N'] → (M →+ M') → (N →+ N') → M × N →+ M' × N' | `Prod.map` as an `AddMonoidHom`. | true |
CategoryTheory.oplaxFunctorOfIsLocallyDiscrete_mapId | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory B]
[inst_1 : CategoryTheory.Bicategory.IsLocallyDiscrete B] [inst_2 : CategoryTheory.Bicategory C] (obj : B → C)
(map : {b b' : B} → (b ⟶ b') → (obj b ⟶ obj b'))
(mapId : (b : B) → map (CategoryTheory.CategoryStruct.id b) ⟶ CategoryTheory.CategoryS... | null | true |
OrderedFinpartition.atomic | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | (n : ℕ) → OrderedFinpartition n | The ordered finpartition of `Fin n` into singletons. | true |
MeasureTheory.IsAddFundamentalDomain.mk | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_2} [inst : Zero G] [inst_1 : VAdd G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : autoParam (MeasureTheory.Measure α) MeasureTheory.IsAddFundamentalDomain._auto_1},
MeasureTheory.NullMeasurableSet s μ →
(∀ᵐ (x : α) ∂μ, ∃ g, g +ᵥ x ∈ s) →
Pairwise (Function.onFun (MeasureThe... | null | true |
Traversable.foldlm | Mathlib.Control.Fold | {α β : Type u} →
{t : Type u → Type u} → [Traversable t] → {m : Type u → Type u} → [Monad m] → (α → β → m α) → α → t β → m α | Deprecated alias for `foldlM`. | true |
FinTrdeg.of_trdeg | Mathlib.FieldTheory.FinTrdeg | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L],
Algebra.trdeg K L < Cardinal.aleph0 → FinTrdeg K L | **Alias** of the reverse direction of `finTrdeg_iff_trdeg`. | true |
Function.Injective.completeLattice._proof_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : SupSet α] [inst_1 : CompleteLattice β] (f : α → β),
(∀ (s : Set α), f (sSup s) = ⨆ a ∈ s, f a) → ∀ (x : Set α), IsLUB ((fun {y} => f y) '' x) (f (sSup x)) | null | false |
Std.TreeSet.Raw.Equiv.beq | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {m₁ m₂ : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.beq m₂ = true | null | true |
AlgebraicGeometry.HasRingHomProperty.instIsZariskiLocalAtTarget | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme)
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q], AlgebraicGeometry.IsZariskiLocalAtTarget P | This is only `inferInstance` because of the `@[local instance]` on `HasAffineProperty` above. | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.instHashableAbsoluteLspSemanticToken.hash.match_1 | Lean.Server.FileWorker.SemanticHighlighting | (motive : Lean.Server.FileWorker.AbsoluteLspSemanticToken → Sort u_1) →
(x : Lean.Server.FileWorker.AbsoluteLspSemanticToken) →
((a a_1 : Lean.Lsp.Position) →
(a_2 : Lean.Lsp.SemanticTokenType) →
(a_3 : ℕ) → motive { pos := a, tailPos := a_1, type := a_2, priority := a_3 }) →
motive x | null | false |
ZeroAtInftyContinuousMap.instPseudoMetricSpace._proof_7 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero β]
(a a_1 : ZeroAtInftyContinuousMap α β), 0 ≤ dist a.toBCF a_1.toBCF | null | false |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.rec | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {motive_1 : Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
{motive_2 : Array (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_3 : List (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_4 : String × Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
((exact? : Option Lean.Ela... | null | false |
Std.AnyAsyncStream._sizeOf_1 | Std.Sync.StreamMap | {α : Type} → [SizeOf α] → Std.AnyAsyncStream α → ℕ | null | false |
ENNReal.rpow_le_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x y : ENNReal} {z : ℝ}, x ≤ y → 0 ≤ z → x ^ z ≤ y ^ z | null | true |
ProofWidgets.RpcEncodablePacket.mk.sizeOf_spec._@.ProofWidgets.Component.HtmlDisplay.3304690324._hygCtx._hyg.1 | ProofWidgets.Component.HtmlDisplay | ∀ (html : Lean.Json), sizeOf { html := html } = 1 + sizeOf html | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_20 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u' v' : V} {p₂ : G.Walk u' v'} (k i : ℕ),
k + i + 1 ≤ p₂.support.length → k + i < p₂.support.length | null | false |
Aesop.Script.UScript.toSScriptStatic | Aesop.Script.StructureStatic | Aesop.Script.TacticState → Aesop.Script.UScript → Lean.CoreM (Aesop.Script.SScript × Bool) | null | true |
CategoryTheory.Mon.instMonoidalForget._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.Mon C} (f : X ⟶ Y) (X' : CategoryTheory.Mon C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.SSet.stdSimplex.nonDegenerateEquiv'_symm_apply_mem._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
induced_mono | Mathlib.Topology.Order | ∀ {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {g : β → α},
t₁ ≤ t₂ → TopologicalSpace.induced g t₁ ≤ TopologicalSpace.induced g t₂ | null | true |
VitaliFamily.enlarge.eq_1 | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
(v : VitaliFamily μ) (δ : ℝ) (δpos : 0 < δ),
v.enlarge δ δpos =
{ setsAt := fun x => v.setsAt x ∪ {s | MeasurableSet s ∧ (interior s).Nonempty ∧ ¬s ⊆ Metric.closedBall x δ},
measurableSet := ⋯, nonempty_in... | null | true |
SimpleGraph.Walk.edges_injective | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, Function.Injective SimpleGraph.Walk.edges | null | true |
Lean.Elab.ConfigEval.EvalConfigItemView.mk._flat_ctor | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Array (Lean.Ident × Lean.Name) →
Array Lean.Elab.ConfigEval.EvalConfigItemHandler → Lean.Elab.ConfigEval.EvalConfigItemView | null | false |
Std.DTreeMap.Internal.Impl.link2._unary | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(_x :
(l : Std.DTreeMap.Internal.Impl α β) ×'
(r : Std.DTreeMap.Internal.Impl α β) ×' (_ : l.Balanced) ×' r.Balanced) →
Std.DTreeMap.Internal.Impl.Tree α β (_x.1.size + _x.2.1.size) | Builds the tree `l ++ r` without any balancing information at the root. | false |
Std.Time.FormatType.eq_3 | Std.Time.Format.Basic | ∀ (result : Type), Std.Time.FormatType result [] = result | null | true |
Std.TreeSet.Equiv.getLT?_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.getLT? k = t₂.getLT? k | null | true |
cyclotomicCharacter.toFun | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | {L : Type u} → [inst : CommRing L] → [IsDomain L] → (p : ℕ) → [inst_2 : Fact (Nat.Prime p)] → L ≃+* L → ℤ_[p] | The underlying function of the cyclotomic character. See `cyclotomicCharacter`. | true |
List.length_eq_one_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, l.length = 1 ↔ ∃ a, l = [a] | null | true |
Lean.ReducibilityStatus._sizeOf_inst | Lean.ReducibilityAttrs | SizeOf Lean.ReducibilityStatus | null | false |
AddCommGroup.ModEq.sub_right_cancel | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a₁ a₂ b₁ b₂ : G},
a₂ ≡ b₂ [PMOD p] → a₁ - a₂ ≡ b₁ - b₂ [PMOD p] → a₁ ≡ b₁ [PMOD p] | **Alias** of the forward direction of `AddCommGroup.ModEq.sub_iff_right`. | true |
_private.Init.Meta.Defs.0.Lean.Name.escape | Init.Meta.Defs | String → String | null | true |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_zero_iff._simp_1_3 | Mathlib.Topology.Bornology.Absorbs | ∀ {α : Type u_1} {β : Type u_2} {t : Set β} {f : α → β} {x : α}, Set.MapsTo f {x} t = (f x ∈ t) | null | false |
CategoryTheory.Abelian.LeftResolution.karoubi.F'._proof_2 | Mathlib.Algebra.Homology.LeftResolution.Reduced | ∀ {A : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive A] (X : A),
CategoryTheory.Cat... | null | false |
Function.Surjective.tprod_eq_tprod_of_hasProd_iff_hasProd | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] [T2Space α]
{α' : Type u_4} [inst_3 : CommMonoid α'] [inst_4 : TopologicalSpace α'] {e : α' → α},
Function.Surjective e →
e 1 = 1 →
∀ {f : β → α} {g : γ → α'}, (∀ {a : α'}, HasProd f (e a) ↔ HasProd g a) → ∏... | null | true |
Lean.Grind.CommRing.Poly.powC | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → ℕ → Lean.Grind.CommRing.Poly | null | true |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.closure_coe_completion_v_mul_v_lt._simp_1_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a b c : G₀},
0 < c → (a * c < b) = (a < b / c) | null | false |
_private.Mathlib.RingTheory.DividedPowers.DPMorphism.0.DividedPowers.DPMorphism.fromGens._simp_3 | Mathlib.RingTheory.DividedPowers.DPMorphism | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : AddSubmonoid M}
{x : M} (h : ∀ (c : R) {x : M}, x ∈ S.carrier → c • x ∈ S.carrier),
(x ∈ { toAddSubmonoid := S, smul_mem' := h }) = (x ∈ S) | null | false |
SSet.prodStdSimplex.pairingCore.IsIndex | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | {m : ℕ} →
{k : Fin (m + 1)} →
{n : ℕ} →
(x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N) → {d : ℕ} → x.dim = d → Fin (d + 1) → Prop | Let `x` be a nondegenerate `d`-simplex of `Δ[m + 1] ⊗ Δ[n]` which
does not belong to `Λ[m + 1, k.castSucc].unionProd ∂Δ[n]`. In particular,
`x` induces a strictly monotone map from `Fin (d + 1)` to
`{0, ..., m + 1} × {0, ..., n}`. We introduce a predicate on elements in
`Fin (d + 1)` which shall be satisfied for `l.suc... | true |
NumberField.IsCMField.casesOn | Mathlib.NumberTheory.NumberField.CMField | {K : Type u_1} →
[inst : Field K] →
[inst_1 : CharZero K] →
{motive : NumberField.IsCMField K → Sort u} →
(t : NumberField.IsCMField K) →
([to_isTotallyComplex : NumberField.IsTotallyComplex K] →
[is_quadratic : Algebra.IsQuadraticExtension (↥(NumberField.maximalRealSubfield ... | null | false |
CategoryTheory.CostructuredArrow.toOverCompYoneda.eq_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
(T : CategoryTheory.Over A),
CategoryTheory.CostructuredArrow.toOverCompYoneda A T =
CategoryTheory.NatIso.ofComponents
(fun X =>
(CategoryTheory.overEquivPresheafCostructuredArrow A).fullyFaithfulFu... | null | true |
Quaternion.linearIsometryEquivTuple._proof_1 | Mathlib.Analysis.Quaternion | RingHomInvPair (RingHom.id ℝ) (RingHom.id ℝ) | null | false |
ENNReal.ofNNReal_liminf | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {ι : Type u_4} {f : Filter ι} {u : ι → NNReal},
Filter.IsCoboundedUnder (fun x1 x2 => x1 ≥ x2) f u → ↑(Filter.liminf u f) = Filter.liminf (fun i => ↑(u i)) f | null | true |
MeasureTheory.volume_preserving_finTwoArrow | Mathlib.MeasureTheory.Constructions.Pi | ∀ (α : Type u) [inst : MeasureTheory.MeasureSpace α] [MeasureTheory.SigmaFinite MeasureTheory.volume],
MeasureTheory.MeasurePreserving (⇑MeasurableEquiv.finTwoArrow) MeasureTheory.volume MeasureTheory.volume | null | true |
Nat.toArray_rco_eq_if | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m...n).toArray = if m < n then #[m] ++ (m + 1...n).toArray else #[] | null | true |
sign_finRotate | Mathlib.GroupTheory.Perm.Fin | ∀ (n : ℕ), Equiv.Perm.sign (finRotate n) = (-1) ^ (n - 1) | null | true |
Nat.exists_base_eq_prime_pow_of_prime_pow_eq_base_pow | Mathlib.Data.Nat.Factorization.PrimePow | ∀ {p a m n : ℕ}, Nat.Prime p → n ≠ 0 → p ^ m = a ^ n → ∃ k, a = p ^ k | null | true |
Lean.Meta.Try.Collector.checkInductive | Lean.Meta.Tactic.Try.Collect | Lean.LocalDecl → Lean.Meta.Try.Collector.M Unit | null | true |
List.SortedGT.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGT → List.IsChain (fun x1 x2 => x1 > x2) l | **Alias** of the forward direction of `List.sortedGT_iff_isChain`. | true |
Fintype.nonempty_field_iff | Mathlib.FieldTheory.Cardinality | ∀ {α : Type u_1} [inst : Fintype α], Nonempty (Field α) ↔ IsPrimePow (Fintype.card α) | A `Fintype` can be given a field structure iff its cardinality is a prime power. | true |
_private.Mathlib.CategoryTheory.Category.RelCat.0.CategoryTheory.RelCat.rel_iso_iff._simp_1_2 | Mathlib.CategoryTheory.Category.RelCat | ∀ {X : CategoryTheory.RelCat} (x y : X), ((x, y) ∈ (CategoryTheory.CategoryStruct.id X).rel) = (x = y) | null | false |
Complex.UnitDisc.instIsScalarTower_circle_circle | Mathlib.Analysis.Complex.UnitDisc.Basic | IsScalarTower Circle Circle Complex.UnitDisc | null | true |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.grind._sparseCasesOn_1 | Lean.Elab.Tactic.Grind.Main | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ArithmeticFunction.instSemiring._proof_6 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
CategoryTheory.GrothendieckTopology.pointBot | Mathlib.CategoryTheory.Sites.Point.Presheaf | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.LocallySmall.{w, v, u} C] → C → ⊥.Point | If `X` is an object of `C`, this is the point of the site `(C, ⊥)` (whose
sheaves are presheaves, see `sheafBotEquivalence`) corresponding to `X`. | true |
HasFPowerSeriesAt._proof_1 | Mathlib.Analysis.Analytic.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.