name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BoundedOrderHom.toOrderHom | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedOrderHom α β → α →o β | null | true |
AddAut.applyAddAction._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_1} [inst : AddMonoid M] (x : M), 0 +ᵥ x = 0 +ᵥ x | null | false |
HomologicalComplex₂.totalFlipIso_hom_f_D₁ | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c]
[inst_3 : TotalComplexShap... | null | true |
CategoryTheory.Limits.HasImage.exists_image | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y}
[self : CategoryTheory.Limits.HasImage f], Nonempty (CategoryTheory.Limits.ImageFactorisation f) | `HasImage f` means that there exists an image factorisation of `f`. | true |
ContinuousLinearMap.IsPositive.isSelfAdjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E}, T.IsPositive → IsSelfAdjoint T | null | true |
_private.Mathlib.LinearAlgebra.Dual.Defs.0.LinearMap.range_dualMap_dual_eq_span_singleton.match_1_3 | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
(f m : Module.Dual R M₁) (motive : (∃ a, a • f = m) → Prop) (x : ∃ a, a • f = m),
(∀ (r : R) (hr : r • f = m), motive ⋯) → motive x | null | false |
Ordinal.uniqueIioOne._proof_1 | Mathlib.SetTheory.Ordinal.Basic | 0 < 1 | null | false |
CategoryTheory.ShortComplex.homologyFunctorIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory... | null | false |
CategoryTheory.Limits.Sigma.constCompSigmaIsoConst_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasCoproductsOfShape α C] {I : α → Type u_1}
[inst_2 : (i : α) → CategoryTheory.Category.{v_1, u_1} (I i)] (X : α → C) (X_1 : (i : α) → I i),
(CategoryTheory.Limits.Sigma.constCompSigmaIsoConst X).hom.app X_1 = ... | null | true |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Adjunction_Basic___unexpand_CategoryTheory_Bicategory_Adjunction_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Equiv.permCongrHom_symm | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} (e : α ≃ β), e.permCongrHom.symm = e.symm.permCongrHom | null | true |
ZMod.prime_ne_zero | Mathlib.Data.ZMod.ValMinAbs | ∀ (p q : ℕ) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p ≠ q → ↑q ≠ 0 | null | true |
CategoryTheory.ComposableArrows.Mk₁.obj | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} → C → C → Fin 2 → C | The map which sends `0 : Fin 2` to `X₀` and `1` to `X₁`. | true |
String.Slice.splitInclusive | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
(s : String.Slice) → (pat : ρ) → [inst : String.Slice.Pattern.ToForwardSearcher pat σ] → Std.Iter String.Slice | Splits a slice at each subslice that matches the pattern `pat`. Unlike `split` the
matched subslices are included at the end of each subslice.
This function is generic over all currently supported patterns.
Examples:
* `("coffee tea water".toSlice.splitInclusive Char.isWhitespace).toList == ["coffee ".toSlice, "tea ... | true |
Std.Iterators.Types.Flatten.mk.inj | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type u_1} {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Option (Std.IterM m β)}
{it₁_1 : Std.IterM m (Std.IterM m β)} {it₂_1 : Option (Std.IterM m β)},
{ it₁ := it₁, it₂ := it₂ } = { it₁ := it₁_1, it₂ := it₂_1 } → it₁ = it₁_1 ∧ it₂ = it₂_1 | null | true |
IsPredArchimedean.findAtom | Mathlib.Order.SuccPred.Tree | {α : Type u_1} →
[inst : PartialOrder α] → [inst_1 : PredOrder α] → [IsPredArchimedean α] → [OrderBot α] → [DecidableEq α] → α → α | The unique atom less than an element in an `OrderBot` with archimedean predecessor.
| true |
_private.Std.Data.String.ToInt.0.String.Slice.isInt_iff._simp_1_4 | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.isNat = s.toNat?.isSome | null | false |
Turing.ToPartrec.Code.fix.sizeOf_spec | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Code), sizeOf a.fix = 1 + sizeOf a | null | true |
ContinuousMap.continuousAt | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (x : α),
ContinuousAt (⇑f) x | Deprecated. Use `map_continuousAt` instead. | true |
LinearMap.mapMatrix_neg | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {S : Type u_8} {α : Type u_11} {β : Type u_12} [inst : Semiring R]
[inst_1 : Semiring S] {σᵣₛ : R →+* S} [inst_2 : AddCommMonoid α] [inst_3 : AddCommGroup β] [inst_4 : Module R α]
[inst_5 : Module S β] (f : α →ₛₗ[σᵣₛ] β), (-f).mapMatrix = -f.mapMatrix | null | true |
CategoryTheory.Limits.Types.Pushout.Rel'.inr_inl | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} (s : S),
CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr ((CategoryTheory.ConcreteCategory.hom g) s))
(Sum.inl ((CategoryTheory.ConcreteCategory.hom f) s)) | null | true |
SSet.π₀.lift | Mathlib.AlgebraicTopology.SimplicialSet.PiZero | {X : SSet} →
{T : Type u_1} →
(f : X.obj (Opposite.op { len := 0 }) → T) →
(∀ ⦃x₀ x₁ : X.obj (Opposite.op { len := 0 })⦄ (x : SSet.Edge x₀ x₁), f x₀ = f x₁) → X.π₀ → T | Constructor for maps from the type of connected components of a simplicial set. | true |
Lean.Grind.CommRing.Poly.insert.go._f | Init.Grind.Ring.CommSolver | ℤ →
Lean.Grind.CommRing.Mon → (a : Lean.Grind.CommRing.Poly) → Lean.Grind.CommRing.Poly.below a → Lean.Grind.CommRing.Poly | null | false |
Polynomial.leadingCoeffHom | Mathlib.Algebra.Polynomial.Degree.Operations | {R : Type u} → [inst : Semiring R] → [NoZeroDivisors R] → Polynomial R →* R | `Polynomial.leadingCoeff` bundled as a `MonoidHom` when `R` has `NoZeroDivisors`, and thus
`leadingCoeff` is multiplicative | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.formula3._simp_1_1 | Mathlib.NumberTheory.FLT.Three | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | null | false |
RelSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).last = f p.last | null | true |
Matroid.IsBase.compl_isBase_of_dual | Mathlib.Combinatorics.Matroid.Dual | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M✶.IsBase B → M.IsBase (M.E \ B) | null | true |
MeasureTheory.measure_union_lt_top_iff | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
μ (s ∪ t) < ⊤ ↔ μ s < ⊤ ∧ μ t < ⊤ | null | true |
Lean.PrettyPrinter.Parenthesizer.Context._sizeOf_1 | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.Context → ℕ | null | false |
WittVector.equiv._proof_1 | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x y : WittVector p (ZMod p)),
(WittVector.toPadicInt p) (x * y) = (WittVector.toPadicInt p) x * (WittVector.toPadicInt p) y | null | false |
Lean.logInfo | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.MessageData → m Unit | Log a new information message using the given message data. The position is provided by `getRef`. | true |
ContinuousLinearEquiv.coe_inj | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | true |
Std.DTreeMap.isEmpty_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.keys.isEmpty = t.isEmpty | null | true |
list_sum_pow_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_3} [inst : CommSemiring R] (p : ℕ) [ExpChar R p] (l : List R),
l.sum ^ p = (List.map (fun x => x ^ p) l).sum | null | true |
Hypergraph.Adj | Mathlib.Combinatorics.Hypergraph.Basic | {α : Type u_1} → Hypergraph α → α → α → Prop | Predicate for adjacency. Two vertices `x` and `y` are adjacent if there is some edge `e ∈ E(H)`
where `x` and `y` are both incident to `e`.
Note that we do not need to explicitly check that `x, y ∈ V(H)` here because a vertex that is not in
the vertex set cannot be incident to any edge.
| true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_g | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).obj F).g =... | null | true |
SSet.horn₃₂.desc._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | (SSet.horn 3 2).MulticoequalizerDiagram (fun j => SSet.stdSimplex.face {↑j}ᶜ) fun j k => SSet.stdSimplex.face {↑j, ↑k}ᶜ | null | false |
Submodule.annihilator_mono | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N P : Submodule R M}, N ≤ P → P.annihilator ≤ N.annihilator | null | true |
Finset.sdiff_eq_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = {x ∈ s₁ | x ∉ s₂} | null | true |
instDecidableEqProd._proof_2 | Init.Core | ∀ {α : Type u_2} {β : Type u_1} (a : α) (b : β) (a' : α) (b' : β), ¬b = b' → (a, b) = (a', b') → False | null | false |
_private.Std.Data.TreeMap.Raw.Lemmas.0.Std.TreeMap.Raw.Equiv.trans.match_1_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp}
(motive : t₁.Equiv t₂ → t₂.Equiv t₃ → Prop) (x : t₁.Equiv t₂) (x_1 : t₂.Equiv t₃),
(∀ (h : t₁.inner.Equiv t₂.inner) (h' : t₂.inner.Equiv t₃.inner), motive ⋯ ⋯) → motive x x_1 | null | false |
Nat.twoStepInduction | Mathlib.Data.Nat.Init | {motive : ℕ → Sort u_1} →
motive 0 → motive 1 → ((n : ℕ) → motive n → motive (n + 1) → motive (n + 2)) → (a : ℕ) → motive a | Induction principle deriving the next case from the two previous ones. | true |
Fin.coe_divNat | Batteries.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m * n)), ↑i.divNat = ↑i / n | null | true |
Std.ExtDTreeMap.maxKeyD_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
NormedAddGroupHom.Equalizer.lift.congr_simp | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ φ_1 : NormedAddGroupHom V₁ V) (e_φ : φ = φ_1)
(h : f.comp φ = g.comp φ), NormedAddGroupHom.Equalizer.lift φ h = NormedAddGroupHo... | null | true |
Metric.hausdorffEDist_ne_top_of_nonempty_of_bounded | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α},
s.Nonempty → t.Nonempty → Bornology.IsBounded s → Bornology.IsBounded t → Metric.hausdorffEDist s t ≠ ⊤ | If two sets are nonempty and bounded in a metric space, they are at finite Hausdorff
edistance. | true |
codisjoint_subtype_iff | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {pr : α → Prop},
(∀ ⦃s t : α⦄, pr s → pr t → pr (s ⊔ t)) → ∀ (htop : pr ⊤) {a b : Subtype pr}, Codisjoint a b ↔ Codisjoint ↑a ↑b | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._proof_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → ∀ x ∈ Set.Icc b (b + c), x ∈ Set.uIcc a (b + c) | null | false |
_private.Mathlib.RingTheory.IntegralClosure.Algebra.Ideal.0.Polynomial.exists_monic_aeval_eq_zero_forall_mem_of_mem_map._proof_1_2 | Mathlib.RingTheory.IntegralClosure.Algebra.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (p : Polynomial R), ∀ i < p.natDegree, ¬p.natDegree - i = 0 | null | false |
LinearMap.FiniteRangeSetoid.equiv_iff_isNoetherian_quotient_eqLocus | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] {u v : V →ₗ[K] V₂}, u ≈ v ↔ IsNoetherian K (V ⧸ u.eqLocus v) | null | true |
continuousAt_sign_of_neg | Mathlib.Topology.Instances.Sign | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] [inst_2 : PartialOrder α] [inst_3 : DecidableLT α]
[OrderTopology α] {a : α}, a < 0 → ContinuousAt (⇑SignType.sign) a | null | true |
Lean.Meta.Grind.AttrKind.cases.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | ∀ (eager : Bool), sizeOf (Lean.Meta.Grind.AttrKind.cases eager) = 1 + sizeOf eager | null | true |
_private.Lean.Meta.Tactic.Induction.0.Lean.MVarId.induction.match_1 | Lean.Meta.Tactic.Induction | (motive : Option ℕ → Sort u_1) →
(paramPos? : Option ℕ) → (Unit → motive none) → ((paramPos : ℕ) → motive (some paramPos)) → motive paramPos? | null | false |
PNat.XgcdType | Mathlib.Data.PNat.Xgcd | Type | A term of `XgcdType` is a system of six naturals. They should
be thought of as representing the matrix
`[[w, x], [y, z]] = [[wp + 1, x], [y, zp + 1]]`
together with the vector `[a, b] = [ap + 1, bp + 1]`.
| true |
Valuation.is_topological_valuation | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3} [inst_2 : LinearOrderedCommGroupWithZero Γ₀]
[inst_3 : TopologicalSpace R] [IsValuativeTopology R] (v : Valuation R Γ₀) [v.Compatible] (s : Set R),
s ∈ nhds 0 ↔ ∃ γ, {x | v.restrict x < ↑γ} ⊆ s | **Alias** of `Valuation.mem_nhds_zero_iff`. | true |
IsApproximateAddSubgroup.addSubgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] [AddSubgroupClass S G] {H : S},
IsApproximateAddSubgroup 1 ↑H | null | true |
CommBialgCat.isoMk | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
{x : CommRing X} →
{x_1 : CommRing Y} →
{x_2 : Bialgebra R X} → {x_3 : Bialgebra R Y} → (X ≃ₐc[R] Y) → (CommBialgCat.of R X ≅ CommBialgCat.of R Y) | Build an isomorphism in the category `CommBialgCat R` from a `BialgEquiv` between
`Bialgebra`s. | true |
_private.Mathlib.Probability.BrownianMotion.Basic.0.ProbabilityTheory.IsBrownianReal.neg._simp_1_2 | Mathlib.Probability.BrownianMotion.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) = Continuous f | null | false |
Convex.uniformContinuous_gauge | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → s ∈ nhds 0 → UniformContinuous (gauge s) | null | true |
RestrictedProduct.continuous_eval | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
(i : ι), Continuous fun x => x i | null | true |
Std.DTreeMap.Raw.size_le_size_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, t.size ≤ (t.insertIfNew k v).size | null | true |
Std.HashMap.values | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List β | Returns a list of all values present in the hash map in some order. | true |
DFinsupp.subset_support_tsub | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : ∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)]
[inst_4 : ∀ (i : ι), OrderedSub (α i)] {f g : Π₀ (i : ι), α i} [inst_5 : DecidableEq ι]
[inst_6 : (i : ι) → (x : α i) ... | null | true |
Std.HashMap.Raw.getKey?_filter_key | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → Bool} {k : α},
m.WF → (Std.HashMap.Raw.filter (fun k x => f k) m).getKey? k = Option.filter f (m.getKey? k) | null | true |
IsLocallyConstant.iff_is_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f ↔ ∀ (x y : X), f x = f y | null | true |
instAddCommMonoidWeakDual._proof_11 | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
autoParam
(∀ (n : ℕ) (x : WeakDual 𝕜 E),
instAddCommMonoidWeakDual._au... | null | false |
_private.Mathlib.Data.List.Basic.0.List.foldr_ext._simp_1_4 | Mathlib.Data.List.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
VSub.casesOn | Mathlib.Algebra.Notation.Defs | {G : Type u_1} →
{P : Type u_2} →
{motive : VSub G P → Sort u} → (t : VSub G P) → ((vsub : P → P → G) → motive { vsub := vsub }) → motive t | null | false |
Lex.instDivisionRing._proof_3 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K],
autoParam (∀ (n : ℕ) (a : Lex K), DivInvMonoid.zpow (↑n.succ) a = DivInvMonoid.zpow (↑n) a * a)
DivInvMonoid.zpow_succ'._autoParam | null | false |
Lean.Lsp.FileChangeType.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileChangeType → ℕ | null | false |
Std.Sat.AIG.Decl.rec | Std.Sat.AIG.Basic | {α : Type} →
{motive : Std.Sat.AIG.Decl α → Sort u} →
motive Std.Sat.AIG.Decl.false →
((idx : α) → motive (Std.Sat.AIG.Decl.atom idx)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → (t : Std.Sat.AIG.Decl α) → motive t | null | false |
Module.Basis.ofSplitExact._proof_3 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_2} {M : Type u_4} {K : Type u_6} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup K] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R K] [inst_6 : Module R P]
{f : K →ₗ[R] M} {g : M →ₗ[R] P} {s : M →ₗ[R] K},
s ∘ₗ f = LinearMap.id →
Function.Exact ... | null | false |
Std.IterM.mk.injEq | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (internalState internalState_1 : α),
({ internalState := internalState } = { internalState := internalState_1 }) = (internalState = internalState_1) | null | true |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.containsHoverPos | Lean.Server.Completion.CompletionInfoSelection | String.Pos.Raw → Lean.Elab.CompletionInfo → Bool | null | true |
SeparationQuotient.instNormedAlgebra._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedRing E] [inst_2 : NormedAlgebra 𝕜 E],
ContinuousConstSMul 𝕜 E | null | false |
Equiv.funSplitAt_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} [inst : DecidableEq α] (i : α) (β : Type u_10) (f : (j : α) → (fun a => β) j),
(Equiv.funSplitAt i β) f = (f i, fun j => f ↑j) | null | true |
CategoryTheory.WithInitial.mapId | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.WithInitial.map (CategoryTheory.Functor.id C) ≅
CategoryTheory.Functor.id (CategoryTheory.WithInitial C) | A natural isomorphism between the functor `map (𝟭 C)` and `𝟭 (WithInitial C)`. | true |
Lean.Elab.Command.Scope.varUIds._default | Lean.Elab.Command.Scope | Array Lean.Name | null | false |
CategoryTheory.ShortComplex.Splitting.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp e.inv.τ₃ (CategoryTheory.CategoryStruct.comp s.s e.hom.τ₂)) S₂... | null | false |
_private.Mathlib.Topology.Irreducible.0.isPreirreducible_iff_subset_closure_inter_open.match_1_1 | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} (S a : Set X) (motive : (S ∩ a).Nonempty → Prop) (h : (S ∩ a).Nonempty),
(∀ (p : X) (pS : p ∈ S) (pa : p ∈ a), motive ⋯) → motive h | null | false |
_private.Mathlib.Order.Filter.ListTraverse.0.Filter.mem_traverse.match_1_7 | Mathlib.Order.Filter.ListTraverse | ∀ {α β γ : Type u_1} {f : β → Filter α} {s : γ → Set α},
let funType_1 := fun x x_1 x_2 => traverse s x_1 ∈ traverse f x;
∀
(motive :
(x : List β) → (x_1 : List γ) → (x_2 : List.Forall₂ (fun b c => s c ∈ f b) x x_1) → List.Forall₂.below x_2 → Prop)
(x : List β) (x_1 : List γ) (x_2 : List.Forall₂ (fun ... | null | false |
HurwitzZeta.completedHurwitzZetaEven_zero | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ (s : ℂ), HurwitzZeta.completedHurwitzZetaEven 0 s = completedRiemannZeta s | null | true |
Lean.Grind.Ring.neg_zsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (i : ℤ) (a : α), -i • a = -(i • a) | Scalar multiplication by the negation of an integer is the negation of scalar multiplication by that integer. | true |
Submodule.localized'_inf | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} (S : Type u_2) {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Algebra R S] [inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (p : Submonoid R)
[inst_9 : ... | null | true |
Turing.PartrecToTM2.K'.elim_update_aux | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {a b c d c' : List Turing.PartrecToTM2.Γ'},
Function.update (Turing.PartrecToTM2.K'.elim a b c d) Turing.PartrecToTM2.K'.aux c' =
Turing.PartrecToTM2.K'.elim a b c' d | null | true |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{id id' : ℕ} →
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id' →
(id = id' → P) → P | null | false |
PolynormableSpace.withSeminorms | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ (𝕜 : Type u_2) (E : Type u_6) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [PolynormableSpace 𝕜 E], WithSeminorms fun p => ↑p | null | true |
MeasureTheory.exp_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
(fun x => Real.exp (MeasureTheory.llr μ ν x)) =ᵐ[ν] fun x => if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal | null | true |
ProbabilityTheory.mgf_sum_of_identDistrib₀ | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : ι → Ω → ℝ} {s : Finset ι}
{j : ι},
(∀ (i : ι), AEMeasurable (X i) μ) →
ProbabilityTheory.iIndepFun X μ →
(∀ i ∈ s, ∀ j ∈ s, ProbabilityTheory.IdentDistrib (X i) (X j) μ μ) →
j ∈ s → ∀ (t : ℝ), ProbabilityThe... | null | true |
HasFDerivAt.sub_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (c : F), HasFDerivAt f f' x → HasFDerivAt (fun x => f x - c) f' x | **Alias** of the reverse direction of `hasFDerivAt_sub_const_iff`. | true |
Finset.singleton_subset_coe._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, ({a} ⊆ ↑s) = ({a} ⊆ s) | null | false |
Lean.Meta.Match.Overlaps.mk.sizeOf_spec | Lean.Meta.Match.MatcherInfo | ∀ (map : Std.HashMap ℕ (Std.TreeSet ℕ compare)), sizeOf { map := map } = 1 + sizeOf map | null | true |
CategoryTheory.Limits.BinaryBicone.inlCokernelCofork_π | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (c : CategoryTheory.Limits.BinaryBicone X Y), CategoryTheory.Limits.Cofork.π c.inlCokernelCofork = c.snd | null | true |
Mathlib.Meta.NormNum.isNat_abs_nonneg | Mathlib.Tactic.NormNum.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Lattice α] [IsOrderedRing α] {a : α} {na : ℕ},
Mathlib.Meta.NormNum.IsNat a na → Mathlib.Meta.NormNum.IsNat |a| na | null | true |
CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A}
(hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) → E ⟶ P.obj (Opposite.o... | null | true |
_private.Lean.Compiler.LCNF.PublicDeclsExt.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.PublicDeclsExt.3962556520._hygCtx._hyg.2 | Lean.Compiler.LCNF.PublicDeclsExt | IO (Lean.EnvExtension (List Lean.Name × Lean.NameSet)) | null | false |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt64.instLawfulUpwardEnumerableLE._simp_1 | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec 64},
Std.PRange.UpwardEnumerable.LE { toBitVec := x } { toBitVec := y } = Std.PRange.UpwardEnumerable.LE x y | null | false |
Pi.single_mul_left_apply | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i j : ι) (a : α i)
(f : (i : ι) → α i), Pi.single i (a * f i) j = Pi.single i a j * f j | null | true |
Aesop.BuilderName.forward | Aesop.Rule.Name | Aesop.BuilderName | null | true |
Mathlib.Tactic.ClickSuggestions.Premise.fvar | Mathlib.Tactic.ClickSuggestions.Util | Lean.FVarId → Mathlib.Tactic.ClickSuggestions.Premise | A free variable. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.