name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Left.self_le_neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] {a : α}, a ≤ 0 → a ≤ -a | null | true |
_private.Init.Data.Array.Find.0.Array.getElem_zero_flatten.proof._simp_1_2 | Init.Data.Array.Find | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x | null | false |
meromorphicAt_of_meromorphicOrderAt_ne_zero | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x ≠ 0 → MeromorphicAt f x | null | true |
TopologicalSpace.Compacts.mem_singleton | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x y : α), x ∈ {y} ↔ x = y | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_B._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
(∀ i ∈ s, IsOpen (f i)) → IsOpen (⋃ i ∈ s, f i) = True | null | false |
Nat.le_of_ble_eq_true | Init.Prelude | ∀ {n m : ℕ}, n.ble m = true → n ≤ m | null | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}) (motive : { x // x ∈ Set.Iio o } → Sort u_2) (x : Ordinal.{u_1}) (property : x ∈ Set.Iio o)
(h_1 : (x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩),
(match ⟨x, property⟩ with
| ⟨x, property⟩ => h_1 x property) =
h_1 x property | null | true |
CategoryTheory.WithTerminal.equivComma_functor_map_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{X Y : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D} (η : X ⟶ Y) (X_1 : C),
(CategoryTheory.WithTerminal.equivComma.functor.map η).left.app X_1 = η.app (CategoryTheory.WithTerminal.inc... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isLongestRevMatch_cast_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
SimpleGraph.EdgeLabeling.compRight_get | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {K' : Type u_4} {C : G.EdgeLabeling K} (f : K → K') (x y : V)
(h : G.Adj x y), (C.compRight f).get x y h = f (C.get x y h) | null | true |
BoolRing.instCategory._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := { hom' := RingHom.id ↑Y }.hom'.comp f.hom' } = f | null | false |
TopologicalSpace.Clopens.exists_finset_eq_sup_prod | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
[CompactSpace X] (W : TopologicalSpace.Clopens (X × Y)), ∃ I, W = I.sup fun i => i.1 ×ˢ i.2 | Every clopen set in a product of two compact spaces
is a union of finitely many clopen boxes. | true |
Subalgebra.mulMap_comm | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
(A B : Subalgebra R S), B.mulMap A = (A.mulMap B).comp ↑(Algebra.TensorProduct.comm R ↥B ↥A) | null | true |
instSliceableByteArrayNatByteSlice_3 | Std.Data.ByteSlice | Std.Roc.Sliceable ByteArray ℕ ByteSlice | null | true |
SSet.stdSimplex.faceRepresentableBy._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory} (f : j ⟶ { len := m }),
∀
x ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((OrderHom.Subtype.val fun x => x ∈ S).com... | null | false |
Std.DHashMap.Raw.get?_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → (m₁ ∩ m₂).get? k = m₁.get? k | null | true |
IsAddLeftRegular.all | Mathlib.Algebra.Group.Semigroup | ∀ {R : Type u_2} [inst : Add R] [IsLeftCancelAdd R] (g : R), IsAddLeftRegular g | If all additions cancel on the left then every element is add-left-regular. | true |
stdSimplex.instUniqueElemForall._proof_1 | Mathlib.Analysis.Convex.StdSimplex | ∀ {S : Type u_1} [inst : Semiring S] [inst_1 : PartialOrder S] {X : Type u_2} [IsOrderedRing S] (x : X), 0 ≤ 1 x | null | false |
DirectLimit.Ring.of_apply | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.BaseChange.0.Algebra.tensorH1CotangentOfFlat._proof_7 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T],
LinearMap.CompatibleSMul (Algebra.Generators.self R S).toExtension.baseChange.H1Cotangent
(Algebra.Generators.baseChange T (Algebra.Generators.self R S)).... | null | false |
WeierstrassCurve.Jacobian.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) | null | true |
Int.fdiv_eq_ediv_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → a.fdiv b = a / b | null | true |
AddMonoidAlgebra.semiring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] (x : AddMonoidAlgebra R M), x ^ 0 = 1 | null | false |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.initFn._@.Lean.PrettyPrinter.4173001584._hygCtx._hyg.2 | Lean.PrettyPrinter | IO Unit | null | false |
Lean.findField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name | Returns the name of the structure that contains the field relative to structure `structName`.
If `structName` contains the field itself, returns that,
and otherwise recursively looks into parents that are subobjects.
| true |
Std.DTreeMap.Internal.Impl.size_balanceR | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β} (hlb : l.Balanced)
(hrb : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size l.size),
(Std.DTreeMap.Internal.Impl.balanceR k v l r hlb hrb hlr).size = l.size + 1 + r.size | null | true |
AList.toFinmap_entries | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (s : AList β), s.toFinmap.entries = ↑s.entries | null | true |
SpectralMap.coe_id | Mathlib.Topology.Spectral.Hom | ∀ (α : Type u_2) [inst : TopologicalSpace α], ⇑(SpectralMap.id α) = id | null | true |
DifferentiableOn.isConservativeOn | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {U : Set ℂ},
DifferentiableOn ℂ f U → Complex.IsConservativeOn f U | null | true |
_private.Mathlib.Analysis.Asymptotics.TVS.0.Asymptotics.isLittleOTVS_iff_isLittleO._simp_1_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {f : α → E} {g : α → F} {l : Filter α} [inst : Norm E] [inst_1 : Norm F],
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | null | false |
Nat.add_sub_add_right | Init.Data.Nat.Basic | ∀ (n k m : ℕ), n + k - (m + k) = n - m | null | true |
CategoryTheory.Iso.inv_hom_id_app_apply | Mathlib.CategoryTheory.Types.Basic | ∀ {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 : C) {F_1 : D → D → Type uF} {carrier : D → Type w}
{instFunLike : (X Y : D) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : CategoryTheory... | null | true |
Std.Iterators.Types.DropWhile.dropping | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} → Std.Iterators.Types.DropWhile α m β P → Bool | Internal implementation detail of the iterator library. | true |
EuclideanSpace.inner_single_right | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜)
(v : EuclideanSpace 𝕜 ι), inner 𝕜 v (EuclideanSpace.single i a) = a * (starRingEnd ((fun x => 𝕜) i)) (v.ofLp i) | null | true |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_empty._proof_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {p : ↑unitInterval} (s : Set (Set ι)), ∅ ∉ s → {t | t ∈ s ∧ t ⊆ ∅} = ∅ | null | false |
Aesop.RuleStats.mk._flat_ctor | Aesop.Stats.Basic | Aesop.DisplayRuleName → Aesop.Nanos → Bool → Aesop.RuleStats | null | false |
Aesop.GoalData.ctorIdx | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → ℕ | null | false |
_private.Mathlib.Algebra.Order.Ring.Int.0.Nat.exists_add_mul_eq_of_gcd_dvd_of_mul_pred_le.match_1_1 | Mathlib.Algebra.Order.Ring.Int | ∀ (q n : ℕ) (motive : q ∣ n → Prop) (x : q ∣ n), (∀ (b : ℕ) (eq : n = q * b), motive ⋯) → motive x | null | false |
ModularForm.cuspFormSubmodule.eq_1 | Mathlib.NumberTheory.ModularForms.CuspFormSubmodule | ∀ (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ) [inst : Γ.HasDetOne],
ModularForm.cuspFormSubmodule Γ k = CuspForm.toModularFormₗ.range | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Trimmed.recOn | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Trimming | ∀
{motive :
{basis : Tactic.ComputeAsymptotics.Basis} →
(a : Tactic.ComputeAsymptotics.MultiseriesExpansion basis) → a.Trimmed → Prop}
{basis : Tactic.ComputeAsymptotics.Basis} {a : Tactic.ComputeAsymptotics.MultiseriesExpansion basis} (t : a.Trimmed),
(∀ {c : ℝ}, motive c ⋯) →
(∀ {basis_hd : ℝ → ℝ}... | null | false |
TopCat.pathEquiv_symm_apply_hom_hom_apply | Mathlib.Topology.Homotopy.TopCat.Path | ∀ {X : TopCat} {x y : ↑X} (p : Path x y) (a : ULift.{u, 0} ↑unitInterval),
(TopCat.Hom.hom (TopCat.pathEquiv.symm p).hom) a = p (TopCat.I.homeomorph a) | null | true |
CategoryTheory.Presieve.HasPairwisePullbacks.casesOn | Mathlib.CategoryTheory.Sites.Sieves.Presieve | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{R : CategoryTheory.Presieve X} →
{motive : R.HasPairwisePullbacks → Sort u} →
(t : R.HasPairwisePullbacks) →
((has_pullbacks :
∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → Category... | null | false |
CategoryTheory.Comma.equivProd_functor_obj | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (a : CategoryTheory.Comma L R),
(CategoryTheory.... | null | true |
Array.scanrM.loop._unary | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → β → m β) → (as : Array α) → ℕ → (_ : β) ×' (start : ℕ) ×' (_ : start ≤ as.size) ×' Array β → m (Array β) | auxiliary tail-recursive function for scanrM | false |
Subsemigroup.coe_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup N) (f : M →ₙ* N),
↑(Subsemigroup.comap f S) = ⇑f ⁻¹' ↑S | null | true |
MvPolynomial.coeffs_C | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq R] (r : R),
(MvPolynomial.C r).coeffs = if r = 0 then ∅ else {r} | null | true |
_private.Init.Data.Range.Polymorphic.Int.0.Std.PRange.instLawfulUpwardEnumerableInt._proof_3 | Init.Data.Range.Polymorphic.Int | ∀ (n : ℕ) (a : ℤ), ¬a + ↑(n + 1) = a + ↑n + 1 → False | null | false |
ExteriorAlgebra.map._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M), 0 (f.toFun x) = 0 (f.toFun x) | null | false |
WithOne.coe_inv._simp_2 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} [inst : Inv α] (a : α), (↑a)⁻¹ = ↑a⁻¹ | null | false |
hasSum_of_isLUB_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), 0 ≤ f i) → IsLUB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | null | true |
IsLocalization.bot_lt_comap_prime | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[IsLocalization M S] [IsDomain R],
M ≤ nonZeroDivisors R → ∀ (p : Ideal S) [hpp : p.IsPrime], p ≠ ⊥ → ⊥ < Ideal.under R p | **Alias** of `IsLocalization.bot_lt_under_prime`. | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence.0.EisensteinSeries.eisensteinSeries_tendstoLocallyUniformly._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {p : Filter ι} [LocallyCompactSpace α],
TendstoLocallyUniformly F f p = ∀ (K : Set α), IsCompact K → TendstoUniformlyOn F f p K | null | false |
Submonoid.center.smulCommClass_left | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Monoid M], SMulCommClass (↥(Submonoid.center M)) M M | The center of a monoid acts commutatively on that monoid. | true |
Submonoid.rec | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : MulOneClass M] →
{motive : Submonoid M → Sort u} →
((toSubsemigroup : Subsemigroup M) →
(one_mem' : 1 ∈ toSubsemigroup.carrier) → motive { toSubsemigroup := toSubsemigroup, one_mem' := one_mem' }) →
(t : Submonoid M) → motive t | null | false |
Filter.hnot_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α}, ￢Filter.principal s = Filter.principal sᶜ | null | true |
Submodule.subtype_injective | Mathlib.Algebra.Module.Submodule.LinearMap | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M),
Function.Injective ⇑p.subtype | null | true |
Finset.tendsto_Ioc_atBot_prod_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [NoBotOrder α],
Filter.Tendsto (fun p => Finset.Ioc p.1 p.2) (Filter.atBot ×ˢ Filter.atTop) Filter.atTop | null | true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_conj_iff._simp_1_2 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.leadingTerm_eq_zero_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {s : σ →₀ ℕ} {b : R}, ((MvPolynomial.monomial s) b = 0) = (b = 0) | null | false |
Lean.IR.FnBody.sset | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → ℕ → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FnBody → Lean.IR.FnBody | Store `y : ty` at Position `sizeof(void*)*i + offset` in `x`. `x` must be a Constructor object and `RC(x)` must be 1.
`ty` must not be `object`, `tobject`, `erased` nor `Usize`. | true |
instDecidableEqInt64 | Init.Data.SInt.Basic | DecidableEq Int64 | null | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsColimitCokernelCofork_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hg₁ : S₁.g = 0)
(c₁ : CategoryTheory.Limits.CokernelCofork S₁.f) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hg₂ : S₂.g = 0)
(c₂ : CategoryTheor... | null | true |
finSigmaFinEquiv.match_1 | Mathlib.Algebra.BigOperators.Fin | (motive : (m : ℕ) → {n : Fin m → ℕ} → Sort u_1) →
(m : ℕ) → {n : Fin m → ℕ} → ((n : Fin 0 → ℕ) → motive 0) → ((m : ℕ) → (n : Fin m.succ → ℕ) → motive m.succ) → motive m | null | false |
IsAlgebraic.of_aeval_of_transcendental | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : A} {f : Polynomial R},
IsAlgebraic R ((Polynomial.aeval r) f) → Transcendental R f → IsAlgebraic R r | null | true |
CategoryTheory.Limits.Multifork.isoOfι | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
{I : CategoryTheory.Limits.MulticospanIndex J C} →
(t : CategoryTheory.Limits.Multifork I) → t ≅ CategoryTheory.Limits.Multifork.ofι I t.pt t.ι ⋯ | Every multifork is isomorphic to one of the form `Multifork.ofι`. | true |
MvPowerSeries.IsRestricted.smul | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] {σ : Type u_2} {c : σ → ℝ} (r : R) {f : MvPowerSeries σ R},
MvPowerSeries.IsRestricted c f → MvPowerSeries.IsRestricted c (r • f) | null | true |
_private.Mathlib.Combinatorics.Digraph.Orientation.0.Digraph.toSimpleGraphStrict_bot.match_1_1 | Mathlib.Combinatorics.Digraph.Orientation | ∀ {V : Type u_1} (x x_1 : V) (motive : ⊥.toSimpleGraphStrict.Adj x x_1 → Prop) (x_2 : ⊥.toSimpleGraphStrict.Adj x x_1),
(∀ (left : x ≠ x_1) (h : ⊥.Adj x x_1 ∧ ⊥.Adj x_1 x), motive ⋯) → motive x_2 | null | false |
Std.ExtDHashMap.not_mem_diff_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₁ → k ∉ m₁ \ m₂ | null | true |
Lean.Lsp.instToJsonTypeDefinitionParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.TypeDefinitionParams | null | true |
Lean.Parser.ParserModuleContext.mk.noConfusion | Lean.Parser.Types | {P : Sort u} →
{env : Lean.Environment} →
{options : Lean.Options} →
{currNamespace : Lean.Name} →
{openDecls : List Lean.OpenDecl} →
{env' : Lean.Environment} →
{options' : Lean.Options} →
{currNamespace' : Lean.Name} →
{openDecls' : List Lean.Ope... | null | false |
Lean.Lsp.TextDocumentSyncOptions.mk.injEq | Lean.Data.Lsp.TextSync | ∀ (openClose : Bool) (change : Lean.Lsp.TextDocumentSyncKind) (willSave willSaveWaitUntil : Bool)
(save? : Option Lean.Lsp.SaveOptions) (openClose_1 : Bool) (change_1 : Lean.Lsp.TextDocumentSyncKind)
(willSave_1 willSaveWaitUntil_1 : Bool) (save?_1 : Option Lean.Lsp.SaveOptions),
({ openClose := openClose, change... | null | true |
ZeroHom.toFun_eq_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] (f : ZeroHom M N), f.toFun = ⇑f | null | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.normEq0.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{p : Lean.Grind.CommRing.Poly} →
{d : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c : Lean.Meta.Grind.Arith.CommRing.EqCnstr} →
{p' : Lean.Grind.CommRing.Poly} →
{d' : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c' : Lean.Meta.Grind.Arith.CommRing.EqC... | null | false |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtOfIso'._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} (E : L.RightExtension F) {Y Y' : D} (e : Y ≅ Y')
(j : Categ... | null | false |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.IsUniformInducing.mk'._simp_1_2 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {f g : Filter α}, (f = g) = ∀ (s : Set α), s ∈ f ↔ s ∈ g | null | false |
Batteries.Tactic._aux_Batteries_Tactic_Unreachable___macroRules_Batteries_Tactic_unreachableConv_1 | Batteries.Tactic.Unreachable | Lean.Macro | null | false |
Mathlib.Meta.Positivity.Strictness.nonzero.elim | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{e : Q(«$α»)} →
{motive : (a : Option Q(PartialOrder «$α»)) → Mathlib.Meta.Positivity.Strictness zα e a → Sort u} →
{a : Option Q(PartialOrder «$α»)} →
(t : Mathlib.Meta.Positivity.Strictness zα e a) →
t.c... | null | false |
MonomialOrder.lex_le_iff | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {c d : σ →₀ ℕ},
MonomialOrder.lex.toSyn c ≤ MonomialOrder.lex.toSyn d ↔ toLex c ≤ toLex d | null | true |
AlgHom.snd_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), (AlgHom.snd R B C).comp (f.prod g) = g | null | true |
List.length_eraseP_le | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.eraseP p l).length ≤ l.length | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_one_two_three_iff._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Filter.filter_eq | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {f g : Filter α}, f.sets = g.sets → f = g | null | true |
Finset.gcd_eq_of_dvd_sub | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommRing α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β} {f g : β → α}
{a : α}, (∀ x ∈ s, a ∣ f x - g x) → gcd a (s.gcd f) = gcd a (s.gcd g) | null | true |
Turing.PartrecToTM2.Γ'.consₗ.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Γ' → Sort u} →
(t : Turing.PartrecToTM2.Γ') → t.ctorIdx = 0 → motive Turing.PartrecToTM2.Γ'.consₗ → motive t | null | false |
CategoryTheory.MorphismProperty.FunctorsInverting.hom_ext | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{W : CategoryTheory.MorphismProperty C} {F₁ F₂ : W.FunctorsInverting D} {α β : F₁ ⟶ F₂}, α.hom.app = β.hom.app → α = β | null | true |
CategoryTheory.Limits.piComparison_comp_π_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : β → C)
[inst_2 : CategoryTheory.Limits.HasCoproduct f] [inst_3 : CategoryTheory.Limits.HasCoproduct fun b => G.obj (f b)]
(b : β) {Z : D} (h : Z ⟶... | null | false |
RBTree.RBSet.mem_iff_lowerBound? | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : RBTree.RBSet α cmp} [Std.TransCmp cmp],
x ∈ t ↔ ∃ y, t.lowerBound? x = some y ∧ cmp x y = Ordering.eq | null | true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : NonUnitalNonAssocSemiring R] (x x_1 x_2 : QuadraticAlgebra R a b),
(x + x_1) * x_2 = x * x_2 + x_1 * x_2 | null | false |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.instField._proof_38 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
CompletableTopField (WithVal (IsDedekindDomain.HeightOneSpectrum.valuation K v)) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.expOpenPartialHomeomorph._simp_1 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {z : ℂ}, (Complex.exp z ∈ Complex.slitPlane) = (toIocMod Real.two_pi_pos (-Real.pi) z.im ≠ Real.pi) | null | false |
lowerBounds_Icc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ≤ a → lowerBounds (Set.Icc b a) = Set.Iic b | null | true |
HopfAlgCat.instMonoidalCategoryStruct._proof_2 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), SMulCommClass R R X.carrier | null | false |
spectrum.map_star | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] [inst_3 : InvolutiveStar R]
[inst_4 : StarRing A] [StarModule R A] (a : A), spectrum R (star a) = star (spectrum R a) | null | true |
LightCondensed.lanPresheafIso | Mathlib.Condensed.Discrete.Colimit | {S : LightProfinite} →
{F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)} →
CategoryTheory.Limits.IsColimit (F.mapCocone (CategoryTheory.Limits.coconeRightOpOfCone S.asLimitCone)) →
((LightCondensed.lanPresheaf F).obj (Opposite.op S) ≅ F.obj (Opposite.op S)) | A presheaf, which takes a light profinite set written as a sequential limit to the corresponding
colimit, agrees with the left Kan extension of its restriction.
| true |
AlgebraicGeometry.instSubsingletonOverTerminalScheme | Mathlib.AlgebraicGeometry.Limits | ∀ {X : AlgebraicGeometry.Scheme}, Subsingleton (X.Over (⊤_ AlgebraicGeometry.Scheme)) | null | true |
CategoryTheory.Limits.opCoproductIsoProduct_hom_comp_π_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct Z] (i : α) {Z_1 : Cᵒᵖ} (h : Opposite.op (Z i) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opCoproductIsoProduct Z).hom
(CategoryTheory.CategoryStruct.comp (... | null | true |
CategoryTheory.BasedFunctor.isHomLift_iff | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴) {R S : 𝒮} {a b : 𝒳.obj} (f : R ⟶ S)
(φ : a ⟶ b), 𝒴.p.IsHomLift f (F.map φ) ↔ 𝒳.p.IsHomLift f φ | null | true |
Polynomial.eval₂AlgHom | Mathlib.Algebra.Polynomial.AlgebraMap | {R : Type u} →
{A : Type z} →
{B : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] → (f : A →ₐ[R] B) → (b : B) → (∀ (a : A), Commute (f a) b) → Polynomial A →ₐ[R] B | `Polynomial.eval₂` as an `AlgHom` for noncommutative algebras.
This is `Polynomial.eval₂RingHom'` for `AlgHom`s. | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.searchArrayLiteral.identifyChain._sparseCasesOn_6 | Lean.Compiler.LCNF.ExtractClosed | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.surjective_quotientMap_of_maximal_of_localization._simp_1_2 | Mathlib.RingTheory.Localization.Ideal | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.