name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasurableEquiv.divLeft._proof_2 | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [MeasurableMul G] [MeasurableInv G] (g : G),
Measurable fun x => x⁻¹ * g | null | false |
_private.Mathlib.Data.Set.Basic.0.Set.univ_nonempty.match_1_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} (motive : Nonempty α → Prop) (x : Nonempty α), (∀ (x : α), motive ⋯) → motive x | null | false |
CategoryTheory.IsMonHom.monoidHom.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (f : M ⟶ N)
[inst_4 : CategoryTheory.IsMonHom f] (X : C),
CategoryTheory.IsMonHom.monoidHom f X =
{ toFun := fun x ... | null | true |
WithZero.mulArchimedean_iff | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Type u_2} [inst : CommGroup α] [inst_1 : PartialOrder α], MulArchimedean (WithZero α) ↔ MulArchimedean α | null | true |
Subsemiring.unop_iSup | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} [inst : NonAssocSemiring R] (S : ι → Subsemiring Rᵐᵒᵖ), (iSup S).unop = ⨆ i, (S i).unop | null | true |
_private.Mathlib.Data.Finset.Powerset.0.Finset.mem_powerset._simp_1_5 | Mathlib.Data.Finset.Powerset | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
Lean.Lsp.RenameParams.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams} →
{newName : String} →
{toTextDocumentPositionParams' : Lean.Lsp.TextDocumentPositionParams} →
{newName' : String} →
{ toTextDocumentPositionParams := toTextDocumentPositionParams, newName := newName } =
... | null | false |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_le_iff_le_kernMap._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f | null | false |
Topology.WithUpper.toUpper_le_toUpper._simp_1 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] {x y : α}, (Topology.WithUpper.toUpper x ≤ Topology.WithUpper.toUpper y) = (x ≤ y) | null | false |
ByteArray.get_push_eq | Batteries.Data.ByteArray | ∀ (a : ByteArray) (x : UInt8), (a.push x)[a.size] = x | null | true |
Lean.Lsp.instFromJsonPublishDiagnosticsParams | Lean.Data.Lsp.Diagnostics | Lean.FromJson Lean.Lsp.PublishDiagnosticsParams | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardPattern.0.String.Slice.Pattern.Model.ForwardSliceSearcher.instLawfulForwardPatternModel._simp_2 | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | ∀ {pat s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatch pat pos = ((s.sliceTo pos).copy = pat.copy) | null | false |
UInt64.le_zero_iff | Init.Data.UInt.Lemmas | ∀ {a : UInt64}, a ≤ 0 ↔ a = 0 | null | true |
Inclusion.InclusionParamDecl.ctorIdx | Mathlib.Tactic.Inclusion.Core.Extensions | Inclusion.InclusionParamDecl → ℕ | null | false |
SSetPair.instHasCokernelFunctorChainComplexNatAppChainComplexFunctorLeftToRight | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (R : C),
CategoryTheory.Limits.HasCokernel ((SSetPair.chainComplexFunctorLeftToRight C).app R) | null | true |
VectorBundleCore.mem_localTriv_target | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) (i : ι)
(p : B × F), p ∈ (Z.localTriv i).target ↔ p.1 ∈ (Z.localTriv i).baseSet | null | true |
CommGroup.rec | Mathlib.Algebra.Group.Defs | {G : Type u_2} →
{motive : CommGroup G → Sort u} →
([toGroup : Group G] →
(mul_comm : ∀ (a b : G), a * b = b * a) → motive { toGroup := toGroup, mul_comm := mul_comm }) →
(t : CommGroup G) → motive t | null | false |
CategoryTheory.Limits.Concrete.small_sections_of_hasLimit | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type v)}
[inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[(CategoryTheory.forget C).IsCorepresentable] {J : Type w} [inst_4 : CategoryTheor... | If a functor `G : J ⥤ C` to a concrete category has a limit and that `forget C`
is corepresentable, then `(G ⋙ forget C).sections` is small. | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxo.Iterator.instIteratorLoop.loopWf_eq._unary | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] {n : Type u → Type w}
[inst_5 : Monad n] [LawfulMonad n] (γ : Type u) {lift : (γ δ : Type u) → (γ → n δ) → Id γ → n δ}
[ins... | null | false |
Lean.Level.isNeverZero._f | Lean.Level | (x : Lean.Level) → Lean.Level.below x → Bool | null | false |
Bornology.IsVonNBounded.of_add_left | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousSMul 𝕜 E] [ContinuousAdd E] {s t : Set E},
Bornology.IsVonNBounded 𝕜 (s + t) → t.Nonempty → Bornology.IsVonNBounded 𝕜 s | null | true |
CategoryTheory.Limits.IsKernel.isoKernel._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (f : X ⟶ Y) {Z : C} (l : Z ⟶ X) {s : CategoryTheory.Limits.KernelFork f} (i : Z ≅ s.pt)
(h : CategoryTheory.CategoryStruct.comp i.hom (CategoryTheory.Limits.Fork.ι s) = l)
(j : CategoryTheo... | null | false |
Lean.Grind.AC.Context.noConfusion | Init.Grind.AC | {P : Sort u_1} →
{α : Sort u} →
{t : Lean.Grind.AC.Context α} →
{α' : Sort u} → {t' : Lean.Grind.AC.Context α'} → α = α' → t ≍ t' → Lean.Grind.AC.Context.noConfusionType P t t' | null | false |
Manifold.Elab.FindModelResult.normedSpaceInfo? | Mathlib.Geometry.Manifold.Notation | Manifold.Elab.FindModelResult → Option Manifold.Elab.NormedSpaceInfo | Information on the underlying normed space,
if this model is the trivial model with corners on a normed space. | true |
IsLocalization.map_left_cancel | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] {x y : R} {c : ↥M},
(algebraMap R S) (x * ↑c) = (algebraMap R S) (y * ↑c) → (algebraMap R S) x = (algebraMap R S) y | null | true |
MeasurableEquiv.subRight.eq_1 | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableAdd G] (g : G),
MeasurableEquiv.subRight g = { toEquiv := Equiv.subRight g, measurable_toFun := ⋯, measurable_invFun := ⋯ } | null | true |
ContinuousWithinAt.coeFun | Mathlib.Topology.Hom.ContinuousEvalConst | ∀ {F : Type u_1} {α : Type u_2} {X : Type u_3} {Z : Type u_4} [inst : FunLike F α X] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [ContinuousEvalConst F α X] [inst_4 : TopologicalSpace Z] {f : Z → F} {s : Set Z}
{z : Z}, ContinuousWithinAt f s z → ContinuousWithinAt (fun z => ⇑(f z)) s z | null | true |
_private.Aesop.RuleTac.ElabRuleTerm.0.Aesop.elabSimpTheorems.match_1 | Aesop.RuleTac.ElabRuleTerm | (motive : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(x : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult) →
((fst : Lean.Syntax) → motive (fst, Lean.Elab.Tactic.ElabSimpArgResult.star)) →
((x : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult) → motive x) → motive x | null | false |
_private.Lean.Meta.Instances.0.Lean.Meta.computeSynthOrder | Lean.Meta.Instances | Lean.Expr → Option Lean.ProjectionFunctionInfo → Lean.MetaM (Array ℕ) | Compute the order the arguments of `inst` should be synthesized.
The synthesization order makes sure that all mvars in non-out-params of the
subgoals are assigned before we try to synthesize it. Otherwise it goes left
to right.
For example:
- `[Add α] [Zero α] : Foo α` returns `[0, 1]`
- `[Mul A] [Mul B] [MulHom... | true |
Batteries.Tactic.unreachableConv | Batteries.Tactic.Unreachable | Lean.ParserDescr | This tactic causes a panic when run (at compile time).
(This is distinct from `exact unreachable!`, which inserts code which will panic at run time.)
It is intended for tests to assert that a tactic will never be executed, which is otherwise an
unusual thing to do (and the `unreachableTactic` linter will give a warnin... | true |
MulAction.isPreprimitive_stabilizer_subgroup | Mathlib.GroupTheory.Perm.MaximalSubgroups | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α}
[MulAction.IsPreprimitive ↥(MulAction.stabilizer M s) ↑s] {G : Subgroup M},
MulAction.stabilizer M s ≤ G → MulAction.IsPreprimitive ↥(MulAction.stabilizer (↥G) s) ↑s | A (mostly trivial) primitivity criterion for stabilizers. | true |
CategoryTheory.Functor.CoconeTypes.IsColimit.bijective | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes},
c.IsColimit → Function.Bijective (F.descColimitType c) | null | true |
CategoryTheory.ObjectProperty.prop_of_isColimit_binaryCofan | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderBinaryCoproducts] {X Y : C} {B : CategoryTheory.Limits.BinaryCofan X Y}
(hB : CategoryTheory.Limits.IsColimit B), P X → P Y → P B.pt | null | true |
Std.HashMap.containsThenInsert_fst | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {k : α} {v : β},
(m.containsThenInsert k v).1 = m.contains k | null | true |
Batteries.Tactic.TransRelation.rec | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} →
((rel : Lean.Expr) → motive (Batteries.Tactic.TransRelation.app rel)) →
((name : Lean.Name) → (bi : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name bi)) →
(t : Batteries.Tactic.TransRelation) → motive t | null | false |
CategoryTheory.instMonoidalFunctorObjWhiskeringRight._proof_2 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_1} {D : Type u_6} {E : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
[inst_3 : CategoryTheory.MonoidalCategory D] [inst_4 : CategoryTheory.MonoidalCategory E]
(L : CategoryTheory.Functor D E) [i... | null | false |
Std.Async.System.UserId.mk._flat_ctor | Std.Async.System | ℕ → Std.Async.System.UserId | null | false |
Array.erase_range' | Init.Data.Array.Range | ∀ {s n i : ℕ},
(Array.range' s n).erase i =
Array.range' s (min n (i - s)) ++ Array.range' (max s (i + 1)) (min s (i + 1) + n - (i + 1)) | null | true |
Std.ExtTreeSet.containsThenInsert.congr_simp | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeSet α cmp),
t = t_1 → ∀ (a a_1 : α), a = a_1 → t.containsThenInsert a = t_1.containsThenInsert a_1 | null | true |
Std.Http.Header.Connection.serialize | Std.Http.Data.Headers.Basic | Std.Http.Header.Connection → Std.Http.Header.Name × Std.Http.Header.Value | Serializes a `Connection` header back to a comma-separated value.
| true |
AlgebraicClosure.instCommRing._proof_19 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (a : AlgebraicClosure k), a * 0 = 0 | null | false |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.IsCharP.mk'_aux | Init.Grind.Ring.Basic | ∀ {x y : ℕ} (p : ℕ), y ≤ x → ((x - y) % p = 0 ↔ ∃ k₁ k₂, x + k₁ * p = y + k₂ * p) | null | true |
String.Pos.instLawfulOrderBEq | Init.Data.String.OrderInstances | ∀ {s : String}, Std.LawfulOrderBEq s.Pos | null | true |
MeasureTheory.Measure.FiniteSpanningSetsIn.mk.noConfusion | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{C : Set (Set α)} →
{P : Sort u} →
{set : ℕ → Set α} →
{set_mem : ∀ (i : ℕ), set i ∈ C} →
{finite : ∀ (i : ℕ), μ (set i) < ⊤} →
{spanning : ⋃ i, set i = Set.univ} →
... | null | false |
CFilter | Mathlib.Data.Analysis.Filter | (α : Type u_1) → Type u_2 → [PartialOrder α] → Type (max u_1 u_2) | A `CFilter α σ` is a realization of a filter (base) on `α`,
represented by a type `σ` together with operations for the top element and
the binary `inf` operation. | true |
NonUnitalNonAssocRing.right_distrib | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonUnitalNonAssocRing α] (a b c : α), (a + b) * c = a * c + b * c | Multiplication is right distributive over addition | true |
Module.mem_support_iff_of_span_eq_top | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R} {s : Set M},
Submodule.span R s = ⊤ → (p ∈ Module.support R M ↔ ∃ m ∈ s, (R ∙ m).annihilator ≤ p.asIdeal) | null | true |
AlgebraicGeometry.LocallyRingedSpace.isLocalHomStalkMap' | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) (x : ↑X.toTopCat),
IsLocalHom (CommRingCat.Hom.hom (f.stalkMap x)) | null | true |
AddSubmonoid.instCompleteLattice._proof_3 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b c : AddSubmonoid M), a ≤ b → b ≤ c → a ≤ c | null | false |
Filter.Germ.instDistribMulAction'._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_3} {N : Type u_2} [inst : Monoid M] [inst_1 : AddMonoid N]
[inst_2 : DistribMulAction M N] (c : α → M), ↑c • 0 = 0 | null | false |
_private.Mathlib.Analysis.Convex.Combination.0.AffineIndependent.convexHull_inter._simp_1_1 | Mathlib.Analysis.Convex.Combination | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
differentiable_add_const_iff | 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 : E → F}
(c : F), (Differentiable 𝕜 fun y => f y + c) ↔ Differentiable 𝕜 f | null | true |
Std.Time.DateFormatSymbols.eraNarrow | Std.Time.Format.DateFormat | Std.Time.DateFormatSymbols → Vector String 2 | Narrow era names (2 elements: index 0 = B, index 1 = C).
| true |
rootsOfUnityCircleEquiv._proof_6 | Mathlib.Analysis.SpecialFunctions.Complex.CircleAddChar | ∀ (n : ℕ) [inst : NeZero n] (x : ↥(rootsOfUnity n Circle)),
(fun z => ⟨(rootsOfUnitytoCircle n).toHomUnits z, ⋯⟩)
((↑((rootsOfUnityUnitsMulEquiv ℂ n).toMonoidHom.comp (restrictRootsOfUnity Circle.toUnits n))).toFun x) =
x | null | false |
IsZGroup.of_squarefree | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G], Squarefree (Nat.card G) → IsZGroup G | null | true |
Con.noConfusionType | Mathlib.GroupTheory.Congruence.Defs | Sort u → {M : Type u_1} → [inst : Mul M] → Con M → {M' : Type u_1} → [inst' : Mul M'] → Con M' → Sort u | null | false |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mspecNoSimp_1 | Std.Tactic.Do.Syntax | Lean.Macro | Like `mspec`, but does not attempt slight simplification and closing of trivial sub-goals.
`mspec $spec` is roughly (the set of simp lemmas below might not be up to date)
```
mspec_no_simp $spec
all_goals
((try simp only [SPred.true_intro_simp, SPred.apply_pure]);
(try mpure_intro; trivial))
```
| false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix._sizeOf_inst | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | (n m : ℕ) → SizeOf (Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m) | null | false |
Lean.Meta.SolveByElim.SolveByElimConfig.synthAssignedInstances._inherited_default | Lean.Meta.Tactic.SolveByElim | Bool | null | false |
instFreeMvPolynomialKaehlerDifferential | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (σ : Type u_1), Module.Free (MvPolynomial σ R) Ω[MvPolynomial σ R⁄R] | null | true |
min_ind | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} {motive : α → Prop},
(a ≤ b → motive a) → (b ≤ a → motive b) → motive (min a b) | null | true |
Real.hasDerivAt_fourier | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℝ → E},
MeasureTheory.Integrable f MeasureTheory.volume →
MeasureTheory.Integrable (fun x => x • f x) MeasureTheory.volume →
∀ (w : ℝ),
HasDerivAt (FourierTransform.fourier f)
(FourierTransform.fourier (fun x =>... | null | true |
SubMulAction.inclusion._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {M : Type u_2} {α : Type u_1} [inst : Monoid M] [inst_1 : MulAction M α] (s : SubMulAction M α) (x : M) (x_1 : ↥s),
↑(x • x_1) = ↑(x • x_1) | null | false |
MemHolder.add | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : NormedAddCommGroup Y] {r : NNReal} {f g : X → Y},
MemHolder r f → MemHolder r g → MemHolder r (f + g) | null | true |
Std.DTreeMap.Raw.Const.equiv_iff_toArray_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → (t₁.Equiv t₂ ↔ Std.DTreeMap.Raw.Const.toArray t₁ = Std.DTreeMap.Raw.Const.toArray t₂) | null | true |
Std.HashMap.getKeyD_inter_of_mem_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k fallback : α}, k ∈ m₂ → (m₁ ∩ m₂).getKeyD k fallback = m₁.getKeyD k fallback | null | true |
_private.Lean.Parser.Extra.0.Lean.Parser.manyIndent._regBuiltin.Lean.Parser.manyIndent.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
min_ne_bot | Mathlib.Order.BoundedOrder.Lattice | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderBot α] {a b : α}, a ≠ ⊥ → b ≠ ⊥ → min a b ≠ ⊥ | null | true |
Submodule.finite_ne_bot_of_iSupIndep | Mathlib.RingTheory.Noetherian.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [IsNoetherian R M]
{ι : Type u_5} {N : ι → Submodule R M}, iSupIndep N → {i | N i ≠ ⊥}.Finite | null | true |
LieSubalgebra.IsCartanSubalgebra.rec | Mathlib.Algebra.Lie.CartanSubalgebra | {R : Type u} →
{L : Type v} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{H : LieSubalgebra R L} →
{motive : H.IsCartanSubalgebra → Sort u_1} →
((nilpotent : LieRing.IsNilpotent ↥H) → (self_normalizing : H.normalizer = H) → motive ⋯) ... | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_insertEntryIfNew_le._proof_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} {l : List ((a : α) × β a)}, ¬l.length ≤ l.length + 1 → False | null | false |
Plausible.TotalFunction.ctorIdx | Plausible.Functions | {α : Type u} → {β : Type v} → Plausible.TotalFunction α β → ℕ | null | false |
min_mul_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] (a b c : α), min (a * b) (a * c) = a * min b c | null | true |
Equiv.refl_symm | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u}, (Equiv.refl α).symm = Equiv.refl α | null | true |
HurwitzZeta.cosKernel._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (x : ℝ), Function.Periodic (fun ξ => (jacobiTheta₂ (↑ξ) (Complex.I * ↑x)).re) 1 | null | false |
String.Slice.RevPosIterator.instIteratorSubtypePosNeEndPosOfPure._proof_6 | Init.Data.String.Iterate | ∀ {s : String.Slice} (currPos : s.Pos) (h : ¬currPos = s.startPos), currPos.prev h ≠ s.endPos | null | false |
Equiv.sigmaSigmaSubtype | Mathlib.Logic.Equiv.Basic | {α : Type u_8} →
{β : α → Type u_9} →
{γ : (a : α) → β a → Type u_10} →
(p : (a : α) × β a → Prop) →
[uniq : Unique { ab // p ab }] → {a : α} → {b : β a} → p ⟨a, b⟩ → { s // p ⟨s.fst, s.snd.fst⟩ } ≃ γ a b | A subtype of a dependent triple which pins down both bases is equivalent to the
respective fiber. | true |
RelEmbedding.ofMonotone.congr_simp | Mathlib.SetTheory.Ordinal.Univ | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [inst : Std.Trichotomous r] [inst_1 : Std.Asymm s]
(f f_1 : α → β) (e_f : f = f_1) (H : ∀ (a b : α), r a b → s (f a) (f b)),
RelEmbedding.ofMonotone f H = RelEmbedding.ofMonotone f_1 ⋯ | null | true |
String.Model.revPositionsFrom | Init.Data.String.Lemmas.Iterate | {s : String} → s.Pos → List { p // p ≠ s.endPos } | A list of all positions strictly before `p`, ordered from largest to smallest.
This function is not meant to be used in actual programs. Actual programs should use
`Slice.revPositionsFrom` and `Slice.revPositions`.
| true |
CategoryTheory.Pretriangulated.rotCompInvRot_hom_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.Pretriangulated.rotCompInvRot.hom.app X).hom₁ =
... | null | true |
Filter.ker_sInf | Mathlib.Order.Filter.Ker | ∀ {α : Type u_2} (S : Set (Filter α)), (sInf S).ker = ⋂ f ∈ S, f.ker | null | true |
RCLike.uniqueNonUnitalContinuousFunctionalCalculus | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : RCLike 𝕜] [inst_1 : TopologicalSpace A] [T2Space A] [inst_3 : NonUnitalRing A]
[inst_4 : StarRing A] [inst_5 : Module 𝕜 A] [inst_6 : IsScalarTower 𝕜 A A] [inst_7 : SMulCommClass 𝕜 A A],
ContinuousMapZero.UniqueHom 𝕜 A | null | true |
TensorialAt.pointwise₂ | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | If the operation `Φ` on sections of vector bundles `V` and `V'` is tensorial at `x` in each
argument, then it depends only on the value of the sections at `x`. | true |
_private.Mathlib.CategoryTheory.Monoidal.Free.Basic.0.CategoryTheory.FreeMonoidalCategory.projectMapAux.match_1.eq_10 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} (motive : (x x_1 : CategoryTheory.FreeMonoidalCategory C) → x.Hom x_1 → Sort u_2)
(X₁ X₂ : CategoryTheory.FreeMonoidalCategory C) (p : X₁.Hom X₂) (X : CategoryTheory.FreeMonoidalCategory C)
(h_1 : (x : CategoryTheory.FreeMonoidalCategory C) → motive x x (CategoryTheory.FreeMonoidalCategory.Hom.id x... | null | true |
Batteries.UnionFind.FindAux.mk.noConfusion | Batteries.Data.UnionFind.Basic | {n : ℕ} →
{P : Sort u} →
{s : Array Batteries.UFNode} →
{root : Fin n} →
{size_eq : s.size = n} →
{s' : Array Batteries.UFNode} →
{root' : Fin n} →
{size_eq' : s'.size = n} →
{ s := s, root := root, size_eq := size_eq } = { s := s', root := root', ... | null | false |
SimpleGraph.isTree_pathGraph_add_one | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ (n : ℕ), (SimpleGraph.pathGraph (n + 1)).IsTree | null | true |
ModularForm.weakFEPair._proof_8 | Mathlib.NumberTheory.ModularForms.LFunction | ∀ {k : ℤ}, 0 < k → 0 < ↑k | null | false |
_private.Init.Data.Nat.Basic.0.Nat.repeat_eq_repeatTR.go.match_1 | Init.Data.Nat.Basic | ∀ (motive : ℕ → ℕ → Prop) (x x_1 : ℕ), (∀ (n : ℕ), motive 0 n) → (∀ (m n : ℕ), motive m.succ n) → motive x x_1 | null | false |
AntitoneOn.comp_MonotoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
{f : α → β} {s : Set α} {t : Set β}, AntitoneOn g t → MonotoneOn f s → Set.MapsTo f s t → AntitoneOn (g ∘ f) s | null | true |
SymmetricAlgebra.algebraMap_eq_one_iff._simp_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : R),
((algebraMap R (SymmetricAlgebra R M)) x = 1) = (x = 1) | null | false |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toLower_toUpper_eq_toLower._simp_1_4 | Batteries.Data.Char.AsciiCasing | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
IsCoveringMapOn.of_isCoveringMap_restrictPreimage | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} (s : Set X),
IsOpen s → IsOpen (f ⁻¹' s) → IsCoveringMap (s.restrictPreimage f) → IsCoveringMapOn f s | null | true |
Ring.ofMinimalAxioms._proof_5 | Mathlib.Algebra.Ring.MinimalAxioms | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : One R] (mul_assoc : ∀ (a b c : R), a * b * c = a * (b * c)) (n : ℕ) (x : R),
x ^ (n + 1) = x ^ n * x | null | false |
_private.Mathlib.Data.Fin.Basic.0.Fin.sub_succ_le_sub_of_le._simp_1_2 | Mathlib.Data.Fin.Basic | ∀ {m n : ℕ}, (m ≤ n) = (↑m ≤ ↑n) | null | false |
ContDiffAt.cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℝ n f x → ContDiffAt ℝ n (fun x => Real.cos (f x)) x | null | true |
ContinuousMap.Homotopy.apply_zero_path | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X}
(p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁),
(FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f)).map p =
CategoryTheory.CategoryStruct.comp (ContinuousMap.Homotopy.hcast ⋯)
(CategoryTheory.Catego... | Proof that `f(p) = H(0 ⟶ 0, p)`, with the appropriate casts | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ {σ : Type} [inst : SizeOf σ] (id : ℕ) (mkInitial : IO σ)
(internalize : Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit)
(newEq newDiseq : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) (mbtc : Lean.Meta.Grind.GoalM Bool)
(action : Lean.Meta.Grind.Action) (check : Lean.Meta.Grind.GoalM Bool) (che... | null | true |
_private.Mathlib.Topology.UniformSpace.Dini.0.Monotone.tendstoLocallyUniformly_of_forall_tendsto._simp_1_2 | Mathlib.Topology.UniformSpace.Dini | ∀ {α : Type u} {β : Type v} {ι : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : TopologicalSpace β] {F : ι → β → α}
{f : β → α} {p : Filter ι},
TendstoLocallyUniformly F f p = ∀ ε > 0, ∀ (x : β), ∃ t ∈ nhds x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, dist (f y) (F n y) < ε | null | false |
_private.Mathlib.RingTheory.AdicCompletion.LocalRing.0.AdicCompletion.spanFinrank_maximalIdeal_eq._simp_1_6 | Mathlib.RingTheory.AdicCompletion.LocalRing | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Std.TreeMap.contains_congr | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k k' : α},
cmp k k' = Ordering.eq → t.contains k = t.contains k' | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.