name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TestFunction.toBoundedContinuousFunctionCLM._proof_17 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_3) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_1} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} [inst_6 : Algebra ℝ 𝕜] [inst_7 : IsScalarTowe... | null | false |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Poly.maxDegreeOf.go._sunfold | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → ℕ → ℕ | null | false |
Std.Tactic.BVDecide.BVPred.ExprPair._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred.ExprPair | null | false |
_private.Mathlib.Algebra.BigOperators.Field.0.Finset.dens_biUnion_le._simp_1_1 | Mathlib.Algebra.BigOperators.Field | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a | null | false |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K] {x : NumberField.RingOfIntegers K},
hζ.toInteger - 1 ∣ x + 1 → (hζ.toInteger - 1) ^ 4 ∣ x ^ 3 + 1 | If `λ` divides `x + 1`, then `λ ^ 4` divides `x ^ 3 + 1`. | true |
LieSubalgebra.coe_bracket_of_module | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{M : Type w} [inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] (x : ↥L') (m : M), ⁅x, m⁆ = ⁅↑x, m⁆ | null | true |
SimpleGraph.Subgraph.neighborSet_subset_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v : V), G'.neighborSet v ⊆ G'.verts | null | true |
IsManifold.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : 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} →
{n : WithTop ℕ∞} →
... | null | false |
Convert.CheapConfig.closePost._inherited_default | Mathlib.Tactic.Convert | Bool | null | false |
Topology.IsQuotientMap.isStrictMap | Mathlib.Topology.Maps.Strict.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Topology.IsQuotientMap f → Topology.IsStrictMap f | A quotient map is strict. See also `isQuotientMap_iff_isStrictMap_surjective`. | true |
MeasureTheory.VectorMeasure.of_biUnion_finset | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
{v : MeasureTheory.VectorMeasure α M} [T2Space M] {ι : Type u_4} {s : Finset ι} {f : ι → Set α},
(↑s).PairwiseDisjoint f → (∀ b ∈ s, MeasurableSet (f b)) → ↑v (⋃ b ∈ s, f b) = ∑ p ∈ s, ↑v (f p) | null | true |
Set.powersetCard.ofFinEmb.eq_1 | Mathlib.Data.Set.PowersetCard | ∀ (n : ℕ) (β : Type u_2) (f : Fin n ↪ β), Set.powersetCard.ofFinEmb n β f = Set.powersetCard.map n f ⟨Finset.univ, ⋯⟩ | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | null | false |
linearIndependent_algebraMap_comp_iff._simp_1 | Mathlib.LinearAlgebra.LinearIndependent.BaseChange | ∀ {ι : Type u_1} {ι' : Type u_2} [Finite ι'] {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [FaithfulSMul R S] [IsDomain S] {v : ι → ι' → R},
(LinearIndependent S fun i => ⇑(algebraMap R S) ∘ v i) = LinearIndependent R v | null | false |
UniformSpace.Completion.ring._proof_26 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(x : UniformSpace.Completion α), npowRecAuto 0 x = 1 | null | false |
ModuleCat.instModuleCarrierObjRestrictScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] {f : R →+* S} {M : ModuleCat S}
(b : ↑((ModuleCat.restrictScalars f).obj M)), 1 • b = b | null | false |
Lean.Meta.Grind.instHashableCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → UInt64 | null | false |
Topology.CWComplex.coe_skeletonLT | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) {D : Set X}
[inst_1 : Topology.RelCWComplex C D] (n : ℕ∞),
↑(Topology.RelCWComplex.skeletonLT C n) = D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.closedCell m j | **Alias** of `Topology.RelCWComplex.coe_skeletonLT`. | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Cauchy.map_of_le._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} {m' : β → γ},
Filter.map (m' ∘ m) f = Filter.map m' (Filter.map m f) | null | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isEagerCasesCandidate.match_1 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
Std.Http.Method.noConfusion | Std.Http.Data.Method | {P : Sort v✝} → {x y : Std.Http.Method} → x = y → Std.Http.Method.noConfusionType P x y | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.AddAndFinalizeContext✝ → Array Lean.Expr | null | true |
TopModuleCat.instAddCommGroupHom | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → {X Y : TopModuleCat R} → AddCommGroup (X ⟶ Y) | null | true |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_degree._simp_1_2 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
ENNReal.div_le_iff_le_mul | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) | null | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Intro.0.Lean.Elab.Tactic.Do.ProofMode.elabMIntro._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMIntro_1 | Lean.Elab.Tactic.Do.ProofMode.Intro | IO Unit | null | false |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | null | true |
Filter.covariant_vadd | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β],
CovariantClass (Filter α) (Filter β) (fun x1 x2 => x1 +ᵥ x2) fun x1 x2 => x1 ≤ x2 | null | true |
grade_strictMono | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
StrictMono (grade 𝕆) | null | true |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (h : j < i),
(xs.set i a w).eraseIdx j ⋯ = (xs.eraseIdx j ⋯).set (i - 1) a ⋯ | null | true |
Std.HashMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂)[k]? = none | null | true |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X ⟶ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom | null | true |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} → [inst : DivisionRing K] → PartialOrder (Subfield K) | null | true |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | (L : FirstOrder.Language) → (M : Type w) → [L.Structure M] → Set (CategoryTheory.Bundled L.Structure) | The age of a structure `M` is the class of finitely-generated structures that embed into it. | true |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [inst_3 : Zero γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | null | true |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α : Type u_1} (a : α), Std.Do.PredTrans.Conjunctive fun Q => Q.1 a | null | false |
CategoryTheory.Limits.pushout.desc.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] (h h_1 : Y ⟶ W) (e_h : h = h_1) (k k_1 : Z ⟶ W) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limit... | null | true |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : ℕ),
0 < ↑x ^ n | null | false |
Std.Http.Method.acl | Std.Http.Data.Method | Std.Http.Method | Access control list for a resource.
Source: https://www.rfc-editor.org/rfc/rfc3744#section-8.1
| true |
Quiver.Path.comp_inj' | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c},
p₁.length = p₂.length → (p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂) | null | true |
Finset.prod_coe_sort | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} (s : Finset ι) [inst : CommMonoid M] (f : ι → M), ∏ i, f ↑i = ∏ i ∈ s, f i | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_430 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Lean.Grind.CutsatConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5 | Mathlib.Tactic.MkIffOfInductiveProp | (motive : ℕ → ℕ → Sort u_1) →
(m n : ℕ) →
(Unit → motive 0 0) →
((n : ℕ) → motive 0 n.succ) → ((m n : ℕ) → motive m.succ n.succ) → ((x x_1 : ℕ) → motive x x_1) → motive m n | null | false |
CStarAlgebra.norm_le_natCast_iff_of_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
NNRat.nndist_eq._simp_1 | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist ↑p ↑q = nndist p q | null | false |
Matrix.reindex_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, M ∈ Matrix.colStochastic R n → (Matrix.reindex e₁ e₂) M ∈ Matrix.col... | Reindexing a matrix preserves column-stochasticity. | true |
List.Sublist.tail | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.tail.Sublist l₂.tail | null | true |
QuadraticMap.zero_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (x : M), 0 x = 0 | null | true |
«term_<|_» | Init.Notation | Lean.TrailingParserDescr | A pipe operator that feeds values from the right into functions on the left.
`f <| x` means the same as `f x`, except that it parses `x` with lower precedence, which means that
`f <| g <| x` is interpreted as `f (g x)` rather than `(f g) x`.
| true |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.elabDeriving._regBuiltin.Lean.Elab.elabDeriving.declRange_3 | Lean.Elab.Deriving.Basic | IO Unit | null | false |
CategoryTheory.Under.map.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y),
CategoryTheory.Under.map f =
CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun x => f) | null | true |
CategoryTheory.Limits.parallelPairOpIso_inv_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : X ⟶ Y),
(CategoryTheory.Limits.parallelPairOpIso f g).inv.app CategoryTheory.Limits.WalkingParallelPair.zero =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.walkingParallelPairOpEquiv.functor.comp (CategoryTheory.Limits.... | null | true |
Unitary.toUnits_comp_map | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S] [inst_3 : StarMul S]
(f : R →⋆* S), Unitary.toUnits.comp (Unitary.map f).toMonoidHom = (Units.map f.toMonoidHom).comp Unitary.toUnits | null | true |
smul_nonneg_iff_neg_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[PosSMulStrictMono α β] {a : α} {b : β}, 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) | null | true |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_7 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Std.Iterators.Types.ArrayIterator.stepAsHetT_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).stepAsHetT =
if x : pos < array.size then pure (Std.IterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos])
else pure Std.IterStep.done | null | true |
Projectivization.logHeight_mk | Mathlib.NumberTheory.Height.Projectivization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [inst_2 : Finite ι] {x : ι → K}
(hx : x ≠ 0), (Projectivization.mk K x hx).logHeight = Height.logHeight x | null | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right' | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
CategoryTheory.Limits.HasLimit
(CategoryTheory.Limits.cospan
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.Sheaf... | null | true |
if_true_right._simp_1 | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then q else True) = (p → q) | null | false |
ENat.forall_natCast_le_iff_le | Mathlib.Data.ENat.Basic | ∀ {m n : ℕ∞}, (∀ (a : ℕ), ↑a ≤ m → ↑a ≤ n) ↔ m ≤ n | Version of `WithTop.forall_coe_le_iff_le` using `Nat.cast` rather than `WithTop.some`. | true |
SimpContFract.of_isContFract | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} (v : K) [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [inst_3 : FloorRing K],
(SimpContFract.of v).IsContFract | null | true |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
CategoryTheory.Limits.Types.limit_ext_iff | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)}
[inst_1 : CategoryTheory.Limits.HasLimit F] {x y : CategoryTheory.Limits.limit F},
x = y ↔
∀ (j : J),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π F j)) x =
(CategoryTheory.Concr... | null | true |
hasFPowerSeriesAt_log_one | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt Real.log (FormalMultilinearSeries.ofScalars ℝ fun n => -(-1) ^ n / ↑n) 1 | null | true |
Tactic.ComputeAsymptotics.Seq.Stream'.dist_le_one | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (s t : Stream' α), dist s t ≤ 1 | null | true |
DivisionMonoid.toInvolutiveInv | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : DivisionMonoid G] → InvolutiveInv G | null | true |
Std.Packages.PreorderOfLEArgs.mk.noConfusion | Init.Data.Order.PackageFactories | {α : Type u} →
{P : Sort u_1} →
{le : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE : autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt :
autoParam
(let this := le;
LT α)
Std.Pack... | null | false |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n : ℕ), ¬Std.Tactic.BVDecide.BVUnOp.reverse = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n | null | false |
Field.Emb.cardinal_eq_of_isSeparable | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
Cardinal.mk (Field.Emb F E) = (fun c => if Cardinal.aleph0 ≤ c then 2 ^ c else c) (Module.rank F E) | null | true |
PowerSeries.exist_eq_span_eq_ncard_of_X_notMem | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal (PowerSeries R)} [I.IsPrime],
PowerSeries.X ∉ I →
∀ {S : Set R},
Ideal.span S = Ideal.map PowerSeries.constantCoeff I →
S.Finite → ∃ T, I = Ideal.span T ∧ T.Finite ∧ T.ncard = S.ncard | Given a prime ideal `I` of `R⟦X⟧` such that `X ∉ I`, if `I.map constantCoeff` is generated by a
finite set `S : Set T`, then there exists `T : Set R`, of the same cardinality as `S`, that
generates `I`. | true |
NonUnitalSubalgebraClass.nonUnitalSeminormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : NonUnitalSeminormedRing E] [inst_1 : SetLike S E]
[inst_2 : NonUnitalSubringClass S E] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c | null | false |
ProbabilityTheory.integrable_rpow_mul_cexp_of_re_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => ↑(X ω ^ p) * Complex.exp (z * ↑(X ω))) μ | null | true |
SkewMonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] {R : Type u_3}
[inst_3 : Semiring R] (f : k →+* R) (g : G →* R),
(∀ {x : k} {y : G}, f (y • x) * g y = g y * f x) →
∀ (x x_1 : SkewMonoidAlgebra k G),
(SkewMonoidAlgebra.liftNC ↑f ⇑g) (x * x_1) =
... | null | false |
CategoryTheory.Limits.reflexivePair.mkNatIso_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C}
(e₀ : F.obj CategoryTheory.Limits.WalkingReflexivePair.zero ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
(e₁ : F.obj CategoryTheory.Limits.WalkingReflexivePair.one ≅ G.o... | null | true |
Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty ((k, v) :: tl) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany!
(Std.DTreeMap.Internal.Impl.insert! k v Std.DTreeMap.Internal.Impl.empty) tl) | null | true |
Plausible.Testable.mk | Plausible.Testable | {p : Prop} → (Plausible.Configuration → Bool → Plausible.Gen (Plausible.TestResult p)) → Plausible.Testable p | null | true |
HahnSeries.SummableFamily.casesOn | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_8} →
{R : Type u_9} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] →
{α : Type u_7} →
{motive : HahnSeries.SummableFamily Γ R α → Sort u} →
(t : HahnSeries.SummableFamily Γ R α) →
((toFun : α → HahnSeries Γ R) →
(isPWO_iUnion_... | null | false |
Complex.arg_of_im_pos | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, 0 < z.im → z.arg = Real.arccos (z.re / ‖z‖) | null | true |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_pow._proof_1_2 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ} (n : ℕ), (Even (m ^ n) ↔ Even m ∧ n ≠ 0) → (Even (m ^ (n + 1)) ↔ Even m ∧ ¬n + 1 = 0) | null | false |
Nat.dfold_zero._proof_7 | Init.Data.Nat.Fold | 0 ≤ 0 | null | false |
Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadSemiring | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusionType P t t' | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_70 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CategoryTheory.Under.eqToHom_right._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X : T} {f g : CategoryTheory.Under X},
f = g → f.right = g.right | null | false |
Real.continuousAt_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, ContinuousAt Real.arctan x | null | true |
Std.TreeMap.Raw.Equiv.congr_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp},
t₁.Equiv t₂ → (t₁.Equiv t₃ ↔ t₂.Equiv t₃) | null | true |
List.Subperm.idxInj.congr_simp | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} (h : xs.Subperm ys) (i i_1 : Fin xs.length),
i = i_1 → h.idxInj i = h.idxInj i_1 | null | true |
Ideal.comap_map_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided],
I ≤ J → Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J | null | true |
prodXSubSMul.eval | Mathlib.Algebra.Polynomial.GroupRingAction | ∀ (G : Type u_2) [inst : Group G] [inst_1 : Fintype G] (R : Type u_3) [inst_2 : CommRing R]
[inst_3 : MulSemiringAction G R] (x : R), Polynomial.eval x (prodXSubSMul G R x) = 0 | null | true |
QuotientGroup.instSeminormedCommGroup._proof_4 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M) (x y z : M ⧸ S), dist x z ≤ dist x y + dist y z | null | false |
Convexity.ConvexSpace | Mathlib.Geometry.Convex.ConvexSpace.Defs | (R : Type u) →
Type v → [inst₁ : PartialOrder R] → [inst₂ : Semiring R] → [inst₃ : IsStrictOrderedRing R] → Type (max u v) | A set equipped with an operation of finite convex combinations,
where the coefficients must be non-negative and sum to 1.
| true |
Order.IsIntent.eq | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} {t : Set β}, Order.IsIntent r t → upperPolar r (lowerPolar r t) = t | **Alias** of the forward direction of `Order.isIntent_iff`. | true |
Algebra.Generators.Hom.toAlgHom_monomial | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra R R']
... | null | true |
Lean.Meta.Grind.EMatch.State.gmt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → ℕ | Goal modification time. | true |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum'_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_3} {β : Type u_4} {M : Matroid α} (f : α ≃ β) {I X : Set β},
(M.mapEquiv f).IsBasis I X = M.IsBasis (⇑f.symm '' I) (⇑f.symm '' X) | null | false |
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism is weakly étale if it is flat and the diagonal map is flat. | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) | null | false |
Set.InjOn.eq_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x = f y ↔ x = y) | null | true |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.