name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Finset.coe_sdiv | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SDiv α β] [inst_1 : DecidableEq α] (s t : Finset β), ↑(s /ₛ t) = ↑s /ₛ ↑t | null | true |
SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {G : SimpleGraph α},
G.EdgeDisjointTriangles ↔ ∀ ⦃e : Sym2 α⦄, ¬e.IsDiag → {s | s ∈ G.cliqueSet 3 ∧ e ∈ s.sym2}.Subsingleton | null | true |
SimpleGraph.Walk.isSubwalk_concat._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w), p.IsSubwalk (p.concat h) = True | null | false |
_private.Lean.Data.Json.Printer.0.Lean.Json.CompressWorkItemQueue.popObjectFieldKey! | Lean.Data.Json.Printer | Lean.Json.CompressWorkItemQueue✝ → String × Lean.Json.CompressWorkItemQueue✝ | null | true |
CategoryTheory.NatTrans.naturality_app | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
{F G : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : F ⟶ G) (Z : D) {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct... | null | true |
CategoryTheory.InjectiveResolution.instInjectiveXNatOfCocomplex | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C) (n : ℕ),
CategoryTheory.Injective ((CategoryTheory.InjectiveResolution.ofCocomplex Z).X n) | null | true |
IsFreeAddGroup.Generators | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | (G : Type u_1) → [inst : AddGroup G] → [IsFreeAddGroup G] → Type u_1 | A set of generators of an additive free group, chosen arbitrarily | true |
instNonAssocSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : NonAssocSemiring α], Nat.unaryCast 0 = 0 | null | false |
FiberBundle.prod_trivializationAt' | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] (F₁ : Type u_2) [inst_1 : TopologicalSpace F₁] (E₁ : B → Type u_3)
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] (F₂ : Type u_4) [inst_3 : TopologicalSpace F₂]
(E₂ : B → Type u_5) [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] [inst_5 : (x : B) → Zero (E₁ ... | null | true |
Matroid.contract_spanning_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {X C : Set α},
autoParam (C ⊆ M.E) Matroid.contract_spanning_iff._auto_1 →
((M.contract C).Spanning X ↔ M.Spanning (X ∪ C) ∧ Disjoint X C) | null | true |
CategoryTheory.Functor.preservesProjectiveObjects_of_isEquivalence | Mathlib.CategoryTheory.Preadditive.Projective.Preserves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [F.IsEquivalence], F.PreservesProjectiveObjects | null | true |
Valued.maximalIdeal._proof_2 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ (K : Type u_1) [inst : Field K] {Γ₀ : outParam (Type u_2)} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[vK : Valued K Γ₀], IsLocalRing ↥(Valued.integer K) | null | false |
Topology.IsInducing.r1Space | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : TopologicalSpace Y] {f : Y → X},
Topology.IsInducing f → R1Space Y | null | true |
omegaLimit_def | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β) (s : Set α),
omegaLimit f ϕ s = ⋂ u ∈ f, closure (Set.image2 ϕ u s) | null | true |
Submonoid.comap_iInf | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ι → Submonoid N),
Submonoid.comap f (iInf s) = ⨅ i, Submonoid.comap f (s i) | null | true |
_private.Mathlib.Order.Filter.Ultrafilter.Basic.0.Filter.tendsto_iff_ultrafilter._simp_1_1 | Mathlib.Order.Filter.Ultrafilter.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = (l₁ ≤ Filter.comap f l₂) | null | false |
Real.Angle.two_zsmul_toReal_eq_two_mul | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (2 • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-Real.pi / 2) (Real.pi / 2) | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_eq_singleton_iff._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, m < n → ¬(m = k ∧ n ≤ m + 1 ↔ n = m + 1 ∧ m = k) → False | null | false |
WithVal.instAlgebra._proof_4 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {S : Type u_3} [inst_1 : CommRing R]
(v : Valuation R Γ₀) [inst_2 : Semiring S] [inst_3 : Algebra R S] (x y : WithVal v),
(↑↑(algebraMap (WithVal v) S)).toFun (x * y) =
(↑↑(algebraMap (WithVal v) S)).toFun x * (↑↑(algebraMap (WithVal v)... | null | false |
MeasureTheory.ae_le_toMeasurable | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
s ≤ᵐ[μ] MeasureTheory.toMeasurable μ s | null | true |
_private.Mathlib.Probability.Decision.Risk.Basic.0.ProbabilityTheory.avgRisk_le_mul'._simp_1_1 | Mathlib.Probability.Decision.Risk.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Set.indicator_eq_zero._simp_1 | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] {s : Set α} {f : α → M},
(s.indicator f = fun x => 0) = Disjoint (Function.support f) s | null | false |
Std.ExtTreeMap.isEmpty_iff._simp_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [Std.TransCmp cmp],
(t.isEmpty = true) = (t = ∅) | null | false |
IsOfFinOrder.isUnit | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_6} [inst : Monoid M] {x : M}, IsOfFinOrder x → IsUnit x | null | true |
Std.Rcc.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type u} → Std.Rcc α → ℕ | null | false |
Mathlib.Tactic.TermCongr.unexpandCHole | Mathlib.Tactic.TermCongr | Lean.PrettyPrinter.Unexpander | For error reporting purposes, make the hole pretty print as its value.
We can still see that it is a hole in the info view on mouseover. | true |
_private.Std.Http.Data.Status.0.Std.Http.Status.ofCode._proof_3 | Std.Http.Data.Status | ∀ (n : UInt16), (100 ≤ n ∧ n ≤ 999) ∧ ¬Std.Http.isKnownStatusCode n = true → ¬Std.Http.isKnownStatusCode n = true | null | false |
instIsAtomisticSubmodule | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
IsAtomistic (Submodule K V) | The lattice of submodules of a module over a division ring is atomistic. | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.binop_lazy._regBuiltin.Lean.Parser.Term.binop_lazy_1 | Lean.Parser.Term | IO Unit | null | false |
AddOpposite.instNonUnitalSemiring | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NonUnitalSemiring R] → NonUnitalSemiring Rᵃᵒᵖ | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt8.toUSize_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.toOption.match_1 | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
{s : String.Slice} →
(motive : String.Slice.SplitInclusiveIterator pat s → Sort u_1) →
(x : String.Slice.SplitInclusiveIterator pat s) →
((currPos : s.Pos)... | null | false |
Equiv.sigmaProdDistrib._proof_4 | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_3} (α : ι → Type u_1) (β : Type u_2),
Function.RightInverse (fun p => (⟨p.fst, p.snd.1⟩, p.snd.2)) fun p => ⟨p.1.fst, (p.1.snd, p.2)⟩ | null | false |
Lean.StructureResolutionOrderConflict.ctorIdx | Lean.Structure | Lean.StructureResolutionOrderConflict → ℕ | null | false |
SimpleGraph.cliqueSet_zero | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α), G.cliqueSet 0 = {∅} | null | true |
CategoryTheory.PreZeroHypercover.I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {S : C} → CategoryTheory.PreZeroHypercover S → Type w | the index type of the covering of `S` | true |
Cardinal.IsStrongLimit.isSuccLimit | Mathlib.SetTheory.Cardinal.Order | ∀ {c : Cardinal.{u_1}}, c.IsStrongLimit → Order.IsSuccLimit c | null | true |
CategoryTheory.GrpObj.lift_comp_inv_left | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp f CategoryTheory.Grp... | null | true |
instFaithfulSMulOfIsRightCancelMul | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) [inst : Mul R] [IsRightCancelMul R], FaithfulSMul R R | `instSMulOfMul` is faithful when multiplication is right cancellative. | true |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.analyticOnNhd_univ_iff_differentiable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F}, Differentiable 𝕜 f = DifferentiableOn 𝕜 f Set.univ | null | false |
PosSMulStrictMono.nnrat_of_rat | Mathlib.Algebra.Order.Module.Rat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : MulAction ℚ≥0 α] [inst_2 : MulAction ℚ α] [IsScalarTower ℚ≥0 ℚ α]
[PosSMulStrictMono ℚ α], PosSMulStrictMono ℚ≥0 α | null | true |
List.subperm_of_subset | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Nodup → l₁ ⊆ l₂ → l₁.Subperm l₂ | null | true |
CategoryTheory.Limits.Cocone.equivStructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
CategoryTheory.Limits.Cocone F ≌ CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J) | The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
functor. | true |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.specializePartialApp.match_1 | Lean.Compiler.LCNF.Simp.Main | (motive :
Option
(Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure ×
Subarray (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
Sort u_1) →
(x :
Option
(Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure ×
Subarray (Lean.Compiler.LCNF.Arg Lean.Compi... | null | false |
Multiset.rel_map | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {δ : Type u_3} {p : γ → δ → Prop} {s : Multiset α} {t : Multiset β}
{f : α → γ} {g : β → δ},
Multiset.Rel p (Multiset.map f s) (Multiset.map g t) ↔ Multiset.Rel (fun a b => p (f a) (g b)) s t | null | true |
Finset.lt_eq_subset | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1}, (fun x1 x2 => x1 ⊂ x2) = fun x1 x2 => x1 ⊂ x2 | null | true |
MeasureTheory.VectorMeasure.integral_integral_smul_swap | Mathlib.MeasureTheory.VectorMeasure.Prod | ∀ {X : Type u_2} {Y : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X}
{mY : MeasurableSpace Y} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
{μ : Measure... | Change the order of integration in integrals wrt vector measures.
Case where `f` is scalar. | true |
CategoryTheory.Prod.sectL_obj | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(Z : D) (X : C), (CategoryTheory.Prod.sectL C Z).obj X = (X, Z) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.exists_bijective_of_forall_ncard_le._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {α : Type u_1} (s : Finset α), s.card = (↑s).ncard | null | false |
SSet.Truncated.HomotopyCategory.isoTerminal._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | { len := 1 }.len ≤ 2 | null | false |
IntermediateField.adjoin_toSubfield | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E),
(IntermediateField.adjoin F S).toSubfield = Subfield.closure (Set.range ⇑(algebraMap F E) ∪ S) | null | true |
CliffordAlgebra.instAlgebra' | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_3} →
{A : Type u_4} →
{M : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : CommRing A] →
[inst_3 : Algebra R A] →
[inst_4 : Module R M] →
[inst_5 : Module A M] → (Q : QuadraticForm A M) → [IsScalarTower R A M... | null | true |
_private.Mathlib.Data.Set.Prod.0.Set.disjoint_prod._simp_1_3 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
NumberField.mixedEmbedding.fundamentalCone.volume_frontier_normLeOne | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
MeasureTheory.volume (frontier (NumberField.mixedEmbedding.fundamentalCone.normLeOne K)) = 0 | null | true |
CategoryTheory.Limits.binaryCofanZeroRight | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[CategoryTheory.Limits.HasZeroMorphisms C] → (X : C) → CategoryTheory.Limits.BinaryCofan X 0 | The colimit cocone for the coproduct with a zero object. | true |
UniqueMDiffWithinAt.bundle_preimage' | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {𝕜 : 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] {s : Set M} {F : Type u_9} [inst_6 : No... | In a fiber bundle, the preimage under the projection of a set with unique differentials
in the base has unique differentials in the bundle. Version with a point `⟨b, x⟩`. | true |
Lean.Elab.Term.LevelMVarErrorInfo.logError | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LevelMVarErrorInfo → Lean.Elab.TermElabM Unit | null | true |
Lean.Lsp.InitializationOptions.noConfusion | Lean.Data.Lsp.InitShutdown | {P : Sort u} → {t t' : Lean.Lsp.InitializationOptions} → t = t' → Lean.Lsp.InitializationOptions.noConfusionType P t t' | null | false |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ._proof_3 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : R),
IsScalarTower R R ((AlgebraicGeometry.structureSheafInType R M).obj.obj (Opposite.op (PrimeSpectrum.basicOpen f))) | null | false |
_private.Init.Data.List.Pairwise.0.List.pairwise_flatten._simp_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | null | false |
Mathlib.Meta.FunProp.LambdaTheoremArgs.const.elim | Mathlib.Tactic.FunProp.Theorems | {motive : Mathlib.Meta.FunProp.LambdaTheoremArgs → Sort u} →
(t : Mathlib.Meta.FunProp.LambdaTheoremArgs) →
t.ctorIdx = 1 → motive Mathlib.Meta.FunProp.LambdaTheoremArgs.const → motive t | null | false |
MulAction.noConfusion | Mathlib.Algebra.Group.Action.Defs | {P : Sort u} →
{α : Type u_9} →
{β : Type u_10} →
{inst : Monoid α} →
{t : MulAction α β} →
{α' : Type u_9} →
{β' : Type u_10} →
{inst' : Monoid α'} →
{t' : MulAction α' β'} → α = α' → β = β' → inst ≍ inst' → t ≍ t' → MulAction.noConfusionType P t ... | null | false |
MonovaryOn.pow_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f g s → ∀ (n : ℕ), MonovaryOn f (g ^ n) s | null | true |
Int.gcd_pos_of_ne_zero_left | Init.Data.Int.Gcd | ∀ {a : ℤ} (b : ℤ), a ≠ 0 → 0 < a.gcd b | null | true |
Lean.LLVM.CodegenFileType.ctorIdx | Lean.Compiler.IR.LLVMBindings | Lean.LLVM.CodegenFileType → ℕ | null | false |
Lean.Elab.InlayHintKind.ctorElim | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintKind → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.InlayHintKind) → ctorIdx = t.ctorIdx → Lean.Elab.InlayHintKind.ctorElimType ctorIdx → motive t | null | false |
Std.HashMap.Raw.Equiv.diff_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ m₃ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₁.Equiv m₂ → (m₁ \ m₃).Equiv (m₂ \ m₃) | null | true |
Lean.Parser.AliasValue._sizeOf_inst | Lean.Parser.Extension | (α : Type) → [SizeOf α] → SizeOf (Lean.Parser.AliasValue α) | null | false |
CategoryTheory.SemiadditiveOfBinaryBiproducts.isUnital_leftAdd | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (X Y : C),
EckmannHilton.IsUnital (fun x1 x2 => CategoryTheory.SemiadditiveOfBinaryBiproducts.leftAdd X Y x1 x2) 0 | null | true |
Fin.pos_iff_ne_zero | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, 0 < a ↔ a ≠ 0 | null | true |
IsLocalization.mk'_spec | 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] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
IsLocalization.mk' S x y * (algebraMap R S) ↑y = (algebraMap R S) x | null | true |
CategoryTheory.Over.associator_inv_left_fst_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
(R S T : CategoryTheory.Over X) {Z : C} (h : S.left ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.associator R S T).inv)
... | null | true |
DedekindCut.principal_sInf_right | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : CompleteLattice α] (A : DedekindCut α), DedekindCut.principal (sInf A.right) = A | null | true |
Set.Ico.coe_eq_zero | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Zero R] [inst_1 : One R] [inst_2 : PartialOrder R] [inst_3 : ZeroLEOneClass R]
[inst_4 : NeZero 1] {x : ↑(Set.Ico 0 1)}, ↑x = 0 ↔ x = 0 | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorAccess.match_1.splitter | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → (Unit → motive none) → ((next : α) → motive (some next)) → motive x | null | true |
Set.iUnion_iInter_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Finite ι] [inst : Preorder ι'] [IsCodirectedOrder ι'] [Nonempty ι']
{s : ι → ι' → Set α}, (∀ (i : ι), Antitone (s i)) → ⋃ j, ⋂ i, s i j = ⋂ i, ⋃ j, s i j | A decreasing union distributes over finite intersection. | true |
Lean.Lsp.CodeActionTriggerKind.casesOn | Lean.Data.Lsp.CodeActions | {motive : Lean.Lsp.CodeActionTriggerKind → Sort u} →
(t : Lean.Lsp.CodeActionTriggerKind) →
motive Lean.Lsp.CodeActionTriggerKind.invoked → motive Lean.Lsp.CodeActionTriggerKind.automatic → motive t | null | false |
Int16.ofIntTruncate_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 16), Int16.ofIntClamp n.toInt = Int16.ofBitVec n | null | true |
DirectSum.ring | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
[DecidableEq ι] →
(A : ι → Type u_2) →
[inst : (i : ι) → AddCommGroup (A i)] →
[inst_1 : AddMonoid ι] → [DirectSum.GRing A] → Ring (DirectSum ι fun i => A i) | The `Ring` derived from `GSemiring A`. | true |
HolderWith.holderWith_zero_of_bounded | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {r : NNReal} {f : X → Y}
{C D : NNReal}, (∀ (x y : X), edist x y ≤ ↑D) → HolderWith C r f → HolderWith (C * D ^ ↑r) 0 f | If a function is Hölder over a bounded space, then it is bounded. | true |
Nat.strongSubRecursion.match_1 | Mathlib.Data.Nat.Init | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((n m : ℕ) → motive n m) → motive x x_1 | null | false |
Std.DTreeMap.contains_filterMap | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {γ : α → Type w} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.DTreeMap.filterMap f t).contains k = Option.any (fun x => (f k x).isSome) (t.get? k) | null | true |
ZMod.instIsDomainOfNatNat | Mathlib.Data.ZMod.Basic | IsDomain (ZMod 0) | null | true |
_private.Lean.Data.Json.Printer.0.Lean.Json.CompressWorkItemQueue.rec | Lean.Data.Json.Printer | {motive : Lean.Json.CompressWorkItemQueue✝ → Sort u} →
((kinds : Array Lean.Json.CompressWorkItemKind✝) →
(values : Array Lean.Json) →
(objectFieldKeys : Array String) →
motive { kinds := kinds, values := values, objectFieldKeys := objectFieldKeys }) →
(t : Lean.Json.CompressWorkItemQueue✝... | null | false |
Setoid.instLE_mathlib | Mathlib.Order.Setoid.Basic | {α : Type u_1} → LE (Setoid α) | Defining `≤` for equivalence relations. | true |
IsModularLattice.recOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsModularLattice α → Sort u} →
(t : IsModularLattice α) →
((sup_inf_le_assoc_of_le : ∀ {x : α} (y : α) {z : α}, x ≤ z → (x ⊔ y) ⊓ z ≤ x ⊔ y ⊓ z) → motive ⋯) → motive t | null | false |
CategoryTheory.SymmetricCategory.symmetry | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.SymmetricCategory C] (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | true |
CategoryTheory.DinatTrans.recOn | Mathlib.CategoryTheory.DinatTrans | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor C D)} →
{motive : CategoryTheory.DinatTrans F G → Sort u} →
(t : CategoryTheory.DinatTrans F G... | null | false |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.eLpNorm_restrict_eq_of_support_subset._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
CategoryTheory.Monad.ForgetCreatesColimits.liftedCoconeIsColimit._proof_4 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.... | null | false |
HahnEmbedding.Partial.eval_zero | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | null | true |
LocallyCompactPair.rec | Mathlib.Topology.Defs.Filter | {X : Type u_3} →
{Y : Type u_4} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : LocallyCompactPair X Y → Sort u} →
((exists_mem_nhds_isCompact_mapsTo :
∀ {f : X → Y} {x : X} {s : Set Y},
Continuous f → s ∈ nhds (f x) → ∃ K ∈ nhds ... | null | false |
FirstOrder.Ring.compatibleRingOfRingStructure | Mathlib.ModelTheory.Algebra.Ring.Basic | (R : Type u_2) → [inst : FirstOrder.Language.ring.Structure R] → FirstOrder.Ring.CompatibleRing R | Given a Type `R` with a `Language.ring.Structure R`, the instance given by
`addOfRingStructure` etc. are compatible with the `Language.ring.Structure` instance on `R`.
This definition is only to be used when `addOfRingStructure`, `mulOfRingStructure` etc
are local instances.
| true |
Frm.coe_of | Mathlib.Order.Category.Frm | ∀ (X : Type u) [inst : Order.Frame X], ↑↧X = X | null | true |
unitSphereToUnits._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ (𝕜 : Type u_1) [inst : NormedDivisionRing 𝕜] (x : ↑(Metric.sphere 0 1)), ↑x ≠ 0 | null | false |
_private.Mathlib.Logic.Equiv.Multiset.0.instDecidableRelEnle | Mathlib.Logic.Equiv.Multiset | {α : Type u_1} → [inst : Encodable α] → DecidableRel enle✝ | null | true |
RegularExpression.zero.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 0 → motive RegularExpression.zero → motive t | null | false |
LinearMap.isPositive_toContinuousLinearMap_iff | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E), (LinearMap.toContinuousLinearMap T).IsPositive ↔ T.IsPositive | null | true |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast._proof_2 | Mathlib.Data.Rat.Cast.Order | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
Lean.Elab.Tactic.Omega.MetaProblem.processFacts | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → Lean.Elab.Tactic.Omega.OmegaM (Lean.Elab.Tactic.Omega.MetaProblem × ℕ) | Process all the facts in a `MetaProblem`, returning the new problem, and the number of new facts.
This is partial because new facts may be generated along the way.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.