name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.computePrioritizedCompletionPartitions.match_13 | Lean.Server.Completion.CompletionInfoSelection | (motive : (Bool × Option String.Pos.Raw) × Array (Lean.Server.Completion.ContextualizedCompletionInfo × ℕ) → Sort u_1) →
(x : (Bool × Option String.Pos.Raw) × Array (Lean.Server.Completion.ContextualizedCompletionInfo × ℕ)) →
((isId₂ : Bool) →
(size₂? : Option String.Pos.Raw) →
(snd : Array (Lea... | null | false |
Mathlib.Tactic.ClickSuggestions.GrwLemma.name | Mathlib.Tactic.ClickSuggestions.GRewrite | Mathlib.Tactic.ClickSuggestions.GrwLemma → Mathlib.Tactic.ClickSuggestions.Premise | The lemma | true |
AlternatingMap.smulRight._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_2} {M₁ : Type u_4} {M₂ : Type u_1} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) (v : ι → M₁)
(i j : ι), v i = v j → i ≠ j → ((↑f).smulRight z).toFun v = 0 | null | false |
_private.Lean.Compiler.LCNF.SimpCase.0.Lean.Compiler.LCNF.simplifyCases._proof_2 | Lean.Compiler.LCNF.SimpCase | ∀ (alts : Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure)), alts.size = 1 → 0 < alts.size | null | false |
Mathlib.Tactic.ClickSuggestions.SectionKind.rec | Mathlib.Tactic.ClickSuggestions.SectionState | {motive : Mathlib.Tactic.ClickSuggestions.SectionKind → Sort u} →
motive Mathlib.Tactic.ClickSuggestions.SectionKind.hyp →
motive Mathlib.Tactic.ClickSuggestions.SectionKind.currFile →
motive Mathlib.Tactic.ClickSuggestions.SectionKind.imported →
(t : Mathlib.Tactic.ClickSuggestions.SectionKind) → m... | null | false |
Lean.Server.CodeActionResolveData.mk | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeActionParams → Lean.Name → ℕ → Lean.Server.CodeActionResolveData | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.applyPartition.go.match_1.splitter | Std.Data.DTreeMap.Internal.Model | (motive : Ordering → Sort u_1) →
(x : Ordering) →
(x = Ordering.lt → motive Ordering.lt) →
(x = Ordering.eq → motive Ordering.eq) → (x = Ordering.gt → motive Ordering.gt) → motive x | null | true |
Lean.Parser.ParserAttributeHook.casesOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
(t : Lean.Parser.ParserAttributeHook) →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) → motive t | null | false |
CategoryTheory.Adjunction.Triple.whiskerRight_rightToLeft | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H) [inst_2 : G.Full] [inst_3 : G.Faithful],
Cat... | For an adjoint triple `F ⊣ G ⊣ H` where `G` is fully faithful, whiskering the natural
transformation `H ⟶ F` with `G` yields the composition of the counit of the second adjunction with
the unit of the first adjunction. | true |
NormedAddCommGroup.ofAddDist' | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} →
[inst : Norm E] →
[inst_1 : AddCommGroup E] →
[inst_2 : MetricSpace E] →
(∀ (x : E), ‖x‖ = dist 0 x) → (∀ (x y z : E), dist (z + x) (z + y) ≤ dist x y) → NormedAddCommGroup E | Construct a normed group from a translation-invariant pseudodistance. | true |
AddAut.instAddGroup._proof_1 | Mathlib.Algebra.Group.End | ∀ (M : Type u_1) [inst : Add M] (x : AddAut M), 0 • x = 0 | null | false |
PiLp.continuousLinearEquiv._proof_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) (𝕜 : Type u_3) {ι : Type u_1} (β : ι → Type u_2) [inst : Semiring 𝕜]
[inst_1 : (i : ι) → AddCommGroup (β i)] [inst_2 : (i : ι) → Module 𝕜 (β i)]
[inst_3 : (i : ι) → TopologicalSpace (β i)], Continuous (↑(WithLp.linearEquiv p 𝕜 ((i : ι) → β i))).toFun | null | false |
_private.Batteries.Tactic.PrintDependents.0.Batteries.Tactic.CollectDependents.collect.match_1 | Batteries.Tactic.PrintDependents | (motive : Option Bool → Sort u_1) →
(x : Option Bool) → ((b : Bool) → motive (some b)) → ((x : Option Bool) → motive x) → motive x | null | false |
CategoryTheory.Equivalence.instMonoidalInverseTrans | 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] →
{E : Type u₃} →
[inst_4 : CategoryTheory.Cat... | null | true |
dist_le_of_le_geometric_two_of_tendsto₀ | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {C : ℝ} {f : ℕ → α},
(∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C / 2 / 2 ^ n) →
∀ {a : α}, Filter.Tendsto f Filter.atTop (nhds a) → dist (f 0) a ≤ C | If `dist (f n) (f (n+1))` is bounded by `(C / 2) / 2^n`, then the distance from
`f 0` to the limit of `f` is bounded above by `C`. | true |
Ideal.quotientKerAlgEquivOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R₁ : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A]
[inst_3 : Semiring B] [inst_4 : Algebra R₁ B] {f : A →ₐ[R₁] B} (hf : Function.Surjective ⇑f),
Function.RightInverse (Classical.choose ⋯) ⇑f | null | false |
Real.Angle.sin_coe | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (x : ℝ), (↑x).sin = Real.sin x | null | true |
CategoryTheory.tensorRightHomEquiv._proof_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y Y' Z : C) [inst_2 : CategoryTheory.ExactPairing Y Y']
(f : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
(fun f =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategor... | null | false |
Differentiable.fun_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {𝔸 : Type u_4} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a b : E → 𝔸},
Differentiable 𝕜 a → Differentiable 𝕜 b → Differentiable 𝕜 fun i => a i * b i | Eta-expanded form of `Differentiable.mul` | true |
TypeVec.dropFun_from_append1_drop_last | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)}, TypeVec.dropFun TypeVec.fromAppend1DropLast = TypeVec.id | null | true |
Lean.Elab.Term.getMatchAlt | Lean.Elab.Match | (k : Lean.SyntaxNodeKinds) → Lean.Syntax → Option (Lean.Elab.Term.MatchAltView k) | Given the `stx` of a single match alternative, return a corresponding `TermMatchAltView`. | true |
Ring.instDirectLimit._aux_6 | Mathlib.Algebra.Colimit.Ring | {ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → CommRing (G i)] →
(f : (i j : ι) → i ≤ j → G i → G j) → ℕ → Ring.DirectLimit G f → Ring.DirectLimit G f | null | false |
SMulWithZero.casesOn | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
[inst : Zero M₀] →
[inst_1 : Zero A] →
{motive : SMulWithZero M₀ A → Sort u} →
(t : SMulWithZero M₀ A) →
([toSMulZeroClass : SMulZeroClass M₀ A] →
(zero_smul : ∀ (m : A), 0 • m = 0) →
motive { toSMulZeroClass ... | null | false |
Std.TreeSet.Raw.min?_eq_some_iff_mem_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
t.WF → ∀ {km : α}, t.min? = some km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
Summable.abs | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : UniformSpace α] [IsUniformAddGroup α] [CompleteSpace α] {f : ι → α}, Summable f → Summable fun x => |f x| | **Alias** of the reverse direction of `summable_abs_iff`. | true |
Lean.Meta.Grind.EvalTactic | Lean.Meta.Tactic.Grind.Types | Type | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_emod.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : ℤ → Prop) (a : ℤ), (∀ (a : ℕ), motive (Int.ofNat a)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive a | null | false |
CategoryTheory.PreGaloisCategory.GaloisCategory.getFiberFunctor | Mathlib.CategoryTheory.Galois.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{u₂, u₁} C] → [CategoryTheory.GaloisCategory C] → CategoryTheory.Functor C FintypeCat | **Alias** of `CategoryTheory.GaloisCategory.getFiberFunctor`.
---
Arbitrarily choose a fiber functor for a Galois category using choice. | true |
Set.prod_insert | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β}, s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t | null | true |
Perfect | Mathlib.Topology.Perfect | {α : Type u_1} → [TopologicalSpace α] → Set α → Prop | A set `C` is called perfect if it is closed and all of its
points are accumulation points of itself.
Note that we do not require `C` to be nonempty. | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_cons_cons._simp_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a * a ^ n = a ^ (n + 1) | null | false |
groupHomology.chainsMap_f_single | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (n : ℕ) (x : Fin n → G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom ((groupHomology.chainsMap f φ).f n)) fun₀ | x => a) =
fun₀ | ⇑f ∘ x => (Rep.Hom.... | null | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic___macroRules__private_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic_0_MeasureTheory_term_→ₛ__1» | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | Lean.Macro | null | false |
Finset.image_comm | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {s : Finset α} {β' : Type u_4}
[inst_1 : DecidableEq β'] [inst_2 : DecidableEq γ] {f : β → γ} {g : α → β} {f' : α → β'} {g' : β' → γ},
(∀ (a : α), f (g a) = g' (f' a)) → Finset.image f (Finset.image g s) = Finset.image g' (Finset.image f' s) | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_le_size | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w),
aig.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.decls.size | null | true |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._proof_68 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (q : ℚ≥0) (a : AdjoinPthRoots k), instFieldAdjoinPthRoots._aux_66✝ k q a = ↑q * a)
DivisionRing.nnqsmul_def._autoParam | null | false |
CategoryTheory.Limits.CategoricalPullback.fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} → Cate... | the first component element | true |
_private.Mathlib.Analysis.Distribution.TemperateGrowth.0.Function.HasTemperateGrowth.sub._proof_1_1 | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup F] {f g : E → F}, f - g = f + -g | null | false |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.inf_neBot_iff_frequently_left._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Projectivization.Independent.mk | Mathlib.LinearAlgebra.Projectivization.Independence | ∀ {ι : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(f : ι → V) (hf : ∀ (i : ι), f i ≠ 0),
LinearIndependent K f → Projectivization.Independent fun i => Projectivization.mk K (f i) ⋯ | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_259 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
FloorRing.gc_ceil_coe | Mathlib.Algebra.Order.Floor.Defs | ∀ {α : Type u_3} {inst : Ring α} {inst_1 : LinearOrder α} [self : FloorRing α], GaloisConnection FloorRing.ceil Int.cast | `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. | true |
inner_self_eq_one_of_norm_eq_one | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x : E}, ‖x‖ = 1 → inner 𝕜 x x = 1 | null | true |
Lean.Grind.CommRing.Expr.sub.sizeOf_spec | Init.Grind.Ring.CommSolver | ∀ (a b : Lean.Grind.CommRing.Expr), sizeOf (a.sub b) = 1 + sizeOf a + sizeOf b | null | true |
TopPair.HomologyPretheory.comp_homₚ | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {X Y Z : TopPair.HomologyPretheory C c} (f : X.Hom Y) (g : Y.Hom Z) (x : ι),
(CategoryTheory.CategoryStruct.comp f g).homₚ x = CategoryTheory.CategoryStruct.comp (f.... | null | true |
OreLocalization.instAddGroupOreLocalization._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddGroup X] [inst_3 : DistribMulAction R X] (a : OreLocalization S X), 0 • a = 0 | null | false |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_8 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c) | null | false |
NumberField.InfinitePlace.IsUnramified.liesOver_isReal_over | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(w : NumberField.InfinitePlace L) (v : NumberField.InfinitePlace K) [w.LiesOver v],
NumberField.InfinitePlace.IsUnramified K w → v.IsReal → w.IsReal | null | true |
Lean.JsonNumber.instNeg | Lean.Data.Json.Basic | Neg Lean.JsonNumber | null | true |
Finsupp.span_image_eq_map_linearCombination | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : α → M} (s : Set α),
Submodule.span R (v '' s) = Submodule.map (Finsupp.linearCombination R v) (Finsupp.supported R R s) | null | true |
ByteArray.toUInt64BE! | Init.Data.ByteArray.Extra | ByteArray → UInt64 | Interprets a `ByteArray` of size 8 as a big-endian `UInt64`.
Panics if the array's size is not 8.
| true |
CategoryTheory.Kleisli.Adjunction.adj._proof_3 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X Y : C}
{Z : CategoryTheory.Kleisli T} (f : X ⟶ Y) (g : Y ⟶ (CategoryTheory.Kleisli.Adjunction.fromKleisli T).obj Z),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }.symm
(Ca... | null | false |
ProbabilityTheory.HasGaussianLaw.memLp | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] [CompleteSpace E]
[SecondCountableTopology E], ProbabilityTheory.HasGaussianLaw X P → ∀ {p : ENNReal}, p ≠ ⊤ → Measu... | A Gaussian random variable has moments of all orders. | true |
Mathlib.Tactic.ITauto.Proof.orInR | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof | `(p: B) ⊢ A ∨ B` | true |
CategoryTheory.SimplicialObject.Splitting.fromNondegComplex_toNondegComplex_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] {Z : ChainComplex C ℕ} (h : s.nondegComplex ⟶ Z),
CategoryTheory.CategoryStruct.comp s.fromNondegComplex (CategoryTheory.CategoryStruct.comp s.toNondegComp... | null | true |
_private.Mathlib.RingTheory.AdicCompletion.Completeness.0.AdicCompletion.ofValEqZero._proof_7 | Mathlib.RingTheory.AdicCompletion.Completeness | ∀ {n : ℕ} (i : ℕ), i + n = i + n | null | false |
Set.finite_iff_bddAbove | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} {s : Set α} [inst : SemilatticeSup α] [LocallyFiniteOrder α] [OrderBot α], s.Finite ↔ BddAbove s | null | true |
Representation.Equiv.trans_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A G W... | null | true |
banach_steinhaus_iSup_nnnorm | Mathlib.Analysis.Normed.Operator.BanachSteinhaus | ∀ {E : Type u_1} {F : Type u_2} {𝕜 : Type u_3} {𝕜₂ : Type u_4} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ... | This version of Banach-Steinhaus is stated in terms of suprema of `↑‖·‖₊ : ℝ≥0∞`
for convenience. | true |
RootPairing.EmbeddedG2.threeShortAddLongRoot | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | {ι : 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.EmbeddedG2] → M | The short root `3α + β`. | true |
CategoryTheory.Presheaf.instPreservesFiniteProductsOppositeObjFunctorIsSheafCoherentTopology | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] [inst_2 : CategoryTheory.Preregular C]
[inst_3 : CategoryTheory.FinitaryExtensive C] (F : CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A),
CategoryTheory.Limits.PreservesFinitePro... | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.String.0.String.Slice.revAll_slice_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.BackwardPattern pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s : String.Slice},
(s.revAll pat = true) = String.Slice.Pattern.Model.IsLongestRevMatchAtChain pat s.startPos s.endPos | null | false |
CategoryTheory.Limits.PullbackCone.unopOpIso | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y Z : Cᵒᵖ} → {f : X ⟶ Z} → {g : Y ⟶ Z} → (c : CategoryTheory.Limits.PullbackCone f g) → c.unop.op ≅ c | If `c` is a pullback cone in `Cᵒᵖ`, then `c.unop.op` is isomorphic to `c`. | true |
BoundedContinuousFunction.toContinuousMapₐ._proof_4 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedRing γ]
(x x_1 : BoundedContinuousFunction α γ), ↑(x * x_1) = ↑(x * x_1) | null | false |
instUniqueEmbOfIsPurelyInseparable._proof_1 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (E : Type u_1) [inst : Field E], IsReduced (AlgebraicClosure E) | null | false |
HomologicalComplex.cylinder.homotopy₀₁._proof_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} (K : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasCylinder],
Homological... | null | false |
Lean.Elab.ContextInfo.mk.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (toCommandContextInfo : Lean.Elab.CommandContextInfo) (parentDecl? : Option Lean.Name)
(autoImplicits : Array Lean.Expr),
sizeOf { toCommandContextInfo := toCommandContextInfo, parentDecl? := parentDecl?, autoImplicits := autoImplicits } =
1 + sizeOf toCommandContextInfo + sizeOf parentDecl? + sizeOf autoImpl... | null | true |
CategoryTheory.GrothendieckTopology.Point.skyscraperPresheafHomEquiv | Mathlib.CategoryTheory.Sites.Point.Skyscraper | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(Φ : J.Point) →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[inst_2 : CategoryTheory.Limits.HasProducts A] →
{P : CategoryTheory.Functor Cᵒ... | If `Φ` is a point of a site `(C, J)`, `P : Cᵒᵖ ⥤ A` and `M : A`, this is
the bijection `(Φ.presheafFiber.obj P ⟶ M) ≃ (P ⟶ Φ.skyscraperPresheaf M)`
that is part of the adjunction `skyscraperPresheafAdjunction`. | true |
sup_inf_left | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : DistribLattice α] (a b c : α), a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c) | null | true |
_private.Mathlib.Data.Subtype.0.Subtype.coe_eq_iff._proof_1_1 | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α}, ↑a = b → p b | null | false |
_private.Batteries.Data.List.Interleave.0.List.interleave_ofFn_ofFn_odd._proof_1_6 | Batteries.Data.List.Interleave | ∀ (n : ℕ) (i : Fin (2 * n)), ¬(↑i + 3) % 2 = 0 → (↑i + 3) / 2 < n + 1 | null | false |
OrderMonoidHom.casesOn | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : MulOneClass α] →
[inst_3 : MulOneClass β] →
{motive : (α →*o β) → Sort u} →
(t : α →*o β) →
((toMonoidHom : α →* β) →
(monotone' : Monoton... | null | false |
CategoryTheory.RetractArrow.unop | Mathlib.CategoryTheory.Retract | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z W : Cᵒᵖ} →
{f : X ⟶ Y} → {g : Z ⟶ W} → CategoryTheory.RetractArrow f g → CategoryTheory.RetractArrow f.unop g.unop | If a morphism `f` in the opposite category is a retract of `g`,
then `f.unop` is a retract of `g.unop`. | true |
Mathlib.Command.MinImports.isInitImport | Mathlib.Tactic.MinImports | Lean.Name → Bool | Returns `true` if `n` is `Init` or a descendant of `Init`. These imports are always available
in ordinary Mathlib files, so they are omitted from user-facing `#min_imports` output. | true |
Lean.Expr.CollectLooseBVars.State.bvars._default | Lean.Util.CollectLooseBVars | Std.HashSet ℕ | null | false |
Lean.Compiler.LCNF.Ownedness.borrow.sizeOf_spec | Lean.Compiler.LCNF.PropagateBorrow | sizeOf Lean.Compiler.LCNF.Ownedness.borrow = 1 | null | true |
Array.insertIdx_comm._proof_5 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} (b : α) {i j : ℕ} {xs : Array α}, i ≤ j → ∀ (x : j ≤ xs.size), i ≤ (xs.insertIdx j b x).size | null | false |
HomotopicalAlgebra.ModelCategory.instIsWeakFactorizationSystemTrivialCofibrationsFibrations | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C) | null | true |
Aesop.instInhabitedSubstitution | Aesop.Forward.Substitution | Inhabited Aesop.Substitution | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceTo_next._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos},
(String.Slice.Pos.ofSliceTo p ≤ q) = ∀ (h : q ≤ p₀), p ≤ p₀.sliceTo q h | null | false |
_private.Mathlib.RingTheory.SimpleRing.Field.0.IsSimpleRing.isField_center._simp_1_4 | Mathlib.RingTheory.SimpleRing.Field | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
CategoryTheory.Endofunctor.Coalgebra.Hom.comp._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
{V₀ V₁ V₂ : CategoryTheory.Endofunctor.Coalgebra F} (f : V₀.Hom V₁) (g : V₁.Hom V₂),
CategoryTheory.CategoryStruct.comp V₀.str (F.map (CategoryTheory.CategoryStruct.comp f.f g.f)) =
CategoryTheory.CategoryStruct.comp... | null | false |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_1 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (x q : R) (motive : x ∣ q → Prop) (x_1 : x ∣ q),
(∀ (r : R) (hr : q = x * r), motive ⋯) → motive x_1 | null | false |
LieAlgebra.Prod.instLieAlgebra | Mathlib.Algebra.Lie.Prod | {R : Type u_1} →
{L₁ : Type u_2} →
{L₂ : Type u_3} →
[inst : CommRing R] →
[inst_1 : LieRing L₁] → [LieAlgebra R L₁] → [inst_3 : LieRing L₂] → [LieAlgebra R L₂] → LieAlgebra R (L₁ × L₂) | null | true |
LinearEquiv.isPrincipal_iff | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] (e : M ≃ₗ[R] M₂), Module.IsPrincipal R M ↔ Module.IsPrincipal R M₂ | null | true |
HomotopicalAlgebra.PrepathObject.ι_p₁_assoc | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (self : HomotopicalAlgebra.PrepathObject A) {Z : C}
(h : A ⟶ Z), CategoryTheory.CategoryStruct.comp self.ι (CategoryTheory.CategoryStruct.comp self.p₁ h) = h | null | true |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.Scheme.Opens.instIsOpenImmersionι._proof_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens), AlgebraicGeometry.IsOpenImmersion U.ι | null | false |
Algebra.Generators.cotangentCompLocalizationAwayEquiv_symm_comp_inl | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ι)
{x : ((Algebra... | null | true |
_private.Mathlib.Algebra.Star.Unitary.0.Prod.mem_unitary_iff._simp_1_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
DirichletCharacter.unit_norm_eq_one | Mathlib.NumberTheory.DirichletCharacter.Bounds | ∀ {F : Type u_1} [inst : NormedField F] {n : ℕ} (χ : DirichletCharacter F n) (a : (ZMod n)ˣ), ‖χ ↑a‖ = 1 | The value at a unit of a Dirichlet character with target a normed field has norm `1`. | true |
IsAlgClosed.roots_eq_zero_iff | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, p.roots = 0 ↔ p = Polynomial.C (p.coeff 0) | null | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.product_image_snd._simp_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
Lean.Meta.Ext.ExtTheorems.erased | Lean.Meta.Tactic.Ext | Lean.Meta.Ext.ExtTheorems → Lean.PHashSet Lean.Name | Erased `ext`s via `attribute [-ext]`. | true |
ContinuousAlternatingMap.mdifferentiableOn | Mathlib.Geometry.Manifold.MFDeriv.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_8} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {ι : Type u_18}
[inst_5 : Fintype ι] (L : E [⋀^ι]→L[𝕜] F) {s : Set (ι → E)}, MDiff[s] ⇑L | null | true |
Ideal.radical_minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {I : Ideal R}, I.radical.minimalPrimes = I.minimalPrimes | null | true |
AddSubgroup.quotientEquivProdOfLE | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [inst : AddGroup α] → {s t : AddSubgroup α} → s ≤ t → α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t | If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
constructive version is `quotientEquivProdOfLE'`. | true |
Set.Subsingleton.isDiscrete | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s.Subsingleton → IsDiscrete s | null | true |
_private.Mathlib.Topology.Order.IntermediateValue.0.isTotallyDisconnected_iff_lt._simp_1_2 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsPreconnected s = s.OrdConnected | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular.0.Matrix.IsTotallyUnimodular.fromRows_unitlike._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, (∃ y, x = Sum.inr y) = (x.isRight = true) | null | false |
Mathlib.Tactic.Widget.StringDiagram.Node.rec | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.id a)) →
(t : Mathlib.Tactic.W... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.