name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.log_of_lt | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, n < b → Nat.log b n = 0 | null | true |
CommRing.Pic.instAddCommGroupAsModule._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) [inst : CommRing R], Small.{u_1, u_1 + 1} (CategoryTheory.Skeleton (SemimoduleCat R))ˣ | null | false |
instPartialOrderEReal._proof_5 | Mathlib.Data.EReal.Basic | ∀ (a : EReal), a ≤ a | null | false |
Part.sdiff_get_eq | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : Part α) (hab : (a \ b).Dom), (a \ b).get hab = a.get ⋯ \ b.get ⋯ | null | true |
IsPurelyInseparable.finSepDegree_eq_one | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E],
Field.finSepDegree F E = 1 | A purely inseparable extension has finite separable degree one. | true |
Std.DTreeMap.Internal.Impl.maxKey?_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insert! k v t).maxKey? =
some (t.maxKey?.elim k fun k' => if (compare k' k).isLE = true then k else k') | null | true |
SimpleGraph.Walk.length | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → ℕ | The length of a walk is the number of edges/darts along it. | true |
Real.differentiableOn_inv_log | Mathlib.Analysis.SpecialFunctions.Log.InvLog | DifferentiableOn ℝ (fun x => (Real.log x)⁻¹) (Set.Ioi 1) | null | true |
_private.Lean.Syntax.0.Lean.Syntax.asNode._proof_1 | Lean.Syntax | Lean.IsNode (Lean.Syntax.node Lean.SourceInfo.none Lean.nullKind #[]) | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Iic_sub._proof_1_13 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} (a : Fin n), ↑a + 1 ≤ n → ↑a + 1 < n + 1 | null | false |
Polynomial.Splits.zero._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.Splits 0 = True | null | false |
Nat.dfold_add._proof_8 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i < n + m, i ≤ n + m | null | false |
PrimeMultiset.coeNat_prime | Mathlib.Data.PNat.Factors | ∀ (v : PrimeMultiset), ∀ p ∈ v.toNatMultiset, Nat.Prime p | null | true |
Std.DTreeMap.Raw.getKeyD_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k fallback : α}, k ∉ t₁ → (t₁ ∪ t₂).getKeyD k fallback = t₂.getKeyD k fallback | null | true |
Asymptotics.isTheta_completion_left | Mathlib.Analysis.Asymptotics.Completion | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F] {f : α → E}
{g : α → F} {l : Filter α}, (fun x => ↑(g x)) =Θ[l] f ↔ g =Θ[l] f | null | true |
Vector.back_eq_getElem | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} [inst : NeZero n] {xs : Vector α n}, xs.back = xs[n - 1] | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.toList_toArray._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
CategoryTheory.ObjectProperty.instAbelianFullSubcategoryOfContainsZeroOfIsClosedUnderKernelsOfIsClosedUnderCokernelsOfIsClosedUnderFiniteProducts._proof_3 | Mathlib.CategoryTheory.Abelian.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Abelian C] [P.IsClosedUnderCokernels], CategoryTheory.Limits.HasCokernels P.FullSubcategory | null | false |
CategoryTheory.Functor.FullyFaithful.id._proof_1 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C}
(f : (CategoryTheory.Functor.id C).obj X ⟶ (CategoryTheory.Functor.id C).obj Y),
(CategoryTheory.Functor.id C).map f = f | null | false |
Vector.insertIdx_eraseIdx_of_le | Init.Data.Vector.InsertIdx | ∀ {α : Type u} {a : α} {n i j : ℕ} {xs : Vector α n} (w₁ : i < n) (w₂ : j ≤ n - 1) (h : j ≤ i),
(xs.eraseIdx i w₁).insertIdx j a w₂ = Vector.cast ⋯ ((xs.insertIdx j a ⋯).eraseIdx (i + 1) ⋯) | null | true |
AddHom.inverse._proof_2 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (g : N → M) (x y : N),
g (f (g x) + f (g y)) = g (f (g x + g y)) | null | false |
ENat.lift_coe | Mathlib.Data.ENat.Basic | ∀ (n : ℕ), (↑n).lift ⋯ = n | **Alias** of `ENat.lift_natCast`. | true |
Lean.Elab.expandOptNamedPrio | Lean.Elab.Util | Lean.Syntax → Lean.MacroM ℕ | null | true |
_private.Lean.Environment.0.Lean.Environment.instTypeNameRealizeConstResult | Lean.Environment | TypeName Lean.Environment.RealizeConstResult✝ | null | true |
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.ceil_intCast._simp_1_2 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {m : ℤ} {n : ℕ}, (m.toNat ≤ n) = (m ≤ ↑n) | null | false |
ContinuousConstVAdd.toMeasurableConstVAdd | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {M : Type u_7} {α : Type u_8} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α]
[inst_3 : VAdd M α] [ContinuousConstVAdd M α], MeasurableConstVAdd M α | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬1 ≤ 4 → False | null | false |
Std.Http.CustomStatus.mk.sizeOf_spec | Std.Http.Data.Status | ∀ (code : UInt16) (phrase : String)
(validReasonPhrase :
autoParam (Std.Http.IsValidReasonPhrase phrase) Std.Http.CustomStatus.validReasonPhrase._autoParam)
(validCode : autoParam (100 ≤ code ∧ code ≤ 999) Std.Http.CustomStatus.validCode._autoParam)
(validUnknown : autoParam (¬Std.Http.isKnownStatusCode code ... | null | true |
_private.Qq.Match.0.Qq._aux_Qq_Match___macroRules_Lean_Parser_Term_doMatch_1.match_5 | Qq.Match | (motive : Option (Lean.TSyntax `Lean.Parser.Term.doSeq × Subarray (Lean.TSyntax `Lean.Parser.Term.doSeq)) → Sort u_1) →
(x : Option (Lean.TSyntax `Lean.Parser.Term.doSeq × Subarray (Lean.TSyntax `Lean.Parser.Term.doSeq))) →
(Unit → motive none) →
((rhs : Lean.TSyntax `Lean.Parser.Term.doSeq) →
(s'... | null | false |
Finset.neg_mem_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α} {a : α}, a ∈ s → -a ∈ -s | null | true |
Filter.IsBoundedUnder.sup | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] {f : Filter β} {u v : β → α},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v → Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => u a ⊔ v a | null | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.isPrivate | Lean.Meta.Constructions.SparseCasesOn | Lean.Meta.SparseCasesOnKey✝ → Bool | null | true |
Filter.HasBasis.inv | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : InvolutiveInv α] {f : Filter α} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α},
f.HasBasis p s → f⁻¹.HasBasis p fun i => (s i)⁻¹ | null | true |
Finset.add_univ_of_zero_mem | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α} [inst_2 : Fintype α],
0 ∈ s → s + Finset.univ = Finset.univ | null | true |
ContinuousOpenMap.casesOn | Mathlib.Topology.Hom.Open | {α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{motive : (α →CO β) → Sort u} →
(t : α →CO β) →
((toContinuousMap : C(α, β)) →
(map_open' : IsOpenMap toContinuousMap.toFun) →
motive { toContinuous... | null | false |
mem_balancedHull_iff | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {s : Set E}
{x : E} [NormOneClass 𝕜], x ∈ (balancedHull 𝕜) s ↔ ∃ r, ‖r‖ ≤ 1 ∧ x ∈ r • s | null | true |
IsValuativeTopology.hasBasis_nhds | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R]
(x : R), (nhds x).HasBasis (fun x => True) fun γ => {z | (ValuativeRel.valuation R) (z - x) < ↑γ} | null | true |
UniqueFactorizationMonoid.associated_iff_normalizedFactors_eq_normalizedFactors | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : UniqueFactorizationMonoid α]
{x y : α},
x ≠ 0 →
y ≠ 0 →
(Associated x y ↔ UniqueFactorizationMonoid.normalizedFactors x = UniqueFactorizationMonoid.normalizedFactors y) | null | true |
Matroid.cRk_map_image | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} (M : Matroid α) (hf : Set.InjOn f M.E) (X : Set α),
autoParam (X ⊆ M.E) Matroid.cRk_map_image._auto_1 → (M.map f hf).cRk (f '' X) = M.cRk X | null | true |
Std.Internal.Parsec.ByteArray.octDigit | Std.Internal.Parsec.ByteArray | Std.Internal.Parsec.ByteArray.Parser Char | Parse an octal digit `0-7` as a `Char`.
| true |
Computation.recOn | Mathlib.Data.Seq.Computation | {α : Type u} →
{motive : Computation α → Sort v} →
(s : Computation α) → ((a : α) → motive (Computation.pure a)) → ((s : Computation α) → motive s.think) → motive s | Recursion principle for computations, compare with `List.recOn`. | true |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min.noConfusion | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{n : ℕ} →
{X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)} →
{P : Sort u_1} →
{k k' : ℕ} →
{hk : k < n} →
{hk' : k' < n} →
{a : (X k hk).fst} →
{a_1 : (X k' hk').fst... | null | false |
CategoryTheory.MonoidalCategory.Limits.whiskerLeft_inl_comp_pushoutSymmetry_hom_assoc | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] {Q X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Q (CategoryTheory.Limits.pushout g f) ⟶ Z_1),
CategoryTheory.Cat... | null | true |
CategoryTheory.Discrete._aux_Mathlib_CategoryTheory_Discrete_Basic___macroRules_CategoryTheory_Discrete_tacticDiscrete_cases_1 | Mathlib.CategoryTheory.Discrete.Basic | Lean.Macro | A simple tactic to run `cases` on any `Discrete α` hypotheses. | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.name | Mathlib.Tactic.Linter.FlexibleLinter | Lean.Name → Mathlib.Linter.Flexible.Stained✝ | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_le_half_iff._proof_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | (1 + 1).AtLeastTwo | null | false |
norm_inner_eq_norm_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E}, x ≠ 0 → y ≠ 0 → (‖inner 𝕜 x y‖ = ‖x‖ * ‖y‖ ↔ ∃ r, r ≠ 0 ∧ y = r • x) | If the inner product of two vectors is equal to the product of their norms, then the two vectors
are multiples of each other. One form of the equality case for Cauchy-Schwarz.
Compare `inner_eq_norm_mul_iff`, which takes the stronger hypothesis `⟪x, y⟫ = ‖x‖ * ‖y‖`. | true |
CategoryTheory.Functor.LeibnizAdjunction.adj_unit_app_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃))
(G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)) ... | null | true |
Int.Internal.Linear.instBEqPoly.beq_spec_1 | Init.Data.Int.Linear | ∀ (a b : ℤ), (Int.Internal.Linear.Poly.num a == Int.Internal.Linear.Poly.num b) = (a == b) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceVal._regBuiltin.Char.reduceVal.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.164368340._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
autAdjoinRootXPowSubCEquiv.eq_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ} (hζ : (primitiveRoots n K).Nonempty) {a : K}
(H : Irreducible (Polynomial.X ^ n - Polynomial.C a)) [inst_1 : NeZero n],
autAdjoinRootXPowSubCEquiv hζ H =
{ toFun := (↑(autAdjoinRootXPowSubC n a)).toFun, invFun := AdjoinRootXPowSubCEquivToRootsOfUnity hζ H,
left_inv ... | null | true |
Char.val_ofOrdinal._proof_2 | Init.Data.Char.Ordinal | ∀ {f : Fin Char.numCodePoints}, ↑f + Char.numSurrogates < UInt32.size | null | false |
Polynomial.hasseDeriv_apply_one | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : Semiring R] (k : ℕ), 0 < k → (Polynomial.hasseDeriv k) 1 = 0 | null | true |
Std.ExtDTreeMap.minKey?_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α}, t.minKey? = some km → km ∈ t | null | true |
Finset.coe_inj | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ = ↑s₂ ↔ s₁ = s₂ | null | true |
legendreSym.quadratic_reciprocity | Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity | ∀ {p q : ℕ} [inst : Fact (Nat.Prime p)] [inst_1 : Fact (Nat.Prime q)],
p ≠ 2 → q ≠ 2 → p ≠ q → legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2)) | **The Law of Quadratic Reciprocity**: if `p` and `q` are distinct odd primes, then
`(q / p) * (p / q) = (-1)^((p-1)(q-1)/4)`. | true |
Finset.op_vadd_finset_vadd_eq_vadd_vadd_finset | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] [inst_1 : DecidableEq γ] [inst_2 : VAdd αᵃᵒᵖ β]
[inst_3 : VAdd β γ] [inst_4 : VAdd α γ] (a : α) (s : Finset β) (t : Finset γ),
(∀ (a : α) (b : β) (c : γ), (AddOpposite.op a +ᵥ b) +ᵥ c = b +ᵥ a +ᵥ c) → (AddOpposite.op a +ᵥ s) +ᵥ t = s +ᵥ a +ᵥ t | null | true |
_private.Mathlib.Analysis.Convex.Function.0.neg_strictConvexOn_iff._simp_1_2 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, (a + -b < c) = (a < c + b) | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_eq_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I J : Ideal R},
(Ideal.span {x} * I ≤ Ideal.span {y} * J) = ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ | null | false |
Real.range_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | Set.range Real.arctan = Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) | null | true |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof)
(F_1 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) → ... | null | true |
AddMonoidHom.transfer_def | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {A : Type u_2} [inst_1 : AddCommGroup A] (ϕ : ↥H →+ A)
(T : H.LeftTransversal) [inst_2 : H.FiniteIndex] (g : G),
ϕ.transfer g = AddSubgroup.leftTransversals.diff ϕ T (g +ᵥ T) | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Pointwise.0.AffineSubspace.pointwise_vadd_top._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Pointwise | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = y) = (x = -g +ᵥ y) | null | false |
Std.HashMap.getKey?_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, (m₁ ∪ m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k) | null | true |
WithTop.continuousOn_untopD | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] (d : ι),
ContinuousOn (WithTop.untopD d) {a | a ≠ ⊤} | null | true |
ENNReal.orderIsoUnitIntervalBirational | Mathlib.Basic.ENNReal.Inv | ENNReal ≃o ↑(Set.Icc 0 1) | An order isomorphism between the extended nonnegative real numbers and the unit interval. | true |
Homeomorph.Set.prod._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} (s : Set X) (t : Set Y) (x : { x // x ∈ s ×ˢ t }), (↑x).1 ∈ s | null | false |
SemiRingCat.limitSemiring._proof_18 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), 1 * a = a | null | false |
DividedPowers.SubDPIdeal.mk.congr_simp | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (carrier carrier_1 : Ideal A)
(e_carrier : carrier = carrier_1) (isSubideal : carrier ≤ I)
(dpow_mem : ∀ (n : ℕ), n ≠ 0 → ∀ j ∈ carrier, hI.dpow n j ∈ carrier),
{ carrier := carrier, isSubideal := isSubideal, dpow_mem := dpow_mem } =
... | null | true |
SSet.PtSimplex | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | (X : SSet) → ℕ → X.obj (Opposite.op { len := 0 }) → Type u | Given a simplicial set `X`, `n : ℕ` and `x : X _⦋0⦌`, this is the type
of morphisms `Δ[n] ⟶ X` which are constant with value `x` on the boundary. | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates_eq_iff.match_1_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a b : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)) (motive : (∃ ζ, ↑ζ • ↑a = ↑b) → Prop)
(x : ∃ ζ, ↑ζ • ↑a = ↑b),
(∀ (u : (NumberField.RingOfIntegers K)ˣ) (property : u ∈ NumberField.Units.torsion K) (h : ↑⟨u, property⟩ • ↑a = ↑b),
m... | null | false |
AlgebraicTopology.map_alternatingFaceMapComplex | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
(AlgebraicTopology.alternatingFaceMapComplex C).comp... | null | true |
DMatrix.instAddMonoid._proof_7 | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type u_3} [inst : (i : m) → (j : n) → AddMonoid (α i j)],
autoParam (∀ (n_1 : ℕ) (x : DMatrix m n α), (n_1 + 1) • x = n_1 • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
iteratedDerivWithin_of_isOpen_eq_iterate | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F} {s : Set 𝕜},
IsOpen s → Set.EqOn (iteratedDerivWithin n f s) (deriv^[n] f) s | null | true |
Lean.PersistentHashMap.Stats._sizeOf_inst | Lean.Data.PersistentHashMap | SizeOf Lean.PersistentHashMap.Stats | null | false |
IsometryEquiv.mk.noConfusion | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
{inst : PseudoEMetricSpace α} →
{inst_1 : PseudoEMetricSpace β} →
{P : Sort u_1} →
{toEquiv : α ≃ β} →
{isometry_toFun : Isometry toEquiv.toFun} →
{toEquiv' : α ≃ β} →
{isometry_toFun' : Isometry toEquiv'.toFun} →
... | null | false |
CategoryTheory.Functor.mapAddMon_map_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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 : CategoryTheory.AddMon C} (f : X ⟶ Y),
(... | null | true |
StateCpsT.runK_bind_pure | Init.Control.StateCps | ∀ {α σ : Type u} {m : Type u → Type v} {β γ : Type u} (a : α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ),
(pure a >>= f).runK s k = (f a).runK s k | null | true |
LieHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [inst : CommRing R] [inst_1 : LieRing L₁]
[inst_2 : LieAlgebra R L₁] [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] [inst_5 : LieRing L₃]
[inst_6 : LieAlgebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂), ↑f ∘ₗ ↑g = ↑(f.comp g) | null | false |
Std.Do.SPred.Tactic.instIsPureImpPureForall | Std.Do.SPred.DerivedLaws | ∀ {φ ψ : Prop} (σs : List (Type u_1)), Std.Do.SPred.Tactic.IsPure spred(⌜φ⌝ → ⌜ψ⌝) (φ → ψ) | null | true |
Equiv.pointReflection_midpoint_right | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] (x y : P), (Equiv.pointReflection (midpoint R x y)) y = x | null | true |
BiheytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | {α : Type u_4} → BiheytingAlgebra α → ℕ | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Const.0.differentiableAt_of_fderiv_injective._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F}, fderiv 𝕜 f = fderivWithin 𝕜 f Set.univ | null | false |
instFaithfulVAddOfSubsingleton | Mathlib.Algebra.Group.Action.Faithful | ∀ {M : Type u_1} {α : Type u_3} [inst : VAdd M α] [Subsingleton M], FaithfulVAdd M α | null | true |
AlgebraicGeometry.Scheme.residueFieldCongr | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → {x y : ↥X} → x = y → (X.residueField x ≅ X.residueField y) | The isomorphism between residue fields of equal points. | true |
CategoryTheory.MorphismProperty.HasLocalization.noConfusionType | Mathlib.CategoryTheory.Localization.HasLocalization | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
W.HasLocalization →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{W' : CategoryTheory.MorphismProperty C'} → W'.HasLocalization → Sort ... | null | false |
Lean.Server.MonadCancellable.noConfusionType | Lean.Server.RequestCancellation | Sort u →
{m : Type → Type v} → Lean.Server.MonadCancellable m → {m' : Type → Type v} → Lean.Server.MonadCancellable m' → Sort u | null | false |
LinearMap.prod_eq_inf_comap | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
p.prod q = Submodule.comap (LinearMap.fst R M M₂) p ⊓ Submodule.comap (LinearMap.snd R M M₂) q | null | true |
Std.TreeSet.getD_eq_fallback | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getD a fallback = fallback | null | true |
LSeriesHasSum.smul | Mathlib.NumberTheory.LSeries.Linearity | ∀ {f : ℕ → ℂ} (c : ℂ) {s a : ℂ}, LSeriesHasSum f s a → LSeriesHasSum (c • f) s (c * a) | null | true |
CategoryTheory.WithTerminal.comp.match_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u_1} →
(motive : CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → Sort u_2) →
(x x_1 x_2 : CategoryTheory.WithTerminal C) →
((_X _Y _Z : C) →
motive (CategoryTheory.WithTerminal.of _X) (CategoryTheory.WithTerminal.of _Y)
(Categor... | null | false |
Lean.Lsp.InitializationOptions.hasWidgets? | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializationOptions → Option Bool | Whether the client supports interactive widgets. When true, in order to improve performance
the server may cease including information which can be retrieved interactively in some standard
LSP messages. Defaults to false. | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point.0.WeierstrassCurve.Jacobian.Point.toAffine_some._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a | null | false |
Filter.Tendsto.atTop_of_add_le_const | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M]
{l : Filter α} {f g : α → M},
(∃ C, ∀ (x : α), g x ≤ C) → Filter.Tendsto (fun x => f x + g x) l Filter.atTop → Filter.Tendsto f l Filter.atTop | null | true |
groupCohomology.coboundaries₁_le_cocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u u_1, u, u} k G),
groupCohomology.coboundaries₁ A ≤ groupCohomology.cocycles₁ A | null | true |
Padic.limSeq | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [inst : Fact (Nat.Prime p)] → CauSeq ℚ_[p] ⇑padicNormE → ℕ → ℚ | `limSeq f`, for `f` a Cauchy sequence of `p`-adic numbers, is a sequence of rationals with the
same limit point as `f`. | true |
Vector.eq_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {xs : Vector α 0}, xs = #v[] | A vector of length `0` is the empty vector. | true |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Grading.0.ExteriorAlgebra.ιMulti_span.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {i : ℕ}
(motive : ↥(⋀[R]^i M) → Prop) (hm : ↥(⋀[R]^i M)),
(∀ (m : ExteriorAlgebra R M) (hm : m ∈ ⋀[R]^i M), motive ⟨m, hm⟩) → motive hm | null | false |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.explainMutualFailure.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | (motive : Array (Array String) × String → Sort u_1) →
(x : Array (Array String) × String) →
((headerss : Array (Array String)) → (footer : String) → motive (headerss, footer)) → motive x | null | false |
Lean.Meta.instReduceEvalUInt64_qq | Qq.ForLean.ReduceEval | Lean.Meta.ReduceEval UInt64 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.