name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | {n : ℕ} →
(α : Fin (n + 1) → Type u_2) →
[inst : (i : Fin (n + 1)) → LE (α i)] → α (Fin.last n) × ((i : Fin n) → α i.castSucc) ≃o ((i : Fin (n + 1)) → α i) | Order isomorphism between tuples of length `n + 1` and pairs of an element and a tuple of length
`n` given by separating out the last element of the tuple.
This is `Fin.snoc` as an `OrderIso`. | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
x ≈ x_1 →
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x =
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x_1 | null | false |
CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G :
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂)))
(CategoryTheory.Funct... | Given functors `F : C ⥤ D` and
`G : (Cᵒᵖ ⥤ Type max w v₁ v₂) ⥤ (Dᵒᵖ ⥤ Type max w v₁ v₂)`,
and a natural transformation `φ : F ⋙ uliftYoneda ⟶ uliftYoneda ⋙ G`, this is the
(natural) morphism `P ⟶ F.op ⋙ G.obj P` for all `P : Cᵒᵖ ⥤ Type max w v₁ v₂` that is
determined by `φ`. | true |
Lean.Meta.Sym.State.casesOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.State → Sort u} →
(t : Lean.Meta.Sym.State) →
((share : Lean.Meta.Sym.AlphaShareCommon.State) →
(maxFVar : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option Lean.FVarId)) →
(proofInstInfo : Lean.PHashMap Lean.Name (Option Lean.Meta.Sym.ProofInstInfo)) →
(inferType :... | null | false |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | Lean.TSyntax [`ident, `num] → Array Lean.Name → Array Lean.Expr → Lean.MessageData → Lean.MetaM ℕ | Elaborate syntax that refers to an argument of a declaration or hypothesis.
This is either a 1-indexed number, or a name from `argNames`.
- `fvars` is only used to add hover information to `stx`
- `head` is only used for the error message. | true |
HomotopicalAlgebra.Precylinder.symm_I | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A), P.symm.I = P.I | null | true |
CategoryTheory.AddMonObj.ofIso | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M X : C} → [CategoryTheory.AddMonObj M] → (M ≅ X) → CategoryTheory.AddMonObj X | Transfer `AddMonObj` along an isomorphism. | true |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | {α : Type u_1} →
{f : Filter α} →
{motive : f.Realizer → Sort u} →
((σ : Type u_5) → (F : CFilter (Set α) σ) → (eq : F.toFilter = f) → motive { σ := σ, F := F, eq := eq }) →
(t : f.Realizer) → motive t | null | false |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | Lean.Meta.ParamInfo → Bool | null | true |
instSemilatticeSupPrimeMultiset._proof_5 | Mathlib.Data.PNat.Factors | ∀ (a : PrimeMultiset), a ≤ a | null | false |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, Std.Commutative fun x y => x ||| y | null | true |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods.Commensurable 𝒢.periods | null | true |
SimpleGraph.FinsubgraphHom.restrict._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' G'' : G.Finsubgraph}, G'' ≤ G' → ∀ v ∈ (↑G'').verts, v ∈ (↑G').verts | null | false |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.emin = 1 - ↑FP.FloatCfg.emax | null | true |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} [inst : MulZeroOneClass α] {β : Type u_2} [inst_1 : CommMonoidWithZero β], MonoidHomClass (α →*₀ β) α β | null | false |
IsRelUpperSet.iInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {P : α → Prop} [inst : LE α] [Nonempty ι] {f : ι → Set α},
(∀ (i : ι), IsRelUpperSet (f i) P) → IsRelUpperSet (⋂ i, f i) P | null | true |
List.Sublist.below | Init.Data.List.Basic | {α : Type u_1} → {motive : (a a_1 : List α) → a.Sublist a_1 → Prop} → {a a_1 : List α} → a.Sublist a_1 → Prop | null | true |
_private.Plausible.Attr.0.initFn._@.Plausible.Attr.3035915354._hygCtx._hyg.2 | Plausible.Attr | IO Unit | null | false |
SSet.Subcomplex.Pairing.RankFunction.w_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι)
[inst_1 : P.IsProper] [inst_2 : SuccOrder ι] [inst_3 : NoMaxOrder ι] (j : ι) {Z : SSet}
(h : (f.filtration (Order.succ j)).toSSet ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.t j) (CategoryTheory.CategoryStru... | null | true |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X : C} (f : c.pt ⟶ X), (c.extend f).pt = X | null | true |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : α), Function.Embedding.coeWithTop a = ↑a | null | true |
AddMonoid.Coprod.swap_comp_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
(AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inl | null | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) = (p < n) | null | false |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : SetRel α α), (hausdorffEntourage U).inv = hausdorffEntourage U.inv | null | true |
Vector.getElem?_set!_ne | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i j : ℕ} {xs : Vector α n} {x : α}, i ≠ j → (xs.set! i x)[j]? = xs[j]? | null | true |
_private.Mathlib.Computability.Primrec.List.0.Primrec.listLookup._simp_1_2 | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type v} →
[inst_1 : CategoryTheory.SmallCategory I] →
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))) →
{J : Type v} →
[inst_2 : CategoryTheory.SmallCategory J] →
(G :
... | (implementation) Pulling out a colimit out of a hom functor is one half of the key lemma. Note
that all of the heavy lifting actually happens in `CostructuredArrow.toOverCompYonedaColimit`
and `yonedaYonedaColimit`. | true |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUnifor... | **Alias** of `isClosed_setOfPred_isCompactOperator`.
---
The set of compact operators from a normed space to a complete topological vector space is
closed. | true |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a * b = 1 → a⁻¹ = b | null | true |
Nat.lt_irrefl | Init.Prelude | ∀ (n : ℕ), ¬n < n | null | true |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (x y : Fin n), x - y = x + -y | null | true |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_5} {σ : Type u_6} [inst : CommRing R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → (-φ).IsHomogeneous n | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | Lean.Name → Array Lean.Name → Option Lean.Name | Find a name in `ns` that starts with prefix `p`. | true |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{X Y : C} →
(f : Y ⟶ X) →
(motive : (CategoryTheory.Sieve.generateSingleton f).arrows.category → Sort u_3) →
(x : (CategoryTheory.Sieve.generateSingleton f).arrows.category) →
((obj : CategoryTheory.Over X) →
... | null | false |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.wrapped._proof_1._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | @MeasureTheory.Filtration.definition✝ = @MeasureTheory.Filtration.definition✝ | null | false |
_private.Mathlib.NumberTheory.LSeries.Convergence.0.LSeriesSummable_of_abscissaOfAbsConv_lt_re._simp_1_2 | Mathlib.NumberTheory.LSeries.Convergence | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, (sInf s < b) = ∃ a ∈ s, a < b | null | false |
ISize.toBitVec64_minValue | Init.Data.SInt.IntToBitVec | ∀ (h : System.Platform.numBits = 64), ISize.minValue.toBitVec64 h = BitVec.intMin 64 | null | true |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Semiring R] (h : IsField R), (if ha : 0 = 0 then 0 else Classical.choose ⋯) = 0 | null | false |
Lean.Elab.ConfigEval.instEvalExprOccurrences | Lean.Elab.ConfigEval.MetaInstances | Lean.Elab.ConfigEval.EvalExpr Lean.Meta.Occurrences | null | true |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
{D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
(t : CategoryTheory.Limits.IsLimit c) [inst_2 : CategoryTheory.... | null | false |
SimpleGraph.not_isUniform_iff | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {G : SimpleGraph α}
[inst_3 : DecidableRel G.Adj] {ε : 𝕜} {s t : Finset α},
¬G.IsUniform ε s t ↔
∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity ... | null | true |
Float32.ofModel | Init.Data.Float.Float32 | Float32.Model → Float32 | Constructs a `Float32` from a `Float32.Model`. | true |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap α β cmp → δ | Folds the given function over the mappings in the map in ascending order. | true |
CategoryTheory.RetractArrow.unop_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : Cᵒᵖ} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g),
h.unop.i =
CategoryTheory.Arrow.homMk (CategoryTheory.Arrow.Hom.right h.r).unop (CategoryTheory.Arrow.Hom.left h.r).unop ⋯ | null | true |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | Lean.FVarId → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit | Adds a new hypothesis. | true |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [MOD n] → b < n → a % n = b | null | true |
NonemptyInterval.mem_def | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : NonemptyInterval α} {a : α}, a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2 | null | true |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | ℕ → ℕ → ℕ | If `n < k * k`, then `minFacAux n k = n`, if `k | n`, then `minFacAux n k = k`.
Otherwise, `minFacAux n k = minFacAux n (k+2)` using well-founded recursion.
If `n` is odd and `1 < n`, then `minFacAux n 3` is the smallest prime factor of `n`.
This definition is by well-founded recursion, so `rfl` or `decide` cannot be ... | true |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive : CategoryTheory.Limits.WalkingParallelFamily J → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelFamily J) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelFamily.one → motive t | null | false |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | {V : Type u_1} →
{W : Type u_2} →
[inst : AddCommGroup V] →
[inst_1 : Module ℝ V] →
[inst_2 : TopologicalSpace V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module ℝ W] →
[inst_5 : TopologicalSpace W] →
{e : AddChar ℝ Circle} →
{L : ... | Algebra homomorphism mapping `w` to `fun v ↦ e (L v w)`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Data.List.Sort.0.List.orderedInsert.match_1.eq_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} (motive : List α → Sort u_2) (b : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (b : α) → (l : List α) → motive (b :: l)),
(match b :: l with
| [] => h_1 ()
| b :: l => h_2 b l) =
h_2 b l | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) | null | true |
Ordnode.findLeAux._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} →
[inst : LE α] → [DecidableLE α] → α → (x : Ordnode α) → Ordnode.below (motive := fun x => α → α) x → α → α | null | false |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | Std.HashSet Lean.FVarId → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches | Erase matches containing any of the hypotheses `hs` from `ms`. | true |
List.IsSuffix.isInfix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ | null | true |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ofNat_dvd.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ} (motive : m ∣ n → Prop) (x : m ∣ n), (∀ (k : ℕ) (e : n = m * k), motive ⋯) → motive x | null | false |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) {M : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
IsScalarTower A A M | null | false |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | (prec emax : ℕ) → 0 < prec → prec ≤ emax → FP.FloatCfg | null | true |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C)
{X x : CategoryTheory.Cokleisli U} (f : X ⟶ x),
(CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).map f =
CategoryTheory.CategoryStruct.comp (U.δ.app X.of) (U.map f.of) | null | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.sub_mul_div_of_le.match_1_1 | Init.Data.Nat.Div.Basic | ∀ (n : ℕ) (motive : n = 0 ∨ n > 0 → Prop) (x : n = 0 ∨ n > 0),
(∀ (h₀ : n = 0), motive ⋯) → (∀ (h₀ : n > 0), motive ⋯) → motive x | null | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.uniq | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) {U X : C} {m : U ⟶ X} [inst_2 : CategoryTheory.Mono m] {χ' : X ⟶ Ω}
{π : U ⟶ CategoryTheory.Subobject.underlying.obj h.Ω₀}, CategoryTheory.IsPullback m π χ... | **Alias** of `CategoryTheory.SubobjectRepresentableBy.uniq`. | true |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {S : Submonoid Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ | null | true |
Std.ExtTreeMap.get!_eq_getElem! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, t.get! a = t[a]! | null | true |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → ℕ | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (X i)},
s.pi t = s.pi fun i => if i ∈ s then t i else Set.univ | null | false |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | ∀ {α : Type u_1} {r : α → α → Prop}, FaithfulSMul (r ≃r r) α | null | true |
ClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | A point `x` is a cluster point of a filter `F` if `𝓝 x ⊓ F ≠ ⊥`.
Also known as an accumulation point or a limit point, but beware that terminology varies.
This is *not* the same as asking `𝓝[≠] x ⊓ F ≠ ⊥`, which is called `AccPt` in Mathlib.
See `mem_closure_iff_clusterPt` in particular. | true |
CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
(G : CategoryTheory.F... | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._mutual | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(x :
(_ : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) ×' ℕ ⊕'
Lean.PersistentHashMap.Node α β) →
PSum.casesOn x (fun _x => ℕ) fun _x => ℕ | Counts the total entries in an entries array starting at index `i`. | false |
NNReal.coe_inv._simp_1 | Mathlib.Basic.NNReal.Defs | ∀ (r : NNReal), (↑r)⁻¹ = ↑r⁻¹ | null | false |
_private.Mathlib.Data.Vector.MapLemmas.0.List.Vector.mapAccumr_redundant_pair.match_1_1 | Mathlib.Data.Vector.MapLemmas | {σ : Type u_1} → (motive : σ × σ → Sort u_2) → (x : σ × σ) → ((s₁ s₂ : σ) → motive (s₁, s₂)) → motive x | null | false |
HasProdUniformlyOn.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) (g : β → α) (s : Set β)
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = HasProd (⇑(UniformOnFun.ofFun {s}) ∘ f) ((UniformOnFun.ofFun {s}) g) | null | true |
Lean.Elab.PartialFixpointType.inductiveFixpoint | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType | null | true |
AddGroupSeminormClass.toSeminormedAddCommGroup_norm_eq | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddCommGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f : F) (x : α), ‖x‖ = f x | null | true |
Float.Model.ofInt64 | Init.Data.Float.Model.Float | Int64 → Float.Model | Converts an `Int64` to a `Float.Model`, returning positive zero on zero. | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.div._unary._proof_4 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨((a₁, x₁), k₁) :: t₁, t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂... | null | false |
_private.Mathlib.CategoryTheory.Subobject.Limits.0.CategoryTheory.Limits.kernelOrderHom._simp_1 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | null | false |
_private.Mathlib.Analysis.Normed.Operator.NormedSpace.0.ContinuousLinearMap.opNNNorm_comp_linearIsometryEquiv._simp_1_1 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ... | null | false |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.find? p l = (List.dropWhile (fun x => !p x) l).head? | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Eqns.0.Lean.Elab.PartialFixpoint.deltaLHSUntilFix | Lean.Elab.PreDefinition.PartialFixpoint.Eqns | Lean.Name → Lean.Name → Lean.MVarId → Lean.MetaM Lean.MVarId | null | true |
Submodule.finiteQuotientOfFreeOfRankEq | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {M : Type u_3} [inst : AddCommGroup M] [Module.Free ℤ M] [Module.Finite ℤ M] (N : Submodule ℤ M),
Module.finrank ℤ ↥N = Module.finrank ℤ M → Finite (M ⧸ N) | A submodule of full rank of a free finite `ℤ`-module has a finite quotient.
It can't be an instance because of the side condition `Module.finrank ℤ N = Module.finrank ℤ M`.
| true |
Mathlib.Tactic.FieldSimp.NF.one_eq_eval | Mathlib.Tactic.FieldSimp.Lemmas | ∀ (M : Type u_1) [inst : GroupWithZero M], 1 = Mathlib.Tactic.FieldSimp.NF.eval [] | null | true |
Alexandrov.self_mem_principalOpen | Mathlib.Topology.Sheaves.Alexandrov | ∀ {X : Type v} [inst : TopologicalSpace X] [inst_1 : Preorder X] [inst_2 : Topology.IsUpperSet X] (x : X),
x ∈ Alexandrov.principalOpen x | null | true |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), (a.comp a_1 = a_2.comp a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
Lex.instNonAssocRing | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NonAssocRing R] → NonAssocRing (Lex R) | null | true |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | Lean.Macro | null | false |
HAnd.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HAnd α β γ → Sort u_1} → ((hAnd : α → β → γ) → motive { hAnd := hAnd }) → (t : HAnd α β γ) → motive t | null | false |
UInt32.toFin_ofNatClamp_of_le._proof_1 | Init.Data.UInt.Lemmas | UInt32.size - 1 < UInt32.size | null | false |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
s ⊆ ↑(Algebra.adjoin R s) | null | true |
Std.Rxc.size_pos_iff_le | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, 0 < Std.Rxc.HasSize.size lo hi ↔ lo ≤ hi | null | true |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(s t : TopologicalSpace.CompactOpens α), ↑s ⇨ ↑t = ↑(s ⇨ t) | null | false |
MeasureTheory.VectorMeasure.«_aux_Mathlib_MeasureTheory_VectorMeasure_Integral___delab_app_MeasureTheory_VectorMeasure_term∫ᵛ_In_,_∂<•__1» | Mathlib.MeasureTheory.VectorMeasure.Integral | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
CauchyFilter.mem_uniformity | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, CauchyFilter.gen t ⊆ s | null | true |
Std.HashMap.Raw.getKeyD_empty | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {a fallback : α}, ∅.getKeyD a fallback = fallback | null | true |
floorDiv_of_nonpos | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : SMulZeroClass α β] [inst_5 : FloorDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌊/⌋ a = 0 | null | true |
Std.ExtTreeMap.getElem_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
{f : β → β} {hc : k' ∈ t.modify k f}, (t.modify k f)[k'] = if heq : cmp k k' = Ordering.eq then f t[k] else t[k'] | null | true |
hasDerivAtFilter_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {L : Filter (𝕜 × 𝕜)},
HasDerivAtFilter f f' L ↔ Filter.Tendsto (fun p => ‖p.1 - p.2‖⁻¹ * ‖f p.1 - f p.2 - (p.1 - p.2) • f'‖) L (nhds 0) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.