name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniformConvergenceCLM.instAddCommGroup._proof_8 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | null | false |
Lean.Meta.ZetaUnusedMode.ctorElim | Lean.Meta.HaveTelescope | {motive : Lean.Meta.ZetaUnusedMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.ZetaUnusedMode) → ctorIdx = t.ctorIdx → Lean.Meta.ZetaUnusedMode.ctorElimType ctorIdx → motive t | null | false |
Mathlib.Tactic.Echelon.Carrier.ctorElimType | Mathlib.Tactic.Echelon.Core | {motive : Mathlib.Tactic.Echelon.Carrier → Sort u} → ℕ → Sort (max 1 u) | null | false |
Mathlib.Tactic.DepRewrite.Conv.depRw | Mathlib.Tactic.DepRewrite | Lean.ParserDescr | `rw!` is like `rewrite!`, but also cleans up introduced refl-casts after every substitution.
It is available as an ordinary tactic and a `conv` tactic.
| true |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.Fin.isAddFreimanIso_Iio._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
MulArchimedeanOrder.le_def | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : Group M] [inst_1 : Lattice M] {a b : MulArchimedeanOrder M},
a ≤ b ↔ ∃ n, |MulArchimedeanOrder.val b|ₘ ≤ |MulArchimedeanOrder.val a|ₘ ^ n | null | true |
ContinuousLinearMap.reApplyInnerSelf_continuous | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E), Continuous T.reApplyInnerSelf | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.primeCounting_eq_theta_div_log_add_integral._simp_1_7 | Mathlib.NumberTheory.Chebyshev | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
CategoryTheory.WithInitial.of.injEq | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} (a a_1 : C), (CategoryTheory.WithInitial.of a = CategoryTheory.WithInitial.of a_1) = (a = a_1) | null | true |
conditionallyCompleteLatticeOfLatticeOfsSup | Mathlib.Order.ConditionallyCompleteLattice.Defs | (α : Type u_2) →
[H1 : Lattice α] →
[inst : SupSet α] → (∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) → ConditionallyCompleteLattice α | A version of `conditionallyCompleteLatticeOfsSup` when we already know that `α` is a lattice.
This should only be used when it is both hard and unnecessary to provide `sInf` explicitly. | true |
Lean.Linter.UnusedVariables.References.casesOn | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.References → Sort u} →
(t : Lean.Linter.UnusedVariables.References) →
((constDecls : Std.HashSet Lean.Syntax.Range) →
(fvarDefs : Std.HashMap Lean.Syntax.Range Lean.Linter.UnusedVariables.FVarDefinition) →
(fvarUses : Std.HashSet Lean.FVarId) →
(... | null | false |
CategoryTheory.PreZeroHypercover.Hom.mk.injEq | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} (s₀ : E.I₀ → F.I₀) (h₀ : (i : E.I₀) → E.X i ⟶ F.X (s₀ i))
(w₀ :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀ i) (F.f (s₀ i)) = E.f i)
Catego... | null | true |
Equiv.Set.sumDiffSubset_apply_inl | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} (h : s ⊆ t) [inst : DecidablePred fun x => x ∈ s] (x : ↑s),
(Equiv.Set.sumDiffSubset h) (Sum.inl x) = Set.inclusion h x | null | true |
_private.Mathlib.Algebra.Regular.Defs.0.isRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Mul R] {c : R} (motive : IsLeftRegular c ∧ IsRightRegular c → Prop)
(x : IsLeftRegular c ∧ IsRightRegular c), (∀ (h1 : IsLeftRegular c) (h2 : IsRightRegular c), motive ⋯) → motive x | null | false |
Option.forIn'_join._proof_1 | Init.Data.Option.Monadic | ∀ {α : Type u_1} (o : Option (Option α)), ∀ o' ∈ o, ∀ a ∈ o', a ∈ o.join | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkDefEq.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (rhsExpr : Lean.Expr) → motive (fst, fst_1, rhsExpr)) →
motive x | null | false |
DiscrTreeExt.State.mk.noConfusion | Mathlib.Tactic.Inclusion.Core.DiscrTreeExt | {α : Type} →
{P : Sort u} → {tree tree' : Lean.Meta.DiscrTree α} → { tree := tree } = { tree := tree' } → (tree ≍ tree' → P) → P | null | false |
_private.Lean.OriginalConstKind.0.Lean.wasOriginallyTheorem.match_1 | Lean.OriginalConstKind | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) → (Unit → motive Lean.ConstantKind.thm) → ((x : Lean.ConstantKind) → motive x) → motive x | null | false |
CategoryTheory.ShortComplex.rightHomologyIso_hom_comp_homologyι_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] {Z : C} (h : S.opcycles ⟶ Z),
CategoryTheory.CategoryStruct.comp S.rightHomologyIso.hom (CategoryTheory.CategoryStruct.comp S.homologyι h) =
C... | null | true |
MeasurableEquiv.curry_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (ι : Type u_6) (κ : Type u_7) (X : Type u_8) [inst : MeasurableSpace X] (a : ι × κ → X) (a_1 : ι) (a_2 : κ),
(MeasurableEquiv.curry ι κ X) a a_1 a_2 = a (a_1, a_2) | null | true |
Prod.instCompleteAtomicBooleanAlgebra._proof_9 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x : α × β), x ⊓ xᶜ ≤ ⊥ | null | false |
Std.ExtDHashMap.getKey?_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (m.modify k f).getKey? k' = if (k == k') = true then if k ∈ m then some k else none else m.getKey? k' | null | true |
Lean.Lsp.LeanIdentifier.mk._flat_ctor | Lean.Data.Lsp.Internal | Lean.Name → Lean.Name → Bool → Lean.Lsp.LeanIdentifier | null | false |
ZMod.ringEquivCongr._proof_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ) (h : m + 1 = n + 1) (a b : ZMod (m + 1)),
(finCongr h).toFun (a * b) = (finCongr h).toFun a * (finCongr h).toFun b | null | false |
ImportGraph.Widget.goToModule | ImportGraph.Widget.GoToModule | Lean.Name →
optParam Lean.Lsp.Position { line := 0, character := 0 } → optParam (Option String) none → Lean.CoreM Lean.MessageData | Creates a clickable link which takes the user to the provided module.
By default, takes the user to the top of the module. Providing `pos` will bring the user to that
position in the file.
By default, the module name is used as the link's text. The text can be overridden by providing
`overrideText`.
| true |
isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | (R : Type u_2) →
(M : Type u) → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Set (Submodule R M) | The set of all (nontrivial) isotypic components of a module. | true |
Bundle.Trivialization.liftCM.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (T : Bundle.Trivialization F proj),
T.liftCM = { toFun := fun ex => ⟨T.lift ↑ex.1 ↑ex.2, ⋯⟩, continuous_toFun := ⋯ } | null | true |
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsState.numClauses._default | Std.Sat.CNF.Dimacs | ℕ | null | false |
System.Uri.UriEscape.letterF | Init.System.Uri | UInt8 | null | true |
Lean.Meta.LazyDiscrTree.instInhabitedKey | Lean.Meta.LazyDiscrTree | Inhabited Lean.Meta.LazyDiscrTree.Key | null | true |
_private.Mathlib.Tactic.Simps.Basic.0.NameStruct.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {parent : Lean.Name} {components : List String} {parent_1 : Lean.Name} {components_1 : List String},
{ parent := parent, components := components } = { parent := parent_1, components := components_1 } →
parent = parent_1 ∧ components = components_1 | null | true |
_private.Std.Time.Zoned.Database.TZdb.0.Std.Time.Database.TZdb.localRules.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(x : Option String) → ((id : String) → motive (some id)) → ((x : Option String) → motive x) → motive x | null | false |
Dioph.diophFn_vec_comp1 | Mathlib.NumberTheory.Dioph | ∀ {n : ℕ} {S : Set (Vector3 ℕ n.succ)},
Dioph S → ∀ {f : Vector3 ℕ n → ℕ}, Dioph.DiophFn f → Dioph {v | Vector3.cons (f v) v ∈ S} | null | true |
EuclideanGeometry.Sphere.self_mem_orthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P) (p : P), p ∈ s.orthRadius p | null | true |
RingHom.map_adjugate | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_1} {S : Type u_2} [inst_2 : CommRing R]
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), f.mapMatrix M.adjugate = (f.mapMatrix M).adjugate | null | true |
_private.Mathlib.Computability.Language.0.Language.kstar_eq_iSup_pow._simp_1_2 | Mathlib.Computability.Language | ∀ {α : Type u_1} {ι : Sort v} {l : ι → Language α} {x : List α}, (x ∈ ⨆ i, l i) = ∃ i, x ∈ l i | null | false |
Multiset.mem_Ioc._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
(x ∈ Multiset.Ioc a b) = (a < x ∧ x ≤ b) | null | false |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_2 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ},
(0 < ↑n) = (0 < n) | null | false |
Std.PRange.UpwardEnumerable.succMany_eq_get | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {n : ℕ} {a : α},
Std.PRange.succMany n a = (Std.PRange.succMany? n a).get ⋯ | null | true |
Float.Model.mk._flat_ctor | Init.Data.Float.Model.Float | (toBits : UInt64) → Float.Model.Format.binary64.Valid toBits.toBitVec → Float.Model | null | false |
Lean.Expr.NumApps.State.casesOn | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
(t : Lean.Expr.NumApps.State) →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
motive t | null | false |
Lean.Elab.Visibility.noConfusionType | Lean.Elab.DeclModifiers | Sort v✝ → Lean.Elab.Visibility → Lean.Elab.Visibility → Sort v✝ | null | true |
PresheafOfModules.ofPresheaf_map | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : CategoryTheory.Functor Cᵒᵖ Ab) [inst_1 : (X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)]
(map_smul :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)),
(CategoryTheory.ConcreteCategory.hom (M.map ... | null | true |
MeasureTheory.Measure.ae_ae_eq_curry_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [hν : MeasureTheory.SFinite ν] {γ : Type u_4} {f g : α × β → γ},
f =ᵐ[μ.prod ν] g → ∀ᵐ (x : α) ∂μ, Function.curry f x =ᵐ[ν] Function.curry g x | null | true |
DirectLimit.Ring.lift._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_4}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → NonAssocSemiring (G i)] (P : Type u_2) [inst_3 : NonAssocSemiring P] (g : (i : ι) → G i →+* P),
(∀ (... | null | false |
CategoryTheory.Bicategory.mateEquiv_symm_apply' | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d e f : B} {g : c ⟶ e} {h : d ⟶ f} {l₁ : c ⟶ d} {r₁ : d ⟶ c}
{l₂ : e ⟶ f} {r₂ : f ⟶ e} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂)
(β : CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.Catego... | null | true |
CommAlgCat.instIsArtinianRingCarrierObjFiniteEtale | Mathlib.RingTheory.Etale.Finite | ∀ (k : Type u) [inst : Field k] (R : CommAlgCat.FiniteEtale k), IsArtinianRing ↑R.obj | null | true |
_private.Std.Http.Data.Body.Length.0.Std.Http.Body.instReprLength.repr.match_1 | Std.Http.Data.Body.Length | (motive : Std.Http.Body.Length → Sort u_1) →
(x : Std.Http.Body.Length) →
(Unit → motive Std.Http.Body.Length.chunked) → ((a : ℕ) → motive (Std.Http.Body.Length.fixed a)) → motive x | null | false |
MeasureTheory.VectorMeasure.equivMeasure_symm_apply | Mathlib.MeasureTheory.VectorMeasure.Operations | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α),
MeasureTheory.VectorMeasure.equivMeasure.symm μ = μ.toENNRealVectorMeasure | null | true |
CommHopfAlgCat.isoMk._proof_4 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} {x : CommRing X} {x_1 : CommRing Y} {x_2 : HopfAlgebra R X}
{x_3 : HopfAlgebra R Y} (e : X ≃ₐc[R] Y),
CategoryTheory.CategoryStruct.comp (CommHopfAlgCat.ofHom ↑e.symm) (CommHopfAlgCat.ofHom ↑e) =
CategoryTheory.CategoryStruct.id ↧Y | null | false |
Dynamics.dynEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {T : X → X} {n : ℕ}, Dynamics.dynEntourage T Set.univ n = Set.univ | null | true |
IsLowerSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet sᶜ | null | true |
TensorAlgebra.instAlgebra._aux_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | {R : Type u_1} →
{A : Type u_3} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : CommSemiring A] → [Algebra R A] → [inst_4 : Module A M] → R →+* TensorAlgebra A M | null | false |
BoxIntegral.Prepartition.mem_disjUnion._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (H : Disjoint π₁.iUnion π₂.iUnion),
(J ∈ π₁.disjUnion π₂ H) = (J ∈ π₁ ∨ J ∈ π₂) | null | false |
Std.DHashMap.Internal.AssocList.cons.injEq | Std.Data.DHashMap.Internal.AssocList.Basic | ∀ {α : Type u} {β : α → Type v} (key : α) (value : β key) (tail : Std.DHashMap.Internal.AssocList α β) (key_1 : α)
(value_1 : β key_1) (tail_1 : Std.DHashMap.Internal.AssocList α β),
(Std.DHashMap.Internal.AssocList.cons key value tail = Std.DHashMap.Internal.AssocList.cons key_1 value_1 tail_1) =
(key = key_1 ... | null | true |
Subspace.quotAnnihilatorEquiv._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomCompTriple (RingHom.id K) (RingHom.id K) (RingHom.id K) | null | false |
Disjoint.exists_open_convexes | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [ZeroLEOneClass 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] [inst_5 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[LocallyConvexSpace 𝕜 E] {s t : Set E},
Disjoint s t →
Convex 𝕜 s →
IsCo... | In a locally convex space, every two disjoint convex sets such that one is compact and the other
is closed admit disjoint convex open neighborhoods. | true |
Matroid.uniqueBaseOn_isBase_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E B I : Set α}, I ⊆ E → ((Matroid.uniqueBaseOn I E).IsBase B ↔ B = I) | null | true |
ascPochhammer_zero | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (S : Type u) [inst : Semiring S], ascPochhammer S 0 = 1 | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_268 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CategoryTheory.Limits.hasPullback_unop_iff_hasPushout._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.unop g.unop = CategoryTheory.Limits.HasPushout f g | null | false |
Lean.Meta.Cases.Context.recOn | Lean.Meta.Tactic.Cases | {motive : Lean.Meta.Cases.Context → Sort u} →
(t : Lean.Meta.Cases.Context) →
((inductiveVal : Lean.InductiveVal) →
(nminors : ℕ) →
(majorDecl : Lean.LocalDecl) →
(majorTypeFn : Lean.Expr) →
(majorTypeArgs majorTypeIndices : Array Lean.Expr) →
motive
... | null | false |
AddGrpCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddGrpCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
FractionalIdeal.coeIdeal_mul._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : Ideal R), ↑I * ↑J = ↑(I * J) | null | false |
AlgebraicGeometry.Scheme.RationalMap.comp | Mathlib.AlgebraicGeometry.Birational.Composition | {X Y Z : AlgebraicGeometry.Scheme} →
[PreirreducibleSpace ↥X] → [Nonempty ↥Y] → (f : X.RationalMap Y) → [f.IsDominant] → Y.RationalMap Z → X.RationalMap Z | Composition of rational maps. Requires `f` to be dominant, so that we may choose
a dominant representative. | true |
Matrix.blockDiag_map | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_11} {β : Type u_12} (M : Matrix (m × o) (n × o) α)
(f : α → β), (M.map f).blockDiag = fun k => (M.blockDiag k).map f | null | true |
Finset.biUnion_op_vadd_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} [inst : Add α] [inst_1 : DecidableEq α] (s t : Finset α),
(t.biUnion fun a => AddOpposite.op a +ᵥ s) = s + t | null | true |
SymbolicDynamics.FullShift.forbidden | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{G : Type u_2} → [inst : Inhabited A] → [AddMonoid G] → Set (SymbolicDynamics.FullShift.Pattern A G) → Set (G → A) | `forbidden F` is the set of configurations that avoid every pattern in `F`.
Formally: `x ∈ forbidden F` if and only if for every pattern `p ∈ F` and every
monoid element `g : G`, the pattern `p` does not occur in `x` at position `g`.
Intuitively, `forbidden F` is the shift space defined by declaring the finite set
(o... | true |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_rcc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | null | false |
not_of_iff_false | Init.Core | ∀ {p : Prop}, (p ↔ False) → ¬p | null | true |
Polynomial.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) | null | true |
SimpleGraph.mk.sizeOf_spec | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} [inst : SizeOf V] (Adj : V → V → Prop) (symm : autoParam (Std.Symm Adj) SimpleGraph.symm._autoParam)
(loopless : autoParam (Std.Irrefl Adj) SimpleGraph.loopless._autoParam),
sizeOf { Adj := Adj, symm := symm, loopless := loopless } = 1 + sizeOf symm + sizeOf loopless | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | null | true |
_private.Init.Data.Ord.Vector.0.Vector.instReflOrd._proof_1 | Init.Data.Ord.Vector | ∀ {α : Type u_1} [inst : Ord α] [Std.ReflOrd α] {n : ℕ}, Std.ReflOrd (Vector α n) | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : G →₀ ↑A),
(x ∈ groupHomology.cycles₁ A) = ((x.sum fun g a => (A.ρ g⁻¹) a) = x.sum fun x a => a) | null | false |
CategoryTheory.HasShift.recOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.HasShift C A → Sort u_1} →
(t : CategoryTheory.HasShift C A) →
((shift : CategoryTheory.Functor (CategoryTheory.Discrete A) (CategoryTheory.Functor C C)... | null | false |
ProbabilityTheory.avgRisk_countable | Mathlib.Probability.Decision.Risk.Countable | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_3} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {ℓ : Θ → 𝓨 → ENNReal} {P : ProbabilityTheory.Kernel Θ 𝓧} {κ : ProbabilityTheory.Kernel 𝓧 𝓨}
{π : MeasureTheory.Measure Θ} [Countable Θ] [MeasurableSingletonClass Θ],
ProbabilityTheor... | null | true |
_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_2 | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {u' v' : V}, ∀ j < [u', v'].length, 0 < [u', v'].length | null | false |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool), (BitVec.ofFnBE f).msb = if h : ¬n = 0 then f ⟨0, ⋯⟩ else false | null | false |
CategoryTheory.Limits.FormalCoproduct.mk.inj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} {I : Type w} {obj : I → C} {I_1 : Type w} {obj_1 : I_1 → C},
{ I := I, obj := obj } = { I := I_1, obj := obj_1 } → I = I_1 ∧ obj ≍ obj_1 | null | true |
isEmbedding_of_iSup_eq_top_of_preimage_subset_range | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_6} {Y : Type u_7} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
Continuous f →
∀ {ι : Type u_4} (U : ι → TopologicalSpace.Opens Y),
Set.range f ⊆ ↑(iSup U) →
∀ (V : ι → Type u_5) [inst_2 : (i : ι) → TopologicalSpace (V i)] (iV : (i : ι) → V i → X),
(∀... | Given a continuous map `f : X → Y` between topological spaces.
Suppose we have an open cover `U i` of the range of `f`, and a family of continuous maps `V i → X`
whose images are a cover of `X` that is coarser than the pullback of `U` under `f`.
To check that `f` is an embedding it suffices to check that `V i → Y` is a... | true |
Nat.even_mul | Mathlib.Algebra.Group.Nat.Even | ∀ {m n : ℕ}, Even (m * n) ↔ Even m ∨ Even n | null | true |
Subring.instCompleteLattice.match_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] (_x : R) (motive : (∃ n, ↑n = _x) → Prop) (x : ∃ n, ↑n = _x),
(∀ (n : ℤ) (hn : ↑n = _x), motive ⋯) → motive x | null | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.ici | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
... | A transfinite composition of shape `J` of morphisms in `W` induces a transfinite
composition of shape `Set.Ici j` (for any `j : J`). | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.tacticSyntax.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Lean.MVarId × Lean.BinderInfo → Sort u_1) →
(x : Lean.MVarId × Lean.BinderInfo) →
((mvarId : Lean.MVarId) → (snd : Lean.BinderInfo) → motive (mvarId, snd)) → motive x | null | false |
Flag.maxChain | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsMaxChain (fun x1 x2 => x1 ≤ x2) ↑s | null | true |
Lean.PrefixTreeNode.rec | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{... | null | false |
Mathlib.Tactic.ClickSuggestions.RwLemma.mk.noConfusion | Mathlib.Tactic.ClickSuggestions.Rewrite | {P : Sort u} →
{name : Mathlib.Tactic.ClickSuggestions.Premise} →
{symm : Bool} →
{name' : Mathlib.Tactic.ClickSuggestions.Premise} →
{symm' : Bool} →
{ name := name, symm := symm } = { name := name', symm := symm' } → (name = name' → symm = symm' → P) → P | null | false |
Function.iterate_zero | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α), f^[0] = id | null | true |
IsSeqCompact.exists_tendsto_of_frequently_mem | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : UniformSpace X] {s : Set X},
IsSeqCompact s →
∀ {u : ℕ → X}, (∃ᶠ (n : ℕ) in Filter.atTop, u n ∈ s) → CauchySeq u → ∃ x ∈ s, Filter.Tendsto u Filter.atTop (nhds x) | null | true |
String.Slice.Pos.revSkipWhile_string_eq_revSkipWhile_toSlice | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | ∀ {pat : String} {s : String.Slice} (curr : s.Pos), curr.revSkipWhile pat = curr.revSkipWhile pat.toSlice | null | true |
Int.isSome_getElem?_toArray_rco_eq | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m...n).toArray[i]?.isSome = true) = (i < (n - m).toNat) | null | true |
Antivary.div_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Monovary f g₂ → Antivary f (g₁ / g₂) | null | true |
rexp_neg_quadratic_isLittleO_rpow_atTop | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℝ}, a < 0 → ∀ (b s : ℝ), (fun x => Real.exp (a * x ^ 2 + b * x)) =o[Filter.atTop] fun x => x ^ s | null | true |
Matroid.sigma._proof_4 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_1} {α : ι → Type u_2} (M : (i : ι) → Matroid (α i)), ∃ B, ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B) | null | false |
CategoryTheory.Limits.WalkingParallelPair.one.elim | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {motive : CategoryTheory.Limits.WalkingParallelPair → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelPair) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelPair.one → motive t | null | false |
GenContFract.IntFractPair.seq1.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.seq1 v =
(GenContFract.IntFractPair.of v, Stream'.Seq.tail ⟨GenContFract.IntFractPair.stream v, ⋯⟩) | null | true |
Nat.lt_wfRel | Init.WF | WellFoundedRelation ℕ | null | true |
UniformSpace.Completion.coe_vlt_coe_iff | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K] [inst_3 : IsValuativeTopology K]
[inst_4 : IsUniformAddGroup K] {x y : K}, ↑x <ᵥ ↑y ↔ x <ᵥ y | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.