name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Meta.FunProp.LambdaTheoremType.comp | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremType | Composition theorem e.g. `Continuous f → Continuous g → Continuous fun x ↦ f (g x)` | true |
Set.iUnion_dite | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} (p : ι → Prop) [inst : DecidablePred p] (f : (i : ι) → p i → Set α)
(g : (i : ι) → ¬p i → Set α),
(⋃ i, if h : p i then f i h else g i h) = (⋃ i, ⋃ (h : p i), f i h) ∪ ⋃ i, ⋃ (h : ¬p i), g i h | null | true |
Ideal.Quotient.algebraMap_mk_of_liesOver | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_3} {B : Type u_4} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (P : Ideal B)
(p : Ideal A) [inst_3 : P.LiesOver p] (x : A),
(algebraMap (A ⧸ p) (B ⧸ P)) ((Ideal.Quotient.mk p) x) = (Ideal.Quotient.mk P) ((algebraMap A B) x) | null | true |
Representation.finsuppToCoinvariants._proof_2 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} [inst : CommRing k], RingHomInvPair (RingHom.id k) (RingHom.id k) | null | false |
Lean.Elab.Command.MacroExpandedSnapshot.mk.noConfusion | Lean.Elab.Command | {P : Sort u} →
{toSnapshot : Lean.Language.Snapshot} →
{macroDecl : Lean.Name} →
{newStx : Lean.Syntax} →
{newNextMacroScope : ℕ} →
{hasTraces : Bool} →
{next : Array (Lean.Language.SnapshotTask Lean.Language.DynamicSnapshot)} →
{toSnapshot' : Lean.Language.Snapsh... | null | false |
Std.DTreeMap.Internal.Impl.Balanced.inner | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
l.Balanced →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size →
sz = l.size + 1 + r.size → (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced | Inner node is balanced if it is locally balanced, both children are balanced and size
information is correct.
| true |
ContinuousMultilinearMap.ofSubsingletonₗᵢ_apply | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (G : Type wG) {G' : Type wG'} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] [inst_3 : SeminormedAddCommGroup G']
[inst_4 : NormedSpace 𝕜 G'] [inst_5 : Fintype ι] [inst_6 : Subsingleton ι] (i : ι) (a : G →L[𝕜] G'),
(ContinuousMult... | null | true |
Nat.castAddMonoidHom | Mathlib.Data.Nat.Cast.Basic | (α : Type u_3) → [inst : AddMonoidWithOne α] → ℕ →+ α | `Nat.cast : ℕ → α` as an `AddMonoidHom`. | true |
Std.Http.Server.Connection.rec | Std.Http.Server.Connection | {α : Type} →
{motive : Std.Http.Server.Connection α → Sort u} →
((socket : α) →
(machine : Std.Http.Protocol.H1.Machine Std.Http.Protocol.H1.Direction.receiving) →
(extensions : Std.Http.Extensions) →
motive { socket := socket, machine := machine, extensions := extensions }) →
... | null | false |
Std.DTreeMap.Internal.Impl.updateCell._proof_37 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (ky : α) (y : β ky) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz ky y l r).Balanced) (newL : Std.DTreeMap.Internal.Impl α β)
(h₁ : newL.Balanced) (h₂ : l.size - 1 ≤ newL.size) (h₃ : newL.size ≤ l.size + 1),
(Std.DTreeMap.Internal.Im... | null | false |
Polynomial.isPrimitiveRoot_of_mahlerMeasure_eq_one | Mathlib.NumberTheory.MahlerMeasure | ∀ {p : Polynomial ℤ},
(Polynomial.map (Int.castRingHom ℂ) p).mahlerMeasure = 1 →
∀ {z : ℂ}, z ≠ 0 → z ∈ p.aroots ℂ → ∃ n, 0 < n ∧ IsPrimitiveRoot z n | If an integer polynomial has Mahler measure equal to 1, then all its complex nonzero roots are
roots of unity. | true |
RegularExpression.matches'_pow | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (P : RegularExpression α) (n : ℕ), (P ^ n).matches' = P.matches' ^ n | null | true |
hasSum_fintype_support | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Fintype β] (f : β → α)
(L : SummationFilter β) [L.HasSupport] [inst_4 : DecidablePred fun x => x ∈ L.support],
HasSum f (∑ b ∈ L.support.toFinset, f b) L | null | true |
CategoryTheory.Cat.isoOfEquiv._auto_3 | Mathlib.CategoryTheory.Category.Cat | Lean.Syntax | null | false |
IsFractionRing.liftAlgHom | Mathlib.RingTheory.Localization.FractionRing | {R : Type u_1} →
[inst : CommRing R] →
{A : Type u_4} →
[inst_1 : CommRing A] →
{K : Type u_5} →
[inst_2 : Field K] →
{L : Type u_7} →
[inst_3 : Field L] →
[inst_4 : Algebra A K] →
[IsFractionRing A K] →
[inst_... | `AlgHom` version of `IsFractionRing.lift`. | true |
MeasureTheory.AEFinStronglyMeasurable.eq_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] [inst_1 : Zero β] {x : MeasurableSpace α} (f : α → β)
(μ : MeasureTheory.Measure α),
MeasureTheory.AEFinStronglyMeasurable f μ = ∃ g, MeasureTheory.FinStronglyMeasurable g μ ∧ f =ᵐ[μ] g | null | true |
_private.Mathlib.Algebra.Homology.Opposite.0.HomologicalComplex.instHasHomologyUnopOfOpposite._proof_1 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (K : HomologicalComplex Vᵒᵖ c) (i : ι) [K.HasHomology i],
K.unop.HasHomology i | null | false |
MeasureTheory.integral_image_eq_integral_deriv_smul_of_antitoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
AntitoneOn f s → ∀ (g : ℝ → F), ∫ (x : ℝ) in f '' s, g x = ∫ (x : ℝ) in s, -f' x • g (f x) | Change of variable formula for differentiable functions: if a real function `f` is
antitone and differentiable on a measurable set `s`, then the Bochner integral of a function
`g : ℝ → F` on `f '' s` coincides with the integral of `(-f' x) • g ∘ f` on `s` . | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.FullyFaithful.0.DerivedCategory.instFullSingleFunctor.match_1 | Mathlib.Algebra.Homology.DerivedCategory.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (n : ℤ) {A : C}
(X : CochainComplex C ℤ) (s : X ⟶ (CochainComplex.singleFunctor C n).obj A) (A₀ : C)
(e : X ≅ (HomologicalComplex.single C (ComplexShape.up ℤ) n).obj A₀)
(motive : (∃ a, (CochainComplex.singleFunctor... | null | false |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct.0.CategoryTheory.Limits.Types.isIso_colimitPointwiseProductToProductColimit.match_1_1 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {α : Type u_1} (motive : CategoryTheory.Discrete α → Prop) (x : CategoryTheory.Discrete α),
(∀ (s : α), motive { as := s }) → motive x | null | false |
Lean.Meta.RefinedDiscrTree.LazyEntry.mk.inj | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ {previous : Option Lean.Meta.RefinedDiscrTree.ExprInfo} {stack : List Lean.Meta.RefinedDiscrTree.StackEntry}
{mctx : Lean.MetavarContext} {labelledStars? : Option (Array Lean.MVarId)}
{computedKeys : List Lean.Meta.RefinedDiscrTree.Key} {previous_1 : Option Lean.Meta.RefinedDiscrTree.ExprInfo}
{stack_1 : List L... | null | true |
Lean.Lsp.HoverParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams),
sizeOf { toTextDocumentPositionParams := toTextDocumentPositionParams } = 1 + sizeOf toTextDocumentPositionParams | null | true |
NormedAddGroupHom.toNormedAddCommGroup | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_5} →
{V₂ : Type u_6} →
[inst : NormedAddCommGroup V₁] → [inst_1 : NormedAddCommGroup V₂] → NormedAddCommGroup (NormedAddGroupHom V₁ V₂) | Normed group homomorphisms themselves form a normed group with respect to
the operator norm. | true |
Differentiable.fun_add_iff_left._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F},
Differentiable 𝕜 g → (Differentiable 𝕜 fun i => f i + g i) = Differentiable 𝕜 f | null | false |
_private.Mathlib.Order.Atoms.0.le_iff_atom_le_imp.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α} (x : α)
(motive : x ∈ {a_1 | IsAtom a_1 ∧ a_1 ≤ a} → Prop) (x_1 : x ∈ {a_1 | IsAtom a_1 ∧ a_1 ≤ a}),
(∀ (h₁ : IsAtom x) (h₂ : x ≤ a), motive ⋯) → motive x_1 | null | false |
Submodule.coe_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(p : Submodule R A) (h_mul : ∀ (x y : A), x ∈ p → y ∈ p → x * y ∈ p), ↑(p.toNonUnitalSubalgebra h_mul) = ↑p | null | true |
ContinuousMap.instSeminormedRing._proof_6 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : SeminormedRing R] (x : C(α, R)),
Monoid.npow 0 x = 1 | null | false |
MvPolynomial.sumAlgEquiv_comp_rename_inl | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R],
(↑(MvPolynomial.sumAlgEquiv R S₁ S₂)).comp (MvPolynomial.rename Sum.inl) =
MvPolynomial.mapAlgHom (Algebra.ofId R (MvPolynomial S₂ R)) | null | true |
CategoryTheory.conjugateEquiv_leftUnitor_hom | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{L : CategoryTheory.Functor A B} {R : CategoryTheory.Functor B A} (adj : L ⊣ R),
(CategoryTheory.conjugateEquiv adj (CategoryTheory.Adjunction.id.comp adj)) L.leftUnitor.hom = R.rightUnitor.inv | null | true |
CategoryTheory.Limits.CatCospanTransform.rightUnitor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_1} {B : Type u_6} {C : Type u_10} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_4, u_1} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_7, u_10} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | null | false |
_private.Mathlib.Order.Interval.Set.OrdConnectedComponent.0.Set.dual_ordConnectedSection._simp_1_5 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Lean.Meta.Sym.Arith.MonadCommRing.mk._flat_ctor | Lean.Meta.Sym.Arith.MonadRing | {m : Type → Type} →
m Lean.Meta.Sym.Arith.CommRing →
((Lean.Meta.Sym.Arith.CommRing → Lean.Meta.Sym.Arith.CommRing) → m Unit) → Lean.Meta.Sym.Arith.MonadCommRing m | null | false |
VectorField.fderivWithin_pullbackWithin | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {V : F → F} {x : E},
(fderivWithin 𝕜 f s x).IsInvertible → (fderivWithin 𝕜 f s x) (V... | null | true |
Semigrp.str | Mathlib.Algebra.Category.Semigrp.Basic | (self : Semigrp) → Semigroup ↑self | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Basic.0.MeasureTheory.VectorMeasure.exists_variation_le_add'._simp_1_3 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | null | false |
CategoryTheory.Limits.ColimitPresentation.Total.Hom.recOn | Mathlib.CategoryTheory.Presentable.ColimitPresentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u_1} →
{I : J → Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] →
[inst_2 : (j : J) → CategoryTheory.Category.{u_3, u_2} (I j)] →
{D : CategoryTheory.Functor J C} →
{P : (j : J) → Cat... | null | false |
Lean.Compiler.LCNF.markRecDecls | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Array (Lean.Compiler.LCNF.Decl pu) → Array (Lean.Compiler.LCNF.Decl pu) | Traverse the given block of potentially mutually recursive functions
and mark a declaration `f` as recursive if there is an application
`f ...` in the block.
This is an overapproximation, and relies on the fact that our frontend
computes strongly connected components.
See comment at `recursive` field.
| true |
Num.succ'.eq_1 | Mathlib.Data.Num.Lemmas | Num.zero.succ' = 1 | null | true |
DirectSum.equivCongrLeft | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
{κ : Type u_1} → (h : ι ≃ κ) → (DirectSum ι fun i => β i) ≃+ DirectSum κ fun k => β (h.symm k) | Reindexing terms of a direct sum. | true |
Mathlib.Tactic.Widget.StringDiagram.AtomNode.atom | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.AtomNode → Mathlib.Tactic.BicategoryLike.Atom | The underlying expression of the node. | true |
SimpleGraph.map_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W), Function.Injective (SimpleGraph.map ⇑f) | null | true |
ODE.FunSpace.compProj | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} → {t₀ : ↑(Set.Icc tmin tmax)} → {x₀ : E} → {r L : NNReal} → ODE.FunSpace t₀ x₀ r L → ℝ → E | Extend the domain of `α` from `Icc tmin tmax` to `ℝ` such that `α t = α tmin` for all `t ≤ tmin`
and `α t = α tmax` for all `t ≥ tmax`. | true |
Composition.recOnSingleAppend._unary._proof_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (blocks : List ℕ), blocks.sum = blocks.sum | null | false |
WithBot.add_right_cancel | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithBot α} [IsRightCancelAdd α], z ≠ ⊥ → x + z = y + z → x = y | null | true |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_tendsto_lintegral_enorm_sub_div._simp_1_1 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
MeasureTheory.Integrable.condExpKernel_ae | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {F : Type u_2} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] [inst_2 : NormedAddCommGroup F] {f : Ω → F},
MeasureTheory.Integrable f μ → ∀ᵐ (ω : Ω) ∂μ, MeasureTheory.Integrable f ((ProbabilityT... | null | true |
HomologicalComplex.restrictionMap._proof_2 | Mathlib.Algebra.Homology.Embedding.Restriction | ∀ {ι : Type u_1} {ι' : Type u_4} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j : ι),
c.Rel i j →
CategoryTh... | null | false |
ArithmeticFunction.pow_one_eq_id | Mathlib.NumberTheory.ArithmeticFunction.Misc | ArithmeticFunction.pow 1 = ArithmeticFunction.id | null | true |
Module.DualBases.finite._autoParam | Mathlib.LinearAlgebra.Dual.Basis | Lean.Syntax | null | false |
ENNReal.coe_sub._simp_1 | Mathlib.Data.ENNReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) | null | false |
CategoryTheory.Abelian.SpectralObject.toCycles_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | Lean.Syntax | null | false |
_private.Mathlib.Order.CompleteLattice.Basic.0.iSup_prod._simp_1_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Std.DTreeMap.Internal.Impl.applyPartition._proof_4 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (k : α → Ordering) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.contains' k l = true →
Std.DTreeMap.Internal.Impl.contains' k Std.DTreeMap.Internal.Impl.leaf = true) →
Std.DTreeMap.Internal.Impl.contains' k l = true → Std.DTreeMap.Inter... | null | false |
MeasureTheory.OuterMeasure.addCommMonoid._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | IsScalarTower ℕ ENNReal ENNReal | null | false |
Lean.Meta.Grind.Arith.Linear.State.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (structs : Array Lean.Meta.Grind.Arith.Linear.Struct) (typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToStructId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (exprToStructIdEntries : Lean.PArray (Lean.Expr × ℕ))
(forbiddenNatModules : Lean.PHashSet Lean.Meta.Sym.ExprPtr)
(natStructs : Array Lean.Me... | null | true |
Function.Surjective.sumMap | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'},
Function.Surjective f → Function.Surjective g → Function.Surjective (Sum.map f g) | null | true |
Std.DTreeMap.Const.ofList_singleton | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {k : α} {v : β},
Std.DTreeMap.Const.ofList [(k, v)] cmp = ∅.insert k v | null | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.symmetricCategory_braiding_inv_left | Mathlib.CategoryTheory.Monoidal.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.Limits.HasInitial C] [inst_3 : CategoryTheory.CartesianMonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalClosed C] [inst_5 : CategoryTheory.BraidedCategory C]
(X₁ X₂ : CategoryTheory... | null | true |
dist_self_sub_left | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] (a b : E), dist (a - b) a = ‖b‖ | null | true |
dist_single_single | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {β : Type u_2} [inst : Fintype β] {Y : Type u_4} [inst_1 : PseudoMetricSpace Y] [inst_2 : Zero Y]
[inst_3 : DecidableEq β] (i j : β) (a b : Y), i ≠ j → dist (Pi.single i a) (Pi.single j b) = max (dist a 0) (dist b 0) | The (sup metric) distance between `Pi.single i a` and `Pi.single j b` for
`i ≠ j` is `max (dist a 0) (dist b 0)`. | true |
Std.Internal.List.containsKey_filter_not_contains_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α}
{hl₁ : Std.Internal.List.DistinctKeys l₁} {k : α},
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.containsKey k (List.filter (fun p => !l₂.contains p.fst) l₁) = false | null | true |
Std.TreeMap.find?_toArray_eq_some_iff_getKey?_eq_some_and_getElem?_eq_some | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k k' : α} {v : β},
Array.find? (fun x => cmp x.1 k == Ordering.eq) t.toArray = some (k', v) ↔ t.getKey? k = some k' ∧ t[k]? = some v | null | true |
lp.toNorm | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} → [inst : (i : α) → NormedAddCommGroup (E i)] → {p : ENNReal} → ↥(lp E p) → ↥(lp (fun x => ℝ) p) | The sequence of norms of `x : lp E p` as a term of `ℓ^p(α, ℝ)`. Here `E : α → Type*`
is a dependent type and `ℓ^p(α, ℝ)` is the non-dependent `ℝ`-valued `lp` space. | true |
FreeRing.coe_one | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u), ↑1 = 1 | null | true |
Computation.Results.mem | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → a ∈ s | null | true |
ShrinkingLemma.PartialRefinement._sizeOf_inst | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
{inst : TopologicalSpace X} →
(u : ι → Set X) →
(s : Set X) →
(p : Set X → Prop) →
[SizeOf ι] →
[SizeOf X] →
[(a : ι) → (a_1 : X) → SizeOf (u a a_1)] →
[(a : X) → SizeOf (s a)] →
... | null | false |
not_bddAbove_univ._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [NoTopOrder α], BddAbove Set.univ = False | null | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.index_eq_two_iff_exists_notMem_and'._simp_1_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, (H.index = 2) = ∃ a, ∀ (b : G), Xor (a * b ∈ H) (b ∈ H) | null | false |
_private.Mathlib.Order.Filter.NAry.0.Filter.map₂_neBot_iff._simp_1_2 | Mathlib.Order.Filter.NAry | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Finset.addEnergy_univ_right | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] [inst_2 : Fintype α] (s : Finset α),
s.addEnergy Finset.univ = Fintype.card α * s.card ^ 2 | null | true |
exists_isTranscendenceBasis_between | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] [NoZeroDivisors A]
(s t : Set A),
s ⊆ t →
AlgebraicIndepOn R id s →
∀ [ht : Algebra.IsAlgebraic (↥(Algebra.adjoin R t)) A], ∃ u, s ⊆ u ∧ u ⊆ t ∧ IsTranscendenceBasis R Subtype.val | If `s ⊆ t` are subsets in an `R`-algebra `A` such that `s` is algebraically independent over
`R`, and `A` is algebraic over the `R`-algebra generated by `t`, then there is a transcendence
basis of `A` over `R` between `s` and `t`, provided that `A` is a domain.
This may fail if only `R` is assumed to be a domain but `... | true |
galGroupBasis.match_1 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {U : Set Gal(L/K)}
(motive : U ∈ (galBasis K L).sets → Prop) (x : U ∈ (galBasis K L).sets),
(∀ (H : Subgroup Gal(L/K)) (left : H ∈ fixedByFinite K L) (h2 : (fun g => g.carrier) H = U), motive ⋯) → motive x | null | false |
Language.reverse_mem_reverse | Mathlib.Computability.Language | ∀ {α : Type u_1} {l : Language α} {a : List α}, a.reverse ∈ l.reverse ↔ a ∈ l | null | true |
Finset.strongInduction._unsafe_rec | Mathlib.Data.Finset.Card | {α : Type u_1} →
{p : Finset α → Sort u_4} → ((s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) → (s : Finset α) → p s | null | false |
Subgroup.finiteIndex_of_finite | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [Finite G], H.FiniteIndex | null | true |
FP.FloatCfg.prec | Mathlib.Data.FP.Basic | [self : FP.FloatCfg] → ℕ | null | true |
AlgebraicGeometry.Scheme.Cover.locallyDirectedPullbackCover._proof_10 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
[inst : P.IsStableUnderBaseChange] (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst_1 : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀] [inst_2 : 𝒰.LocallyDirected] {Y : AlgebraicGeometry... | null | false |
Equiv.prodPUnit._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_2), Function.RightInverse (fun a => (a, PUnit.unit)) fun p => p.1 | null | false |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_8 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z)
(pb :
(i : Function.Pullback f.f g.f) →
CategoryTheory.Limits.PullbackCone (CategoryTheory.CategoryStruct.comp (f.φ (↑i).1) (CategoryTheory.eqToHom ⋯))
(g.φ (↑i)... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSlice_next._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Lean.Parser.Term.strictImplicitRightBracket | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
starRingOfComm | Mathlib.Algebra.Star.Basic | {R : Type u_1} → [inst : CommSemiring R] → StarRing R | Any commutative semiring admits the trivial \*-structure.
See note [reducible non-instances].
| true |
_private.Mathlib.Data.Analysis.Topology.0.Ctop.mem_nhds_toTopsp.match_1_3 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_2} {σ : Type u_1} (F : Ctop α σ) {s : Set α} {a : α} (motive : (∃ b, a ∈ F.f b ∧ F.f b ⊆ s) → Prop)
(x : ∃ b, a ∈ F.f b ∧ F.f b ⊆ s), (∀ (x : σ) (h : a ∈ F.f x ∧ F.f x ⊆ s), motive ⋯) → motive x | null | false |
MulEquiv.hasEnoughRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ {n : ℕ} [NeZero n] {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] [inst_1 : CommMonoid N]
[hm : HasEnoughRootsOfUnity M n] (e : ↥(rootsOfUnity n M) ≃* ↥(rootsOfUnity n N)), HasEnoughRootsOfUnity N n | null | true |
QuadraticMap.restrictScalars | Mathlib.LinearAlgebra.QuadraticForm.Basic | {S : Type u_1} →
{R : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : Module R M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R N] →
... | If `Q : M → N` is a quadratic map of `R`-modules and `R` is an `S`-algebra,
then the restriction of scalars is a quadratic map of `S`-modules. | true |
_private.Batteries.Data.List.Basic.0.List.max!.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : Unit → motive none) (h_2 : (x : α) → motive (some x)),
(match none with
| none => h_1 ()
| some x => h_2 x) =
h_1 () | null | true |
CategoryTheory.bijection_natural | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
(i : CategoryTheory.Functor D C) [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
[inst_3 : CategoryTheory.Reflective i] [inst_4 : CategoryTheory.MonoidalClosed C]
[inst_5 : CategoryTheory.... | null | true |
Lean.Meta.Sym.Arith.MonadSemiring.noConfusionType | Lean.Meta.Sym.Arith.MonadSemiring | Sort u →
{m : Type → Type} →
Lean.Meta.Sym.Arith.MonadSemiring m → {m' : Type → Type} → Lean.Meta.Sym.Arith.MonadSemiring m' → Sort u | null | false |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Frontend.0.Lean.Elab.Tactic.Do.Internal.elabPreTac | Lean.Elab.Tactic.Do.Internal.VCGen.Frontend | Lean.MVarId → Lean.Syntax → Lean.Elab.TermElabM (Lean.Elab.Tactic.Do.Internal.VCGen.PreTac × Lean.Meta.Grind.Params) | null | true |
ConvexCone.Flat | Mathlib.Geometry.Convex.Cone.Basic | {R : Type u_2} →
{G : Type u_3} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] → [inst_2 : AddCommGroup G] → [inst_3 : SMul R G] → ConvexCone R G → Prop | A convex cone is flat if it contains some nonzero vector `x` and its opposite `-x`. | true |
Std.Sat.AIG.RelabelNat.State.inv2 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)} {idx : ℕ}
(self : Std.Sat.AIG.RelabelNat.State α decls idx), Std.Sat.AIG.RelabelNat.State.Inv2 decls idx self.map | Proof that we inserted all atoms until `idx`.
| true |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.vonStaudtIndicator | Mathlib.NumberTheory.Bernoulli | ℕ → ℕ → ℚ | null | true |
CategoryTheory.Discrete.monoidalFunctor_δ | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u} [inst : Monoid M] {N : Type u'} [inst_1 : Monoid N] (F : M →* N) (m₁ m₂ : CategoryTheory.Discrete M),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Discrete.monoidalFunctor F) m₁ m₂ =
CategoryTheory.Discrete.eqToHom ⋯ | null | true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b : CategoryTheory.CatEnriched C}
{f f' : a ⟶ b} (η : f ⟶ f'),
(CategoryTheory.CatEnriched.hComp η (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id b)) ≍ η) =
True | null | false |
PerfectClosure.instCommRing._proof_5 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (m : ℕ) (x : K) (n : ℕ)
(y : K) (s : ℕ) (z : K),
Quot.mk (PerfectClosure.R K p) (m, x) *
(Quot.mk (PerfectClosure.R K p) (n, y) + Quot.mk (PerfectClosure.R K p) (s, z)) =
Quot.mk (PerfectClosure.R K p) (m, x) *... | null | false |
Stream'.Seq.ext_iff | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {s t : Stream'.Seq α}, s = t ↔ ∀ (n : ℕ), s.get? n = t.get? n | null | true |
BitVec.ssubOverflow | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → BitVec w → Bool | Checks whether the subtraction of `x` and `y` results in *signed* overflow, treating `x` and `y` as
2's complement signed bitvectors.
SMT-Lib name: `bvssubo`.
| true |
_private.Init.Data.List.Pairwise.0.List.pairwise_flatten._simp_1_6 | Init.Data.List.Pairwise | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) | null | false |
Lean.Grind.Linarith.Poly.denoteExpr | Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr | {M : Type → Type} → [Monad M] → [Lean.Meta.Grind.Arith.Linear.MonadGetStruct M] → Lean.Grind.Linarith.Poly → M Lean.Expr | null | true |
CategoryTheory.preadditiveCoyoneda_obj | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (X : Cᵒᵖ),
CategoryTheory.preadditiveCoyoneda.obj X =
(CategoryTheory.preadditiveCoyonedaObj (Opposite.unop X)).comp
(CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End (Opposite.unop X))ᵐᵒᵖ) AddCommGrpCat) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.