name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubgroup.centralizer.eq_1 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.centralizer s = { toAddSubmonoid := AddSubmonoid.centralizer s, neg_mem' := ⋯ } | null | true |
IntermediateField.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B C : IntermediateField F E},
A ⊓ C = B ⊓ C → A.relrank C = B.relrank C | null | true |
AddMonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : M →+ N) (g : M →+ P), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
CategoryTheory.ObjectProperty.limitsClosure.of_isoClosure | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] {X Y : C} (e : X ≅ Y),
P.limitsClosure J X → P.limitsClosure J Y | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Skeleton.0.SSet.mem_skeleton_obj_iff_of_nonDegenerate._simp_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Std.TreeMap.keyAtIdx? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → ℕ → Option α | Returns the `n`-th smallest key, or `none` if `n` is at least `t.size`. | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.IsExtensionBy_trans_left | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf1 cnf2 cnf3 : Std.Sat.CNF ℕ} {new1 : ℕ} {hnew1 : new1 < aig.decls.size} {new2 : ℕ}
{hnew2 : new2 < aig.decls.size} (cache1 : Std.Sat.AIG.toCNF.Cache✝ aig cnf1)
(cache2 : Std.Sat.AIG.toCNF.Cache✝ aig cnf2) (cache3 : Std.Sat.AIG.toCNF.Cache✝ aig cnf3),
Std.Sat.AIG.toCNF.Cache.IsExtension... | null | true |
Matrix.conjTransposeRingEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (α : Type v) [inst : NonUnitalNonAssocSemiring α] [inst_1 : StarRing α] [inst_2 : Fintype m]
(a : (Matrix m m α)ᵐᵒᵖ), (Matrix.conjTransposeRingEquiv m α).symm a = (MulOpposite.unop a).conjTranspose | null | true |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso_inverse | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (f : E ≅ F),
(CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso f).inverse =
CategoryTheory.PreOneHypercover.Hom.mapMulticospan f.inv | null | true |
OrderMonoidIso.toOrderIso_eq_coe | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β), f.toOrderIso = ↑f | null | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | null | false |
_private.Lean.Environment.0.Lean.importModulesCore.match_3 | Lean.Environment | (motive : Option Lean.ImportedModule✝ → Sort u_1) →
(x : Option Lean.ImportedModule✝) →
((mod : Lean.ImportedModule✝) → motive (some mod)) → ((x : Option Lean.ImportedModule✝) → motive x) → motive x | null | false |
CategoryTheory.Mon.instSymmetricCategory.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C],
CategoryTheory.Mon.instSymmetricCategory =
{ braiding := fun X Y => CategoryTheory.Mon.mkIso' (β_ X.X Y.X), braiding_naturality_right := ⋯,
braiding_natur... | null | true |
AddGroupNormClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : AddGroup α] →
[inst_1 : AddCommMonoid β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : AddGroupNormClass F α β → Sort u} →
(t : AddGroupNormClass F α β) →
... | null | false |
Function.support_inv | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] (f : ι → G₀),
(Function.support fun a => (f a)⁻¹) = Function.support f | null | true |
Real.«_aux_Mathlib_Analysis_Real_Sqrt___macroRules_Real_term√__1» | Mathlib.Analysis.Real.Sqrt | Lean.Macro | null | false |
_private.Lean.Expr.0.Lean.Expr.getForallBody._sparseCasesOn_1 | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
RingCat.fullyFaithfulForget₂ToSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | (CategoryTheory.forget₂ RingCat SemiRingCat).FullyFaithful | The forgetful functor from `RingCat` to `SemiRingCat` is fully faithful. | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.pseudoMetricAux._simp_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → (0 ≤ ∑ i ∈ s, f i) = True | null | false |
CategoryTheory.evaluationLeftAdjoint_map_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {x d₂ : D} (f : x ⟶ d₂)
(x_1 : C),
((CategoryTheory.evaluationLeftAdjoint D c).map f).app x_1 =
CategoryT... | null | true |
Mathlib.Notation3.MatchState.getBinders | Mathlib.Util.Notation3 | Mathlib.Notation3.MatchState → Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinderParenthesized) | Get the accumulated array of delaborated terms for a given foldr/foldl.
Returns `#[]` if nothing has been pushed yet. | true |
LinearPMap.mem_graph_snd_inj' | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F) {x y : E × F},
x ∈ f.graph → y ∈ f.graph → x.1 = y.1 → x.2 = y.2 | null | true |
Std.Internal.Do.Spec.forIn'_array._proof_4 | Std.Internal.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : Array α}, xs.toList ++ [] = xs.toList | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastClz.go_denote_eq._proof_1_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz | ∀ {w : ℕ} (idx idx curr : ℕ), curr + 1 < 2 ^ (curr + 1) → 2 ^ (curr + 1) < 2 ^ w → ¬curr + 1 < 2 ^ w → False | null | false |
Lean.Server.Reference.aliases._default | Lean.Server.References | Array Lean.Lsp.RefIdent | null | false |
BoxIntegral.unitPartition.box_upper | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] (ν : ι → ℤ),
(BoxIntegral.unitPartition.box n ν).upper = fun i => (↑(ν i) + 1) / ↑n | null | true |
Int.testBit_land | Mathlib.Data.Int.Bitwise | ∀ (m n : ℤ) (k : ℕ), (m.land n).testBit k = (m.testBit k && n.testBit k) | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Action.End.0.CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._simp_12 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f.unmop g.unmop = (CategoryTheory.CategoryStruct.comp f g).unmop | null | false |
ContinuousLinearMap.toLinearMap₁₂ | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | {R : Type u_1} →
{𝕜₂ : Type u_3} →
{𝕜₃ : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
{G : Type u_7} →
[inst : Semiring R] →
[inst_1 : NormedField 𝕜₂] →
[inst_2 : NormedField 𝕜₃] →
[inst_3 : AddCommMonoid E] →
... | Send a continuous sesquilinear map to an abstract sesquilinear map (forgetting continuity). | true |
_private.Mathlib.FieldTheory.KummerExtension.0.exists_root_adjoin_eq_top_of_isCyclic.match_1_5 | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_2) [inst : Field K] (L : Type u_1) [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : ↥(OrderDual.ofDual ⊥) → Prop) (h : ↥(OrderDual.ofDual ⊥)),
(∀ (σ' : Gal(L/K)) (hσ' : σ' ∈ OrderDual.ofDual ⊥), motive ⟨σ', hσ'⟩) → motive h | null | false |
FreeSemigroup.noConfusion | Mathlib.Algebra.Free | {P : Sort u_1} →
{α : Type u} →
{t : FreeSemigroup α} →
{α' : Type u} → {t' : FreeSemigroup α'} → α = α' → t ≍ t' → FreeSemigroup.noConfusionType P t t' | null | false |
MeasureTheory.JordanDecomposition.smul_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α) (r : NNReal),
(r • j).posPart = r • j.posPart | null | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_toDigitsCore | Init.Data.Nat.ToString | ∀ {b n d fuel nf df : ℕ} {cs : List Char},
1 < b →
0 < n →
d < b →
b * n + d < fuel →
n < nf → d < df → b.toDigitsCore nf n (b.toDigitsCore df d cs) = b.toDigitsCore fuel (b * n + d) cs | null | true |
_private.Mathlib.RingTheory.Ideal.Over.0.Ideal.Quotient.ker_stabilizerHom._simp_1_2 | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {x y : R} [inst_1 : I.IsTwoSided],
((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) = (x - y ∈ I) | null | false |
Real.mk_zero | Mathlib.Data.Real.Basic | Real.mk 0 = 0 | null | true |
List.dropSlice.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : ℕ → ℕ → List α → Sort u_2) →
(x x_1 : ℕ) →
(x_2 : List α) →
((x x_3 : ℕ) → motive x x_3 []) →
((m : ℕ) → (xs : List α) → motive 0 m xs) →
((n m : ℕ) → (x : α) → (xs : List α) → motive n.succ m (x :: xs)) → motive x x_1 x_2 | null | false |
List.Perm.union | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {l₁ l₂ t₁ t₂ : List α}, l₁.Perm l₂ → t₁.Perm t₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₂) | null | true |
Option.instMax | Init.Data.Option.Basic | {α : Type u_1} → [Max α] → Max (Option α) | null | true |
OrderIso.map_ciInf | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddBelow (Set.range f) → e (⨅ i, f i) = ⨅ i, e (f i) | null | true |
QuadraticMap.restrict._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (Q : QuadraticMap R M N) (V : Submodule R M) (a : R) (v : ↥V),
Q.toFun (a • ↑v) = (a * a) • Q.toFun ↑v | null | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation._proof_1 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice),
WellFounded (InvImage WellFoundedRelation.rel fun it => it.internalState.currPos) | null | false |
_private.Std.Http.Data.Body.Full.0.Std.Http.Body.Full.mk.inj | Std.Http.Data.Body.Full | ∀ {state state_1 : Std.Mutex (Option ByteArray)}, { state := state } = { state := state_1 } → state = state_1 | null | true |
Std.HashMap.Raw.getKey?_union_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k | null | true |
Std.Sat.CNF.sat_empty._simp_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {assign : α → Bool}, Std.Sat.CNF.Sat assign Std.Sat.CNF.empty = True | null | false |
Lean.Core.State.messages | Lean.CoreM | Lean.Core.State → Lean.MessageLog | Message log. | true |
CommRingCat.equalizer_ι_isLocalHom' | Mathlib.Algebra.Category.Ring.Constructions | ∀ (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPairᵒᵖ CommRingCat),
IsLocalHom
(CommRingCat.Hom.hom (CategoryTheory.Limits.limit.π F (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one))) | null | true |
List.reflBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], ReflBEq (List α) ↔ ReflBEq α | null | true |
Homotopy.mkInductiveAux₁._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(su... | null | false |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.not_isNonloop_iff_closure._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e = (M.closure {e} = M.loops ∧ e ∈ M.E) | null | false |
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp_assoc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F G : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j ... | null | true |
neg_strictConvexOn_iff | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f : E → β}, StrictConvexOn 𝕜 s (-f) ↔ StrictConcaveOn 𝕜 s f | A function `-f` is strictly convex iff `f` is strictly concave. | true |
Std.ExtTreeSet.mem_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k : α}, k ∈ t.insertMany l ↔ k ∈ t ∨ l.contains k = true | null | true |
Lean.Grind.AC.Seq.endsWithVar_k_var | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var), (Lean.Grind.AC.Seq.var y).endsWithVar_k x = (x == y) | null | true |
Aesop.SimpTheorems.foldSimpEntries | Aesop.Util.Basic | {σ : Type u_1} → (σ → Lean.Meta.SimpEntry → σ) → σ → Lean.Meta.SimpTheorems → σ | null | true |
_private.Mathlib.Topology.Algebra.MetricSpace.Lipschitz.0.LocallyLipschitzOn.exists_lipschitzOnWith_of_compact.match_1_5 | Mathlib.Topology.Algebra.MetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {s : Set α}
(ε : (x : α) → x ∈ s → ℝ) (x : α) (hx : x ∈ s)
(motive : BddAbove ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx))) → Prop)
(x_1 : BddAbove ((fun y => dist (f x) (f y) / dist ... | null | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_toReal_le._simp_1_2 | Mathlib.Data.EReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
IntervalIntegrable.iff_comp_neg._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | null | false |
Ideal.ramificationIdx_le_finrank | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] (S : Type v) [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDedekindDomain S]
(K : Type u_1) (L : Type u_2) [inst_4 : Field K] [inst_5 : Field L] [IsDedekindDomain R] [inst_7 : Algebra R K]
[IsFractionRing R K] [inst_9 : Algebra S L] [IsFractionRing S L] [inst_11 : Algebra K L] [... | null | true |
LieAlgebra.Orthogonal.JD | Mathlib.Algebra.Lie.Classical | (l : Type u_4) → (R : Type u₂) → [DecidableEq l] → [CommRing R] → Matrix (l ⊕ l) (l ⊕ l) R | A matrix defining a canonical even-rank symmetric bilinear form.
It looks like this as a `2l x 2l` matrix of `l x l` blocks:
```
[ 0 1 ]
[ 1 0 ]
```
| true |
MeasureTheory.MemLp.locallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ]
{p : ENNReal}, MeasureTheory.MemLp f p μ → 1 ≤ p → MeasureTheory.LocallyIntegrable f ... | null | true |
Nat.any._f | Init.Data.Nat.Fold | (x : ℕ) → Nat.below (motive := fun x => ((i : ℕ) → i < x → Bool) → Bool) x → ((i : ℕ) → i < x → Bool) → Bool | null | false |
εNFA.stepSet | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → Set σ → α → Set σ | `M.stepSet S a` is the union of the ε-closure of `M.step s a` for all `s ∈ S`. | true |
CategoryTheory.Subobject.inf_comp_right_assoc | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A : C}
(f g : CategoryTheory.Subobject A) {Z : C} (h : A ⟶ Z),
CategoryTheory.CategoryStruct.comp ((f ⊓ g).ofLE g ⋯) (CategoryTheory.CategoryStruct.comp g.arrow h) =
CategoryTheory.CategoryStruct.comp (f... | null | true |
CategoryTheory.Functor.hasPointwiseRightKanExtensionAt_of_equivalence | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {D' : Type u_3} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} D']
[inst_3 : CategoryTheory.Category.{v_4, u_4} H] (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor ... | null | true |
Turing.TM2to1.StAct.push.sizeOf_spec | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {σ : Type u_4} {k : K} [inst : SizeOf K] [inst_1 : (a : K) → SizeOf (Γ a)]
[inst_2 : SizeOf σ] (a : σ → Γ k), sizeOf (Turing.TM2to1.StAct.push a) = 1 | null | true |
Std.Do.SPred.and_or_elim_l | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R T : Std.Do.SPred σs}, (P ∧ R ⊢ₛ T) → (Q ∧ R ⊢ₛ T) → (P ∨ Q) ∧ R ⊢ₛ T | null | true |
differentiableWithinAt_sub_const_iff | 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}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithin... | null | true |
Continuous.measurable | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ] [BorelSpace γ] {f : α → γ}, Continuous f → Measurable f | A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is measurable. | true |
Std.ExtDHashMap.get_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → γ a} {k : α} {h' : k ∈ Std.ExtDHashMap.map f m},
(Std.ExtDHashMap.map f m).get k h' = f k (m.get k ⋯) | null | true |
_private.BatteriesRecycling.RBTree.WF.0.RBTree.RBNode.balance1_All._simp_1_3 | BatteriesRecycling.RBTree.WF | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | null | false |
_private.Mathlib.Data.List.Sort.0.List.«_aux_Mathlib_Data_List_Sort___macroRules__private_Mathlib_Data_List_Sort_0_List_term_≼__1_1» | Mathlib.Data.List.Sort | Lean.Macro | null | false |
CategoryTheory.Discrete.functor_obj_eq_as | Mathlib.CategoryTheory.Discrete.Basic | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (X : CategoryTheory.Discrete I),
(CategoryTheory.Discrete.functor F).obj X = F X.as | null | true |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_right_eq_self | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b : BitVec w), (a + b == a) = (b == 0#w) | null | true |
Lean.IR.IRType._sizeOf_3_eq | Lean.Compiler.IR.Basic | ∀ (x : List Lean.IR.IRType), Lean.IR.IRType._sizeOf_3 x = sizeOf x | null | false |
_private.Mathlib.Algebra.SkewPolynomial.Basic.0.SkewPolynomial.monomial_eq_monomial_iff._simp_1_1 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k),
(fun₀ | a => b) = (SkewMonoidAlgebra.single a b).toFinsupp | null | false |
CategoryTheory.Under.isLeftAdjoint_post | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : CategoryTheory.Functor T D) [F.IsLeftAdjoint], (CategoryTheory.Under.post F).IsLeftAdjoint | null | true |
Function.HasUncurry.noConfusionType | Mathlib.Logic.Function.Basic | Sort u →
{α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
Function.HasUncurry α β γ →
{α' : Type u_5} → {β' : Type u_6} → {γ' : Type u_7} → Function.HasUncurry α' β' γ' → Sort u | null | false |
Int.add_neg_mul_fmod_self_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b c : ℤ), (a + -(b * c)).fmod b = a.fmod b | null | true |
Lean.IR.Arg.var.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Arg → Sort u} →
(t : Lean.IR.Arg) → t.ctorIdx = 0 → ((id : Lean.IR.VarId) → motive (Lean.IR.Arg.var id)) → motive t | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functor_ext._proof_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C]
{F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C},
(∀ (i : J.L),
F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) =
G.obj (CategoryTheory.Limits.WalkingMultico... | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_6 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u_2} {A M B : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup A] [inst_2 : Module R A]
[inst_3 : AddCommGroup B] [inst_4 : Module R B] [inst_5 : AddCommGroup M] [inst_6 : Module R M] {j : A →ₗ[R] M}
{g : M →ₗ[R] B} (exac : j.range = g.ker),
(CategoryTheory.ShortComplex.moduleCatMkOfKerLERange (Module... | null | false |
ENNReal.inv_mul_ne_top | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a⁻¹ * a ≠ ⊤ | null | true |
_private.Std.Sync.Semaphore.0.Std.mkResolvedPromise | Std.Sync.Semaphore | {α : Type} → [Nonempty α] → α → BaseIO (IO.Promise α) | Creates a resolved promise.
| true |
groupHomology.cyclesOfIsCycle₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (x : G →₀ A),
groupHomology.IsCycle₁ x → x ∈ groupHomology.cycles₁ (Rep.ofDistribMulAction k G A) | null | false |
Finset.sum_indicator_subset | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] (f : ι → β) {s t : Finset ι},
s ⊆ t → ∑ i ∈ t, (↑s).indicator f i = ∑ i ∈ s, f i | Summing an indicator function over a possibly larger `Finset` is the same as
summing the original function over the original finset. | true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision._simp_1_7 | Mathlib.NumberTheory.Rayleigh | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c | null | false |
SupHom.mk.sizeOf_spec | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_6} {β : Type u_7} [inst : Max α] [inst_1 : Max β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b), sizeOf { toFun := toFun, map_sup' := map_sup' } = 1 | null | true |
KStar | Mathlib.Algebra.Order.Kleene | Type u_5 → Type u_5 | Notation typeclass for the Kleene star `∗`. | true |
UniformOnFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Finite ↑𝔖] [inst_1 : PseudoMetricSpace β] [BoundedSpace β]
(f g : UniformOnFun α β 𝔖),
edist f g = ENNReal.ofReal (⨆ x, dist ((UniformOnFun.toFun 𝔖) f ↑x) ((UniformOnFun.toFun 𝔖) g ↑x)) | null | false |
Subring.instCovariantClassHSMulLe | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R],
CovariantClass M (Subring R) HSMul.hSMul LE.le | null | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.natCast_image_Iio._proof_1_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (n : ℕ) (o : Ordinal.{u_1}), (∀ {b : ℕ}, o ≤ ↑b → ∃ c, o = ↑c) → (o ∈ NatCast.natCast '' Set.Iio n ↔ o ∈ Set.Iio ↑n) | null | false |
TopCat.Presheaf.SheafConditionPairwiseIntersections.isLimitMapConeOfIsLimitSheafConditionFork._proof_2 | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
{X : TopCat} (F : TopCat.Presheaf C X) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X)
(j : (CategoryTheory.Pairwise ι)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id (C... | null | false |
Lean.Meta.Sym.AlphaShareCommon.State | Lean.Meta.Sym.AlphaShareCommon | Type | null | true |
MeasureTheory.IsLocallyFiniteMeasure.casesOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
[inst : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.IsLocallyFiniteMeasure μ → Sort u} →
(t : MeasureTheory.IsLocallyFiniteMeasure μ) →
((finiteAtNhds : ∀ (x : α), μ.FiniteAtFilter (nhds x)) → motive ... | null | false |
lift_rank_add_lift_rank_le_rank_prod | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ (R : Type u) (M : Type v) (M' : Type v') [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M']
[inst_3 : Module R M] [inst_4 : Module R M'] [Nontrivial R],
Cardinal.lift.{v', v} (Module.rank R M) + Cardinal.lift.{v, v'} (Module.rank R M') ≤ Module.rank R (M × M') | null | true |
HahnSeries.support_embDomain_subset | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).support ⊆ ⇑f '' x.support | null | true |
CategoryTheory.Limits.coprod.map_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T U V W : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct U W] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct T V]
(f : U ⟶ S) (g : W ⟶ S) (h : T ⟶ U) (k : V ⟶ W) {Z : C} (h_1 : S ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.... | null | true |
Matrix.twoBlockTriangular_det | Mathlib.LinearAlgebra.Matrix.Block | ∀ {m : Type u_3} {R : Type v} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] (M : Matrix m m R)
(p : m → Prop) [inst_3 : DecidablePred p],
(∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0) →
M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det | null | true |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.collectHeaders.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} →
(motive : α × ℕ × String → Sort u_1) →
(x : α × ℕ × String) → ((x : α) → (fst : ℕ) → (footer : String) → motive (x, fst, footer)) → motive x | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.instRKHS._proof_2 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)} [inst_4 : Fact K.PosSemidef],
ContinuousConstSMul 𝕜 (UniformSpace.Completion (RKHS.H₀ K)) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.