name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Manifold.IsSubmersion.prodMap | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E' : Type u_2} {E'' : Type u_3} {E''' : Type u_4} {H : Type u_7} {H' : Type u_8} {G : Type u_9}
{G' : Type u_10} {E : Type u} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
[inst_5 : N... | If `f: M → N` and `g: M' → N'` are submersions at `x` and `x'`, respectively,
then `f × g: M × M' → N × N'` is a submersion at `(x, x')`. | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently₂._simp_1_2 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (f '' s ∩ t).Nonempty = (s ∩ f ⁻¹' t).Nonempty | null | false |
ENat.toENNReal_ne_top._simp_1 | Mathlib.Basic.Real.ENatENNReal | ∀ {n : ℕ∞}, (↑n ≠ ⊤) = (n ≠ ⊤) | null | false |
Lean.Meta.Sym.Internal.mkAppS₈ | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} →
[Lean.Meta.Sym.Internal.MonadShareCommon m] →
[Monad m] →
Lean.Expr →
Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → m Lean.Expr | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.SSet.stdSimplex.bijective_image_objEquiv_toOrderHom_univ._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n m : SimplexCategory} {f : n ⟶ m}, CategoryTheory.Mono f = Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.all.eq_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} (s : String.Slice) (pat : ρ) [inst : String.Slice.Pattern.ForwardPattern pat],
s.all pat = (s.skipPrefixWhile pat == s.endPos) | null | true |
Matroid.loopless_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} (M : Matroid α), M.Loopless ↔ M.loops = ∅ | null | true |
_private.Batteries.Recycling.RBTree.Alter.0.RBTree.RBNode.Path.Balanced.del.match_1_11 | Batteries.Recycling.RBTree.Alter | ∀ (motive : RBTree.RBColor.black = RBTree.RBColor.black → RBTree.RBColor.black = RBTree.RBColor.red → Prop)
(a : RBTree.RBColor.black = RBTree.RBColor.black) (a_1 : RBTree.RBColor.black = RBTree.RBColor.red), motive a a_1 | null | false |
FirstOrder.Language.BoundedFormula.sumElim_comp_relabelAux | Mathlib.ModelTheory.Syntax | ∀ {M : Type w} {α : Type u'} {β : Type v'} {n m : ℕ} {g : α → β ⊕ Fin n} {v : β → M} {xs : Fin (n + m) → M},
Sum.elim v xs ∘ FirstOrder.Language.BoundedFormula.relabelAux g m =
Sum.elim (Sum.elim v (xs ∘ Fin.castAdd m) ∘ g) (xs ∘ Fin.natAdd n) | null | true |
_private.Init.System.FilePath.0.System.instHashableFilePath.hash.match_1 | Init.System.FilePath | (motive : System.FilePath → Sort u_1) → (x : System.FilePath) → ((a : String) → motive { toString := a }) → motive x | null | false |
Finset.inf'._proof_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] (s : Finset β),
s.Nonempty → ∀ (f : β → α), s.inf (WithTop.some ∘ f) ≠ ⊤ | null | false |
Filter.div_mem_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s / t ∈ f / g | null | true |
ContinuousLinearMapWOT.delabOfCLM | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | Lean.PrettyPrinter.Delaborator.Delab | This prevents `ofCLM A` being printed as `{ toCLM := x }` by `delabStructureInstance`. | true |
Lean.FuzzyMatching.CharType.separator.elim | Lean.Data.FuzzyMatching | {motive : Lean.FuzzyMatching.CharType → Sort u} →
(t : Lean.FuzzyMatching.CharType) → t.ctorIdx = 2 → motive Lean.FuzzyMatching.CharType.separator → motive t | null | false |
MeasureTheory.pdf.eq_of_map_eq_withDensity' | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω}
{μ : MeasureTheory.Measure E} [MeasureTheory.SigmaFinite μ] {X : Ω → E} [MeasureTheory.HasPDF X ℙ μ]
(f : E → ENNReal),
AEMeasurable f μ → (MeasureTheory.Measure.map X ℙ = μ.withDensity f ↔ MeasureTheo... | null | true |
MonoidAlgebra.liftGroupLikeBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Bialgebra.counitAlgHom R A).comp
((MonoidAlgebra.lift R A (GroupLike R A)) { toFun := fun g => ↑g, map_one' := ⋯, map_mul' := ⋯ }) =
Bialgebra.counitAlgHom R (MonoidAlgebra R (GroupLike R A)) | null | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Option.getD.match_1.splitter | Mathlib.Computability.TuringMachine.ToPartrec | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | null | true |
mabs_div_lt_of_one_le_of_lt | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b n : G},
1 ≤ a → a < n → 1 ≤ b → b < n → |a / b|ₘ < n | `|a / b|ₘ < n` if `1 ≤ a < n` and `1 ≤ b < n`. | true |
lebesgue_number_of_compact_open | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type ua} [inst : UniformSpace α] {K U : Set α},
IsCompact K → IsOpen U → K ⊆ U → ∃ V ∈ uniformity α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U | A useful consequence of the Lebesgue number lemma: given any compact set `K` contained in an
open set `U`, we can find an (open) entourage `V` such that the ball of size `V` about any point of
`K` is contained in `U`. | true |
Submodule.smul_le_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{s t : SetSemiring A} {M N : Submodule R A}, SetSemiring.down s ⊆ SetSemiring.down t → M ≤ N → s • M ≤ t • N | null | true |
MeasureTheory.measureReal_abs_dual_gt_le_integral_charFunDual | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mE : MeasurableSpace E}
[OpensMeasurableSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ] (L : StrongDual ℝ E)
{r : ℝ},
0 < r → μ.real {x | r < |L x|} ≤ 2⁻¹ * r * ‖∫ (t : ℝ) in -2 * r⁻¹..2 * r⁻¹, 1 - MeasureTheo... | For a probability measure on a normed space `E` and `L : Dual ℝ E`, a bound on the measure
of the set `{x | r < |L x|}` in terms of the integral of the characteristic function. | true |
finRotate_last | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ}, (finRotate (n + 1)) (Fin.last n) = 0 | null | true |
Finset.instAddTorsorForall | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} → [inst : Ring k] → {ι : Type u_4} → AddTorsor (ι → k) (ι → k) | null | true |
Std.Sat.AIG.RefVec.IfInput.rec | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Sat.AIG.RefVec.IfInput aig w → Sort u} →
((discr : aig.Ref) → (lhs rhs : aig.RefVec w) → motive { discr := discr, lhs := lhs, rhs := rhs }) →
(t : Std.Sat... | null | false |
InnerProductSpace.canonicalCovariantTensor.congr_simp | Mathlib.Analysis.Distribution.DerivNotation | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E],
InnerProductSpace.canonicalCovariantTensor E = InnerProductSpace.canonicalCovariantTensor E | null | true |
BitVec.not_lt_zero._simp_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (x < 0#w) = False | null | false |
imp_false | Init.Core | ∀ {a : Prop}, a → False ↔ ¬a | null | true |
CategoryTheory.categoryFree._proof_5 | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u_1) [inst : CommRing R] (C : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
{W X Y Z : CategoryTheory.Free R C} (f : (W ⟶ X) →₀ R) (g : (X ⟶ Y) →₀ R) (h : (Y ⟶ Z) →₀ R),
((f.sum fun f' s => g.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t).sum fun f' s =>
h.su... | null | false |
_private.Mathlib.Data.Set.Prod.0.Set.compl_prod_eq_union._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), (s ×ˢ t)ᶜ = sᶜ ×ˢ Set.univ ∪ Set.univ ×ˢ tᶜ | null | false |
upperPolar_empty | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop), upperPolar r ∅ = Set.univ | null | true |
AlgebraicGeometry.Scheme.Modules.conjugateEquiv_pullbackId_hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ (X : AlgebraicGeometry.Scheme),
(CategoryTheory.conjugateEquiv CategoryTheory.Adjunction.id
(AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction (CategoryTheory.CategoryStruct.id X)))
(AlgebraicGeometry.Scheme.Modules.pullbackId X).hom =
(AlgebraicGeometry.Scheme.Modules.pushforwardId X... | null | true |
HomologicalComplex₂.toGradedObjectMap | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} → (K ⟶ L) → (K.toGraded... | The morphism of graded objects induced by a morphism of bicomplexes. | true |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_50 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
Lean.Meta.useEtaStruct | Lean.Meta.Basic | Lean.Name → Lean.MetaM Bool | `useEtaStruct inductName` return `true` if we eta for structures is enabled for
for the inductive datatype `inductName`.
Recall we have three different settings: `.none` (never use it), `.all` (always use it), `.notClasses`
(enabled only for non-recursive structure types that are not classes).
The parameter `inductNa... | true |
CategoryTheory.Endofunctor.Algebra.functorOfNatTransId_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
(X : CategoryTheory.Endofunctor.Algebra F),
(CategoryTheory.Endofunctor.Algebra.functorOfNatTransId.inv.app X).f = CategoryTheory.CategoryStruct.id X.a | null | true |
SkewMonoidAlgebra.coeff_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k),
(SkewMonoidAlgebra.single a b).coeff = fun₀ | a => b | null | true |
Filter.Germ.total | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : LE β] [Std.Total fun x1 x2 => x1 ≤ x2],
Std.Total fun x1 x2 => x1 ≤ x2 | null | true |
EReal.sub_add_cancel_right | Mathlib.Data.EReal.Operations | ∀ {a : EReal} {b : ℝ}, ↑b - (a + ↑b) = -a | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lake.instDecidableEqToolchainVer | Lake.Util.Version | DecidableEq Lake.ToolchainVer | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._proof_1_7 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : Set α} {s : Set (Set α)},
s ⊆ 𝒫 K →
∀ (S : Set (Set (Set α))),
∀ L ∈ s,
L \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ⊆ K \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ∩ L | null | false |
CategoryTheory.AddGrp.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
autoParam
(∀ {X Y : CategoryTheory.AddGrp C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
Alexandrov.principals | Mathlib.Topology.Sheaves.Alexandrov | (X : Type v) →
[inst : TopologicalSpace X] →
[inst_1 : Preorder X] → [Topology.IsUpperSet X] → CategoryTheory.Functor X (TopologicalSpace.Opens X)ᵒᵖ | The functor sending `x : X` to the principal open associated with `x`. | true |
ComplexShape.σ_symm | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₂ c₁ c₁₂]
[inst_2 : TotalComplexShapeSymmetry c₁ c₂ c₁₂] [inst_3 : TotalComplexShapeSymmetry c₂ c₁ c₁₂]
[TotalComplexShapeSymm... | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_3 | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
{a b : Q(«$α»)} →
(motive : Mathlib.Meta.NormNum.Result a → Mathlib.Meta.NormNum.Result b → Sort u_1) →
(ra : Mathlib.Meta.NormNum.Result a) →
(rb : Mathlib.Meta.NormNum.Result b) →
((val : Bool) →
(proof : Lean.Expr) →
... | null | false |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew._sparseCasesOn_3 | Mathlib.Util.WhatsNew | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
RBTree.RBSet.contains | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → RBTree.RBSet α cmp → α → Bool | `O(log n)`. Returns true if the given key `a` is in the RBSet. | true |
NonUnitalSubsemiring.instBot._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a + b ∈ {0} | null | false |
_private.Lean.Compiler.LCNF.DependsOn.0.Lean.Compiler.LCNF.LetDecl.depOn | Lean.Compiler.LCNF.DependsOn | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.M✝ Bool | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.cRk_map_image_lift._simp_1_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
FreeAddSemigroup.rec._@.Mathlib.Algebra.Free.2508704951._hygCtx._hyg.3 | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeAddSemigroup α → Sort u_1} →
((head : α) → (tail : List α) → motive { head := head, tail := tail }) → (t : FreeAddSemigroup α) → motive t | null | false |
Lean.Grind.CommRing.Mon.concat.eq_1 | Init.Grind.Ring.CommSolver | ∀ (m₂ : Lean.Grind.CommRing.Mon), Lean.Grind.CommRing.Mon.unit.concat m₂ = m₂ | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.processParsedHeader._unsafe_rec | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} →
Std.Http.Protocol.H1.Machine dir → ℕ → ℕ → String → String → Std.Http.Protocol.H1.Machine dir | null | false |
EmbeddingLike.casesOn | Mathlib.Basic.FunLike.Embedding | {F : Sort u_1} →
{α : Sort u_2} →
{β : Sort u_3} →
[inst : FunLike F α β] →
{motive : EmbeddingLike F α β → Sort u} →
(t : EmbeddingLike F α β) → ((injective' : ∀ (f : F), Function.Injective ⇑f) → motive ⋯) → motive t | null | false |
Substring.Raw.Valid.validFor | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∃ l m r, Substring.Raw.ValidFor l m r s | null | true |
LinearIsometry.rTensor_apply | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] (f : E →ₗᵢ[𝕜] F) (x : TensorProduct... | null | true |
ArchimedeanClass.stdPart_sub_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x y : K},
0 < ArchimedeanClass.mk y → ArchimedeanClass.stdPart (x - y) = ArchimedeanClass.stdPart x | null | true |
Mathlib.Tactic.RingNF.Config | Mathlib.Tactic.Ring.RingNF | Type | Configuration for `ring_nf`. | true |
_private.Mathlib.Order.Defs.Unbundled.0.of_eq.match_1_1 | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (motive : (x x_1 : α) → x = x_1 → Prop) (x x_1 : α) (x_2 : x = x_1),
(∀ (x : α), motive x x ⋯) → motive x x_1 x_2 | null | false |
AlgebraicGeometry.Scheme.Cover.glueMorphisms._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Cover.ulift 𝒰).fromGlued | null | false |
MonadShareCommon.mk._flat_ctor | Init.ShareCommon | {m : Type u → Type v} → ({α : Type u} → α → m α) → MonadShareCommon m | null | false |
ContinuousMap.norm_eq_iSup_norm | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] (f : C(α, E)), ‖f‖ = ⨆ x, ‖f x‖ | null | true |
LinearMap.smulRightₗ | Mathlib.Algebra.Module.LinearMap.End | {R : Type u_1} →
{M : Type u_4} →
{M₂ : Type u_6} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M] → [inst_4 : Module R M₂] → (M₂ →ₗ[R] R) →ₗ[R] M →ₗ[R] M₂ →ₗ[R] M | The family of linear maps `M₂ → M` parameterised by `f ∈ M₂ → R`, `x ∈ M`, is linear in `f`, `x`.
This is also known as a rank-one operator.
See `ContinuousLinearMap.smulRightL` for the continuous version of this, and see
`InnerProductSpace.rankOne` for the rank-one operator on Hilbert spaces. | true |
StrictMono.wellFoundedLT | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} [WellFoundedLT β],
StrictMono f → WellFoundedLT α | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt64.reduceEq.declare_287._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx.9.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.254 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
_private.Mathlib.Data.Fin.Basic.0.Fin.exists_eq_add_of_lt._simp_1_3 | Mathlib.Data.Fin.Basic | ∀ {n m : ℕ}, (n < m) = (↑n < ↑m) | null | false |
_private.Lean.Compiler.LCNF.ToImpureType.0.Lean.Compiler.LCNF.impureIrrelevantType._sparseCasesOn_5 | Lean.Compiler.LCNF.ToImpureType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Set.mem_smul | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {s : Set α} {t : Set β} {b : β},
b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b | null | true |
Append.mk.noConfusion | Init.Prelude | {α : Type u} →
{P : Sort u_1} →
{append append' : α → α → α} → { append := append } = { append := append' } → (append ≍ append' → P) → P | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsOverOverObjOfRespectsIso._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {W : CategoryTheory.MorphismProperty T} {X : T}
[W.RespectsIso], W.overObj.IsClosedUnderIsomorphisms | null | false |
MeasureTheory.SimpleFunc.integral_smul | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_4} [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : DistribSMul 𝕜 E] [SMulCommClass ℝ 𝕜 E] (c : 𝕜)
{f : MeasureTheory.SimpleFunc α E},
MeasureTheory.Integrable (⇑f) μ →
MeasureTheory.SimpleF... | null | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.go._unsafe_rec | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
Finpartition.map | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{β : Type u_2} →
[inst_2 : Lattice β] → [inst_3 : OrderBot β] → {a : α} → (e : α ≃o β) → Finpartition a → Finpartition (e a) | Transfer a finpartition over an order isomorphism. | true |
_private.Mathlib.Algebra.Homology.ModelCategory.Injective.0.CochainComplex.Plus.modelCategoryQuillen.instHasTwoOutOfThreePropertyWeakEquivalences._proof_1 | Mathlib.Algebra.Homology.ModelCategory.Injective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopicalAlgebra.weakEquivalences (CochainComplex.Plus C)).HasTwoOutOfThreeProperty | null | false |
Graph.not_isLink_of_notMem_edgeSet | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, e ∉ G.edgeSet → ¬G.IsLink e x y | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks.0.CategoryTheory.Limits.PreservesPullback.iso_inv_fst._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.instLawfulSliceSizeTakeListIteratorIdListSliceData._simp_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u} {s : ListSlice α}, Std.ToIterator.iter s = Std.Slice.Internal.iter s | null | false |
Subgroup.isFiniteRelIndex_top_iff._simp_2 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.IsFiniteRelIndex ⊤ = H.FiniteIndex | null | false |
AddMonoidAlgebra.of'_mul_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G] (a : G)
(x : AddMonoidAlgebra k G), (AddMonoidAlgebra.of' k G a * x).divOf a = x | null | true |
CategoryTheory.Sheaf.ΓNatIsoLim | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
[inst_2 : CategoryTheory.HasWeakSheafify J A] →
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Cᵒᵖ A] →
... | Global sections of sheaves are naturally isomorphic to the limits of the underlying presheaves.
Note that while `HasLimitsOfShape Cᵒᵖ A` is needed here to talk about `lim` as a functor, global
sections are still limits without it - see `Sheaf.isLimitConeΓ`. | true |
ISize.add_assoc | Init.Data.SInt.Lemmas | ∀ (a b c : ISize), a + b + c = a + (b + c) | null | true |
PolynomialModule.eval_smul | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) (p • q) = Polynomial.eval r p • (PolynomialModule.eval r) q | null | true |
CategoryTheory.Span.SpanBicat.id_l | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | true |
_private.Std.Sync.Barrier.0.Std.BarrierState.mk._flat_ctor | Std.Sync.Barrier | ℕ → ℕ → Std.BarrierState✝ | null | false |
Std.Time.TimeZone.TZif.instInhabitedTZif | Std.Time.Zoned.Database.TzIf | Inhabited Std.Time.TimeZone.TZif.TZif | null | true |
_private.LeanSearchClient.Syntax.0.LeanSearchClient.checkTactic.match_1 | LeanSearchClient.Syntax | (motive : List Lean.MVarId × Lean.Elab.Term.State → Sort u_1) →
(x : List Lean.MVarId × Lean.Elab.Term.State) →
((goals : List Lean.MVarId) → (snd : Lean.Elab.Term.State) → motive (goals, snd)) → motive x | null | false |
Lean.Compiler.LCNF.isClass? | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.CoreM (Option Lean.Name) | `isClass? type` return `some ClsName` if the LCNF `type` is an instance of the class `ClsName`.
| true |
AlgCat.adj._proof_4 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_1) [inst : CommRing R] (x : Type u_1) (x_1 : AlgCat R)
(f : x ⟶ (CategoryTheory.forget (AlgCat R)).obj x_1),
(fun f => TypeCat.ofHom ((FreeAlgebra.lift R).symm (AlgCat.Hom.hom f)))
((fun f => AlgCat.ofHom ((FreeAlgebra.lift R) ⇑(CategoryTheory.ConcreteCategory.hom f))) f) =
f | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers.0.CategoryTheory.NormalMonoCategory.pullback_of_mono.match_1_3 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : CategoryTheory.Limits.HasKernels C] {X Z : C}
(a : X ⟶ Z) (P : C) (f : Z ⟶ P) (haf : CategoryTheory.CategoryStruct.comp a f = 0) (Q : C) (... | null | false |
PresheafOfModules.Sheafify.SMulCandidate.casesOn | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} →
{R : CategoryTheory.Sheaf J RingCat} →
{α : R₀ ⟶ R.obj} →
{M₀ : PresheafOfModules R₀} →
{A : CategoryTheory.Shea... | null | false |
Vector.insertIdx | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i ≤ n) Vector.insertIdx._auto_1 → Vector α (n + 1) | Insert an element into a vector using a `Nat` index and a tactic provided proof. | true |
MulOpposite.op_ne_zero_iff | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Zero α] (a : α), MulOpposite.op a ≠ 0 ↔ a ≠ 0 | null | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvLetValue._sparseCasesOn_15 | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.unbox fvarId h)) →
(Nat.hasNotBit 16384 t.ctorIdx → mot... | null | false |
Class._aux_Mathlib_SetTheory_ZFC_Class___unexpand_Class_sUnion_1 | Mathlib.SetTheory.ZFC.Class | Lean.PrettyPrinter.Unexpander | null | false |
BesselPotentialSpace.instModuleComplex._proof_9 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : NormedSpace ℂ F] {p : ENNReal}, IsScalarTower ℂ ℂ ↥(MeasureTheory.Lp F p MeasureTheory.volume... | null | false |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (motive : (n : ℕ) → Composition n → Sort u_1) (blocks : List ℕ) (blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i)
(h_1 :
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
motive blocks.sum { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ }),
(match blocks.sum, { blocks :... | null | true |
ProbabilityTheory.exponentialPDF_of_nonneg | Mathlib.Probability.Distributions.Exponential | ∀ {r x : ℝ}, 0 ≤ x → ProbabilityTheory.exponentialPDF r x = ENNReal.ofReal (r * Real.exp (-(r * x))) | null | true |
IccRightChart_symm_apply_of_le._proof_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ {x y : ℝ} {z : EuclideanHalfSpace 1}, (↑z).ofLp 0 ≤ y - x → y - (↑z).ofLp 0 ∈ Set.Icc x y | null | false |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_snd | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β},
(Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?! t k v).2 = Std.DTreeMap.Internal.Impl.insertIfNew! k v t | null | true |
HasFPowerSeriesAt.hasFDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {f : E → F} {x : E},
HasFPowerSeriesAt f p x → HasFDerivAt f ((continuousMult... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.