name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.checkMVar | Lean.Meta.LetToHave | Lean.MVarId → Array Lean.Expr → Lean.Meta.LetToHave.M✝ Unit | Checks whether the mvar creates a dependency on any let fvars.
Note: the local context of `mvarId` cannot depend on `letFVars`, since it was created outside these `let`s.
The only consideration is delayed assignments and which variables they depend on;
if the fvar is not passed among the `args`, the mvar cannot depend ... | true |
Polynomial.natDegree_mul_leadingCoeff_inv | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {K : Type u_1} [inst : DivisionRing K] (p : Polynomial K) {q : Polynomial K},
q ≠ 0 → (p * Polynomial.C q.leadingCoeff⁻¹).natDegree = p.natDegree | null | true |
MvPolynomial.coe_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ),
⇑(MvPolynomial.expand p) = MvPolynomial.eval₂ MvPolynomial.C ((fun s => MvPolynomial.X s) ^ p) | null | true |
CuspForm.instIsAddApplyUpperHalfPlaneComplex | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ}, IsAddApply (CuspForm Γ k) UpperHalfPlane ℂ | null | true |
NormedAddGroupHom.noConfusionType | Mathlib.Analysis.Normed.Group.Hom | Sort u →
{V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] →
NormedAddGroupHom V W →
{V' : Type u_1} →
{W' : Type u_2} →
[inst' : SeminormedAddCommGroup V'] →
[inst'_1 : Semi... | null | false |
_private.Mathlib.Algebra.Lie.Engel.0.LieAlgebra.isEngelian_of_isNoetherian._simp_1_1 | Mathlib.Algebra.Lie.Engel | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{x : L}, (x ∈ L'.toSubmodule) = (x ∈ L') | null | false |
IsDedekindDomain.instCommRingFiniteAdeleRing._aux_13 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → IsDedekindDomain.FiniteAdeleRing R K | null | false |
GroupFilterBasis.one' | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} {inst : Group G} [self : GroupFilterBasis G] {U : Set G}, U ∈ self.sets → 1 ∈ U | null | true |
_private.Init.Data.Fin.Lemmas.0.Fin.coe_sub_iff_le._proof_1_4 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, ¬n ≤ n - ↑b + ↑a → ¬n - ↑b + ↑a < n → False | null | false |
_private.Mathlib.Tactic.Algebra.Lemmas.0.Mathlib.Tactic.Algebra.rat_ofNat_smul_2._simp_1_1 | Mathlib.Tactic.Algebra.Lemmas | ∀ {R : Type u_1} [sR : CommSemiring R] {n : ℕ} [inst : n.AtLeastTwo], OfNat.ofNat n = n.rawCast | null | false |
AddMonoidHom.surjective_of_surjective_of_surjective_of_injective | Mathlib.Algebra.FiveLemma | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {M₃ : Type u_3} {M₄ : Type u_4} {N₁ : Type u_6} {N₂ : Type u_7} {N₃ : Type u_8}
{N₄ : Type u_9} [inst : AddGroup M₁] [inst_1 : AddGroup M₂] [inst_2 : AddGroup M₃] [inst_3 : AddGroup M₄]
[inst_4 : AddGroup N₁] [inst_5 : AddGroup N₂] [inst_6 : AddGroup N₃] [inst_7 : AddGroup N₄] (f₁ ... | One four lemma in terms of additive groups.
For a diagram explaining the variables, see the module docstring. | true |
NNReal.lt_iff_exists_rat_btwn | Mathlib.Basic.NNReal.Defs | ∀ (a b : NNReal), a < b ↔ ∃ q, 0 ≤ q ∧ a < (↑q).toNNReal ∧ (↑q).toNNReal < b | null | true |
EuclideanDomain.gcd._unary._proof_2 | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u_1} [inst : EuclideanDomain R] (a b : R),
EuclideanDomain.r (b % a) a →
(invImage (fun x => PSigma.casesOn x fun a b => a) EuclideanDomain.wellFoundedRelation).1 ⟨b % a, a⟩ ⟨a, b⟩ | null | false |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isSyntheticTacticCompletion.isEmpty.match_1 | Lean.Server.Completion.SyntheticCompletion | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
(Unit → motive Lean.Syntax.missing) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info rawVal val preresolved)) ... | null | false |
_private.Init.Data.Nat.Fold.0.Nat.all_eq_allTR._proof_1_1 | Init.Data.Nat.Fold | ∀ (m n i : ℕ), i < n → ¬i < m + n → False | null | false |
WithZero.isOrderedMonoid | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [IsOrderedMonoid α], IsOrderedMonoid (WithZero α) | null | true |
concaveOn_of_slope_anti_adjacent | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
Convex 𝕜 s →
(∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)) → ConcaveOn 𝕜 s f | If for any three points `x < y < z`, the slope of the secant line of `f : 𝕜 → 𝕜` on `[x, y]` is
greater than the slope of the secant line of `f` on `[y, z]`, then `f` is concave. | true |
SimpleGraph.chromaticNumber_mono | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} (G' : SimpleGraph V), G ≤ G' → G.chromaticNumber ≤ G'.chromaticNumber | null | true |
CategoryTheory.Functor.LaxMonoidal.μ_whiskerRight_comp_μ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C),
CategoryTheory.CategoryStruct.com... | null | true |
_private.Mathlib.Topology.Filter.0.Filter.mem_closure._simp_1_8 | Mathlib.Topology.Filter | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Valuation.closure_image_coe_le.match_1 | Mathlib.Topology.Algebra.ValuativeRel.Completion | {K : Type u_1} → (motive : K × K → Sort u_2) → (x : K × K) → ((x y : K) → motive (x, y)) → motive x | null | false |
AddSubgroup.IsComplement.rightQuotientEquiv_apply | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {f : Quotient (QuotientAddGroup.rightRel H) → G}
(hf : ∀ (q : Quotient (QuotientAddGroup.rightRel H)), Quotient.mk'' (f q) = q)
(q : Quotient (QuotientAddGroup.rightRel H)), ↑(⋯.rightQuotientEquiv q) = f q | null | true |
ContinuousMap.Homotopy.refl._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)),
Continuous fun x => f x.2 | null | false |
_private.Mathlib.NumberTheory.NumberField.DirichletDensity.0.NumberField.Set.primeIdealZetaSum_le_card_of_finite._simp_1_3 | Mathlib.NumberTheory.NumberField.DirichletDensity | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Module.Free ℤ S] [Module.Finite ℤ S]
{I : Ideal S}, (Ideal.absNorm I = 0) = (I = ⊥) | null | false |
ModuleCat.FilteredColimits.colimitModule._proof_3 | Mathlib.Algebra.Category.ModuleCat.FilteredColimits | ∀ {R : Type u_1} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.SmallCategory J]
[inst_2 : CategoryTheory.IsFiltered J] (F : CategoryTheory.Functor J (ModuleCat R)) (a : R), a • 0 = 0 | null | false |
Lean.Compiler.LCNF.MonadFVarSubst.noConfusionType | Lean.Compiler.LCNF.CompilerM | Sort u →
{m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{translator : Bool} →
Lean.Compiler.LCNF.MonadFVarSubst m pu translator →
{m' : Type → Type} →
{pu' : Lean.Compiler.LCNF.Purity} →
{translator' : Bool} → Lean.Compiler.LCNF.MonadFVarSubst m' pu' trans... | null | false |
Finset.HasMulAntidiagonal.mem_mulAntidiagonal_ofAdd_iff_toAdd_mem_antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_2} [inst : Add A] [inst_1 : Finset.HasAntidiagonal A] {a : A} {p : Multiplicative A × Multiplicative A},
p ∈ Finset.HasMulAntidiagonal.mulAntidiagonal (Multiplicative.ofAdd a) ↔
(Multiplicative.toAdd p.1, Multiplicative.toAdd p.2) ∈ Finset.HasAntidiagonal.antidiagonal a | null | true |
not_le._simp_1 | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
PowerSeries.coe_zero | Mathlib.RingTheory.LaurentSeries | ∀ {R : Type u_1} [inst : Semiring R], (HahnSeries.ofPowerSeries ℤ R) 0 = 0 | null | true |
QuadraticMap.instNeg | Mathlib.LinearAlgebra.QuadraticForm.Basic | {R : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → [inst_3 : AddCommGroup N] → [inst_4 : Module R N] → Neg (QuadraticMap R M N) | null | true |
Std.DTreeMap.Internal.Impl.Equiv.constMinEntry_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
∀ (h : t₁.Equiv t₂) {he : t₁.isEmpty = false},
Std.DTreeMap.Internal.Impl.Const.minEntry t₁ he = Std.DTreeMap.Internal.Impl.Const.minEntry t₂ ⋯ | null | true |
ISize.toInt32_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), (ISize.ofBitVec b).toInt32 = Int32.ofBitVec (BitVec.signExtend 32 b) | null | true |
PointedCone.IsFaceOf.snd | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : DivisionRing R] [inst_1 : LinearOrder R]
[inst_2 : IsOrderedRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] {C₁ : PointedCone R M} {C₂ : PointedCone R N} {F : PointedCone R (M × N)},
F.IsFaceOf (Submodul... | The projection of a face of a product cone onto the second component is a face of the
projection of the product cone onto the second component. | true |
LieAlgebra.SemiDirectSum.inl.eq_1 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K),
LieAlgebra.SemiDirectSum.inl ψ =
{ toFun := fun x => { left := x, right := 0 }, map_add' := ⋯, map_smul' := ⋯, map_l... | null | true |
CochainComplex.HomComplex.δ_zero_cochain_v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (z : CochainComplex.HomComplex.Cochain F G 0) (p q : ℤ) (hpq : p + 1 = q),
(CochainComplex.HomComplex.δ 0 1 z).v p q hpq =
CategoryTheory.CategoryStruct.comp (z.v p p ⋯) (G.d p q) - Catego... | null | true |
CategoryTheory.Limits.coprod.associator.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(P Q R : C),
CategoryTheory.Limits.coprod.associator P Q R =
{
hom :=
CategoryTheory.Limits.coprod.desc
(CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl
... | null | true |
DirectLimit.Module.of._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ (R : Type u_4) (ι : Type u_1) [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : Semiring R]
[inst_3 : (i : ι) → AddCommMonoid (G i)] [inst_4 : (i : ι) → Module R (G i)]
[∀ (i j : ι) (h : i ≤ j), LinearMapClass (T h)... | null | false |
LinearMap.prod | Mathlib.LinearAlgebra.Prod | {R : Type u} →
{M : Type v} →
{M₂ : Type w} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M] →
[inst_5 : Module R M₂] → [inst_6 ... | The prod of two linear maps is a linear map. | true |
Lean.Server.ReferencedObject.obj | Lean.Server.Rpc.Basic | Lean.Server.ReferencedObject → Dynamic | null | true |
System.Platform.System.Platform.dvd_numBits | Init.System.Platform | 32 ∣ System.Platform.numBits | null | true |
Nat.primeFactors_mul | Mathlib.Data.Nat.PrimeFin | ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → (a * b).primeFactors = a.primeFactors ∪ b.primeFactors | null | true |
MeasureTheory.setIntegral_rnDeriv_smul' | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {E : Type u_4} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [MeasureTheory.SigmaFinite μ] {f : α → E} [MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → ∀ (s : Set α), ∫ (x : α) in s, (μ.rnDeriv ν x).toReal • f x ∂ν = ∫ (x :... | A version of `setIntegral_rnDeriv_smul` that requires both measures to be σ-finite,
but doesn't require `s` to be a measurable set. | true |
Mathlib.Tactic.Order.AtomicFact.le.inj | Mathlib.Tactic.Order.CollectFacts | ∀ {lhs rhs : ℕ} {proof : Lean.Expr} {lhs_1 rhs_1 : ℕ} {proof_1 : Lean.Expr},
Mathlib.Tactic.Order.AtomicFact.le lhs rhs proof = Mathlib.Tactic.Order.AtomicFact.le lhs_1 rhs_1 proof_1 →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ proof = proof_1 | null | true |
SubmodulesBasis.openAddSubgroup | Mathlib.Topology.Algebra.Nonarchimedean.Bases | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace R] →
[inst_4 : Nonempty ι] → {B : ι → Submodule R M} → (hB : SubmodulesBasis B) → ι → OpenAddSubgroup M | Given a submodules basis, the basis elements as open additive subgroups in the associated
topology. | true |
MonoidAlgebra.addSubmonoidClosure_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R], AddSubmonoid.closure {x | ∃ m r, x = MonoidAlgebra.single m r} = ⊤ | null | true |
AddUnits.instTopologicalSpaceAddUnits | Mathlib.Topology.Algebra.Constructions | {M : Type u_1} → [TopologicalSpace M] → [inst : AddMonoid M] → TopologicalSpace (AddUnits M) | The additive units of a monoid are equipped with a topology, via the embedding into `M × M`. | true |
Complex.hasMeasurablePow | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | MeasurablePow ℂ ℂ | null | true |
Lean.PersistentEnvExtensionDescrCore.mk.inj | Lean.Environment | ∀ {α β σ : Type} {name : autoParam Lean.Name Lean.PersistentEnvExtensionDescrCore.name._autoParam} {mkInitial : IO σ}
{addImportedFn : Array (Array α) → Lean.ImportM σ} {addEntryFn : σ → β → σ}
{exportEntriesFnEx : Lean.Environment → σ → Lean.OLeanEntries (Array α)} {statsFn : σ → Std.Format}
{asyncMode : Lean.En... | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.mk.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {P : Sort u} →
{varMap : Lean.Meta.KExprMap ℕ} →
{vars : Array Lean.Expr} →
{varMap' : Lean.Meta.KExprMap ℕ} →
{vars' : Array Lean.Expr} →
{ varMap := varMap, vars := vars } = { varMap := varMap', vars := vars' } →
(varMap = varMap' → vars = vars' → P) → P | null | false |
CommSemiRingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J CommSemiRingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections] →
CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) | We show that the forgetful functor `CommSemiRingCat ⥤ SemiRingCat` creates limits.
All we need to do is notice that the limit point has a `CommSemiring` instance available,
and then reuse the existing limit.
| true |
_private.Batteries.Data.AssocList.Lemmas.0.Batteries.AssocList.isEmpty.match_1.eq_2 | Batteries.Data.AssocList.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (motive : Batteries.AssocList α β → Sort u_3) (x : Batteries.AssocList α β)
(h_1 : Unit → motive Batteries.AssocList.nil) (h_2 : (x : Batteries.AssocList α β) → motive x),
(x = Batteries.AssocList.nil → False) →
(match x with
| Batteries.AssocList.nil => h_1 ()
| x =>... | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.traceForm_dualSubmodule_adjoin.match_1_6 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (K : Type u_1) {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {x : L} (pb : PowerBasis K L)
(y : L) (motive : (∃ y_1, x ^ ↑y_1 = y) → Prop) (x_1 : ∃ y_1, x ^ ↑y_1 = y),
(∀ (a : ℕ) (b : a < pb.dim) (c : x ^ ↑⟨a, b⟩ = y), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Bimon.instCategory._aux_1 | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Bimon C → CategoryTheory.Bimon C → Type u_1 | null | false |
OrderMonoidHom | Mathlib.Algebra.Order.Hom.Monoid | (α : Type u_6) → (β : Type u_7) → [Preorder α] → [Preorder β] → [MulOneClass α] → [MulOneClass β] → Type (max u_6 u_7) | `α →*o β` is the type of functions `α → β` that preserve the ordered monoid structure.
`OrderMonoidHom` is also used for ordered group homomorphisms.
When possible, instead of parametrizing results over `(f : α →*o β)`,
you should parametrize over
`(F : Type*) [FunLike F M N] [MonoidHomClass F M N] [OrderHomClass F M... | true |
_private.Mathlib.Analysis.Asymptotics.SpecificAsymptotics.0.tendsto_pow_div_pow_atTop_atTop._proof_1_1 | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {p q : ℕ}, q < p → 0 < ↑p - ↑q | null | false |
Profinite.projective_of_extrDisc | Mathlib.Topology.Category.Stonean.Basic | ∀ {X : Profinite}, ExtremallyDisconnected ↑X.toTop → CategoryTheory.Projective X | null | true |
Algebra.Presentation.coeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → Algebra.Presentation R S ι σ → Set R | The coefficients of a presentation are the coefficients of the relations. | true |
NumberField.mixedEmbedding.indexEquiv_apply_isComplex_snd | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (w : { w // w.IsComplex }),
(NumberField.mixedEmbedding.indexEquiv K) (Sum.inr (w, 1)) = NumberField.ComplexEmbedding.conjugate (↑w).embedding | null | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.List.aestronglyMeasurable_fun_prod._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → Monoid (M a)] (a : α) (l : List ((a : α) → M a)),
(List.map (fun f => f a) l).prod = l.prod a | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix._aux_Mathlib_LinearAlgebra_Matrix_Notation___macroRules_Matrix_matrixNotation_1.match_3 | Mathlib.LinearAlgebra.Matrix.Notation | (motive : Option (Array (Array (Lean.TSyntax `term))) → Sort u_1) →
(x : Option (Array (Array (Lean.TSyntax `term)))) →
((rows : Array (Array (Lean.TSyntax `term))) → motive (some rows)) → (Unit → motive none) → motive x | null | false |
Rat.IsRat.isInt_round | Mathlib.Data.Rat.Floor | ∀ {R : Type u_3} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorRing R] (r : R)
(n : ℤ) (d : ℕ) (res : ℤ),
round (↑n / ↑d) = res → Mathlib.Meta.NormNum.IsRat r n d → Mathlib.Meta.NormNum.IsInt (round r) res | null | true |
CategoryTheory.Equivalence.congrFullSubcategory_unitIso | Mathlib.CategoryTheory.ObjectProperty.Equivalence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{P : CategoryTheory.ObjectProperty C} {Q : CategoryTheory.ObjectProperty D} (e : C ≌ D)
[inst_2 : Q.IsClosedUnderIsomorphisms] (h : Q.inverseImage e.functor = P),
(e.congrFullSubcategory h).unitIso... | null | true |
CategoryTheory.Comon.ComonToMonOpOp._proof_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : CategoryTheory.Comon C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one f.hom.op = CategoryTheory.MonObj.one | null | false |
Std.HashSet.size_left_le_size_union | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₁.size ≤ (m₁ ∪ m₂).size | null | true |
AlgebraicGeometry.Scheme.Modules.instModuleCarrierCarrierObjOppositeOpensCarrierCarrierCommRingCatSpecAbPresheafOp | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
{M : (AlgebraicGeometry.Spec R).Modules} →
{U : (AlgebraicGeometry.Spec R).Opens} → Module ↑R ↑(M.presheaf.obj (Opposite.op U)) | null | true |
Std.DHashMap.isSome_getKey?_iff_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{a : α}, (m.getKey? a).isSome = true ↔ a ∈ m | null | true |
CategoryTheory.topologyOfClosureOperator._proof_1 | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (c : (X : C) → ClosureOperator (CategoryTheory.Sieve X)),
(∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : CategoryTheory.Sieve X),
(c Y) (CategoryTheory.Sieve.pullback f S) = CategoryTheory.Sieve.pullback f ((c X) S)) →
∀ (X Y : C) (S : CategoryTheory.Sieve X) (f... | null | false |
Convex.combo_affine_apply | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Ring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] {x y : E} {a b : 𝕜} {f : E →ᵃ[𝕜] F},
a + b = 1 → f (a • x + b • y) = a • f x + b • f y | Applying an affine map to an affine combination of two points yields an affine combination of
the images. | true |
Polynomial.isNilpotent_C_mul_pow_X_of_isNilpotent | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_1} {r : R} [inst : Semiring R] (n : ℕ), IsNilpotent r → IsNilpotent (Polynomial.C r * Polynomial.X ^ n) | null | true |
_private.Mathlib.RingTheory.WittVector.FrobeniusFractionField.0.WittVector.exists_frobenius_solution_fractionRing_aux._simp_1_3 | Mathlib.RingTheory.WittVector.FrobeniusFractionField | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.evalNot.match_5 | Mathlib.Tactic.NormNum.Basic | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) →
((us : List Lean.Level) → (a : Q(Prop)) → motive ((Lean.Expr.const `Not us).app a)) →
((x : Lean.Expr) → motive x) → motive __x | null | false |
ContinuousAddMonoidHom.isClosedEmbedding_coe | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_1} {B : Type u_2} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [DiscreteTopology A] [ContinuousAdd B] [T2Space B],
Topology.IsClosedEmbedding DFunLike.coe | null | true |
RingCat.Hom.noConfusionType | Mathlib.Algebra.Category.Ring.Basic | Sort u_1 → {R S : RingCat} → R.Hom S → {R' S' : RingCat} → R'.Hom S' → Sort u_1 | null | false |
Function.Injective.list_map._f | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β},
Function.Injective f →
∀ (x : List α) (f_1 : List.below (motive := fun x => ∀ (x_1 : List α), List.map f x = List.map f x_1 → x = x_1) x)
(x_1 : List α), List.map f x = List.map f x_1 → x = x_1 | null | false |
Int8.ofIntLE.eq_1 | Init.Data.SInt.Lemmas | ∀ (i : ℤ) (_hl : Int8.minValue.toInt ≤ i) (_hr : i ≤ Int8.maxValue.toInt), Int8.ofIntLE i _hl _hr = Int8.ofInt i | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.instHasSupportMap._simp_2 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (f '' s ⊆ t) = (s ⊆ f ⁻¹' t) | null | false |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'₁₂_eq_pullHom_of_chosenPullback₃._proof_6 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃)) (i₁ i₂ i₃ : ι),
CategoryTheo... | null | false |
RBTree.RBNode.upperBound?_mem_ub | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cut : α → Ordering} {ub : Option α} {x : α} {t : RBTree.RBNode α},
RBTree.RBNode.upperBound? cut t ub = some x → x ∈ t ∨ ub = some x | null | true |
Module.End.baseChangeHom | Mathlib.LinearAlgebra.TensorProduct.Tower | (R : Type u_1) →
(A : Type u_2) →
(M : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : AddCommMonoid M] → [inst_4 : Module R M] → Module.End R M →ₐ[R] Module.End A (TensorProduct R A M) | `baseChange` as an `AlgHom`. | true |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | (x x_1 : Std.Tactic.BVDecide.BVUnOp) → Decidable (x = x_1) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.SpecialLinearGroup.mem_center_iff.match_1_3 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_1} [inst_2 : CommRing R]
{A : Matrix.SpecialLinearGroup n R} (motive : (∃ r, r ^ Fintype.card n = 1 ∧ (Matrix.scalar n) r = ↑A) → Prop)
(x : ∃ r, r ^ Fintype.card n = 1 ∧ (Matrix.scalar n) r = ↑A),
(∀ (r : R) (left : r ^ Fintype.card n = 1) ... | null | false |
Matroid.dualIndepMatroid | Mathlib.Combinatorics.Matroid.Dual | {α : Type u_1} → Matroid α → IndepMatroid α | Given `M : Matroid α`, the `IndepMatroid α` whose independent sets are
the subsets of `M.E` that are disjoint from some base of `M` | true |
_private.Mathlib.Topology.MetricSpace.Snowflaking.0.Metric.Snowflaking.instPseudoEMetricSpace._simp_4 | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {x y : ENNReal} {z : ℝ}, 0 < z → (x ^ z < y ^ z) = (x < y) | null | false |
Finset.nsmul_right_strictMono | Mathlib.Geometry.Group.Growth.LinearLowerBound | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : DecidableEq G] {X : Finset G},
0 ∈ X → (↑(AddSubgroup.closure ↑X)).Infinite → StrictMono fun n => n • X | null | true |
_private.Lean.Elab.Tactic.Grind.Basic.0.Lean.Elab.Tactic.Grind.instBEqDSimpArgs.beq.match_1 | Lean.Elab.Tactic.Grind.Basic | (motive : Lean.Elab.Tactic.Grind.DSimpArgs → Lean.Elab.Tactic.Grind.DSimpArgs → Sort u_1) →
(x x_1 : Lean.Elab.Tactic.Grind.DSimpArgs) →
((a : Array Lean.FVarId) →
(a_1 : Bool) →
(b : Array Lean.FVarId) →
(b_1 : Bool) → motive { fvarIds := a, zetaDeltaAll := a_1 } { fvarIds := b, zet... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUmod.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
(motive : aig.BinaryRefVec w → Sort u_1) →
(input : aig.BinaryRefVec w) → ((lhs rhs : aig.RefVec w) → motive { lhs := lhs, rhs := rhs }) → motive input | null | false |
Polynomial.X_eq_normalize | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] [inst_1 : NoZeroDivisors R] [inst_2 : NormalizationMonoid R],
Polynomial.X = normalize Polynomial.X | null | true |
NonUnitalStarSubalgebra.prod._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A]
[inst_2 : StarRing A] [inst_3 : Module R A] [inst_4 : NonUnitalSemiring B] [inst_5 : StarRing B] [inst_6 : Module R B]
(S : NonUnitalStarSubalgebra R A) (S₁ : NonUnitalStarSubalgebra R B) {a b : A × B},
a ∈ (S.pr... | null | false |
Mathlib.Tactic.Matrix.ofList.eq_3 | Mathlib.Tactic.Matrix.OfLists | ∀ {α : Type u_1} [inst : Zero α] (n : ℕ) (a : α) (l : List α),
Mathlib.Tactic.Matrix.ofList n.succ (a :: l) = Matrix.vecCons a (Mathlib.Tactic.Matrix.ofList n l) | null | true |
Matrix.nonneg_iff_posSemidef | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] {A : Matrix n n 𝕜}, 0 ≤ A ↔ A.PosSemidef | null | true |
BoxIntegral.IntegrationParams._sizeOf_inst | Mathlib.Analysis.BoxIntegral.Partition.Filter | SizeOf BoxIntegral.IntegrationParams | null | false |
Algebra.GrothendieckGroup.lift.eq_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G],
Algebra.GrothendieckGroup.lift =
{ toFun := fun f => (Localization.monoidOf ⊤).lift ⋯, invFun := fun f => f.comp Algebra.GrothendieckGroup.of,
left_inv := ⋯, right_inv := ⋯ } | null | true |
Monoid.PushoutI.NormalWord.cons_toList | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} {i : ι} (g : G i)
(w : Monoid.PushoutI.NormalWord d) (hmw : w.fstIdx ≠ some i) (hgr : g ∉ (φ i).range),
(Monoid.PushoutI.NormalWord.cons g w ... | null | true |
Real.Gamma_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ (s : ℝ), Real.Gamma s = 0 ↔ ∃ m, s = -↑m | null | true |
_private.Mathlib.CategoryTheory.Abelian.SerreClass.Localization.0.CategoryTheory.ObjectProperty.SerreClassLocalization.isZero_obj_iff._simp_1_2 | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.single_mem_cycles₂_iff._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : G × G →₀ ↑A),
(x ∈ groupHomology.cycles₂ A) =
((x.sum fun g a => (fun₀ | g.2 => (A.ρ g.1⁻¹) a) + fun₀ | g.1 => a) = x.sum fun g a => fun₀ | g.1 * g.2 => a) | null | false |
Relation.EqvGen.rec | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} {motive : (a a_1 : α) → Relation.EqvGen r a a_1 → Prop},
(∀ (x y : α) (a : r x y), motive x y ⋯) →
(∀ (x : α), motive x x ⋯) →
(∀ (x y : α) (a : Relation.EqvGen r x y), motive x y a → motive y x ⋯) →
(∀ (x y z : α) (a : Relation.EqvGen r x y) (a_1 : Relation.EqvGe... | null | false |
Std.DTreeMap.Internal.Impl.getKeyLT?.go._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Ord α] → α → Option α → Std.DTreeMap.Internal.Impl α β → Option α | null | false |
zero_eq_nndist._simp_1 | Mathlib.Topology.MetricSpace.Defs | ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, (0 = nndist x y) = (x = y) | null | false |
Lean.Meta.Sym.canon | Lean.Meta.Sym.Canon | Lean.Expr → Lean.Meta.Sym.SymM Lean.Expr | Canonicalize `e` by normalizing types, instances, and support arguments.
Applies targeted reductions (projection, match/ite/cond, Nat arithmetic) in all positions;
eta reduction is applied only inside types. Instances are re-synthesized.
Runs at reducible transparency.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.