name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Bornology.isVonNBounded_neg._simp_1 | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : TopologicalSpace E]
[IsTopologicalAddGroup E] [inst_4 : DistribMulAction 𝕜 E] {s : Set E},
Bornology.IsVonNBounded 𝕜 (-s) = Bornology.IsVonNBounded 𝕜 s | false |
Lean.Grind.GrobnerConfig.maxSuggestions._inherited_default | Init.Grind.Config | Option ℕ | false |
pow_ne_one_of_lt_orderOf | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, n ≠ 0 → n < orderOf x → x ^ n ≠ 1 | true |
hasDerivAt_iff_hasFDerivAt | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] {f : 𝕜 → F} {x : 𝕜} [inst_4 : ContinuousSMul 𝕜 F] {f' : F},
HasDerivAt f f' x ↔ HasFDerivAt f (ContinuousLinearMap.toSpanSingleton 𝕜 f') x | true |
Std.ExtDHashMap.Const.get!_erase | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited β] {k a : α},
Std.ExtDHashMap.Const.get! (m.erase k) a = if (k == a) = true then default else Std.ExtDHashMap.Const.get! m a | true |
CategoryTheory.leftDualFunctor_map | Mathlib.CategoryTheory.Monoidal.Rigid.Functor | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.LeftRigidCategory C] {X Y : C} (f : X ⟶ Y),
(CategoryTheory.leftDualFunctor C).map f = (ᘁf).op.mop | true |
_private.Mathlib.AlgebraicGeometry.PullbackCarrier.0.AlgebraicGeometry.Scheme.Pullback.range_snd._simp_1_4 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
TrivSqZeroExt.addGroup._proof_4 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroup R] [inst_1 : AddGroup M],
autoParam (∀ (a : TrivSqZeroExt R M), TrivSqZeroExt.addGroup._aux_2 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam | false |
instMinStructureGroupoid._proof_3 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (G G' : StructureGroupoid H),
∀ e ∈ G.members ∩ G'.members, e.symm ∈ G.members ∧ e.symm ∈ G'.members | false |
CategoryTheory.ThinSkeleton.lowerAdjunction._proof_2 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (R : CategoryTheory.Functor D C) (L : CategoryTheory.Functor C D)
(h : L ⊣ R) ⦃X Y : CategoryTheory.ThinSkeleton D⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.... | false |
Std.IterM.TerminationMeasures.Finite.mk.sizeOf_spec | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β] [inst_1 : SizeOf α]
[inst_2 : (a : Type w) → SizeOf (m a)] [inst_3 : SizeOf β] (it : Std.IterM m β), sizeOf { it := it } = 1 + sizeOf it | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.sdiff_insert_insert_of_mem_of_notMem._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {x : α}, x ∈ s → x ∉ t → insert x (s \ insert x t) = s \ t | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.isEmpty_inter_iff._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
_private.Lean.Data.RArray.0.Lean.RArray.get_ofFn._proof_1_5 | Lean.Data.RArray | ∀ {n : ℕ} (i : Fin n) (lb ub : ℕ), ¬↑i < (lb + ub) / 2 → ¬(lb + ub) / 2 ≤ ↑i → False | false |
instIsTopologicalRingReal | Mathlib.Topology.Algebra.Ring.Real | IsTopologicalRing ℝ | true |
Std.Rii.getElem?_toArray_eq | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_4 : Std.Rxi.IsAlwaysFinite α] {i : ℕ}, r.toArray[i]? = Std.PRange.least?.bind (Std.PRange.succMany? i) | true |
Finset.Nonempty.to_subtype | Mathlib.Data.Finset.Empty | ∀ {α : Type u_1} {s : Finset α}, s.Nonempty → Nonempty ↥s | true |
Lean.Meta.Grind.Order.ProofInfo.mk | Lean.Meta.Tactic.Grind.Order.Types | Lean.Meta.Grind.Order.NodeId → Lean.Meta.Grind.Order.Weight → Lean.Expr → Lean.Meta.Grind.Order.ProofInfo | true |
Equiv.dvd._proof_4 | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {G : Type u_1} [inst : LeftCancelSemigroup G] (g : G),
Function.RightInverse
(fun x =>
match x with
| ⟨val, h⟩ => Exists.choose h)
fun a => ⟨g * a, ⋯⟩ | false |
instReprAtomInt64 | Init.Data.SInt.Basic | ReprAtom Int64 | true |
MvPolynomial.monomial_mul_mem_coeffsIn._simp_1 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u_2} {S : Type u_3} {σ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Module R S]
{M : Submodule R S} {p : MvPolynomial σ S} {i : σ →₀ ℕ},
((MvPolynomial.monomial i) 1 * p ∈ MvPolynomial.coeffsIn σ M) = (p ∈ MvPolynomial.coeffsIn σ M) | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getKey | Lean.Meta.Sym.Simp.DiscrTree | Lean.Expr → Lean.Meta.DiscrTree.Key | true |
_private.Mathlib.CategoryTheory.Sites.ConcreteSheafification.0.CategoryTheory.GrothendieckTopology.isoSheafify_inv._simp_1_1 | Mathlib.CategoryTheory.Sites.ConcreteSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | false |
Lean.Meta.Grind.Arith.Linear.RingIneqCnstr.mk.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {p : Lean.Grind.CommRing.Poly} {strict : Bool} {h : Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof}
{p_1 : Lean.Grind.CommRing.Poly} {strict_1 : Bool} {h_1 : Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof},
{ p := p, strict := strict, h := h } = { p := p_1, strict := strict_1, h := h_1 } →
p = p_1 ∧ strict ... | true |
Std.DTreeMap.mem_diff_iff._simp_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(k ∈ t₁ \ t₂) = (k ∈ t₁ ∧ k ∉ t₂) | false |
instCoeTCInfTopHomOfInfTopHomClass.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Min α] [inst_2 : Min β] [inst_3 : Top α]
[inst_4 : Top β] [inst_5 : InfTopHomClass F α β],
instCoeTCInfTopHomOfInfTopHomClass = { coe := fun f => { toFun := ⇑f, map_inf' := ⋯, map_top' := ⋯ } } | true |
CategoryTheory.isRegularMono_of_regularMono | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} (h : CategoryTheory.RegularMono f),
CategoryTheory.IsRegularMono f | true |
MeasurableEquiv.restrict_map | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} (e : α ≃ᵐ β)
(μ : MeasureTheory.Measure α) (s : Set β),
(MeasureTheory.Measure.map (⇑e) μ).restrict s = MeasureTheory.Measure.map (⇑e) (μ.restrict (⇑e ⁻¹' s)) | true |
DFinsupp.lattice._proof_1 | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Lattice (α i)] (a b : DFinsupp α),
a ≤ SemilatticeSup.sup a b | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.instUsableInSimplexAlgorithmDenseMatrix | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm Mathlib.Tactic.Linarith.SimplexAlgorithm.DenseMatrix | true |
BoundedContinuousFunction.norm_le_of_nonempty | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β] [Nonempty α]
{f : BoundedContinuousFunction α β} {M : ℝ}, ‖f‖ ≤ M ↔ ∀ (x : α), ‖f x‖ ≤ M | true |
List.idxOf?_cons | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] {a : α} {xs : List α} {b : α},
List.idxOf? b (a :: xs) = if (a == b) = true then some 0 else Option.map (fun x => x + 1) (List.idxOf? b xs) | true |
_private.Lean.Elab.Tactic.Grind.Basic.0.Lean.Elab.Tactic.Grind.liftGoalM.match_1 | Lean.Elab.Tactic.Grind.Basic | {α : Type} →
(motive : α × Lean.Meta.Grind.Goal → Sort u_1) →
(__discr : α × Lean.Meta.Grind.Goal) → ((a : α) → (goal : Lean.Meta.Grind.Goal) → motive (a, goal)) → motive __discr | false |
List.prod_eq_zero_iff._simp_1 | Mathlib.Algebra.BigOperators.Ring.List | ∀ {M₀ : Type u_4} [inst : MonoidWithZero M₀] [Nontrivial M₀] [NoZeroDivisors M₀] {l : List M₀}, (l.prod = 0) = (0 ∈ l) | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.IsStrictlyPositive.nnrpow._proof_1_7 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A] [inst_5 : Algebra ℝ A]
[inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint | false |
ContinuousAlternatingMap.bound | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] (f : E [⋀^ι]→L[𝕜] F),
∃ C, 0 < C ∧ ∀ (m : ι → E), ‖f m‖ ≤ C * ∏ i, ‖m i... | true |
Fin.lt_or_le | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), a < b ∨ b ≤ a | true |
_private.Mathlib.Algebra.Lie.InvariantForm.0.LinearMap.BilinForm.lieInvariant_iff._simp_1_1 | Mathlib.Algebra.Lie.InvariantForm | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Std.Sat.AIG.mkBEqCached_le_size | Std.Sat.AIG.CachedGatesLemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) {input : aig.BinaryInput},
aig.decls.size ≤ (aig.mkBEqCached input).aig.decls.size | true |
eq_moduleTopology | Mathlib.Topology.Algebra.Module.ModuleTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] (A : Type u_2) [inst_1 : Add A] [inst_2 : SMul R A]
[τA : TopologicalSpace A] [IsModuleTopology R A], τA = moduleTopology R A | true |
_private.Mathlib.Tactic.Order.ToInt.0.Mathlib.Tactic.Order.ToInt.toInt_inf_toInt_eq_toInt._simp_1_3 | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u} [inst : SemilatticeInf α] {c a b : α}, (c ≤ a ⊓ b) = (c ≤ a ∧ c ≤ b) | false |
SMulCommClass.continuousConstSMul | Mathlib.Topology.Algebra.Monoid | ∀ {R : Type u_6} {A : Type u_7} [inst : Monoid A] [inst_1 : SMul R A] [SMulCommClass R A A]
[inst_3 : TopologicalSpace A] [SeparatelyContinuousMul A], ContinuousConstSMul R A | true |
Equiv.Perm.sameCycle_pow_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℕ}, f.SameCycle x ((f ^ n) y) ↔ f.SameCycle x y | true |
CompleteLinearOrder | Mathlib.Order.CompleteLattice.Defs | Type u_8 → Type u_8 | true |
Lean.TraceResult.success.elim | Lean.Message | {motive : Lean.TraceResult → Sort u} →
(t : Lean.TraceResult) → t.ctorIdx = 0 → motive Lean.TraceResult.success → motive t | false |
ZFSet.toSet_iUnion | Mathlib.SetTheory.ZFC.Basic | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] (f : α → ZFSet.{u}), ↑(ZFSet.iUnion fun i => f i) = ⋃ i, ↑(f i) | true |
QuadraticModuleCat.hasForgetToModule._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y Z : QuadraticModuleCat R} (f : X ⟶ Y) (g : Y ⟶ Z),
ModuleCat.ofHom (QuadraticModuleCat.Hom.toIsometry (CategoryTheory.CategoryStruct.comp f g)).toLinearMap =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (QuadraticModuleCat.Hom.toIsometry f).toLinearMap)
(Modu... | false |
Array.getElem_append._proof_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs ys : Array α}, i < (xs ++ ys).size → ¬i < xs.size → i - xs.size < ys.size | false |
Lean.Meta.SynthInstance.MkTableKey.normExpr | Lean.Meta.SynthInstance | Lean.Expr → Lean.Meta.SynthInstance.MkTableKey.M Lean.Expr | true |
Zsqrtd.le_arch | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℕ} (a : ℤ√↑d), ∃ n, a ≤ ↑n | true |
Module.Grassmannian.mk.noConfusion | Mathlib.RingTheory.Grassmannian | {R : Type u} →
{inst : CommRing R} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{k : ℕ} →
{P : Sort u_1} →
{toSubmodule : Submodule R M} →
{finite_quotient : Module.Finite R (M ⧸ toSubmodule)} →
{projective... | false |
_private.Lean.Meta.Tactic.Grind.Proof.0.Lean.Meta.Grind.mkEqProofCore | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → Bool → Lean.Meta.Grind.GoalM Lean.Expr | true |
Fin.strictMono_succ | Mathlib.Order.Fin.Basic | ∀ {n : ℕ}, StrictMono Fin.succ | true |
SSet.Truncated.Edge.edge | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })} →
SSet.Truncated.Edge x₀ x₁ →
X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.Edge._proof_2 }) | true |
cfcₙ_eq_cfcₙL_mkD | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | true |
_private.Mathlib.Topology.Maps.Proper.Basic.0.IsProperMap.pi_map._simp_1_2 | Mathlib.Topology.Maps.Proper.Basic | ∀ {Y : Type v} {ι : Type u_5} {A : ι → Type u_6} [T : (i : ι) → TopologicalSpace (A i)] {f : Y → (i : ι) → A i}
{g : (i : ι) → A i} {u : Filter Y},
Filter.Tendsto f u (nhds g) = ∀ (x : ι), Filter.Tendsto (fun i => f i x) u (nhds (g x)) | false |
Aesop.Nanos.mk.sizeOf_spec | Aesop.Nanos | ∀ (nanos : ℕ), sizeOf { nanos := nanos } = 1 + sizeOf nanos | true |
Finset.prod_range_succ_div_prod | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {n : ℕ} [inst : CommGroup M],
(∏ i ∈ Finset.range (n + 1), f i) / ∏ i ∈ Finset.range n, f i = f n | true |
Topology.IsOpenEmbedding.toOpenPartialHomeomorph._proof_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
Topology.IsOpenEmbedding f → Set.InjOn f Set.univ | false |
Lean.Elab.InlayHintLabel.parts | Lean.Elab.InfoTree.InlayHints | Array Lean.Elab.InlayHintLabelPart → Lean.Elab.InlayHintLabel | true |
Action._sizeOf_inst | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
{inst : CategoryTheory.Category.{v_1, u_1} V} →
(G : Type u_2) → {inst_1 : Monoid G} → [SizeOf V] → [SizeOf G] → SizeOf (Action V G) | false |
Function.End.applyMulAction._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {α : Type u_1} (x : α), 1 • x = 1 • x | false |
Set.integer_valuation_le_one | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type v) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : ↥(S.integer K))
{v : IsDedekindDomain.HeightOneSpectrum R}, v ∉ S → (IsDedekindDomain.HeightOneSpectrum.valuatio... | true |
CategoryTheory.Iso.core_inv_app_iso_inv | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : CategoryTheory.Core C),
(α.core.inv.app X).iso.inv = α.hom.app X.of | true |
CategoryTheory.GrothendieckTopology.Point.skyscraperSheafAdjunction_homEquiv_apply_hom | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] {F : CategoryTheory.Sheaf ... | true |
zero_lt_iff | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, 0 < a ↔ a ≠ 0 | true |
FreeMagma.lift_comp_of | Mathlib.Algebra.Free | ∀ {α : Type u} {β : Type v} [inst : Mul β] (f : α → β), ⇑(FreeMagma.lift f) ∘ FreeMagma.of = f | true |
String.Slice.RevSplitIterator.instIteratorLoopOfMonad | Init.Data.String.Slice | {ρ : Type} →
{ρ_1 : ρ} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[inst_1 : String.Slice.Pattern.ToBackwardSearcher ρ_1 σ] →
{m : Type → Type u_1} →
{n : Type u_2 → Type u_3} →
{s : Strin... | true |
Lean.JsonRpc.instToJsonErrorCode.match_1 | Lean.Data.JsonRpc | (motive : Lean.JsonRpc.ErrorCode → Sort u_1) →
(x : Lean.JsonRpc.ErrorCode) →
(Unit → motive Lean.JsonRpc.ErrorCode.parseError) →
(Unit → motive Lean.JsonRpc.ErrorCode.invalidRequest) →
(Unit → motive Lean.JsonRpc.ErrorCode.methodNotFound) →
(Unit → motive Lean.JsonRpc.ErrorCode.invalidPar... | false |
Lean.Parser.Term.ensureTypeOf._regBuiltin.Lean.Parser.Term.ensureTypeOf_1 | Lean.Parser.Term | IO Unit | false |
disjoint_sSup_iff | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : Order.Frame α] {a : α} {s : Set α}, Disjoint a (sSup s) ↔ ∀ b ∈ s, Disjoint a b | true |
SimpleGraph.Walk.darts._sunfold | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → List G.Dart | false |
Polynomial.exists_irreducible_of_natDegree_pos | Mathlib.RingTheory.Polynomial.UniqueFactorization | ∀ {R : Type u_1} [inst : CommSemiring R] [NoZeroDivisors R] [WfDvdMonoid R] {f : Polynomial R} [Nontrivial R],
0 < f.natDegree → ∃ g, Irreducible g ∧ g ∣ f | true |
Std.Net.instDecidableEqInterfaceAddress.decEq | Std.Net.Addr | (x x_1 : Std.Net.InterfaceAddress) → Decidable (x = x_1) | true |
ContinuousLinearMap._sizeOf_inst | Mathlib.Topology.Algebra.Module.LinearMap | {R : Type u_1} →
{S : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
(σ : R →+* S) →
(M : Type u_3) →
{inst_2 : TopologicalSpace M} →
{inst_3 : AddCommMonoid M} →
(M₂ : Type u_4) →
{inst_4 : TopologicalSpace M₂} →
... | false |
Polynomial.IsSeparableContraction.natSepDegree_eq | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} [inst : Field F] {f g : Polynomial F} {q : ℕ} [ExpChar F q],
Polynomial.IsSeparableContraction q f g → f.natSepDegree = g.natDegree | true |
Char.ordinal_le_of_le | Init.Data.Char.Ordinal | ∀ {c d : Char}, c ≤ d → c.ordinal ≤ d.ordinal | true |
ContinuousLinearMap.isUniformAddGroup | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_4}
{F : Type u_5} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGr... | true |
IsPrimitiveRoot.ntRootsFinset_pairwise_associated_sub_one_sub_of_prime | Mathlib.RingTheory.RootsOfUnity.CyclotomicUnits | ∀ {p : ℕ} {A : Type u_1} {ζ : A} [inst : CommRing A] [inst_1 : IsDomain A],
IsPrimitiveRoot ζ p →
Nat.Prime p → (↑(Polynomial.nthRootsFinset p 1)).Pairwise fun η₁ η₂ => Associated (ζ - 1) (η₁ - η₂) | true |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.BoundedFormula.realize_iInf._simp_1_4 | Mathlib.ModelTheory.Semantics | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
Cardinal.Real.Ico_countable_iff | Mathlib.Analysis.Real.Cardinality | ∀ {x y : ℝ}, (Set.Ico x y).Countable ↔ y ≤ x | true |
Order.le_succ_iterate | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] (k : ℕ) (x : α), x ≤ Order.succ^[k] x | true |
acc_transGen_iff | Init.WF | ∀ {α : Sort u_1} {r : α → α → Prop} {a : α}, Acc (Relation.TransGen r) a ↔ Acc r a | true |
List.flatMap_id' | Init.Data.List.Lemmas | ∀ {α : Type u_1} {L : List (List α)}, List.flatMap (fun as => as) L = L.flatten | true |
Lean.Meta.Grind.AC.EqCnstrProof.superpose.elim | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstrProof) →
t.ctorIdx = 10 →
((p s c : Lean.Grind.AC.Seq) →
(c₁ c₂ : Lean.Meta.Grind.AC.EqCnstr) → motive_2 (Lean.Meta.Grind.AC.EqCnstrProof.superpose p s c c₁ c₂)) →
motive_2 t | false |
IsDomain.casesOn | Mathlib.Algebra.Ring.Defs | {α : Type u} →
[inst : Semiring α] →
{motive : IsDomain α → Sort u_1} →
(t : IsDomain α) → ([toIsCancelMulZero : IsCancelMulZero α] → [toNontrivial : Nontrivial α] → motive ⋯) → motive t | false |
CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.instRingEmbeddingRing._aux_28 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.SmallCategory D] →
(F : CategoryTheory.Functor D Cᵒᵖ) →
[inst_2 : CategoryTheory.Abelian C] →
[inst_3 : CategoryTheory.IsGrothendieckAbelian.{u_1, u_1, u_2} C] →
... | false |
Associates.bcount.congr_simp | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {inst_1 : DecidableEq (Associates α)}
[inst_2 : DecidableEq (Associates α)] (p p_1 : { a // Irreducible a }),
p = p_1 → ∀ (a a_1 : Associates.FactorSet α), a = a_1 → Associates.bcount p a = Associates.bcount p_1 a_1 | true |
Lean.Expr.consumeMData._sunfold | Lean.Expr | Lean.Expr → Lean.Expr | false |
HomologicalComplex.instCategory._proof_5 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {X Y : HomologicalComplex V c} (f : X.Hom Y),
X.comp Y Y f Y.id = f | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.getRevArg?.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((fn a : Lean.Expr) → motive (fn.app a) 0) →
((f arg : Lean.Expr) → (i : ℕ) → motive (f.app arg) i.succ) →
((x : Lean.Expr) → (x_2 : ℕ) → motive x x_2) → motive x x_1 | false |
CommGroup.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → CommGroup G → ℕ | false |
Asymptotics.isLittleO_pure._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{f'' : α → E''} {g'' : α → F''} {x : α}, f'' =o[pure x] g'' = (f'' x = 0) | false |
Matroid.fundCircuit_subset_ground._auto_1 | Mathlib.Combinatorics.Matroid.Circuit | Lean.Syntax | false |
ULift.seminormedCommRing._proof_14 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a : ULift.{u_1, u_2} α), SubNegMonoid.zsmul 0 a = 0 | false |
Std.Time.OffsetZ.classify | Std.Time.Format.Basic | ℕ → Option Std.Time.OffsetZ | true |
Metric.isUniformInducing_iff | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
IsUniformInducing f ↔ UniformContinuous f ∧ ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, dist (f a) (f b) < ε → dist a b < δ | true |
Std.Time.Second.instDecidableLeOrdinal._aux_1 | Std.Time.Time.Unit.Second | {leap : Bool} → {x y : Std.Time.Second.Ordinal leap} → Decidable (x ≤ y) | false |
IsPrimitiveRoot.primitiveRootsPowEquivOfCoprime._proof_5 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {a n : ℕ} (h : a.Coprime n) [inst : NeZero n], a * ⋯.choose ≡ 1 [MOD n] | false |
Vector.find?_singleton | Init.Data.Vector.Find | ∀ {α : Type} {a : α} {p : α → Bool}, Vector.find? p #v[a] = if p a = true then some a else none | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.