name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WeakDual.isBounded_toWeakDual_preimage_iff_isBounded | Mathlib.Analysis.Normed.Module.WeakDual | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set (WeakDual 𝕜 E)},
Bornology.IsBounded (⇑StrongDual.toWeakDual ⁻¹' s) ↔ Bornology.IsBounded s | A set in `StrongDual 𝕜 E` is bounded iff its image in `WeakDual 𝕜 E` is bounded. | true |
CategoryTheory.Functor.whiskeringLeft₄ObjObjObj_obj | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} (C₄ : Type u_4) {D₁ : Type u_5} {D₂ : Type u_6} {D₃ : Type u_7}
(D₄ : Type u_8) [inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u... | null | true |
Std.DTreeMap.getKey!_eq_default | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {a : α}, a ∉ t → t.getKey! a = default | null | true |
Lean.Parser.InputContext.mk' | Lean.Parser.Types | (inputString : String) →
String →
Lean.FileMap →
(endPos : String.Pos.Raw) →
autoParam (endPos ≤ inputString.rawEndPos) Lean.Parser.InputContext.endPos_valid._autoParam →
Lean.Parser.InputContext | null | true |
Lean.PrettyPrinter.Delaborator.State | Lean.PrettyPrinter.Delaborator.Basic | Type | null | true |
Finset.intervalGapsWithin.fst | Mathlib.Order.Interval.Finset.Gaps | {α : Type u_1} → [LinearOrder α] → (F : Finset (α × α)) → {k : ℕ} → F.card = k → α → Fin (k + 1) → α | The first coordinate of `F.intervalGapsWithin h a b i` is `a` if `i = 0`,
`y (i - 1)` otherwise. | true |
SetLike.gnonUnitalNonAssocSemiring._proof_1 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : Add ι] [inst_1 : NonUnitalNonAssocSemiring R]
[inst_2 : SetLike σ R] [inst_3 : AddSubmonoidClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMul A] {i j : ι}
(x : ↥(A i)), GradedMonoid.GMul.mul x 0 = 0 | null | false |
Subalgebra.LinearDisjoint.map | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B →
∀ {T : Type w} [inst_3 : Semiring T] [inst_4 : Algebra R T] (f : S →ₐ[R] T),
Function.Injective ⇑f → (Subalgebra.map f A).LinearDisjoint (Subalgebra.map f B) | Linear disjointness is preserved by injective algebra homomorphisms. | true |
_private.Mathlib.Tactic.Translate.UnfoldBoundary.0.Mathlib.Tactic.UnfoldBoundary.refoldConsts.go | Mathlib.Tactic.Translate.UnfoldBoundary | Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries → Lean.Expr → Lean.MVarId → Lean.Meta.SimpM Unit | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.errorMessage._sparseCasesOn_1 | Mathlib.Tactic.Linter.TextBased | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_2 | Init.Data.String.OrderInstances | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_15 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p : G.Walk u v} (h : G.Adj u' v') (i : ℕ)
(hi : i < p.darts.length),
p.darts[i] = { fst := u', snd := v', adj := h } →
∀ (j : ℕ) (hj : j < [u', v'].length), p.support[j + i]? = some [u', v'][j] | null | false |
CategoryTheory.LocallyDiscrete.mkPseudofunctor._proof_8 | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {B₀ : Type u_5} {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_5} B₀] [inst_1 : CategoryTheory.Bicategory C]
(obj : B₀ → C) (map : {b b' : B₀} → (b ⟶ b') → (obj b ⟶ obj b')) {b₀ b₁ : B₀} (f : b₀ ⟶ b₁),
map (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id b₀) f) = map f | null | false |
_private.Init.Data.Slice.Array.Iterator.0.SubarrayIterator.step.match_1.eq_1 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u_1} (motive : Std.IterM Id α → Sort u_2) (xs : Subarray α)
(h_1 : (xs : Subarray α) → motive { internalState := { xs := xs } }),
(match { internalState := { xs := xs } } with
| { internalState := { xs := xs } } => h_1 xs) =
h_1 xs | null | true |
Lean.Grind.CommRing.Mon.denoteAsIntModule.go.eq_def | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (m : Lean.Grind.CommRing.Mon)
(acc : α),
Lean.Grind.CommRing.Mon.denoteAsIntModule.go ctx m acc =
match m with
| Lean.Grind.CommRing.Mon.unit => acc
| Lean.Grind.CommRing.Mon.mult pw m =>
Lean.Grind.CommRing.Mon.... | null | true |
add_sub_div_two_lt | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < b → a + (b - a) / 2 < b | null | true |
Set.mem_smul_set_iff_inv_smul_mem | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
x ∈ a • A ↔ a⁻¹ • x ∈ A | null | true |
UniqueFactorizationMonoid.radical_eq_one_iff | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, UniqueFactorizationMonoid.radical a = 1 ↔ a = 0 ∨ IsUnit a | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.resume.match_1 | Lean.Meta.SynthInstance | (motive : Option Lean.MetavarContext → Sort u_1) →
(__do_lift : Option Lean.MetavarContext) →
(Unit → motive none) → ((mctx : Lean.MetavarContext) → motive (some mctx)) → motive __do_lift | null | false |
Aesop.Frontend.Feature.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.Feature → ℕ | null | false |
Ordinal.brange_bfamilyOfFamily | Mathlib.SetTheory.Ordinal.Family | ∀ {α : Type u_1} {ι : Type u} (f : ι → α),
(Ordinal.type WellOrderingRel).brange (Ordinal.bfamilyOfFamily f) = Set.range f | null | true |
Matrix.IsAdjMatrix.compl_compl | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq V] [inst_2 : Zero α] [inst_3 : One α]
{A : Matrix V V α}, A.IsAdjMatrix → A.compl.compl = A | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_filterMap._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
GroupFilterBasis.nhds_eq | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} [inst : Group G] (B : GroupFilterBasis G) {x₀ : G}, nhds x₀ = B.N x₀ | null | true |
DirectSum.gMulLHom | Mathlib.Algebra.DirectSum.Algebra | {ι : Type uι} →
(R : Type uR) →
(A : ι → Type uA) →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
[inst_2 : (i : ι) → Module R (A i)] →
[inst_3 : AddMonoid ι] →
[inst_4 : DirectSum.GSemiring A] → [DirectSum.GAlgebra R A] → {i j : ι} → A i →ₗ... | The piecewise multiplication from the `Mul` instance, as a bundled linear map.
This is the graded version of `LinearMap.mul`, and the linear version of `DirectSum.gMulHom` | true |
CategoryTheory.Limits.IsColimit.op._proof_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit t) (s : CategoryTheory.Limits.Cone F.op) (m : s.pt ⟶ t.op.pt),
(∀ (j : Jᵒᵖ), Cate... | null | false |
_private.Init.Data.Option.Lemmas.0.Option.eq_some_of_isSome.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : (x : Option α) → x.isSome = true → Prop) (x : Option α) (x_1 : x.isSome = true),
(∀ (val : α) (x : (some val).isSome = true), motive (some val) x) → motive x x_1 | null | false |
Lean.Meta.Simp.simprocExtensionMapRef | Lean.Meta.Tactic.Simp.Simproc | IO.Ref Lean.Meta.Simp.SimprocExtensionMap | null | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mrenameIError_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
RootPairing.weylGroupToPerm | Mathlib.LinearAlgebra.RootSystem.WeylGroup | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] → [inst_4 : Module R N] → (P : RootPairing ι R M N) → ↥P.weylGroup →* ι ≃ ι | The permutation representation of the Weyl group induced by `reflectionPerm`. | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabHeaders.match_7 | Lean.Elab.MutualDef | (motive : Array Lean.Syntax × Array Lean.Expr → Sort u_1) →
(x : Array Lean.Syntax × Array Lean.Expr) →
((binderIds : Array Lean.Syntax) → (xs : Array Lean.Expr) → motive (binderIds, xs)) → motive x | null | false |
LowerSet.erase._proof_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : LowerSet α) (a : α), IsLowerSet (↑s \ ↑(UpperSet.Ici a)) | null | false |
MeasureTheory.all_ae_of | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {ι : Sort u_4} {p : α → ι → Prop}, (∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i) → ∀ (i : ι), ∀ᵐ (a : α) ∂μ, p a i | null | true |
CategoryTheory.Pretriangulated.productTriangle.π | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
{J : Type u_1} →
(T : J → CategoryTheory.Pretriangulated.Triangle C) →
[inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁] →
[inst_3 : CategoryTheory.Limits.HasProduc... | A projection from the product of a family of triangles. | true |
YoungDiagram.cells_bot | Mathlib.Combinatorics.Young.YoungDiagram | ⊥.cells = ∅ | null | true |
_private.Mathlib.Order.CountableSupClosed.0.countableSupClosure_eq_sInter._simp_1_1 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, (t ⊆ ⋂₀ S) = ∀ t' ∈ S, t ⊆ t' | null | false |
Continuous.fun_mul | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f g : X → M}, Continuous f → Continuous g → Continuous fun i => f i * g i | Eta-expanded form of `Continuous.mul` | true |
List.tfae_singleton._simp_1 | Mathlib.Data.List.TFAE | ∀ (p : Prop), [p].TFAE = True | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get_diff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.coconeLift.match_1 | Mathlib.CategoryTheory.WithTerminal.Cone | {J : Type u_1} →
(motive : CategoryTheory.WithInitial J → Sort u_2) →
(x : CategoryTheory.WithInitial J) →
((a : J) → motive (CategoryTheory.WithInitial.of a)) → (Unit → motive CategoryTheory.WithInitial.star) → motive x | null | false |
CategoryTheory.Subobject.mk_eq_bot_iff_zero | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [inst_3 : CategoryTheory.Mono f],
CategoryTheory.Subobject.mk f = ⊥ ↔ f = 0 | null | true |
LinearMap.mkContinuous_norm_le' | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ₁₂] F) {C : ℝ}
... | If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound or zero if bound is negative. | true |
ComplexShape.TensorSigns.rel_add | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_7} {inst : AddMonoid I} {c : ComplexShape I} [self : c.TensorSigns] (p q r : I),
c.Rel p q → c.Rel (p + r) (q + r) | null | true |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Over.OverMorphism.ext.match_1_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {X : T} {U V : CategoryTheory.Over X} {g : U ⟶ V}
(motive : (f : U ⟶ V) → CategoryTheory.Over.Hom.left f = CategoryTheory.Over.Hom.left g → Prop) (f : U ⟶ V)
(h : CategoryTheory.Over.Hom.left f = CategoryTheory.Over.Hom.left g),
(∀ (left : U.left ⟶ V.... | null | false |
Aesop.NormRuleInfo.noConfusionType | Aesop.Rule | Sort u → Aesop.NormRuleInfo → Aesop.NormRuleInfo → Sort u | null | false |
SummationFilter.LeAtTop.rec | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_2} →
{L : SummationFilter β} →
{motive : L.LeAtTop → Sort u} → ((le_atTop : L.filter ≤ Filter.atTop) → motive ⋯) → (t : L.LeAtTop) → motive t | null | false |
mem_nhds_left | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} [inst : UniformSpace α] (x : α) {s : SetRel α α}, s ∈ uniformity α → {y | (x, y) ∈ s} ∈ nhds x | null | true |
Nat.minSqFac_le_of_dvd | Mathlib.Data.Nat.Squarefree | ∀ {n d : ℕ}, n.minSqFac = some d → ∀ {m : ℕ}, 2 ≤ m → m * m ∣ n → d ≤ m | null | true |
BoundingSieve.one_le_y | Mathlib.NumberTheory.SelbergSieve | ∀ {s : SelbergSieve}, 1 ≤ s.level | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable.recOn | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {b : ByteArray} →
{v : Array ℕ} →
{motive : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝ b v → Sort u} →
(t : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝ b v) →
((size_le : v.size ≤ b.size) →
(eq_prefixFunction :
∀ (i : ℕ) (hi : i < v.size),
... | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.withRestoreOrSaveFull.match_3 | Lean.Elab.Term.TermElabM | (motive : Option (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u_1) →
(tacSnap? : Option (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot)) →
((snap : Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) → motive (some snap)) →
((x : Option (Le... | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.exists_mul_eq_zero_add_eq_one_basicOpen_eq_of_isClopen._simp_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], IsCompl x y = (x = yᶜ) | null | false |
Lean.Lsp.CompletionItemKind.folder.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionItemKind → Sort u} →
(t : Lean.Lsp.CompletionItemKind) → t.ctorIdx = 18 → motive Lean.Lsp.CompletionItemKind.folder → motive t | null | false |
_private.Init.Data.Array.Monadic.0.List.foldlM_filterMap.match_1.eq_2 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : (b : β) → motive (some b)) (h_2 : Unit → motive none),
(match none with
| some b => h_1 b
| none => h_2 ()) =
h_2 () | null | true |
Std.Do.Spec.IterM.foldM_map | Std.Do.Triple.SpecLemmas | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {ps : Std.Do.PostShape} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : Monad m] [inst_3 : Monad n] [LawfulMonad m] [LawfulMonad n]
[inst_6 : Std.Do.WPMonad n ps] [inst_7 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[... | null | true |
CategoryTheory.Comon.mkIso'_hom_hom | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Comon C} (f : M.X ≅ N.X) [inst_2 : CategoryTheory.IsComonHom f.hom],
(CategoryTheory.Comon.mkIso' f).hom.hom = f.hom | null | true |
Std.DTreeMap.Internal.Impl.mem_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)},
k' ∈ (Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl ↔
if compare k k' = Ordering.eq then (f (t.get? k)).isSome = true else ... | null | true |
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.not_isCyclic_units_of_mul_coprime._simp_1_1 | Mathlib.RingTheory.ZMod.UnitsCyclic | ∀ (m n : ℕ), m.totient.Coprime n.totient = ((m = 1 ∨ m = 2) ∨ n = 1 ∨ n = 2) | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Integral.0.MeasureTheory.VectorMeasure.integral.eq_1 | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (μ : MeasureTheory.VectorMeasure X F) (f : X → E) (B :... | null | true |
BoxIntegral.IntegrationParams.toFilteriUnion | Mathlib.Analysis.BoxIntegral.Partition.Filter | {ι : Type u_1} →
[Fintype ι] →
{l : BoxIntegral.IntegrationParams} →
(I : BoxIntegral.Box ι) → BoxIntegral.Prepartition I → Filter (BoxIntegral.TaggedPrepartition I) | A set `s : Set (TaggedPrepartition I)` belongs to `l.toFilteriUnion I π₀` if for any `c : ℝ≥0`
there exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = true`) such that `s`
contains each prepartition `π` such that `l.MemBaseSet I c r π` and `π.iUnion = π₀.iUnion`. | true |
VectorField.mpullback_smul | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | null | true |
FiniteDimensional.instSubtypeMemSubmoduleMap | Mathlib.LinearAlgebra.FiniteDimensional.Defs | ∀ (K : Type u) {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V →ₗ[K] V₂) (p : Submodule K V) [FiniteDimensional K ↥p],
FiniteDimensional K ↥(Submodule.map f p) | Pushforwards of finite-dimensional submodules are finite-dimensional. | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.locallyLinear | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : CommRing α] {s : Finset α} [Fact (IsUnit 2)],
ThreeAPFree ↑s → (SimpleGraph.TripartiteFromTriangles.graph (triangleIndices✝ s)).LocallyLinear | null | true |
AlgebraicGeometry.Scheme.PartialIso.restrictTarget_target | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialIso Y) (U : Y.Opens) (hU : Dense ↑U) (hU' : U ≤ f.target),
(f.restrictTarget U hU hU').target = (f.symm.restrictSource U hU hU').source | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Order.0.CFC.concaveOn_log._proof_1_6 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A],
Convex ℝ {a | IsStrictlyPositive a} | null | false |
Lean.instInhabitedExternAttrData | Lean.Compiler.ExternAttr | Inhabited Lean.ExternAttrData | null | true |
OrderDual.instCoframe._proof_1 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} [inst : Order.Frame α] (a b c : αᵒᵈ), a \ b ≤ c ↔ a ≤ b ⊔ c | null | false |
Rep.FiniteCyclicGroup.chainComplexFunctor._proof_4 | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ (k : Type u_2) {G : Type u_2} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (g : G)
(A : Rep.{u_1, u_2, u_2} k G),
CategoryTheory.CategoryStruct.comp (A.applyAsHom g - CategoryTheory.CategoryStruct.id A) A.norm.asHom = 0 | null | false |
Lean.Elab.Term.Do.ToCodeBlock.Context | Lean.Elab.Do.Legacy | Type | null | true |
Inclusion.Interval.lt_mem | Mathlib.Tactic.Inclusion.Extension.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : DecidableLT α] (f : α ↪o β)
{x y : β} {I J : Inclusion.Interval α}, x ∈ I.map ⇑f → y ∈ J.map ⇑f → x < y ∈ I.lt J | null | true |
Std.IterM.Equiv.congr_simp | Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect | ∀ {m : Type w → Type w'} [inst : Monad m] [inst_1 : LawfulMonad m] {β α₁ α₂ : Type w} [inst_2 : Std.Iterator α₁ m β]
[inst_3 : Std.Iterator α₂ m β] (ita ita_1 : Std.IterM m β),
ita = ita_1 → ∀ (itb itb_1 : Std.IterM m β), itb = itb_1 → ita.Equiv itb = ita_1.Equiv itb_1 | null | true |
_private.Mathlib.Analysis.Convex.Birkhoff.0.exists_eq_sum_perm_of_mem_doublyStochastic._simp_1_1 | Mathlib.Analysis.Convex.Birkhoff | ∀ {ι : Type u_1} {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → AddCommMonoid (M a)] (a : α) (s : Finset ι)
(g : ι → (a : α) → M a), ∑ c ∈ s, g c a = (∑ c ∈ s, g c) a | null | false |
Lean.NameMap.instInhabited | Lean.Data.NameMap.Basic | (α : Type) → Inhabited (Lean.NameMap α) | null | true |
Set.instBooleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (a : Set α), ⊥ ⊆ a | null | false |
_private.Mathlib.Data.Finset.Prod.0.Finset.Nonempty.snd.match_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (motive : (s ×ˢ t).Nonempty → Prop)
(h : (s ×ˢ t).Nonempty), (∀ (xy : α × β) (hxy : xy ∈ s ×ˢ t), motive ⋯) → motive h | null | false |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.add.match_1 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(r s : Q(«$R»)) →
(motive :
(t : Q(«$R»)) →
Mathlib.Tactic.Ring.Common.ExSum Mathlib.Tactic.Ring.RatCoeff sR t → Q(«$r» + «$s» = «$t») → Sort u_1) →
(t : Q(«$R»)) →
(vt : Mathlib.Tactic... | null | false |
Lean.MonadCacheT.instMonadExceptOf | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] →
[inst_2 : Hashable α] → (ε : Type u_1) → [MonadExceptOf ε m] → MonadExceptOf ε (Lean.MonadCacheT α β m) | null | true |
CategoryTheory.ShortComplex.moduleCatMk_X₃_carrier | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] {X₁ X₂ X₃ : Type v} [inst_1 : AddCommGroup X₁] [inst_2 : AddCommGroup X₂]
[inst_3 : AddCommGroup X₃] [inst_4 : Module R X₁] [inst_5 : Module R X₂] [inst_6 : Module R X₃] (f : X₁ →ₗ[R] X₂)
(g : X₂ →ₗ[R] X₃) (hfg : g ∘ₗ f = 0), ↑(CategoryTheory.ShortComplex.moduleCatMk f g hfg).X₃ = X₃ | null | true |
Coalgebra.rTensor_counit_comp_comul | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : AddCommMonoid A} {inst_2 : Module R A}
[self : Coalgebra R A],
LinearMap.rTensor A CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul = (TensorProduct.mk R R A) 1 | The counit satisfies the left counitality law | true |
hasFDerivAt_const | 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] (c : F) (x : E), HasFDerivAt (fun x => c) 0 x | null | true |
_private.Mathlib.FieldTheory.Minpoly.ConjRootClass.0.ConjRootClass.minpoly_inj._simp_1_1 | Mathlib.FieldTheory.Minpoly.ConjRootClass | ∀ {R : Type u_1} {A : Type u_5} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {x y : A},
IsConjRoot R x y = (minpoly R x = minpoly R y) | null | false |
LinearMap.mapMatrixModule._proof_1 | Mathlib.LinearAlgebra.Matrix.Module | ∀ (ι : Type u_1) {R : Type u_4} {M : Type u_3} {N : Type u_2} [inst : Ring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] (f : M →ₗ[R] N) (x : Matrix ι ι R) (x_1 : ι → M),
(f.compLeft ι) (x • x_1) = (RingHom.id (Matr... | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.filter_eq_self_iff._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] {s : Set α} {f : α → M} {a : α},
(s.indicator f a = f a) = (a ∉ s → f a = 0) | null | false |
FundamentalGroupoid.fundamentalGroupoidFunctor | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | CategoryTheory.Functor TopCat CategoryTheory.Grpd | The functor sending a topological space `X` to its fundamental groupoid. | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSimpa?!__1 | Init.Tactics | Lean.Macro | null | false |
neg_sq | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : Monoid R] [inst_1 : HasDistribNeg R] (a : R), (-a) ^ 2 = a ^ 2 | null | true |
Set.mem_coe_of_mem | Mathlib.Data.Set.Functor | ∀ {α : Type u} {β : Set α} {γ : Set ↑β} {a : α} (ha : a ∈ β),
⟨a, ha⟩ ∈ γ →
a ∈ do
let a ← γ
pure ↑a | null | true |
_private.Mathlib.Algebra.Polynomial.Roots.0.Polynomial.Monic.irreducible_iff_degree_lt._simp_1_2 | Mathlib.Algebra.Polynomial.Roots | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Module.Basis.repr_support_subset_of_mem_span | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) (s : Set ι) {m : M}, m ∈ Submodule.span R (⇑b '' s) → ↑(b.repr m).support ⊆ s | null | true |
LinearEquiv.fst_comp_prodComm | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂],
LinearMap.fst R M₂ M ∘ₗ ↑(LinearEquiv.prodComm R M M₂) = LinearMap.snd R M M₂ | null | true |
IsRelPrime.add_mul_left_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime (x + y * z) y | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.attachCodeDecls.go.match_1.eq_3 | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1)
(decl : Lean.Compiler.LCNF.FunDecl pu)
(h_1 : (decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl))
(h_2 :
(decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF.Purit... | null | true |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.pushWildcards._f | Lean.Meta.DiscrTree.Main | (n : ℕ) → Nat.below (motive := fun n => Array Lean.Expr → Array Lean.Expr) n → Array Lean.Expr → Array Lean.Expr | null | false |
Lean.Language.Lean.CommandElaboratingSnapshot.infoTree?._inherited_default | Lean.Language.Lean.Types | Option Lean.Elab.InfoTree | null | false |
ContinuousLinearMap.flip_mul | Mathlib.Analysis.Normed.Operator.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_3} [inst_1 : NonUnitalSeminormedCommRing R]
[inst_2 : NormedSpace 𝕜 R] [inst_3 : IsScalarTower 𝕜 R R] [inst_4 : SMulCommClass 𝕜 R R],
(ContinuousLinearMap.mul 𝕜 R).flip = ContinuousLinearMap.mul 𝕜 R | null | true |
FreeLieAlgebra.liftAux_map_smul | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(t : R) (a : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (t • a) = t • (FreeLieAlgebra.liftAux R f) a | null | true |
Action.functorCategoryEquivalenceCompEvaluation | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
(G : Type u_2) →
[inst_1 : Monoid G] →
(Action.functorCategoryEquivalence V G).functor.comp
((CategoryTheory.evaluation (CategoryTheory.SingleObj G) V).obj PUnit.unit) ≅
Action.forget V G | The forgetful functor is intertwined by `functorCategoryEquivalence` with
evaluation at `PUnit.star`. | true |
Geometry.SimplicialComplex.noConfusion | Mathlib.Analysis.Convex.SimplicialComplex.Basic | {P : Sort u} →
{𝕜 : Type u_1} →
{E : Type u_2} →
{inst : Ring 𝕜} →
{inst_1 : PartialOrder 𝕜} →
{inst_2 : AddCommGroup E} →
{inst_3 : Module 𝕜 E} →
{t : Geometry.SimplicialComplex 𝕜 E} →
{𝕜' : Type u_1} →
{E' : Type u_2} →
... | null | false |
_private.Mathlib.Data.DFinsupp.Order.0.DFinsupp.instOrderBotOfIsBotZeroClass._simp_1 | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → LE (α i)] {f g : Π₀ (i : ι), α i},
(f ≤ g) = ∀ (i : ι), f i ≤ g i | null | false |
homeomorphSphereProd._proof_5 | Mathlib.Analysis.Normed.Module.Ball.RadialEquiv | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] (x : ↑{0}ᶜ), 0 < ‖↑x‖ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.