name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ordnode.Bounded._sparseCasesOn_1.else_eq | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Ordnode.Bounded._sparseCasesOn_1 t some «else» = «else» h | null | false |
Std.Internal.List.Const.getValue_alterKey_self._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} [inst : BEq α] {β : Type u_1} [EquivBEq α] (k : α) (f : Option β → Option β) (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (Std.Internal.List.Const.alterKey k f l) = true →
(f (Std.Internal.List.getValue? k l)).isSome = true | null | false |
_private.Init.Data.Array.Basic.0.Array.allDiffAux._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), ∀ i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i | null | false |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxo.LawfulHasSize.of_closed._simp_6 | Init.Data.Range.Polymorphic.Instances | ∀ {α : 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 | false |
Submodule.spanRank_toENat_eq_iInf_finset_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.toENat p.spanRank = ⨅ s, ↑(↑s).card | null | true |
ProofWidgets.Component.mk.sizeOf_spec | ProofWidgets.Component.Basic | ∀ {Props : Type} [inst : SizeOf Props] (toModule : Lean.Widget.Module) («export» : String),
sizeOf { toModule := toModule, «export» := «export» } = 1 + sizeOf toModule + sizeOf «export» | null | true |
Int64.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int64.ofNat (a + b) = Int64.ofNat a + Int64.ofNat b | null | true |
Std.Http.URI.Builder.mk.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} →
{scheme : Option Std.Http.URI.Scheme} →
{userInfo : Option Std.Http.URI.UserInfo} →
{host : Option Std.Http.URI.Host} →
{port : Std.Http.URI.Port} →
{pathSegments : Array String} →
{query : Array (String × Option String)} →
{fragment : Option String... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Ioo (-1) 0 → x ∈ Set.Ioo (-1) 1 | null | false |
IsSolvable | Mathlib.GroupTheory.Solvable | (G : Type u_1) → [Group G] → Prop | **Alias** of `Group.IsSolvable`.
---
A group `G` is solvable if its derived series is eventually trivial. We use this definition
because it's the most convenient one to work with. | true |
AddSubgroup.relIndex_eq_two_iff | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K = 2 ↔ ∃ a ∈ K, ∀ b ∈ K, Xor (b + a ∈ H) (b ∈ H) | Relative version of `AddSubgroup.index_eq_two_iff`. | true |
ZMod.valMinAbs_natCast_eq_self._simp_1 | Mathlib.Data.ZMod.ValMinAbs | ∀ {n a : ℕ} [NeZero n], ((↑a).valMinAbs = ↑a) = (a ≤ n / 2) | null | false |
OpenSubgroup.instPartialOrder.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
OpenSubgroup.instPartialOrder = PartialOrder.ofSetLike (OpenSubgroup G) | null | true |
AddOpposite.instNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a b c : Rᵃᵒᵖ), (a + b) * c = a * c + b * c | null | false |
ModuleCon.instAddCommMagmaQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
(M : Type u_3) →
[inst : SMul S M] → [inst_1 : AddCommMagma M] → (c : ModuleCon S M) → AddCommMagma (ModuleCon.Quotient M c) | null | true |
_private.Lean.Server.CodeActions.Attr.0.Lean.CodeAction.mkHoleCodeAction.unsafe_impl_2 | Lean.Server.CodeActions.Attr | Lean.Name → Lean.Environment → Lean.Options → ExceptT String Id Lean.CodeAction.HoleCodeAction | null | true |
List.diff.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(x x_1 : List α) →
((l : List α) → motive l []) → ((l₁ : List α) → (a : α) → (l₂ : List α) → motive l₁ (a :: l₂)) → motive x x_1 | null | false |
_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.SymExtension.mk.inj | Lean.Meta.Sym.SymM | ∀ {σ : Type} {id : ℕ} {mkInitial : IO σ} {id_1 : ℕ} {mkInitial_1 : IO σ},
{ id := id, mkInitial := mkInitial } = { id := id_1, mkInitial := mkInitial_1 } → id = id_1 ∧ mkInitial = mkInitial_1 | null | true |
UniformSpace.replaceTopology_eq | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_2} [i : TopologicalSpace α] (u : UniformSpace α) (h : i = u.toTopologicalSpace), u.replaceTopology h = u | null | true |
Equiv.Perm.cycleOf_apply_apply_self | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} (f : Equiv.Perm α) [inst : DecidableRel f.SameCycle] (x : α), (f.cycleOf x) (f x) = f (f x) | null | true |
instContinuousMulULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M], ContinuousMul (ULift.{u, u_3} M) | null | true |
WithZero.mapAddHom_injective | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : Add β] {f : α →ₙ+ β},
Function.Injective ⇑f → Function.Injective ⇑(WithZero.mapAddHom f) | null | true |
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_15 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionActionOfMonoidalFunctorToEndofunctorMopIso | Mathlib.CategoryTheory.Monoidal.Action.End | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) →
[inst_3 : F.Monoidal] → CategoryTh... | If the (left) action of `C` on `D` comes from a monoidal functor
`C ⥤ (D ⥤ D)ᴹᵒᵖ`, then `curriedActionMop C D` is naturally isomorphic to that
functor. | true |
NormedRing.inverse_add_norm | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R] (x : Rˣ),
(fun t => Ring.inverse (↑x + t)) =O[nhds 0] fun _t => 1 | The function `fun t ↦ inverse (x + t)` is O(1) as `t → 0`. | true |
nonempty_subtype | Mathlib.Basic.Nonempty | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) ↔ ∃ a, p a | null | true |
CategoryTheory.Over.pullback.congr_simp | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Limits.HasPullbacksAlong f],
CategoryTheory.Over.pullback f = CategoryTheory.Over.pullback f_1 | null | true |
SSet.stdSimplex.instFunLikeObjOppositeSimplexCategoryMkOpFinHAddNatOfNat | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n i : ℕ) → FunLike ((SSet.stdSimplex.obj { len := n }).obj (Opposite.op { len := i })) (Fin (i + 1)) (Fin (n + 1)) | If `x : Δ[n] _⦋d⦌` and `i : Fin (d + 1)`, we may evaluate `x i : Fin (n + 1)`. | true |
NumberField.nrRealPlaces_eq_zero_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : NumberField K],
NumberField.InfinitePlace.nrRealPlaces K = 0 ↔ NumberField.IsTotallyComplex K | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (a a_1 : List α),
(a = [] → False) → List.MergeSort.Internal.mergeTR.go✝ le a [] a_1 = a_1.reverseAux a | null | true |
HasCompactMulSupport.comp_homeomorph | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_9} {Y : Type u_10} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {M : Type u_11}
[inst_2 : One M] {f : Y → M}, HasCompactMulSupport f → ∀ (φ : X ≃ₜ Y), HasCompactMulSupport (f ∘ ⇑φ) | null | true |
CategoryTheory.ObjectProperty.nonempty_sup_left | Mathlib.CategoryTheory.ObjectProperty.CompleteLattice | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : CategoryTheory.ObjectProperty C) [P.Nonempty],
(P ⊔ Q).Nonempty | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabPanic._regBuiltin.Lean.Elab.Term.elabPanic_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
CategoryTheory.Limits.MultispanShape._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ | null | false |
differentiableOn_intCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {s : Set E} [inst_7 : IntCast F] (z : ℤ), DifferentiableOn 𝕜 (↑z) s | null | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.inst._@.Lean.Meta.FunInfo.117766202._hygCtx._hyg.65 | Lean.Meta.FunInfo | TypeName Lean.Meta.FunInfoEnvCacheKey✝ | null | false |
String.valid_toSubstring | Batteries.Data.String.Lemmas | ∀ (s : String), s.toRawSubstring.Valid | null | true |
OrderIso.setIsotypicComponents_apply | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M] (s : Set ↑(isotypicComponents R M)),
OrderIso.setIsotypicComponents s = ⨆ c ∈ s, ⟨↑c, ⋯⟩ | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.addAuxRecs.match_1 | Lean.Elab.MutualInductive | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((const : Lean.ConstantInfo) → motive (some const)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
PSigma.Lex.recOn | Init.WF | ∀ {α : Sort u} {β : α → Sort v} {r : α → α → Prop} {s : (a : α) → β a → β a → Prop}
{motive : (a a_1 : PSigma β) → PSigma.Lex r s a a_1 → Prop} {a a_1 : PSigma β} (t : PSigma.Lex r s a a_1),
(∀ {a₁ : α} (b₁ : β a₁) {a₂ : α} (b₂ : β a₂) (a : r a₁ a₂), motive ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⋯) →
(∀ (a : α) {b₁ b₂ : β a} (a_2 :... | null | false |
finsum_eq_if | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] {p : Prop} [inst_1 : Decidable p] {x : M}, ∑ᶠ (_ : p), x = if p then x else 0 | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqPoly.beq.match_1.splitter | Init.Grind.Ring.CommSolver | (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) →
(x x_1 : Lean.Grind.CommRing.Poly) →
((a b : ℤ) → motive (Lean.Grind.CommRing.Poly.num a) (Lean.Grind.CommRing.Poly.num b)) →
((a : ℤ) →
(a_1 : Lean.Grind.CommRing.Mon) →
(a_2 : Lean.Grind.CommRing.Poly) →
... | null | true |
_private.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.Extension.addFunCCAttr | Lean.Meta.Tactic.Grind.Attr | Lean.Meta.Grind.Extension → Lean.Name → Lean.AttributeKind → Lean.CoreM Unit | null | true |
exists_or_eq_imp | Init.PropLemmas | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, (q a ∨ a = a') ∧ p a) ↔ (∃ a, q a ∧ p a) ∨ p a' | null | true |
Nat.recDiagAux_succ_succ | Batteries.Data.Nat.Lemmas | ∀ {motive : ℕ → ℕ → Sort u_1} (zero_left : (n : ℕ) → motive 0 n) (zero_right : (m : ℕ) → motive m 0)
(succ_succ : (m n : ℕ) → motive m n → motive (m + 1) (n + 1)) (m n : ℕ),
Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n) | null | true |
CategoryTheory.Equivalence.changeFunctor._proof_2 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) {G : CategoryTheory.Functor C D} (iso : e.functor ≅ G)
(X : C),
CategoryTheory.CategoryStruct.comp
(G.map ((e.unitIso ≪≫ CategoryTheory.Functor.isoWhiskerRight iso e.inve... | null | false |
CategoryTheory.PreZeroHypercover.hom_inv_h₀._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(e : E ≅ F) (i : E.I₀), E.X i = E.X (e.inv.s₀ (e.hom.s₀ i)) | null | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_11 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x ∈ R] (q : ℚ≥0) (a : ↥R), DivisionRing.nnqsmul q a = ↑q * a | null | false |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_8 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
(∀ t ∈ s, IsCompact t) → ∀ t_1 ∈ {t | t ∈ s ∧ IsOpen t}, IsCompact t_1 | null | false |
_private.Mathlib.CategoryTheory.Limits.Opposites.0.CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι._simp_1_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {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 |
LipschitzWith.compLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{F : Type u_5} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
{g : E → F} →
{c : NNReal} → LipschitzW... | When `g` is a Lipschitz function sending `0` to `0` and `f` is in `Lp`, then `g ∘ f` is well
defined as an element of `Lp`. | true |
FormalMultilinearSeries.leftInv._proof_30 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], SMulCommClass 𝕜 𝕜 E | null | false |
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), Array.range n = Array.ofFn fun i => ↑i | null | true |
List.merge_of_le | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {xs ys : List α},
(∀ (a b : α), a ∈ xs → b ∈ ys → le a b = true) → xs.merge ys le = xs ++ ys | null | true |
Std.TreeMap.Raw.Equiv.getEntryLT?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLT? k = t₂.getEntryLT? k | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map₂_comp | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
self.map₂ (CategoryTheory.CategoryStruct.comp η θ) = CategoryTheory.CategoryStruct.comp (self.map₂ η)... | null | true |
Lean.Parser.Tactic.quot | Lean.Parser.Term | Lean.Parser.Parser | null | true |
String.toInt?_toSlice | Std.Data.String.ToInt | ∀ {s : String}, s.toSlice.toInt? = s.toInt? | null | true |
ContinuousMultilinearMap.currySumEquiv._proof_10 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], SMulCommClass 𝕜 𝕜 G' | null | false |
CommRingCat.limitCommRing._aux_36 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] →
CommRing ↑(F.comp (CategoryTheory.forget CommRingCat)).sections →
ℤ →
(Cate... | null | false |
Std.TreeSet.Raw.toList_roc | Std.Data.TreeSet.Raw.Slice | ∀ {α : Type u} (cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.toList_roc._auto_1) [Std.TransCmp cmp]
{t : Std.TreeSet.Raw α cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t (lowerBound<...=upperBound)) =
List.filter (fun e => decide ((cmp e lowerBound)... | null | true |
contMDiffOn_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | zero-smoothness on a set is equivalent to continuity on this set. | true |
LibraryNote.foundational_algebra_order_theory | Mathlib.Data.Nat.Init | Batteries.Util.LibraryNote | Batteries has a home-baked development of the algebraic and order-theoretic theory of `ℕ` and `ℤ`
which, in particular, is not typeclass-mediated. This is useful to set up the algebra and finiteness
libraries in mathlib (naturals and integers show up as indices/offsets in lists, cardinality in
finsets, powers in groups... | true |
Fintype | Mathlib.Data.Fintype.Defs | Type u_3 → Type u_3 | `Fintype α` means that `α` is finite, i.e. there are only
finitely many distinct elements of type `α`. The evidence of this
is a finset `elems` (a list up to permutation without duplicates),
together with a proof that everything of type `α` is in the list. | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.markNestedSubsingletons.visit._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((b... | null | false |
Subalgebra.val._proof_5 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), ↑((algebraMap R ↥S) x) = ↑((algebraMap R ↥S) x) | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
Rat.instNormedField | Mathlib.Analysis.Normed.Field.Lemmas | NormedField ℚ | null | true |
SimplexCategory.toTopHomeo_symm_naturality_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {n m : SimplexCategory} (f : n ⟶ m) (x : Convexity.StdSimplex ℝ (Fin (n.len + 1))),
m.toTopHomeo.symm (Convexity.StdSimplex.map (⇑(CategoryTheory.ConcreteCategory.hom f)) x) =
(CategoryTheory.ConcreteCategory.hom (SSet.toTop.map (SSet.stdSimplex.map f))) (n.toTopHomeo.symm x) | null | true |
sqrt_one_add_norm_sq_le | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖ | null | true |
instAddUInt32 | Init.Data.UInt.BasicAux | Add UInt32 | null | true |
IsOpen.convexHull | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[ZeroLEOneClass 𝕜] {s : Set E}, IsOpen s → IsOpen ((convexHull 𝕜) s) | null | true |
CategoryTheory.GrothendieckTopology.Point.over | Mathlib.CategoryTheory.Sites.Point.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
[CategoryTheory.LocallySmall.{w, v, u} C] → (Φ : J.Point) → {X : C} → Φ.fiber.obj X → (J.over X).Point | Given a point `Φ` of a site `(C, J)`, an object `X : C`, and `x : Φ.fiber.obj X`,
this is the point of the site `(Over X, J.over X)` such that the fiber of
an object of `Over X` corresponding to a morphism `f : Y ⟶ X` identifies
to subtype of `Φ.fiber.obj Y` consisting of elements `y` such
that `Φ.fiber.map f y = x`. | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.instHasAffinePropertyQuasiCompactCompactSpaceCarrierCarrierCommRingCat._simp_2 | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s = CompactSpace ↑s | null | false |
SimplexCategory.Truncated.instStrongEpiCategory | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {d : ℕ}, CategoryTheory.StrongEpiCategory (SimplexCategory.Truncated d) | null | true |
div_right_injective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {b : G}, Function.Injective fun a => b / a | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow._proof_1_3 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n m : ℕ}, m < n → ¬m ≤ n → False | null | false |
Prod.mk_le_mk._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {a₁ a₂ : α} {b₁ b₂ : β},
((a₁, b₁) ≤ (a₂, b₂)) = (a₁ ≤ a₂ ∧ b₁ ≤ b₂) | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.exists_mem_stabilizer_smul_eq._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Set α},
∀ a ∈ t, ∀ b ∈ t, ∀ c ∈ t, ∀ ⦃b_1 : α⦄, b_1 ∈ t → (⇑(Equiv.swap c a) ∘ ⇑(Equiv.swap a b)) b_1 ∈ t | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.ofNat_mul._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt32), (UInt32.ofNat a = b) = (a % 2 ^ 32 = b.toNat) | null | false |
Lean.FileMap.lineStart | Lean.Data.Position | Lean.FileMap → ℕ → String.Pos.Raw | Returns the position of the start of (1-based) line `line`.
This gives the same result as `map.ofPosition ⟨line, 0⟩`, but is more efficient.
| true |
SimpleGraph.isNIndepSet_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) (n : ℕ) (s : Finset α), G.IsNIndepSet n s ↔ G.IsIndepSet ↑s ∧ s.card = n | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Icc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
CategoryTheory.Functor.LaxMonoidal.μ_whiskerRight_comp_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
F.obj (Category... | null | true |
Nat.gcd_sub_right_right_of_dvd | Init.Data.Nat.Gcd | ∀ {m k : ℕ} (n : ℕ), k ≤ m → n ∣ k → n.gcd (m - k) = n.gcd m | null | true |
FundamentalGroupoid.instIsEmpty | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3) [IsEmpty X], IsEmpty (FundamentalGroupoid X) | null | true |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.ShortComplex.ShortExact.projectiveDimension_X₂_le_sup._simp_1_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C),
(CategoryTheory.projectiveDimension X = ⊥) = CategoryTheory.Limits.IsZero X | null | false |
signedDist_vadd_right_swap | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v w : V) (p q : P), ((signedDist v) p) (w +ᵥ q) = ((signedDist v) (-w +ᵥ p)) q | null | true |
CategoryTheory.Lax.OplaxTrans.Hom._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} → [SizeOf B] → [SizeOf C] → CategoryTheory.Lax.OplaxTrans.Hom η θ → ℕ | null | false |
hasFDerivAt_inv | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜},
x ≠ 0 → HasFDerivAt (fun x => x⁻¹) (ContinuousLinearMap.toSpanSingleton 𝕜 (-(x ^ 2)⁻¹)) x | null | true |
DenselyOrdered.rec | Mathlib.Order.Basic | {α : Type u_5} →
[inst : LT α] →
{motive : DenselyOrdered α → Sort u} →
((dense : ∀ (a₁ a₂ : α), a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂) → motive ⋯) → (t : DenselyOrdered α) → motive t | null | false |
Turing.ToPartrec.Cfg.ctorIdx | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Cfg → ℕ | null | false |
Nat.shiftLeft'._unsafe_rec | Mathlib.Data.Nat.Bits | Bool → ℕ → ℕ → ℕ | null | false |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_iff_le_and_ne._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
Mathlib.Tactic.BicategoryLike.AtomIso.mk.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁),
sizeOf { e := e, src := src, tgt := tgt } = 1 + sizeOf e + sizeOf src + sizeOf tgt | null | true |
CategoryTheory.Bicategory.RightLift.mk | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
(h : c ⟶ b) → (CategoryTheory.CategoryStruct.comp h f ⟶ g) → CategoryTheory.Bicategory.RightLift f g | Construct a right lift from a 1-morphism and a 2-morphism. | true |
Submodule.mem_adjoint_iff | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(g : Submodule 𝕜 (E × F)) (x : F × E),
x ∈ g.adjoint ↔ ∀ (a : E) (b : F), (a, b) ∈ g → inner 𝕜 b x.1 - inner 𝕜 a... | null | true |
ContinuousLinearMap.opNorm_linearIsometryEquiv_comp | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜₁ : Type u_2} {𝕜₂ : Type u_3} {𝕜₃ : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_8}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜₁] [inst_4 : NormedSpace 𝕜₁ E] [inst_5 : NontriviallyNormedField 𝕜₂]
[inst_6 : Norme... | Postcomposition with a linear isometry preserves the operator norm. | true |
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termProj | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | `Proj` as a locally ringed space | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.