name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
QuotientAddGroup.liftEquiv._proof_4 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (N : AddSubgroup G) [nN : N.Normal]
{φ : G →+ H},
Function.Surjective ⇑φ →
∀ (HN : N = φ.ker),
Function.Injective ⇑(QuotientAddGroup.lift N φ ⋯) ∧ Function.Surjective ⇑(QuotientAddGroup.lift N φ ⋯) | false |
Lean.Elab.UserWidgetInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.UserWidgetInfo → ℕ | false |
Stream'.Seq1.join_nil | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (a : α) (S : Stream'.Seq (Stream'.Seq1 α)), Stream'.Seq1.join ((a, Stream'.Seq.nil), S) = (a, S.join) | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_11 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs rls : ℕ) (rll rlr : Std.DTreeMap.Internal.Impl α β) (size : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β),
(rll.Balanced ∧
rlr.Balanced ∧
(rll.size + rlr.size ≤ 1 ∨ rll.size ≤ 3 * rlr.size ∧ rlr.size ≤ 3 * rll.size) ∧
rls = rll.size + 1 + rlr.size) ∧
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(rls + size ≤ 1 ∨ rls ≤ 3 * size ∧ size ≤ 3 * rls) ∧ rs = rls + 1 + size →
¬0 < rll.size + 1 + rlr.size + 1 + (l.size + 1 + r.size) → False | false |
IsDecompositionField.ringEquiv._proof_1 | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (L : Type u_2) [inst : Field L] (D : Type u_1) [inst_1 : Field D] [inst_2 : Algebra D L], FaithfulSMul D L | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.elabPipeProj.match_1 | Lean.Elab.App | (motive : Option String.Pos.Raw × Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw × Option String.Pos.Raw) →
((startPos stopPos : String.Pos.Raw) → motive (some startPos, some stopPos)) →
((x : Option String.Pos.Raw × Option String.Pos.Raw) → motive x) → motive x | false |
finSuccEquivLast | Mathlib.Logic.Equiv.Fin.Basic | {n : ℕ} → Fin (n + 1) ≃ Option (Fin n) | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvArg._sparseCasesOn_2 | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.Arg pu → Sort u} →
(t : Lean.Compiler.LCNF.Arg pu) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
RestrictedProduct.mapAlongAddMonoidHom._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι₁ : Type u_4} {ι₂ : Type u_1} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_2) {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂}
{S₁ : ι₁ → Type u_6} {S₂ : ι₂ → Type u_3} [inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)]
[inst_1 : (j : ι₂) → SetLike (S₂ j) (R₂ j)] {B₁ : (i : ι₁) → S₁ i} {B₂ : (j : ι₂) → S₂ j} (f : ι₂ → ι₁)
(hf : Filter.Tendsto f 𝓕₂ 𝓕₁) [inst_2 : (i : ι₁) → AddMonoid (R₁ i)] [inst_3 : (i : ι₂) → AddMonoid (R₂ i)]
[inst_4 : ∀ (i : ι₁), AddSubmonoidClass (S₁ i) (R₁ i)] [inst_5 : ∀ (i : ι₂), AddSubmonoidClass (S₂ i) (R₂ i)]
(φ : (j : ι₂) → R₁ (f j) →+ R₂ j) (hφ : ∀ᶠ (j : ι₂) in 𝓕₂, Set.MapsTo ⇑(φ j) ↑(B₁ (f j)) ↑(B₂ j))
(x y : RestrictedProduct (fun i => R₁ i) (fun i => ↑(B₁ i)) 𝓕₁),
RestrictedProduct.mapAlong R₁ R₂ f hf (fun j r => (φ j) r) hφ (x + y) =
RestrictedProduct.mapAlong R₁ R₂ f hf (fun j r => (φ j) r) hφ x +
RestrictedProduct.mapAlong R₁ R₂ f hf (fun j r => (φ j) r) hφ y | false |
MeasureTheory.spanningSets_mono | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite μ] {m n : ℕ},
m ≤ n → MeasureTheory.spanningSets μ m ⊆ MeasureTheory.spanningSets μ n | true |
HasStrictFDerivAt.eventually_apply_eq_iff_implicitFunctionOfProdDomain | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E₁ : Type u_2} [inst_1 : NormedAddCommGroup E₁]
[inst_2 : NormedSpace 𝕜 E₁] [inst_3 : CompleteSpace E₁] {E₂ : Type u_3} [inst_4 : NormedAddCommGroup E₂]
[inst_5 : NormedSpace 𝕜 E₂] [inst_6 : CompleteSpace E₂] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
[inst_8 : NormedSpace 𝕜 F] [inst_9 : CompleteSpace F] {u : E₁ × E₂} {f : E₁ × E₂ → F} {f'u : E₁ × E₂ →L[𝕜] F}
(dfu : HasStrictFDerivAt f f'u u) (if₂u : (f'u.comp (ContinuousLinearMap.inr 𝕜 E₁ E₂)).IsInvertible),
∀ᶠ (v : E₁ × E₂) in nhds u, f v = f u ↔ dfu.implicitFunctionOfProdDomain if₂u v.1 = v.2 | true |
IsOfFinOrder.inv | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] {x : G}, IsOfFinOrder x → IsOfFinOrder x⁻¹ | true |
CategoryTheory.Limits.colimit.smul._proof_2 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.IsFiltered C]
(R : CategoryTheory.Functor C RingCat) (M : CategoryTheory.Functor C Ab)
[inst_2 : (i : C) → Module ↑(R.obj i) ↑(M.obj i)],
(∀ {i j : C} (f : i ⟶ j) (r : ↑(R.obj i)) (m : ↑(M.obj i)),
(CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) =
(CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) →
∀ (a₁ a₂ : (j : C) × (R.comp (CategoryTheory.forget RingCat)).obj j)
(b : (j : C) × (M.comp (CategoryTheory.forget Ab)).obj j),
(R.comp (CategoryTheory.forget RingCat)).ColimitTypeRel a₁ a₂ →
(M.comp (CategoryTheory.forget Ab)).ιColimitType (CategoryTheory.IsFiltered.max a₁.fst b.fst)
((CategoryTheory.ConcreteCategory.hom (R.map (CategoryTheory.IsFiltered.leftToMax a₁.fst b.fst))) a₁.snd •
(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.IsFiltered.rightToMax a₁.fst b.fst))) b.snd) =
(M.comp (CategoryTheory.forget Ab)).ιColimitType (CategoryTheory.IsFiltered.max a₂.fst b.fst)
((CategoryTheory.ConcreteCategory.hom (R.map (CategoryTheory.IsFiltered.leftToMax a₂.fst b.fst))) a₂.snd •
(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.IsFiltered.rightToMax a₂.fst b.fst))) b.snd) | false |
_private.Mathlib.RingTheory.IsTensorProduct.0.IsTensorProduct.assoc._proof_3 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_6} {S : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {M₁ : Type u_4}
{M₂ : Type u_7} {M₃ : Type u_3} {M₁₂ : Type u_2} {M₂₃ : Type u_5} [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] [inst_6 : AddCommMonoid M₁₂] [inst_7 : AddCommMonoid M₂₃]
[inst_8 : Module R M₁] [inst_9 : Module R M₂] [inst_10 : Module S M₂] [inst_11 : IsScalarTower R S M₂]
[inst_12 : Module R M₃] [inst_13 : Module S M₃] [inst_14 : IsScalarTower R S M₃] [inst_15 : Module R M₁₂]
[inst_16 : Module S M₁₂] [inst_17 : IsScalarTower R S M₁₂] [inst_18 : Module R M₂₃] [inst_19 : Module S M₂₃]
[inst_20 : IsScalarTower R S M₂₃] {T : Type u_8} [inst_21 : CommSemiring T] [inst_22 : Algebra R T]
[inst_23 : Module T M₁] [inst_24 : IsScalarTower R T M₁] [inst_25 : Module T M₁₂] [inst_26 : SMulCommClass S T M₁₂]
[inst_27 : IsScalarTower R T M₁₂] (f : M₁ →ₗ[T] M₂ →ₗ[S] M₁₂)
(hf : IsTensorProduct (LinearMap.restrictScalars₁₂ R R f)) (g : M₂ →ₗ[S] M₃ →ₗ[S] M₂₃) (hg : IsTensorProduct g)
(x y : TensorProduct S M₁₂ M₃),
(↑(IsTensorProduct.assocAux✝ (LinearMap.restrictScalars₁₂ R S f) hf g hg)).toFun (x + y) =
(↑(IsTensorProduct.assocAux✝¹ (LinearMap.restrictScalars₁₂ R S f) hf g hg)).toFun x +
(↑(IsTensorProduct.assocAux✝² (LinearMap.restrictScalars₁₂ R S f) hf g hg)).toFun y | false |
UniqueFactorizationMonoid.iff_exists_prime_mem_of_isPrime | Mathlib.RingTheory.UniqueFactorizationDomain.Kaplansky | ∀ {R : Type u_1} [inst : CommSemiring R] [IsDomain R],
UniqueFactorizationMonoid R ↔ ∀ (I : Ideal R), I ≠ ⊥ → I.IsPrime → ∃ x ∈ I, Prime x | true |
SSet.Truncated.HomotopyCategory.functorEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u_1} [inst : CategoryTheory.SmallCategory C]
(φ : X ⟶ (SSet.truncation 2).obj (CategoryTheory.nerve C))
(s : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := ⋯ })),
(SSet.Truncated.HomotopyCategory.homToNerveMk (SSet.Truncated.HomotopyCategory.descOfTruncation φ)).app
(Opposite.op { obj := SimplexCategory.mk 1, property := ⋯ }) s =
φ.app (Opposite.op { obj := SimplexCategory.mk 1, property := ⋯ }) s | false |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.mk.noConfusion | Init.Data.Format.Basic | {P : Sort u} →
{foundLine foundFlattenedHardLine : Bool} →
{space : ℕ} →
{foundLine' foundFlattenedHardLine' : Bool} →
{space' : ℕ} →
{ foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space } =
{ foundLine := foundLine', foundFlattenedHardLine := foundFlattenedHardLine', space := space' } →
(foundLine = foundLine' → foundFlattenedHardLine = foundFlattenedHardLine' → space = space' → P) → P | false |
ContinuousMultilinearMap.smul_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : (i : ι) → AddCommMonoid (M₁ i)] [inst_1 : AddCommMonoid M₂]
[inst_2 : (i : ι) → TopologicalSpace (M₁ i)] [inst_3 : TopologicalSpace M₂] {R' : Type u_1} {A : Type u_3}
[inst_4 : Semiring A] [inst_5 : (i : ι) → Module A (M₁ i)] [inst_6 : Module A M₂] [inst_7 : DistribSMul R' M₂]
[inst_8 : ContinuousConstSMul R' M₂] [inst_9 : SMulCommClass A R' M₂] (f : ContinuousMultilinearMap A M₁ M₂) (c : R')
(m : (i : ι) → M₁ i), (c • f) m = c • f m | true |
le_liminf_add._auto_3 | Mathlib.Topology.Algebra.Order.LiminfLimsup | Lean.Syntax | false |
Ideal.Quotient.divisionRing._proof_7 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] [I.IsMaximal], Nontrivial (R ⧸ I) | false |
Mathlib.Tactic.Rify._aux_Mathlib_Tactic_Rify___macroRules_Mathlib_Tactic_Rify_rify_1 | Mathlib.Tactic.Rify | Lean.Macro | false |
CategoryTheory.MonoidalCategory.rightUnitor_tensor_hom | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom) | true |
Lean.Doc.Data.Const.casesOn | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.Data.Const → Sort u} →
(t : Lean.Doc.Data.Const) → ((name : Lean.Name) → motive { name := name }) → motive t | false |
_private.Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion.0.CovariantDerivative.torsion._proof_1 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion | ∀ {𝕜 : 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] [inst_6 : IsManifold I 2 M]
(cov : CovariantDerivative I E (TangentSpace I)), IsCovariantDerivativeOn E ↑cov | false |
CategoryTheory.GrothendieckTopology.Cover.oneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} → {X : C} → J.Cover X → J.OneHypercover X | true |
List.TProd.elim'.eq_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} {l : List ι} [inst : DecidableEq ι] (h : ∀ (i : ι), i ∈ l) (v : List.TProd α l) (i : ι),
List.TProd.elim' h v i = v.elim ⋯ | true |
Mathlib.Notation3.DelabKey.app | Mathlib.Util.Notation3 | Option Lean.Name → ℕ → Mathlib.Notation3.DelabKey | true |
AbsoluteValue.IsAdmissible.exists_approx_aux | Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue | ∀ {R : Type u_1} [inst : EuclideanDomain R] {abv : AbsoluteValue R ℤ} (n : ℕ) (h : abv.IsAdmissible) {ε : ℝ},
0 < ε →
∀ {b : R},
b ≠ 0 →
∀ (A : Fin (h.card ε ^ n).succ → Fin n → R),
∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(abv (A i₁ k % b - A i₀ k % b)) < abv b • ε | true |
IsUnifLocDoublingMeasure.definition._proof_1._@.Mathlib.MeasureTheory.Covering.DensityTheorem.1554790178._hygCtx._hyg.2 | Mathlib.MeasureTheory.Covering.DensityTheorem | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α)
[inst_2 : IsUnifLocDoublingMeasure μ] (K : ℝ),
0 < IsUnifLocDoublingMeasure.scalingScaleOf μ (max (4 * K + 3) 3) →
0 < IsUnifLocDoublingMeasure.scalingScaleOf μ (max (4 * K + 3) 3) / 4 | false |
integrableOn_Icc_iff_integrableOn_Ioc'._auto_3 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax | false |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.hasFiniteMulSupport_int._simp_1_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (w : NumberField.FinitePlace K) (x : K),
w x = ‖(NumberField.FinitePlace.embedding w.maximalIdeal) x‖ | false |
CategoryTheory.SpectralSequence.pageXIsoOfEq | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
(E : CategoryTheory.SpectralSequence C c r₀) →
(pq : κ) →
(r r' : ℤ) →
(h : autoParam (r = r') CategoryTheory.SpectralSequence.pageXIsoOfEq._auto_1) →
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.pageXIsoOfEq._auto_3) →
(E.page r ⋯).X pq ≅ (E.page r' ⋯).X pq | true |
MonoidHom.fst | Mathlib.Algebra.Group.Prod | (M : Type u_3) → (N : Type u_4) → [inst : MulOneClass M] → [inst_1 : MulOneClass N] → M × N →* M | true |
_private.Batteries.Data.List.Lemmas.0.List.isChain_iff_getElem._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (a : α) (i : ℕ), i + 2 ≤ [a].length → i + 1 < [a].length | false |
Matrix.diagonalInvertibleEquivInvertible._proof_2 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (v : n → α)
(x : Invertible v), Matrix.invertibleOfDiagonalInvertible v = x | false |
MeasureTheory.condExp_add | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → E}
[inst : NormedAddCommGroup E] [inst_1 : CompleteSpace E] [inst_2 : NormedSpace ℝ E],
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ → ∀ (m : MeasurableSpace α), μ[f + g | m] =ᵐ[μ] μ[f | m] + μ[g | m] | true |
MeasureTheory.measure_ne_top._simp_1 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] (s : Set α),
(μ s = ⊤) = False | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support_of_mem._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} {c : G.Walk v v}, 0 < c.support.length | false |
ProbabilityTheory.IsRatCondKernelCDFAux.mono' | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν → ∀ (a : α) {q r : ℚ}, q ≤ r → ∀ᵐ (c : β) ∂ν a, f (a, c) q ≤ f (a, c) r | true |
List.instSingletonList | Mathlib.Data.List.Basic | {α : Type u} → Singleton α (List α) | true |
UInt8.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | ∀ (n : UInt8), UInt8.ofNatTruncate n.toNat = n | true |
Std.ExtHashSet.insertMany_list_eq_empty_iff | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List α}, m.insertMany l = ∅ ↔ m = ∅ ∧ l = [] | true |
List.forall_mem_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Prop} {a : α} {n : ℕ}, (∀ b ∈ List.replicate n a, p b) ↔ n = 0 ∨ p a | true |
Std.Internal.IO.Async.EAsync.raceAll | Std.Internal.Async.Basic | {α ε : Type} →
{c : Type u_1} →
[Inhabited α] →
[ForM (Std.Internal.IO.Async.EAsync ε) c (Std.Internal.IO.Async.EAsync ε α)] →
c → optParam Task.Priority Task.Priority.default → Std.Internal.IO.Async.EAsync ε α | true |
OrderMonoidIso.recOn | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Mul α] →
[inst_3 : Mul β] →
{motive : (α ≃*o β) → Sort u} →
(t : α ≃*o β) →
((toMulEquiv : α ≃* β) →
(map_le_map_iff' : ∀ {a b : α}, toMulEquiv.toFun a ≤ toMulEquiv.toFun b ↔ a ≤ b) →
motive { toMulEquiv := toMulEquiv, map_le_map_iff' := map_le_map_iff' }) →
motive t | false |
Localization.one_rel | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (y : ↥S), (Localization.r S) 1 (↑y, y) | true |
MonomialOrder.degree_add_eq_right_of_lt | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f g : MvPolynomial σ R},
m.toSyn (m.degree f) < m.toSyn (m.degree g) → m.degree (f + g) = m.degree g | true |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.isLevelDefEqAuxImpl.match_1 | Lean.Meta.LevelDefEq | (motive : Lean.Level → Lean.Level → Sort u_1) →
(x x_1 : Lean.Level) →
((lhs rhs : Lean.Level) → motive lhs.succ rhs.succ) → ((lhs rhs : Lean.Level) → motive lhs rhs) → motive x x_1 | false |
Algebra.IsIntegral.adjoin | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {S : Set A},
(∀ x ∈ S, IsIntegral R x) → Algebra.IsIntegral R ↥(Algebra.adjoin R S) | true |
CategoryTheory.Limits.ColimitPresentation.bind._proof_3 | Mathlib.CategoryTheory.Presentable.ColimitPresentation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} {I : J → Type u_3}
[inst_1 : CategoryTheory.SmallCategory J] [inst_2 : (j : J) → CategoryTheory.SmallCategory (I j)] {X : C}
(P : CategoryTheory.Limits.ColimitPresentation J X)
(Q : (j : J) → CategoryTheory.Limits.ColimitPresentation (I j) (P.diag.obj j))
(X_1 : CategoryTheory.Limits.ColimitPresentation.Total Q),
(CategoryTheory.CategoryStruct.id X_1).hom = CategoryTheory.CategoryStruct.id ((Q X_1.fst).diag.obj X_1.snd) | false |
List.mem_zipIdx'._proof_2 | Init.Data.List.Nat.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : List α}, (x, i) ∈ xs.zipIdx → i < xs.length | false |
Multiset.instUnion | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → Union (Multiset α) | true |
CauSeq.Completion.Cauchy.divisionRing._proof_5 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (n : ℕ) (a : CauSeq.Completion.Cauchy abv),
DivInvMonoid.zpow (↑n.succ) a = DivInvMonoid.zpow (↑n) a * a | false |
SchwartzMap.smulLeftCLM_compL_smulLeftCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] {g₁ g₂ : E → 𝕜},
Function.HasTemperateGrowth g₁ →
Function.HasTemperateGrowth g₂ →
(SchwartzMap.smulLeftCLM F g₁).comp (SchwartzMap.smulLeftCLM F g₂) = SchwartzMap.smulLeftCLM F (g₁ * g₂) | true |
Lean.Meta.Grind.Arith.Linear.LinearM.Context._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | SizeOf Lean.Meta.Grind.Arith.Linear.LinearM.Context | false |
RpcEncodablePacket._sizeOf_inst._@.Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1 | Mathlib.Tactic.Widget.SelectPanelUtils | SizeOf RpcEncodablePacket✝ | false |
_private.Mathlib.MeasureTheory.Integral.MeanInequalities.0.ENNReal.lintegral_Lp_mul_le_Lq_mul_Lr._simp_1_4 | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
List.destutter'_eq_self_iff._simp_1 | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (l : List α) (R : α → α → Prop) [inst : DecidableRel R] (a : α),
(List.destutter' R a l = a :: l) = List.IsChain R (a :: l) | false |
LinearEquiv.isPositive_symm_iff._simp_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E ≃ₗ[𝕜] E}, (↑T.symm).IsPositive = (↑T).IsPositive | false |
_private.Lean.Elab.SetOption.0.Lean.Elab.elabSetOption.setOption | Lean.Elab.SetOption | {m : Type → Type} →
[Monad m] →
[Lean.MonadOptions m] → [Lean.MonadError m] → Lean.Name → Lean.OptionDecl → Lean.DataValue → m Lean.Options | true |
_private.Init.Data.List.Pairwise.0.List.pairwise_and_iff.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {S : α → α → Prop}
(motive : List.Pairwise R l ∧ List.Pairwise S l → Prop) (x : List.Pairwise R l ∧ List.Pairwise S l),
(∀ (hR : List.Pairwise R l) (hS : List.Pairwise S l), motive ⋯) → motive x | false |
Std.DTreeMap.Raw.Const.get!_insert_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {k : α} {v : β}, Std.DTreeMap.Raw.Const.get! (t.insert k v) k = v | true |
Turing.TM1to1.trTape_mk' | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {n : ℕ} {enc : Γ → List.Vector Bool n} [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (L R : Turing.ListBlank Γ),
Turing.TM1to1.trTape enc0 (Turing.Tape.mk' L R) = Turing.TM1to1.trTape' enc0 L R | true |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isIsotypic_iff_isFullyInvariant_imp_bot_or_top.match_1_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(motive : (∃ m ≤ N, IsSimpleModule R ↥m) → Prop) (x : ∃ m ≤ N, IsSimpleModule R ↥m),
(∀ (S : Submodule R M) (le : S ≤ N) (right : IsSimpleModule R ↥S), motive ⋯) → motive x | false |
CompactlySupportedContinuousMap.instMulActionWithZeroOfContinuousConstSMul | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : Zero β] →
{R : Type u_5} →
[inst_3 : MonoidWithZero R] →
[inst_4 : MulActionWithZero R β] →
[ContinuousConstSMul R β] → MulActionWithZero R (CompactlySupportedContinuousMap α β) | true |
CategoryTheory.ObjectProperty.IsClosedUnderColimitsOfShape.inverseImage | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (J : Type u') [inst_2 : CategoryTheory.Category.{v', u'} J]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) [P.IsClosedUnderColimitsOfShape J]
[CategoryTheory.Limits.PreservesColimitsOfShape J F], (P.inverseImage F).IsClosedUnderColimitsOfShape J | true |
Subring.coe_pow._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : Ring R] (s : Subring R) (x : ↥s) (n : ℕ), ↑x ^ n = ↑(x ^ n) | false |
RelIso.symm_symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s), e.symm.symm = e | true |
Std.ExtTreeSet.get!_empty | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α] {a : α}, ∅.get! a = default | true |
Lean.Meta.Sym.Simp.instInhabitedResult | Lean.Meta.Sym.Simp.SimpM | Inhabited Lean.Meta.Sym.Simp.Result | true |
Polynomial.rootsExpandToRoots._proof_2 | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R] (x x_1 : ↥((Polynomial.expand R p) f).roots.toFinset), ⟨↑x ^ p, ⋯⟩ = ⟨↑x_1 ^ p, ⋯⟩ → x = x_1 | false |
Finset.cons | Mathlib.Data.Finset.Insert | {α : Type u_1} → (a : α) → (s : Finset α) → a ∉ s → Finset α | true |
Std.DTreeMap.Internal.Unit.RocSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} [inst : Ord α] [inst_1 : SizeOf α] (treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit)
(range : Std.Roc α), sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | true |
Lean.Grind.Ring.zsmul_natCast_eq_nsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (n : ℕ) (a : α), ↑n • a = n • a | true |
Lean.Elab.Do.DoElemContKind.duplicable | Lean.Elab.Do.Basic | Lean.Elab.Do.DoElemContKind | true |
PartialEquiv.prod._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {δ : Type u_4} (e : PartialEquiv α β) (e' : PartialEquiv γ δ),
∀ p ∈ e.target ×ˢ e'.target, (↑e.symm p.1, ↑e'.symm p.2) ∈ e.source ×ˢ e'.source | false |
ByteArray.utf8Decode?.go | Init.Data.String.Basic | (b : ByteArray) → (i : ℕ) → Array Char → i ≤ b.size → Option (Array Char) | true |
Fin.orderSucc_eq | Mathlib.Data.Fin.SuccPredOrder | ∀ {n : ℕ}, Order.succ = fun i => Fin.lastCases (Fin.last n) Fin.succ i | true |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.qNF.mkAddProof._unary._proof_2 | Mathlib.Tactic.Module | ∀ {u v : Lean.Level} {M : Q(Type v)} {R : Q(Type u)} (a₁ : Q(«$R»)) (x₁ : Q(«$M»)) (k₁ : ℕ)
(t₁ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) (a₂ : Q(«$R»)) (x₂ : Q(«$M»)) (k₂ : ℕ)
(t₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ),
(invImage (fun x => PSigma.casesOn x fun l₁ l₂ => (l₁, l₂)) Prod.instWellFoundedRelation).1
⟨t₁, ((a₂, x₂), k₂) ::ᵣ t₂⟩ ⟨((a₁, x₁), k₁) :: t₁, ((a₂, x₂), k₂) :: t₂⟩ | false |
UniqueProds.instMulOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Mul G] [h : UniqueProds G], UniqueProds Gᵐᵒᵖ | true |
MulAction.toPermHom | Mathlib.Algebra.Group.Action.End | (G : Type u_1) → (α : Type u_5) → [inst : Group G] → [MulAction G α] → G →* Equiv.Perm α | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.StartsWithResult | Lean.Meta.Tactic.Grind.AC.Seq | Type | true |
Std.ExtTreeMap.instMembershipOfTransCmp | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Membership α (Std.ExtTreeMap α β cmp) | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocContext.close._proof_2 | Lean.DocString.Extension | ∀ (ctx : Lean.VersoModuleDocs.DocContext✝),
¬(Lean.VersoModuleDocs.DocContext.context✝ ctx).size = 0 → 0 < (Lean.VersoModuleDocs.DocContext.context✝¹ ctx).size | false |
LinearEquiv.det | Mathlib.LinearAlgebra.Determinant | {R : Type u_1} →
[inst : CommRing R] → {M : Type u_2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (M ≃ₗ[R] M) →* Rˣ | true |
SemiNormedGrp.of.sizeOf_spec | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier],
sizeOf { carrier := carrier, str := str } = 1 + sizeOf carrier + sizeOf str | true |
IsOrderedCancelAddMonoid.of_add_lt_add_left | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : LinearOrder α],
(∀ (a b c : α), b < c → a + b < a + c) → IsOrderedCancelAddMonoid α | true |
Matrix.isSymm_one | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α], Matrix.IsSymm 1 | true |
IsField.toField._proof_2 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Ring R] (h : IsField R) (a b : R), a * b = b * a | false |
CategoryTheory.SimplicialObject.augmentedCechNerve_map_left_app | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
{X Y : CategoryTheory.Arrow C} (F : X ⟶ Y) (n : SimplexCategoryᵒᵖ),
(CategoryTheory.SimplicialObject.augmentedCechNerve.map F).left.app n =
CategoryTheory.Limits.WidePullback.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.base fun x => X.hom) F.right)
(fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.π (fun x => X.hom) i) F.left) ⋯ | true |
compl_unique | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ⊓ b = ⊥ → a ⊔ b = ⊤ → aᶜ = b | true |
StructureGroupoid.LocalInvariantProp.liftPropOn_congr | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {G : StructureGroupoid H} {G' : StructureGroupoid H'}
{P : (H → H') → Set H → H → Prop} {g g' : M → M'} {s : Set M},
G.LocalInvariantProp G' P → ChartedSpace.LiftPropOn P g s → (∀ y ∈ s, g' y = g y) → ChartedSpace.LiftPropOn P g' s | true |
_private.Lean.Meta.Basic.0.Lean.Meta.forallTelescopeReducingAux | Lean.Meta.Basic | {α : Type} → Lean.Expr → Option ℕ → (Array Lean.Expr → Lean.Expr → Lean.MetaM α) → Bool → Bool → Lean.MetaM α | true |
Set.biUnionEqSigmaOfDisjoint._proof_1 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s : Set ι} {f : ι → Set α}, ⋃ x ∈ s, f x = ⋃ x, f ↑x | false |
LinearMap.compl₁₂.eq_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_2} {R₂ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] {N : Type u_7} {Mₗ : Type u_10}
{Pₗ : Type u_12} {Qₗ : Type u_13} {Qₗ' : Type u_14} [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid Mₗ]
[inst_4 : AddCommMonoid Pₗ] [inst_5 : AddCommMonoid Qₗ] [inst_6 : AddCommMonoid Qₗ'] [inst_7 : Module R₁ Mₗ]
[inst_8 : Module R₂ N] [inst_9 : Module R₁ Pₗ] [inst_10 : Module R₁ Qₗ] [inst_11 : Module R₂ Pₗ]
[inst_12 : Module R₂ Qₗ'] [inst_13 : SMulCommClass R₂ R₁ Pₗ] (f : Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ) (g : Qₗ →ₗ[R₁] Mₗ)
(g' : Qₗ' →ₗ[R₂] N), f.compl₁₂ g g' = (f ∘ₗ g).compl₂ g' | true |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.findSyntheticFieldCompletion? | Lean.Server.Completion.SyntheticCompletion | Lean.FileMap →
String.Pos.Raw → Lean.Syntax → Lean.Elab.InfoTree → Option Lean.Server.Completion.ContextualizedCompletionInfo | true |
Lean.Lsp.DocumentChange.create.injEq | Lean.Data.Lsp.Basic | ∀ (a a_1 : Lean.Lsp.CreateFile), (Lean.Lsp.DocumentChange.create a = Lean.Lsp.DocumentChange.create a_1) = (a = a_1) | true |
CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.coequalizerCoconeIsColimit | Mathlib.CategoryTheory.Limits.Constructions.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[inst_2 : CategoryTheory.Limits.HasPushouts C] →
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C) →
CategoryTheory.Limits.IsColimit
(CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.coequalizerCocone F) | true |
Std.TreeMap.getKeyD_eq_of_contains | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
{k fallback : α}, t.contains k = true → t.getKeyD k fallback = k | true |
TopologicalSpace.Closeds.isUniformEmbedding_coe | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], IsUniformEmbedding SetLike.coe | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.