name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Time.Formats.leanDateTime24HourNoNanos | Std.Time.Format | Std.Time.GenericFormat (Std.Time.Awareness.only Std.Time.TimeZone.GMT) | The leanDateTime24HourNoNanos format, which follows the pattern `uuuu-MM-dd'T'HH:mm:ss` for
representing date, time, and time zone. It uses the default value that can be parsed with the
notation of dates.
| true |
HolderWith.eq_1 | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (C r : NNReal)
(f : X → Y), HolderWith C r f = ∀ (x y : X), edist (f x) (f y) ≤ ↑C * edist x y ^ ↑r | null | true |
Std.TreeSet.Raw.maxD_eq_fallback | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = true → ∀ {fallback : α}, t.maxD fallback = fallback | null | true |
Complex.UnitClosedDisc.instIsScalarTowerCircle_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | IsScalarTower Circle Complex.UnitClosedDisc Complex.UnitClosedDisc | null | true |
Set.kernImage_eq_compl | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Set.kernImage f s = (f '' sᶜ)ᶜ | null | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.eqvTypes._sparseCasesOn_5 | Lean.Compiler.LCNF.InferType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 1032 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicIndependent.matroid | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | (R : Type u_1) →
(A : Type w) →
[inst : CommRing R] →
[inst_1 : CommRing A] → [inst_2 : Algebra R A] → [FaithfulSMul R A] → [NoZeroDivisors A] → Matroid A | If `R` is a commutative ring and `A` is a commutative `R`-algebra with injective algebra map
and no zero-divisors, then the `R`-algebraic independent subsets of `A` form a matroid. | true |
Bicategory.Opposite.bicategory_associator_inv_unop2 | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : Bᵒᵖ} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
(CategoryTheory.Bicategory.associator f g h).inv.unop2 =
(CategoryTheory.Bicategory.associator h.unop g.unop f.unop).hom | null | true |
AntivaryOn.inv_left₀ | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {s : Set ι} {f : ι → α} {g : ι → β},
(∀ i ∈ s, 0 < f i) → AntivaryOn f g s → MonovaryOn f⁻¹ g s | **Alias** of the reverse direction of `monovaryOn_inv_left₀`. | true |
Std.WP.WP.mk | Std.WP.Basic | {Prog : Type u} →
{Value : outParam (Type v)} →
{Pred : outParam (Type w)} →
{EPred : outParam (Type w')} →
[inst : Std.WP.Assertion Pred] →
[inst_1 : Std.WP.Assertion EPred] →
(wpTrans : Prog → Lean.Order.PredTrans Pred EPred Value) →
(∀ (x : Prog), (wpTrans x).m... | null | true |
PrimeSpectrum.instLiesOverAsIdealComapAlgebraMap | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
(p : PrimeSpectrum S), p.asIdeal.LiesOver (PrimeSpectrum.comap (algebraMap R S) p).asIdeal | null | true |
Set.image_inv_Icc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
Inv.inv '' Set.Icc a b = Set.Icc b⁻¹ a⁻¹ | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instLawfulUpwardEnumerableLeast? | Init.Data.Range.Polymorphic.SInt | Std.PRange.LawfulUpwardEnumerableLeast? Int8 | null | true |
Rep.standardComplex.compForgetAugmentedIso | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) →
[inst : CommRing k] →
[inst_1 : Monoid G] →
AlgebraicTopology.AlternatingFaceMapComplex.obj
(CategoryTheory.SimplicialObject.Augmented.drop.obj
(classifyingSpaceUniversalCover.compForgetAugmented.toModule k G)) ≅
Rep.standardComplex.forget₂ToModuleCat k G | If we apply the free functor `Type u ⥤ ModuleCat.{u} k` to the universal cover of the
classifying space of `G` as a simplicial set, then take the alternating face map complex, the result
is isomorphic to the standard resolution of the trivial `G`-representation `k` as a complex of
`k`-modules. | true |
MulMemClass.casesOn | Mathlib.Algebra.Group.Subsemigroup.Defs | {S : Type u_3} →
{M : Type u_4} →
[inst : Mul M] →
[inst_1 : SetLike S M] →
{motive : MulMemClass S M → Sort u} →
(t : MulMemClass S M) → ((mul_mem : ∀ {s : S} {a b : M}, a ∈ s → b ∈ s → a * b ∈ s) → motive ⋯) → motive t | null | false |
CategoryTheory.Subfunctor.orderIsoSubobject_symm_apply | Mathlib.CategoryTheory.Subfunctor.Subobject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
(X : CategoryTheory.Subobject F),
(RelIso.symm (CategoryTheory.Subfunctor.orderIsoSubobject F)) X = CategoryTheory.Subfunctor.range X.arrow | null | true |
CategoryTheory.Limits.terminal.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasTerminal C] {P : C}
(f g : P ⟶ ⊤_ C), f = g | null | true |
Lean.Elab.withMacroExpansionInfo | Lean.Elab.InfoTree.Main | {m : Type → Type} →
{α : Type} →
[MonadFinally m] →
[Monad m] → [Lean.Elab.MonadInfoTree m] → [Lean.MonadLCtx m] → Lean.Syntax → Lean.Syntax → m α → m α | null | true |
Polynomial.toMvPolynomial | Mathlib.Algebra.MvPolynomial.Equiv | {R : Type u_1} → {σ : Type u_3} → [inst : CommSemiring R] → σ → Polynomial R →ₐ[R] MvPolynomial σ R | The embedding of `R[X]` into `R[Xᵢ]` as an `R`-algebra homomorphism. | true |
Std.DTreeMap.Internal.Impl.Const.get_map' | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → γ} {k : α} (h : t.WF)
{h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.map f t) = true},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.... | Variant of `get_map` that holds without `LawfulEqOrd`. | true |
SheafOfModules.pushforwardPushforwardAdj_counit_app_val_app | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} {S : CategoryTheory.Sheaf J RingCat}
{R ... | null | true |
SetRel.preimage_subset_preimage_left | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {R₁ R₂ : SetRel α β} {t : Set β}, R₁ ⊆ R₂ → R₁.preimage t ⊆ R₂.preimage t | null | true |
CategoryTheory.Limits.pullback.congrHom._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Z : C} {f₁ f₂ : X ⟶ Z},
f₁ = f₂ →
CategoryTheory.CategoryStruct.comp f₁ (CategoryTheory.CategoryStruct.id Z) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f₂ | null | false |
_private.Mathlib.RingTheory.Multiplicity.0.Int.finiteMultiplicity_iff_finiteMultiplicity_natAbs._simp_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, FiniteMultiplicity a b = ∃ n, ¬a ^ (n + 1) ∣ b | null | false |
CategoryTheory.IsGrothendieckAbelian.hasSeparator._autoParam | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Basic | Lean.Syntax | null | false |
Std.ExtDTreeMap.not_mem_diff_of_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, k ∈ t₂ → k ∉ t₁ \ t₂ | null | true |
Orientation.oangle_add_right_smul_rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x : V},
x ≠ 0 → ∀ (r : ℝ), o.oangle x (x + r • (o.rotation ↑(Real.pi / 2)) x) = ↑(Real.arctan r) | An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
of a rotation of another by `π / 2`. | true |
essInf_mono_ae._auto_1 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
Set.nonempty_compl_of_nontrivial | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} [Nontrivial α] (x : α), {x}ᶜ.Nonempty | null | true |
_private.Init.Data.Array.Erase.0.Array.eraseP_filterMap.match_1.eq_2 | Init.Data.Array.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : (y : β) → motive (some y)) (h_2 : Unit → motive none),
(match none with
| some y => h_1 y
| none => h_2 ()) =
h_2 () | null | true |
Lean.Meta.Grind.EMatchTheorem.cnstrs | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheorem → List Lean.Meta.Grind.EMatchTheoremConstraint | null | true |
LinearPMap.supSpanSingleton._proof_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {E : Type u_1} [inst : AddCommGroup E] {F : Type u_4} [inst_1 : AddCommGroup F] {K : Type u_2} {L : Type u_3}
[inst_2 : DivisionRing K] [inst_3 : DivisionRing L] {σ : K →+* L} [inst_4 : Module K E] [inst_5 : Module L F]
(f : E →ₛₗ.[σ] F), ∀ x ∉ f.domain, x = 0 → False | null | false |
Asymptotics.IsBigOWith.eq_zero_imp | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{c : ℝ} {f'' : α → E''} {g'' : α → F''} {l : Filter α},
Asymptotics.IsBigOWith c l f'' g'' → ∀ᶠ (x : α) in l, g'' x = 0 → f'' x = 0 | null | true |
ComplexShape.embeddingUp'Add | Mathlib.Algebra.Homology.Embedding.Basic | {A : Type u_3} →
[inst : AddCommSemigroup A] →
[inst_1 : IsRightCancelAdd A] → (a : A) → A → (ComplexShape.up' a).Embedding (ComplexShape.up' a) | The embedding from `up' a` to itself via (· + b). | true |
Order.instPreorderPartialIso._aux_1 | Mathlib.Order.CountableDenseLinearOrder | (α : Type u_1) →
(β : Type u_2) →
[inst : LinearOrder α] → [inst_1 : LinearOrder β] → Order.PartialIso α β → Order.PartialIso α β → Prop | null | false |
AddCircle.setAddOrderOfEquiv | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : Field 𝕜] →
(p : 𝕜) →
[inst_1 : LinearOrder 𝕜] →
[IsStrictOrderedRing 𝕜] →
[hp : Fact (0 < p)] → {n : ℕ} → 0 < n → ↑{u | addOrderOf u = n} ≃ ↑{m | m < n ∧ m.gcd n = 1} | The natural bijection between points of order `n` and natural numbers less than and coprime to
`n`. The inverse of the map sends `m ↦ (m/n * p : AddCircle p)` where `m` is coprime to `n` and
satisfies `0 ≤ m < n`. | true |
CategoryTheory.Under.pushoutComp | Mathlib.CategoryTheory.Comma.Over.Pullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
(f : X ⟶ Y) →
(g : Y ⟶ Z) →
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] →
[inst_2 : CategoryTheory.Limits.HasPushoutsAlong g] →
CategoryTheory.Under.pushout (CategoryTheory.CategorySt... | pushout commutes with composition (up to natural isomorphism). | true |
Std.Tactic.BVDecide.BVBinPred.toString.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | (motive : Std.Tactic.BVDecide.BVBinPred → Sort u_1) →
(x : Std.Tactic.BVDecide.BVBinPred) →
(Unit → motive Std.Tactic.BVDecide.BVBinPred.eq) → (Unit → motive Std.Tactic.BVDecide.BVBinPred.ult) → motive x | null | false |
Std.PRange.UpwardEnumerable.succMany?_succ | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] {n : ℕ} {a : α},
Std.PRange.succMany? (n + 1) a = (Std.PRange.succMany? n a).bind Std.PRange.succ? | null | true |
Combinatorics.Additive.«termσₘ[_]» | Mathlib.Combinatorics.Additive.DoublingConst | Lean.ParserDescr | The doubling constant `σₘ[A]` of a finset `A` in a group is `|A * A| / |A|`. | true |
_private.Init.Data.List.Sublist.0.List.cons_subset._simp_1_5 | Init.Data.List.Sublist | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
List.isChain_append_cons_cons._simp_1 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {b c : α} {l₁ l₂ : List α},
List.IsChain R (l₁ ++ b :: c :: l₂) = (List.IsChain R (l₁ ++ [b]) ∧ R b c ∧ List.IsChain R (c :: l₂)) | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabMutualDef.match_3 | Lean.Elab.MutualDef | (motive : Option (Lean.Elab.ExpandDeclIdResult × Subarray Lean.Elab.ExpandDeclIdResult) → Sort u_1) →
(x : Option (Lean.Elab.ExpandDeclIdResult × Subarray Lean.Elab.ExpandDeclIdResult)) →
(Unit → motive none) →
((declId : Lean.Elab.ExpandDeclIdResult) →
(s' : Subarray Lean.Elab.ExpandDeclIdResult)... | null | false |
Std.Http.Header.Value.mk | Std.Http.Data.Headers.Value | (value : String) →
autoParam (Std.Http.Header.IsValidHeaderValue value) Std.Http.Header.Value.isValidHeaderValue._autoParam →
Std.Http.Header.Value | null | true |
Fintype.card_quotient_le | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [inst : Fintype α] (s : Setoid α) [inst_1 : DecidableRel fun x1 x2 => x1 ≈ x2],
Fintype.card (Quotient s) ≤ Fintype.card α | null | true |
_private.Mathlib.Order.RelIso.Basic.0.RelEmbedding.isWellOrder.match_1_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (motive : r ↪r s → IsWellOrder β s → Prop)
(x : r ↪r s) (x_1 : IsWellOrder β s), (∀ (f : r ↪r s) (x : IsWellOrder β s), motive f x) → motive x x_1 | null | false |
Topology.IsOpenEmbedding.restrictPreimage | Mathlib.Topology.LocalAtTarget | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} (s : Set β),
Topology.IsOpenEmbedding f → Topology.IsOpenEmbedding (s.restrictPreimage f) | **Alias** of `Set.restrictPreimage_isOpenEmbedding`. | true |
Matroid.eRank | Mathlib.Combinatorics.Matroid.Rank.ENat | {α : Type u_1} → Matroid α → ℕ∞ | The rank `Matroid.eRank M` of `M` is the `ℕ∞`-valued cardinality of each base of `M`.
(See `Matroid.cRank` for a worse-behaved cardinal-valued version) | true |
CategoryTheory.Sieve.sInf_apply | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C}
(f : Y ⟶ X), (sInf Ss).arrows f ↔ ∀ S ∈ Ss, S.arrows f | null | true |
_private.Mathlib.GroupTheory.Coxeter.Length.0.CoxeterSystem.isLeftDescent_iff._proof_1_1 | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B},
cs.length (cs.simple i * w) < cs.length w → ¬cs.length (cs.simple i * w) = cs.length w + 1 | null | false |
BoundedContinuousFunction.instZero | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → [Zero β] → Zero (BoundedContinuousFunction α β) | null | true |
Quotient.hrecOn' | Mathlib.Data.Quot | {α : Sort u_1} →
{s₁ : Setoid α} →
{φ : Quotient s₁ → Sort u_5} →
(qa : Quotient s₁) → (f : (a : α) → φ (Quotient.mk'' a)) → (∀ (a₁ a₂ : α), a₁ ≈ a₂ → f a₁ ≍ f a₂) → φ qa | Recursion on a `Quotient` argument `a`, result type depends on `⟦a⟧`. | true |
CategoryTheory.EquivalenceRelation.rec | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.EquivalenceRelation p₁ p₂ → Sort u} →
((toReflexiveRelation : CategoryTheory.ReflexiveRelation p₁ p₂) →
(s : R ⟶ R) →
(symmetry₁ : CategoryT... | null | false |
String.instDecidableIsValid | Init.Data.String.Basic | {s : String} → {p : String.Pos.Raw} → Decidable (String.Pos.Raw.IsValid s p) | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.centralizer_le_alternating_iff._proof_1_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α},
Fintype.card α ≤ g.cycleType.sum + 1 →
Fintype.card ↑(Function.fixedPoints ⇑g) = Fintype.card α - g.cycleType.sum →
Fintype.card { x // x ∈ Function.fixedPoints ⇑g } ≤ 1 | null | false |
Set.Iic_union_Ico_eq_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → Set.Iic a ∪ Set.Ico a b = Set.Iio b | null | true |
AlgebraicGeometry.SpecModulesToSheafFullyFaithful._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {X Y : (AlgebraicGeometry.Spec R).Modules}
(f : AlgebraicGeometry.modulesSpecToSheaf.obj X ⟶ AlgebraicGeometry.modulesSpecToSheaf.obj Y),
AlgebraicGeometry.modulesSpecToSheaf.map
{
val :=
{ app := fun U => ModuleCat.ofHom { toAddHom := (ModuleCat.Hom.hom (f.hom.app U)).to... | null | false |
Float.Model.Format.noConfusionType | Init.Data.Float.Model.Format.Basic | Sort u → Float.Model.Format → Float.Model.Format → Sort u | null | false |
Lean.isLevelMVarAssignable | Lean.MetavarContext | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → Lean.LMVarId → m Bool | null | true |
_private.Lean.Compiler.InitAttr.0.Lean.isIOUnit.match_1 | Lean.Compiler.InitAttr | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((type : Lean.Expr) → motive (some type)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Std.IterM.drain_eq_map_toListRev | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β},
it.drain = (fun x => PUnit.unit) <$> it.toListRev | null | true |
_private.Batteries.Data.List.Perm.0.List.Perm.subperm_left.match_1_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l l₁ : List α} (motive : l.Subperm l₁ → Prop) (x : l.Subperm l₁),
(∀ (_u : List α) (pu : _u.Perm l) (su : _u.Sublist l₁), motive ⋯) → motive x | null | false |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsPrimitiveRoot.subOneIntegralPowerBasisOfPrimePow._simp_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : Field K] {x y : NumberField.RingOfIntegers K}, (x = y) = (↑x = ↑y) | null | false |
Std.TreeSet.Raw.instSliceableRioSlice | Std.Data.TreeSet.Raw.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.instSliceableRioSlice._auto_1) →
Std.Rio.Sliceable (Std.TreeSet.Raw α cmp) α (Std.DTreeMap.Internal.Unit.RioSlice α) | null | true |
Nat.uIcc_eq_range' | Mathlib.Order.Interval.Finset.Nat | ∀ (a b : ℕ), Finset.uIcc a b = { val := ↑(List.range' (min a b) (max a b + 1 - min a b)), nodup := ⋯ } | null | true |
instZeroLocallyFinsuppWithin._proof_3 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : Zero Y] (z : X),
∃ t ∈ nhds z, (t ∩ Function.support fun x => 0).Finite | null | false |
Std.IterM.TerminationMeasures.Productive._sizeOf_inst | Init.Data.Iterators.Basic | (α : Type w) →
(m : Type w → Type w') →
{β : Type w} →
{inst : Std.Iterator α m β} →
[SizeOf α] → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → SizeOf (Std.IterM.TerminationMeasures.Productive α m) | null | false |
CategoryTheory.Limits.pushoutRightPushoutInlIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y Z : C} →
(f : X ⟶ Y) →
(g : X ⟶ Z) →
(f' : Y ⟶ W) →
[inst_1 : CategoryTheory.Limits.HasPushout f g] →
[inst_2 : CategoryTheory.Limits.HasPushout f' (CategoryTheory.Limits.pushout.inl f g)] →
... | The canonical isomorphism `W ⨿[Y] (Y ⨿[X] Z) ≅ W ⨿[X] Z` | true |
AddSubmonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : AddCommMonoid M] →
{S : AddSubmonoid M} →
{N : Type u_2} →
[inst_1 : AddCommMonoid N] →
{P : Type u_3} →
[inst_2 : AddCommMonoid P] →
S.LocalizationMap N →
{g : M →+ P} →
{T : AddSubmonoid P} →
... | Given an `AddCommMonoid` homomorphism `g : M →+ P` where for AddSubmonoids `S ⊆ M, T ⊆ P` we
have `g(S) ⊆ T`, the induced AddMonoid homomorphism from the Localization of `M` at `S` to the
Localization of `P` at `T`: if `f : M →+ N` and `k : P →+ Q` are Localization maps for `S` and
`T` respectively, we send `z : N` to ... | true |
Int.log_zero_left | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (r : R), Int.log 0 r = 0 | null | true |
RingAut.instGroup._proof_5 | Mathlib.Algebra.Ring.Aut | ∀ (R : Type u_1) [inst : Mul R] [inst_1 : Add R] (n : ℕ) (a : RingAut R), a ^ ↑n.succ = a ^ ↑n * a | null | false |
CategoryTheory.Functor.ShiftSequence.induced_shiftMap | Mathlib.CategoryTheory.Shift.InducedShiftSequence | ∀ {C : Type u_1} {D : Type u_2} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} A]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F ≅ G)
(M : Ty... | null | true |
FirstOrder.Language.ElementaryEmbedding.map_rel._simp_1 | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.ElementaryEmbedding M N) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) = FirstOrder.Language.Structure.RelMap r x | null | false |
MeasureTheory.memLp_top_const | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {E : Type u_5} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
(c : E), MeasureTheory.MemLp (fun x => c) ⊤ μ | null | true |
CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{i i' j j' : E.I₀} →
(hii' : i = i') →
(hjj' : j = j') →
(k : E.I₁ i j) → E.Y ((CategoryTheory.PreOneHypercover.congrIndexOneOfEq hii' hjj') k) ≅ E.Y k | If `i = i'` and `j = j'` this is the isomorphism between the `1`-component at
`congrIndexOneOfEq k : E.I₁ i' j'` and the `1`-component at `k : E.I₁ i j`.
Note: This isomorphism could also be constructed inline from `eqToIso`. We only
use `eqToIso` directly to construct isomorphisms `E.Y k ≅ E.Y k'` where `k k' : E.I₁ ... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.getHSMulIntFn? | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | null | true |
JacobsonSpace.recOn | Mathlib.Topology.JacobsonSpace | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : JacobsonSpace X → Sort u} →
(t : JacobsonSpace X) →
((closure_inter_closedPoints : ∀ {Z : Set X}, IsClosed Z → closure (Z ∩ closedPoints X) = Z) → motive ⋯) →
motive t | null | false |
OrderRingIso.toRingEquiv_eq_coe | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Add α] [inst_2 : LE α] [inst_3 : Mul β] [inst_4 : Add β]
[inst_5 : LE β] (f : α ≃+*o β), f.toRingEquiv = f.toRingEquiv | null | true |
RingQuot.smul_quot | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {S : Type uS} [inst_1 : CommSemiring S] (r : R → R → Prop) [inst_2 : Algebra S R]
{n : S} {a : R}, n • { toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (n • a) } | null | true |
CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt.hom_ext' | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.LeftExtension F} {Y : D}
(h : E.IsPointwiseLeftKanEx... | null | true |
Homeomorph.sumCongr._proof_2 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_3} {Y : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {X' : Type u_1}
{Y' : Type u_2} [inst_2 : TopologicalSpace X'] [inst_3 : TopologicalSpace Y'] (h₁ : X ≃ₜ X') (h₂ : Y ≃ₜ Y'),
Continuous (h₁.sumCongr h₂.toEquiv).invFun | null | false |
Std.DTreeMap.Internal.Unit.RiiSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{t : Std.DTreeMap.Internal.Unit.RiiSliceData α} →
{α' : Type u} →
{t' : Std.DTreeMap.Internal.Unit.RiiSliceData α'} →
α = α' → t ≍ t' → Std.DTreeMap.Internal.Unit.RiiSliceData.noConfusionType P t t' | null | false |
List.findIdxNth_cons_zero_of_pos | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α} {a : α}, p a = true → List.findIdxNth p (a :: xs) 0 = 0 | null | true |
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_3 | Mathlib.Order.Filter.Bases.Finite | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | null | false |
Lean.JsonNumber | Lean.Data.Json.Basic | Type | null | true |
IsLocalization.map_integerMultiple | Mathlib.RingTheory.Localization.Integer | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {ι : Type u_3} (s : Finset ι) (f : ι → S) (i : ↥s),
(algebraMap R S) (IsLocalization.integerMultiple M s f i) = IsLocalization.commonDenom M s f • f ↑i | null | true |
Turing.ToPartrec.Code.rec.eq._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.4 | Mathlib.Computability.TuringMachine.ToPartrec | @Turing.ToPartrec.Code.rec = @Turing.ToPartrec.Code.rec✝ | null | false |
ciSup_ciSup_eq_right | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] {b : β} {f : (x : β) → b = x → α},
⨆ x, ⨆ (h : b = x), f x h = f b ⋯ | null | true |
CategoryTheory.ShortComplex.comp_liftCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) {A : C} (k : A ⟶ S.X₂) (hk : CategoryTheory.CategoryStruct.comp k S.g = 0)
[inst_2 : S.HasLeftHomology] {A' : C} (α : A' ⟶ A) {Z : C} (h : S.cycles ⟶ Z),
CategoryT... | null | true |
AlgebraicGeometry.SpecMap_ΓSpecIso_inv_toSpecΓ | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ (R : CommRingCat),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (AlgebraicGeometry.Scheme.ΓSpecIso R).inv)
(AlgebraicGeometry.Spec R).toSpecΓ =
CategoryTheory.CategoryStruct.id (AlgebraicGeometry.Spec ((AlgebraicGeometry.Spec R).presheaf.obj (Opposite.op ⊤))) | null | true |
Lean.Lsp.CompletionItemCapabilities.noConfusionType | Lean.Data.Lsp.Capabilities | Sort u → Lean.Lsp.CompletionItemCapabilities → Lean.Lsp.CompletionItemCapabilities → Sort u | null | false |
dvd_iff_exists_eq_mul_right | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, a ∣ b ↔ ∃ c, b = a * c | **Alias** of `dvd_def`. | true |
RelIso.preimage_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α ≃ β) (s : β → β → Prop) (a : α), (RelIso.preimage f s) a = f a | null | true |
MeasureTheory.AddContent.onIocAux.eq_1 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] {G : Type u_3} [inst_1 : AddCommGroup G] (f : α → G) (s : Set α),
MeasureTheory.AddContent.onIocAux f s =
if h : ∃ p, p.1 ≤ p.2 ∧ s = Set.Ioc p.1 p.2 then f h.choose.2 - f h.choose.1 else 0 | null | true |
CartanMatrix.F₄ | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | Matrix (Fin 4) (Fin 4) ℤ | The Cartan matrix of type F₄. See [bourbaki1968] plate VIII, page 288. | true |
ProbabilityTheory.measure_stieltjesOfMeasurableRat_univ | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : Measurable f) (a : α),
(ProbabilityTheory.stieltjesOfMeasurableRat f hf a).measure Set.univ = 1 | null | true |
_private.Std.Data.Iterators.Combinators.Monadic.Drop.0.Std.Iterators.Types.Drop.productiveRel_of_remaining | Std.Data.Iterators.Combinators.Monadic.Drop | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [Monad m] [inst : Std.Iterator α m β]
[inst_1 : Std.Iterators.Productive α m] {it it' : Std.IterM m β},
it'.internalState.remaining < it.internalState.remaining → Std.Iterators.Types.Drop.ProductiveRel✝ m it' it | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_10 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ),
table.size ≤ pat.utf8ByteSize → ¬table.size < pat.utf8ByteSize → table.size = pat.utf8ByteSize | null | false |
CategoryTheory.ShortComplex.HomologyData._sizeOf_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S : CategoryTheory.ShortComplex C} → [SizeOf C] → S.HomologyData → ℕ | null | false |
Std.DTreeMap.Internal.Impl.Const.getD_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} {l : List α} {k : α}
{fallback : Unit},
Std.DTreeMap.Internal.Impl.Const.getD (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)) k fallback = () | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.