name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric_eq_none_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | null | false |
_private.Mathlib.Data.Set.Card.0.Set.three_lt_ncard_iff._simp_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Finset α},
(3 < s.card) = ∃ a b c d, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ d ∈ s ∧ a ≠ b ∧ a ≠ c ∧ a ≠ d ∧ b ≠ c ∧ b ≠ d ∧ c ≠ d | null | false |
Std.DTreeMap.Internal.Impl.Const.minEntry | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) → t.isEmpty = false → α × β | Implementation detail of the tree map | true |
Batteries.Tactic.Lint.Linter.isFast | Batteries.Tactic.Lint.Basic | Batteries.Tactic.Lint.Linter → Bool | If `isFast` is false, this test will be omitted from `#lint-`. | true |
CategoryTheory.IsCardinalFiltered.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
(∀ {A : Type w} [inst_2 : CategoryTheory.SmallCategory A] (F : CategoryTheory.Functor A J),
HasCardinalLT (CategoryTheory.Arrow A) κ → Nonempty (CategoryTheory.Limits.Cocone F)) →
CategoryTheory.IsCardin... | null | false |
CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_iCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R} (h : S.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.inv (CategoryTheory.CategoryStruct.comp S.iCycles h) =
CategoryTheory.CategoryStruct.comp S.moduleCatLeftHomologyData.i h | null | true |
RingCon.range_mk' | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Ring M] {c : RingCon M}, c.mk'.range = ⊤ | null | true |
Convexity.StdSimplex.restrict | Mathlib.Geometry.Convex.ConvexSpace.Defs | {X : Type u_2} →
{K : Type u_7} →
[inst : Semifield K] →
[inst_1 : LinearOrder K] →
[IsStrictOrderedRing K] →
(w : Convexity.StdSimplex K X) → (s : Set X) → (∃ x ∈ s, w.weights x ≠ 0) → Convexity.StdSimplex K X | Project an element of the standard simplex to a lower-dimensional standard simplex,
assuming at least one non-zero weight subsists. | true |
IsPathConnected.pi | Mathlib.Topology.Connected.PathConnected | ∀ {ι : Type u_3} {Z : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (Z i)] {s : (i : ι) → Set (Z i)},
(∀ (i : ι), IsPathConnected (s i)) → IsPathConnected (Set.univ.pi s) | The product of a family of path-connected sets is path-connected. | true |
CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._proof_6 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(X : CategoryTheory.Functor C D),
{
app := fun X₁ =>
{
app := fun X₂ =>
CategoryTheory.MonoidalCategoryStru... | null | false |
Lean.ToLevel.recOn | Lean.ToLevel | {motive : Lean.ToLevel → Sort u_1} →
(t : Lean.ToLevel) →
((toLevel : Lean.Level) → (univ : ∀ (x : Sort u), True) → motive { toLevel := toLevel }) → motive t | null | false |
Con.lift_range | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} {f : M →* P}
(H : c ≤ Con.ker f), MonoidHom.mrange (c.lift f H) = MonoidHom.mrange f | Given a congruence relation `c` on a monoid and a homomorphism `f` constant on `c`'s
equivalence classes, `f` has the same image as the homomorphism that `f` induces on the
quotient. | true |
_private.Lean.Elab.ConfigEval.MetaInstances.0.Lean.Elab.ConfigEval.instEvalTermOccurrences.evalTerm.match_1 | Lean.Elab.ConfigEval.MetaInstances | (motive : List ℕ × Lean.Expr → Sort u_1) →
(x : List ℕ × Lean.Expr) → ((v : List ℕ) → (e : Lean.Expr) → motive (v, e)) → motive x | null | false |
_private.Mathlib.Topology.Algebra.LinearTopology.0.isLinearTopology_iff_hasBasis_open_twoSidedIdeal.match_1_1 | Mathlib.Topology.Algebra.LinearTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R]
(motive : IsLinearTopology R R ∧ IsLinearTopology Rᵐᵒᵖ R → Prop) (x : IsLinearTopology R R ∧ IsLinearTopology Rᵐᵒᵖ R),
(∀ (left : IsLinearTopology R R) (right : IsLinearTopology Rᵐᵒᵖ R), motive ⋯) → motive x | null | false |
HomotopicalAlgebra.PrepathObject.RightHomotopy.unop._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {P : HomotopicalAlgebra.PrepathObject Y}
{f g : X ⟶ Y} (h : P.RightHomotopy f g), (CategoryTheory.CategoryStruct.comp P.unop.i₁ h.h.unop).op = g.unop.op | null | false |
Ordset.find | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Option α | O(log n). Retrieve an element in the set that is equivalent to `x` in the order,
if it exists. | true |
PointedCone.hull.unexpander | Mathlib.Geometry.Convex.Cone.Pointed | Lean.PrettyPrinter.Unexpander | Unexpander for `R ∙₊ x` notation. This needs to be defined separately because the `{_}`
notation is ambiguous, so we have to specify that it is the `«term{_}»` notation. | true |
Lean.Expr.sort.injEq | Lean.Expr | ∀ (u u_1 : Lean.Level), (Lean.Expr.sort u = Lean.Expr.sort u_1) = (u = u_1) | null | true |
Algebra.Extension.instIsScalarTowerRingTensorProductBaseChange | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Algebra.Extension R S)
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T], IsScalarTower R P.Ring P.baseChange.Ring | null | true |
Bundle.Pretrivialization.mem_target | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e : Bundle.Pretrivialization F proj) {x : B × F}, x ∈ e.target ↔ x.1 ∈ e.baseSet | null | true |
ZLattice.summable_norm_zpow | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] (L : Submodule ℤ E)
[DiscreteTopology ↥L], ∀ n < -↑(Module.finrank ℤ ↥L), Summable fun z => ‖z‖ ^ n | null | true |
CategoryTheory.monoidalCategoryMop._proof_5 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y : Cᴹᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.id Y).unmop X.unmop).mop =
CategoryTheory.CategoryStruct.id { unmop := CategoryTheory.MonoidalCategoryStruc... | null | false |
DirectSum.IsInternal.subordinateOrthonormalBasisIndex | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_7} →
{𝕜 : Type u_8} →
[inst : RCLike 𝕜] →
{E : Type u_9} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[Fintype ι] →
[FiniteDimensional 𝕜 E] →
{n : ℕ} →
Module.finrank 𝕜 E = n →
... | An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. | true |
Real.nnabs_natCast | Mathlib.Basic.NNReal.Defs | ∀ (n : ℕ), Real.nnabs ↑n = ↑n | null | true |
Matroid.restrict_isRestriction._auto_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Syntax | null | false |
EckmannHilton.MulOneClass.isUnital | Mathlib.GroupTheory.EckmannHilton | ∀ {X : Type u} [_G : MulOneClass X], EckmannHilton.IsUnital (fun x1 x2 => x1 * x2) 1 | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.orelseMergeErrorsImp._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.someExistsOneDivLT_subset | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α},
MeasureTheory.SignedMeasure.someExistsOneDivLT✝ s i ⊆ i | null | true |
Lean.Grind.ConfigInteractive.splitIndPred._inherited_default | Init.Grind.Config | Bool | null | false |
MeasureTheory.Measure.sum_apply₀ | Mathlib.MeasureTheory.Measure.Sum | ∀ {α : Type u_1} {ι : Type u_2} {mα : MeasurableSpace α} {s : Set α} (μ : ι → MeasureTheory.Measure α),
MeasureTheory.NullMeasurableSet s (MeasureTheory.Measure.sum μ) →
(MeasureTheory.Measure.sum μ) s = ∑' (i : ι), (μ i) s | null | true |
nndist_self | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (a : α), nndist a a = 0 | `nndist x x` vanishes | true |
RingHom.PropertyIsLocal.localizationAwayPreserves | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.PropertyIsLocal P → RingHom.LocalizationAwayPreserves P | null | true |
ModuleCat.moduleOfAlgebraModule | Mathlib.Algebra.Category.ModuleCat.Algebra | {k : Type u} → [inst : Field k] → {A : Type w} → [inst_1 : Ring A] → [Algebra k A] → (M : ModuleCat A) → Module k ↑M | Type synonym for considering a module over a `k`-algebra as a `k`-module. | true |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Over.instIsAccessibleForget._proof_1 | Mathlib.CategoryTheory.Presentable.Comma | ∀ {D : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} D] [CategoryTheory.IsAccessibleCategory.{u_1, u_2, u_3} D]
(Y : D), CategoryTheory.Functor.IsAccessible.{u_1, u_2, u_2, max u_3 u_2, u_3} (CategoryTheory.Over.forget Y) | null | false |
Lean.Doc.Part.rec | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
((title : Array (Lean.Doc.Inline i)) →
(titleString : String) →
... | null | false |
UniformOnFun.topologicalSpace | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | (α : Type u_1) → (β : Type u_2) → [UniformSpace β] → (𝔖 : Set (Set α)) → TopologicalSpace (UniformOnFun α β 𝔖) | Topology of `𝔖`-convergence, i.e uniform convergence on the elements of `𝔖`, declared as an
instance on `α →ᵤ[𝔖] β`. | true |
AffineMap.instAddTorsor | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_1} →
{V1 : Type u_2} →
{P1 : Type u_3} →
{V2 : Type u_4} →
{P2 : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : Module k V1] →
[inst_3 : AddTorsor V1 P1] →
[inst_4 : AddCommGroup V2] →
... | The space of affine maps from `P1` to `P2` is an affine space over the space of affine maps
from `P1` to the vector space `V2` corresponding to `P2`. | true |
instTransEq_1 | Init.Prelude | {α : Sort u_1} → {β : Sort u_2} → (r : α → β → Sort u) → Trans r Eq r | null | true |
Std.TreeMap.isSome_maxKey?_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.maxKey?.isSome = true | null | true |
alternatingGroup.eq_bot_of_card_le_two | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], Nat.card α ≤ 2 → alternatingGroup α = ⊥ | null | true |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.synthesizeArgs.match_4 | Mathlib.Tactic.FunProp.Core | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((proof : Lean.Expr) → motive (some proof)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | null | false |
CategoryTheory.SemilatticeInf.braidedCategory | Mathlib.CategoryTheory.Monoidal.Cartesian.InfSemilattice | (C : Type u) → [inst : SemilatticeInf C] → [inst_1 : OrderTop C] → CategoryTheory.BraidedCategory C | Braided structure for the preorder category of a meet-semilattice with a greatest element. | true |
AddMonoidHom.sub_apply | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {G : Type u_5} [inst : AddZeroClass M] [inst_1 : AddCommGroup G] (f g : M →+ G) (x : M),
(f - g) x = f x - g x | null | true |
Filter.addAction._proof_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : AddAction α β] (x x_1 : Filter α) (x_2 : Filter β),
Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) (Filter.map₂ (fun x1 x2 => x1 + x2) x x_1) x_2 =
Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) x (Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) x_1 x_2) | null | false |
Nat.succPNat_strictMono | Mathlib.Data.PNat.Basic | StrictMono Nat.succPNat | null | true |
Quiver.Path.cons.noConfusion | Mathlib.Combinatorics.Quiver.Path | {V : Type u} →
{inst : Quiver V} →
{a : V} →
{P : Sort u_1} →
{b c : V} →
{a_1 : Quiver.Path a b} →
{a_2 : b ⟶ c} →
{b' c' : V} →
{a' : Quiver.Path a b'} →
{a'_1 : b' ⟶ c'} →
c = c' → a_1.cons a_2 ≍ a'.cons a'_... | null | false |
CategoryTheory.TransitiveRelation.transitivity₂._autoParam | Mathlib.CategoryTheory.EquivalenceRelation | Lean.Syntax | null | false |
Lean.Compiler.LCNF.getImpureDeclIndices | Lean.Compiler.LCNF.PhaseExt | Lean.Environment → Array Lean.Name → Std.HashMap Lean.Name ℕ | null | true |
Std.ExtDTreeMap.getKey!_map | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited α] {f : (a : α) → β a → γ a} {k : α},
(Std.ExtDTreeMap.map f t).getKey! k = t.getKey! k | null | true |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.vcomp | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.Pseudofunctor B C} →
{η θ ι : F ⟶ G} →
CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ →
CategoryTheory.Pseudofunctor.St... | Vertical composition of modifications. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_maxKeyD._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 |
Std.DTreeMap.Internal.Impl.get!_inter_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h₁ : m₁.WF),
m₂.WF →
∀ {k : α} [inst_1 : Inhabited (β k)],
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter m₂ ⋯).get! k = default | null | true |
Nat.mem_factoredNumbers_iff_forall_le | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ}, m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ≤ m, Nat.Prime p → p ∣ m → p ∈ s | `m` is `s`-factored if and only if `m` is nonzero and all prime divisors `≤ m` of `m`
are in `s`. | true |
Module.End.mem_genEigenspace | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ∞} {x : M}, x ∈ (f.genEigenspace μ) k ↔ ∃ l, ↑l ≤ k ∧ x ∈ ((f - μ • 1) ^ l).ker | null | true |
CategoryTheory.ComposableArrows.isoMk₄_hom | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 4}
(app₀ : f.obj' 0 _proof_369✝ ≅ g.obj' 0 _proof_369✝)
(app₁ :
f.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2 ≅
g.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2)
(ap... | null | true |
Lean.KeyedDeclsAttribute.AttributeEntry._sizeOf_inst | Lean.KeyedDeclsAttribute | (γ : Type) → [SizeOf γ] → SizeOf (Lean.KeyedDeclsAttribute.AttributeEntry γ) | null | false |
CoheytingHom.map_top' | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_6} {β : Type u_7} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (self : CoheytingHom α β),
self.toFun ⊤ = ⊤ | The proposition that a co-Heyting homomorphism preserves the top element. | true |
Dyadic.mul_zero | Init.Data.Dyadic.Basic | ∀ (x : Dyadic), x * 0 = 0 | null | true |
SemimoduleCat.forget₂_obj | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ (R : Type u) [inst : Semiring R] (X : SemimoduleCat R),
(CategoryTheory.forget₂ (SemimoduleCat R) AddCommMonCat).obj X = ↧↑X | null | true |
Lean.Compiler.LCNF.FixedParams.mkAssignment | Lean.Compiler.LCNF.FixedParams | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Array Lean.Compiler.LCNF.FixedParams.AbsValue → Lean.FVarIdMap Lean.Compiler.LCNF.FixedParams.AbsValue | null | true |
ULift.instT3Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T3Space X], T3Space (ULift.{u_3, u_1} X) | null | true |
ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {R : Type u_1} [inst : AddCommGroup R] {f g : ℕ → R},
(∀ n > 0, ∑ i ∈ n.divisors, f i = g n) ↔
∀ n > 0, ∑ x ∈ n.divisorsAntidiagonal, ArithmeticFunction.moebius x.1 • g x.2 = f n | Möbius inversion for functions to an `AddCommGroup`. | true |
skyscraperPresheafCoconeIsColimitOfNotSpecializes.match_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) {y : ↑X} (motive : (∃ S, IsOpen S ∧ y ∈ S ∧ p₀ ∉ S) → Prop)
(x : ∃ S, IsOpen S ∧ y ∈ S ∧ p₀ ∉ S), (∀ (U : Set ↑X) (ho : IsOpen U) (h₀ : y ∈ U) (hy : p₀ ∉ U), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Order.Nonneg.Lattice.0.Nonneg.noMaxOrder._proof_1 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : PartialOrder α] [NoMaxOrder α] {a : α}, NoMaxOrder { x // a ≤ x } | null | false |
Polynomial.adjSylvester_comp_sylvesterMap | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
f.adjSylvester g ∘ₗ f.sylvesterMap g hf hg = f.resultant g m n • LinearMap.id | null | true |
_private.Mathlib.Order.Filter.Pi.0.Filter.mem_pi._simp_1_3 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {g : Filter β} {m : α → β} {s : Set α}, (s ∈ Filter.comap m g) = ∃ t ∈ g, m ⁻¹' t ⊆ s | null | false |
_private.Mathlib.Topology.UrysohnsLemma.0.Urysohns.CU.approx.match_1.splitter | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} →
[inst : TopologicalSpace X] →
{P : Set X → Set X → Prop} →
(motive : ℕ → Urysohns.CU P → X → Sort u_2) →
(x : ℕ) →
(x_1 : Urysohns.CU P) →
(x_2 : X) →
((c : Urysohns.CU P) → (x : X) → motive 0 c x) →
((n : ℕ) → (c : Urysohns.CU P) ... | null | true |
Submonoid.LocalizationMap.ofMulEquivOfDom_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M}
(H : Submonoid.map k.toMonoidHom T = S) (x : P), (f.ofMulEquivOfDom H) x = f (k x) | null | true |
CategoryTheory.Oplax.LaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (... | null | true |
MeasureTheory.IsFundamentalDomain.setIntegral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstSMul G α]
[MeasureTheory.SMulInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureTheo... | null | true |
BoundedContinuousFunction.instNonUnitalRing._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NonUnitalSeminormedRing R]
(a b c : BoundedContinuousFunction α R), a * (b + c) = a * b + a * c | null | false |
SeminormedCommGroup.ctorIdx | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → SeminormedCommGroup E → ℕ | null | false |
MeasurableSet | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_1} → [MeasurableSpace α] → Set α → Prop | `MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`) | true |
MultilinearMap.domCoprod_alternization_coe | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_3} {Mᵢ : Type u_4}
{N₁ : Type u_5} {N₂ : Type u_6} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R'... | **Alias** of `MultilinearMap.domCoprod_alternatization_coe`.
---
A helper lemma for `MultilinearMap.domCoprod_alternatization`. | true |
Differentiable.fun_pow | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedAlgebra 𝕜 𝔸] [inst_4 : NormedSpace 𝕜 E] {f : E → 𝔸},
Differentiable 𝕜 f → ∀ (n : ℕ), Differentiable 𝕜 fun i => f i ^ n | Eta-expanded form of `Differentiable.pow` | true |
Equiv.Perm.subtypePerm._proof_4 | Mathlib.Algebra.Group.End | ∀ {α : Type u_1} {p : α → Prop} (f : Equiv.Perm α), (∀ (x : α), p (f x) ↔ p x) → ∀ (x : { x // p x }), p (f ↑x) | null | false |
FreeAlgebra.equivMonoidAlgebraFreeMonoid._proof_2 | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R],
(((FreeAlgebra.lift R) fun x => (MonoidAlgebra.of R (FreeMonoid X)) (FreeMonoid.of x)).comp
((MonoidAlgebra.lift R (FreeAlgebra R X) (FreeMonoid X)) (FreeMonoid.lift (FreeAlgebra.ι R)))).comp
MonoidAlgebra.singleOneAlgHom =
(AlgHom.id R (Mon... | null | false |
CategoryTheory.ShortComplex.RightHomologyData.mapRightHomologyIso_eq | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (hr : S.RightHomologyData)
(F : CategoryTheory.F... | null | true |
ContinuousLinearEquiv.submoduleMap_apply | Mathlib.Topology.Algebra.Module.Equiv.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] {R₂ : Type u_3} {M₂ : Type u_4} [inst_4 : Semiring R₂] [inst_5 : AddCommMonoid M₂]
[inst_6 : TopologicalSpace M₂] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R}
{re₁₂ : Rin... | null | true |
CategoryTheory.CostructuredArrow.isEquivalence_toOver | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D T) (X : T) [F.IsEquivalence],
(CategoryTheory.CostructuredArrow.toOver F X).IsEquivalence | An equivalence `F` induces an equivalence `CostructuredArrow F X ≌ Over X`. | true |
_private.Mathlib.GroupTheory.SpecificGroups.Quaternion.0.QuaternionGroup.inv | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} → QuaternionGroup n → QuaternionGroup n | The inverse of an element of the quaternion group.
| true |
Nat.Internal.SOM.Poly.add_denote | Init.Data.Nat.Internal.SOM | ∀ (ctx : Nat.Internal.Linear.Context) (p₁ p₂ : Nat.Internal.SOM.Poly),
Nat.Internal.SOM.Poly.denote ctx (p₁.add p₂) =
Nat.Internal.SOM.Poly.denote ctx p₁ + Nat.Internal.SOM.Poly.denote ctx p₂ | null | true |
Qq.instantiateMVarsQ | Qq.MetaM | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Lean.MetaM Q(«$α») | null | true |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitFnDecls.match_1 | Lean.Compiler.IR.EmitLLVM | (motive : Option String → Sort u_1) →
(x : Option String) → ((cName : String) → motive (some cName)) → (Unit → motive none) → motive x | null | false |
Matroid.Loopless.mk._flat_ctor | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α}, M.loops = ∅ → M.Loopless | null | false |
Filter.inv_le_self | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : InvolutiveInv α] {f : Filter α}, f⁻¹ ≤ f ↔ f⁻¹ = f | null | true |
Std.HashMap.Raw.getKey?_modify_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k : α} {f : β → β}, m.WF → (m.modify k f).getKey? k = if k ∈ m then some k else none | null | true |
LinearMap.extendScalarsOfIsLocalizationEquiv._proof_6 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module A N] [IsScalarTower R A N], SMulCommClass R A N | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_twoPow._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ}, i < w → i = w - 1 → ¬0 < w → False | null | false |
_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.headers.match_1 | Std.Http.Protocol.H1.Message | (motive : (dir : Std.Http.Protocol.H1.Direction) → Std.Http.Protocol.H1.Message.Head dir → Sort u_1) →
(dir : Std.Http.Protocol.H1.Direction) →
(m : Std.Http.Protocol.H1.Message.Head dir) →
((m : Std.Http.Protocol.H1.Message.Head Std.Http.Protocol.H1.Direction.receiving) →
motive Std.Http.Protocol... | null | false |
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_corootSpace'._simp_1_7 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
Nat.xor_lt_two_pow | Init.Data.Nat.Bitwise.Lemmas | ∀ {x y n : ℕ}, x < 2 ^ n → y < 2 ^ n → x ^^^ y < 2 ^ n | null | true |
CategoryTheory.LocalizerMorphism.IsLocalizedFullyFaithful.nonempty_fullyFaithful | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} C₁}
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂}
[self : Φ.IsLocalizedFullyFaithful], Nonempty (Φ.localizedFun... | the induced functor on the constructed localized categories is fully faithful | true |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._aux_39 | Mathlib.Geometry.Manifold.Immersion | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_3} →
{E'' : Type u_1} →
{F : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup E''] →
[inst_4 : NormedSpace 𝕜 E''] →
... | null | false |
instLinearOrderWellOrderExtensionOfWellFoundedLT._proof_11 | Mathlib.Order.Extension.Well | ∀ {α : Type u_1} [inst : LT α] [h : WellFoundedLT α] (a b : WellOrderExtension α),
(decide
((WellFounded.rank (fun x1 x2 => x1 < x2) a, embeddingToCardinal a).1 <
(WellFounded.rank (fun x1 x2 => x1 < x2) b, embeddingToCardinal b).1 ∨
(WellFounded.rank (fun x1 x2 => x1 < x2) a, embeddingT... | null | false |
Finset.one_mem_inv_mul_iff | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Group α] {s t : Finset α}, 1 ∈ t⁻¹ * s ↔ ¬Disjoint s t | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel_congr_left.match_1_3 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_1} {S : Stream'.WSeq (Computation α)} {a : α} (motive : (∃ c ∈ S, a ∈ c) → Prop) (x : ∃ c ∈ S, a ∈ c),
(∀ (s : Computation α) (sS : s ∈ S) (as : a ∈ s), motive ⋯) → motive x | null | false |
Simps.ProjectionRule | Mathlib.Tactic.Simps.Basic | Type | The type of rules that specify how metadata for projections in changes.
See `initialize_simps_projections`. | true |
CategoryTheory.Functor.pi._proof_4 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)] {D : I → Type u_5}
[inst_1 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)] (F : (i : I) → CategoryTheory.Functor (C i) (D i))
{X Y Z : (i : I) → C i} (f : X ⟶ Y) (g : Y ⟶ Z),
(fun i => (F i).map (CategoryTheory.C... | null | false |
Mathlib.Tactic.Ring.Common.ExBaseNat.atom.elim | Mathlib.Tactic.Ring.Common | {motive_1 : (e : Q(ℕ)) → Mathlib.Tactic.Ring.Common.ExBaseNat e → Sort u} →
{e : Q(ℕ)} →
(t : Mathlib.Tactic.Ring.Common.ExBaseNat e) →
t.ctorIdx = 0 → ({e : Q(ℕ)} → (id : ℕ) → motive_1 e (Mathlib.Tactic.Ring.Common.ExBaseNat.atom id)) → motive_1 e t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.