name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearMap.concaveOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 β] (f : E →ₗ[𝕜] β)
{s : Set E}, Convex 𝕜 s → ConcaveOn 𝕜 s ⇑f | A linear map is concave. | true |
Fin.natAdd_castLEEmb_apply_val | Mathlib.Data.Fin.Embedding | ∀ {n m : ℕ} (hmn : n ≤ m) (a : Fin n), ↑((Fin.natAdd_castLEEmb hmn) a) = ↑a + (m - n) | null | true |
Lean.Server.statefulRequestHandlers | Lean.Server.Requests | IO.Ref (Lean.PersistentHashMap String Lean.Server.StatefulRequestHandler) | null | true |
AddConstEquiv.symm_refl | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] (a : G), (AddConstEquiv.refl a).symm = AddConstEquiv.refl a | null | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.isRevMatch_iff_isRevMatch_decide.match_1_3 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos}
(motive : String.Slice.Pattern.Model.IsRevMatch (fun x => decide (p x)) pos → Prop)
(x : String.Slice.Pattern.Model.IsRevMatch (fun x => decide (p x)) pos),
(∀ (h : String.Slice.Pattern.Model.PatternModel.Matches (fun x => decide (p x))... | null | false |
Lean.Parser.Attr.sevalprocBuiltinAttr | Init.Simproc | Lean.ParserDescr | Auxiliary attribute for builtin symbolic evaluation procedures.
| true |
zpow_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), a ^ (m * n) = (a ^ n) ^ m | null | true |
Std.Iterators.Types.Empty.noConfusion | Std.Data.Iterators.Producers.Monadic.Empty | {P : Sort u} →
{m : Type w → Type w'} →
{β : Type w} →
{t : Std.Iterators.Types.Empty m β} →
{m' : Type w → Type w'} →
{β' : Type w} →
{t' : Std.Iterators.Types.Empty m' β'} →
m = m' → β = β' → t ≍ t' → Std.Iterators.Types.Empty.noConfusionType P t t' | null | false |
Int.neg_modEq_neg | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n] | null | true |
CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget_inv_app | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F) (X : J),
c.toStructuredArrowCompToUnderCompForget.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X) | null | true |
Lean.Grind.CommRing.Poly.cancelVar'._sunfold | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | false |
AddEquiv.toMultiplicativeLeft_apply_apply | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_2} {H : Type u_3} [inst : Add G] [inst_1 : Mul H] (f : G ≃+ Additive H) (x : Multiplicative G),
(AddEquiv.toMultiplicativeLeft f) x = Additive.toMul (f (Multiplicative.toAdd x)) | null | true |
FractionalIdeal.ringEquivOfRingEquiv._proof_10 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_3} {S : Type u_2} (K : Type u_4) (L : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R]
[inst_2 : CommRing S] [inst_3 : IsDomain S] [inst_4 : CommRing K] [inst_5 : CommRing L] [inst_6 : Algebra R K]
[inst_7 : Algebra S L] [inst_8 : IsFractionRing R K] [inst_9 : IsFractionRing S L] (f : R ≃+* S)
(I... | null | false |
Finset.mem_addSpan._simp_1 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α] {s : Finset α} {a : α},
(a ∈ s.addSpan) = ∃ ε, (∀ (a : α), ε a = -1 ∨ ε a = 0 ∨ ε a = 1) ∧ ∑ a ∈ s, ε a • a = a | null | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.instHasProjectiveDimensionLTHAddNat._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ (n k : ℕ), n ≤ n + k | null | false |
Composition.reverse_eq_ones._simp_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, (c.reverse = Composition.ones n) = (c = Composition.ones n) | null | false |
CategoryTheory.Limits.Cone.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor J C) {X Y : CategoryTheory.Limits.Cone F}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.const J).map f.hom)
(CategoryTheory.Cos... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CStarAlgebra.isStrictlyPositive_iff_exists_isStrictlyPositive_and_eq_mul_self._proof_1_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | 4 ≠ 0 | null | false |
MeasureTheory.cylinderEvents_mono | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} {X : ι → Type u_3} [m : (i : ι) → MeasurableSpace (X i)] {Δ₁ Δ₂ : Set ι},
Δ₁ ⊆ Δ₂ → MeasureTheory.cylinderEvents Δ₁ ≤ MeasureTheory.cylinderEvents Δ₂ | null | true |
BoolAlg.Iso.mk._proof_6 | Mathlib.Order.Category.BoolAlg | ∀ {α β : BoolAlg} (e : ↑α ≃o ↑β) (a b : ↑α),
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | null | false |
MeasureTheory.snd_integral_withLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)} [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [CompleteSpace E],
MeasureTheor... | null | true |
Std.DTreeMap.Internal.Impl.balance!.match_1.congr_eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3)
(r : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.... | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (k : α) (v : β k),
Std.DTreeMap.Internal.Impl.leaf.size ≤
(Std.DTreeMap.Internal.Impl.inner 1 k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | null | false |
instFiniteConjClasses | Mathlib.Algebra.Group.ConjFinite | ∀ {α : Type u_1} [inst : Monoid α] [Finite α], Finite (ConjClasses α) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
MulEquiv.withOneCongr | Mathlib.Algebra.Group.WithOne.Basic | {α : Type u} → {β : Type v} → [inst : Mul α] → [inst_1 : Mul β] → α ≃* β → WithOne α ≃* WithOne β | A version of `Equiv.optionCongr` for `WithOne`. | true |
Int32.sub_eq_iff_eq_add | Init.Data.SInt.Lemmas | ∀ {a b c : Int32}, a - b = c ↔ a = c + b | null | true |
Std.Http.Status.loopDetected.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 60 → motive Std.Http.Status.loopDetected → motive t | null | false |
Submodule.FG.lTensor.directedSystem | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (M : Type u_1) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N],
DirectedSystem (fun Q => TensorProduct R M ↥↑Q) fun x x_1 hPQ => ⇑(LinearMap.lTensor M (Submodule.inclusion hPQ)) | When `Q` ranges over finitely generated submodules of `N`,
the modules of the form `M ⊗[R] Q` form a directed system. | true |
CochainComplex.mappingCone.inl_snd_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain G K d) (he : 0 + d = e) (hf : -1 + e = f),
(Coc... | null | true |
_private.Lean.Meta.SizeOf.0.Lean.Meta.mkLocalInstances.loop | Lean.Meta.SizeOf | {α : Type} → Array Lean.Expr → (Array Lean.Expr → Lean.MetaM α) → ℕ → Array Lean.Expr → Lean.MetaM α | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomLeft_tensor | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {z z' : D} (f : z ⟶ z') (x y : C),
CategoryTheory.MonoidalCategory.MonoidalR... | null | true |
MvPolynomial.mem_degreesLE | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : Multiset σ},
p ∈ MvPolynomial.degreesLE R σ s ↔ p.degrees ≤ s | null | true |
SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint.inj₁ | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)}
[self : SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint t] ⦃a : α⦄ ⦃b : β⦄ ⦃c : γ⦄ ⦃b' : β⦄,
(a, b, c) ∈ t → (a, b', c) ∈ t → b = b' | null | true |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkLawfulDayConvolutionMonoidalCategoryStruct._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCa... | null | false |
CliffordAlgebra.EvenHom.mk.noConfusion | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
{inst : CommRing R} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{Q : QuadraticForm R M} →
{A : Type u_3} →
{inst_3 : Ring A} →
{inst_4 : Algebra R A} →
{P : Sort u} →
... | null | false |
ProbabilityTheory.Kernel.partialTraj.eq_1 | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)}
(κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))) (a b : ℕ),
ProbabilityTheory.Kernel.partialTraj κ a b =
if h : b ≤ a then ProbabilityTheory.Kernel.deterministic (Preorder.frestrictLe₂ h) ⋯
else
Nat.leRec Pr... | null | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul_smul_coe | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : ↥(NumberField.Units.torsion K))
(x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)), ↑(x • x_1) = ↑x • ↑x_1 | null | true |
Lean.Elab.Term.Quotation.MatchResult.covered.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{f : Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM Lean.Elab.Term.Quotation.Alt} →
{exhaustive : Bool} →
{f' : Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM Lean.Elab.Term.Quotation.Alt} →
{exhaustive' : Bool} →
Lean.Elab.Term.Quotation.MatchResult.covered f exhaus... | null | false |
_private.Mathlib.Geometry.Euclidean.PerpBisector.0.AffineSubspace.midpoint_mem_perpBisector._simp_1_1 | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
(c ∈ AffineSubspace.perpBisector p₁ p₂) = (inner ℝ (c -ᵥ midpoint ℝ p₁ p₂) (p₂ -ᵥ p₁) = 0) | null | false |
Polynomial.exists_iff_exists_finsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (P : Polynomial R → Prop), (∃ p, P p) ↔ ∃ q, P { toFinsupp := q } | null | true |
LipschitzOnWith.mk_one | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {s : Set α} {f : α → β},
(∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ dist x y) → LipschitzOnWith 1 f s | null | true |
Lean.Elab.Command.CoinductiveElabData.monotonicity? | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Option Lean.Term | Explicit monotonicity proof from the `monotonicity_by` clause, if provided. | true |
ContinuousMonoidHom.comp._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (g : B →ₜ* C) (f : A →ₜ* B),
Continuous (⇑g ∘ ⇑f.toMonoidHom) | null | false |
CategoryTheory.ObjectProperty.instIsClosedUnderIsomorphisms_1 | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderQuotients], P.IsClosedUnderIsomorphisms | null | true |
WithBot.bot_lt_mul | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] [inst_2 : LT α] {a b : WithBot α},
⊥ < a → ⊥ < b → ⊥ < a * b | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_lintegral_of_nonneg_ae._simp_1_4 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) | null | false |
instNegInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : AddCommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedAddMonoid α] → Neg (Interval α) | null | true |
_private.Mathlib.Algebra.Star.Center.0.Set.star_centralizer._simp_1_5 | Mathlib.Algebra.Star.Center | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∀ y ∈ f '' s, p y) = ∀ ⦃x : α⦄, x ∈ s → p (f x) | null | false |
Std.Do.SPred.not_nil | Std.Do.SPred.SPred | ∀ {P : Std.Do.SPred []}, spred(¬P) = { down := ¬P.down } | null | true |
CategoryTheory.Triangulated.TStructure.liftTruncLT | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Category... | Constructor for morphisms to `(t.truncLT n₁).obj Y`. | true |
Std.Time.TimeZone.TZif.Header.isutcnt | Std.Time.Zoned.Database.TzIf | Std.Time.TimeZone.TZif.Header → UInt32 | The count of UT local indicators in the file.
| true |
BitVec.instDecidableExistsBitVecSucc | Init.Data.BitVec.Decidable | {n : ℕ} →
(P : BitVec (n + 1) → Prop) →
[DecidablePred P] → [Decidable (∀ (x : Bool) (v : BitVec n), ¬P (BitVec.cons x v))] → Decidable (∃ v, P v) | null | true |
DividedPowers.ofRingEquiv._proof_2 | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] {I : Ideal A} [inst_1 : CommSemiring B] {J : Ideal B}
{e : A ≃+* B}, Ideal.map e I = J → ∀ (hI : DividedPowers I) {x : B}, x ∈ J → e (hI.dpow 0 (e.symm x)) = 1 | null | false |
ArithmeticFunction.pdiv._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : GroupWithZero R] (f g : ArithmeticFunction R), f 0 / g 0 = 0 | null | false |
Std.Http.Body.FromByteArray.recOn | Std.Http.Data.Body.Basic | {α : Type} →
{motive : Std.Http.Body.FromByteArray α → Sort u} →
(t : Std.Http.Body.FromByteArray α) →
((fromByteArray : ByteArray → Except String α) → motive { fromByteArray := fromByteArray }) → motive t | null | false |
Lean.mkRawNatLit | Lean.Expr | ℕ → Lean.Expr | Returns the "raw" natural number `.lit (.natVal n)`.
This is not the default representation used by the Lean frontend.
See `mkNatLit`.
| true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdxD_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.Limits.Cone.mk.inj | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} J} {C : Type u₃} {inst_1 : CategoryTheory.Category.{v₃, u₃} C}
{F : CategoryTheory.Functor J C} {pt : C} {π : (CategoryTheory.Functor.const J).obj pt ⟶ F} {pt_1 : C}
{π_1 : (CategoryTheory.Functor.const J).obj pt_1 ⟶ F},
{ pt := pt, π := π } = { pt := pt_1,... | null | true |
NumberField.mixedEmbedding.indexEquiv._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] (φ : K →+* ℂ) (hφ : NumberField.ComplexEmbedding.IsReal φ),
(fun c =>
Sum.casesOn (motive := fun t => c = t → K →+* ℂ) c (fun w h => (↑w).embedding)
(fun wj h =>
Prod.casesOn wj fun w j =>
if j = 0 then (↑w).embedding else NumberField.Compl... | null | false |
Diffeomorph.vadd.eq_1 | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | true |
star_le_iff | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{x y : R}, star x ≤ y ↔ x ≤ star y | null | true |
Std.Http.URI.Path.mk._flat_ctor | Std.Http.Data.URI.Basic | Array Std.Http.URI.EncodedSegment → Bool → Std.Http.URI.Path | null | false |
Bimod.Hom.casesOn | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A B : CategoryTheory.Mon C} →
{M N : Bimod A B} →
{motive : M.Hom N → Sort u} →
(t : M.Hom N) →
((hom : M.X ⟶ N.X) →
(left_act_hom :
... | null | false |
Lean.PrettyPrinter.Parenthesizer.node.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.SyntaxNodeKind → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | null | true |
FunLike.nonUnitalCommRing | Mathlib.Algebra.Ring.FunLike | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Zero F] →
[inst_2 : Add F] →
[inst_3 : Neg F] →
[inst_4 : Sub F] →
[inst_5 : Mul F] →
[inst_6 : SMul ℕ F] →
[inst_7 : SMul ℤ... | A `FunLike` type with `(f * g) x = f x * g x` is a `NonUnitalCommRing` if `β` is a
`NonUnitalCommRing`. | true |
instDecidableEqSum | Init.Core | {α : Type u_1} → {β : Type u_2} → [DecidableEq α] → [DecidableEq β] → DecidableEq (α ⊕ β) | null | true |
CategoryTheory.GradedObject.instIsIsoMapBifunctorMapMap | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6}
(p : I × J ... | null | true |
Vector.countP_false | Init.Data.Vector.Count | ∀ {α : Type u_1} {n : ℕ}, (Vector.countP fun x => false) = fun x => 0 | null | true |
Measurable.iterate._f | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α}, Measurable f → ∀ (x : ℕ) (f_1 : Nat.below x), Measurable f^[x] | null | false |
Std.DTreeMap.Raw.getKey?_maxKeyD | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback) | null | true |
CategoryTheory.ObjectProperty.createsCokernels | Mathlib.CategoryTheory.ObjectProperty.Kernels | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(P : CategoryTheory.ObjectProperty C) →
[P.IsClosedUnderCokernels] →
{X Y : P.FullSubcategory} →
(f : X ⟶ Y) →
[CategoryTheory.Limits.HasCokernel... | If an object property `P` is closed under cokernels, then `P.ι` creates cokernels.
In particular, this implies `P.ι` preserves cokernels. | true |
FourierTransformInv.fourierInv | Mathlib.Analysis.Fourier.Notation | {E : Type u} → {F : outParam (Type v)} → [self : FourierTransformInv E F] → E → F | `𝓕⁻ f` is the inverse Fourier transform of `f`. The meaning of this notation is
type-dependent. | true |
ArithmeticFunction.instCommRing._proof_7 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (a : ArithmeticFunction R), -a + a = 0 | null | false |
AddMonoidAlgebra.smul_single' | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (r' : R) (m : M) (r : R),
r' • AddMonoidAlgebra.single m r = AddMonoidAlgebra.single m (r' * r) | null | true |
CochainComplex.ConnectData.homologyIsoNeg._proof_6 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (n : ℕ) (m : ℤ), m = -↑(n + 1) → (ComplexShape.embeddingUpIntLE (-1)).f n = m | null | false |
CategoryTheory.WithInitial.Hom.eq_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X Y : C),
(CategoryTheory.WithInitial.of X).Hom (CategoryTheory.WithInitial.of Y) = (X ⟶ Y) | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.«termλ» | Mathlib.NumberTheory.FLT.Three | Lean.ParserDescr | null | true |
Std.DTreeMap.Internal.Impl.Ordered.compare_left_beq_gt | Std.Data.DTreeMap.Internal.Ordered | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α → Ordering} [Std.Internal.IsStrictCut compare k]
{sz : ℕ} {k' : α} {v' : β k'} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Ordered →
(k k').isGE = true → ∀ p ∈ l.toListModel, (k p.fst == Ordering.g... | null | true |
CategoryTheory.rightRigidCategoryOfEquivalence | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
[F.... | Pull back a right rigid structure along an equivalence. | true |
_private.Mathlib.Topology.Convenient.HomSpace.0.Topology.ContinuousMapGeneratedBy.curryEquiv._simp_2 | Mathlib.Topology.Convenient.HomSpace | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [inst_1 : TopologicalSpace Y]
{Z : Type v'} [inst_2 : TopologicalSpace Z] {T : Type v''} [inst_3 : TopologicalSpace T]
[∀ (i j : ι), Topology.IsGeneratedBy X (X i × X j)] (g : Y × Z → T),
Topology.ContinuousGeneratedBy X g =
... | null | false |
Std.IO.Process.instReprResourceUsageStats.repr | Std.Async.Process | Std.IO.Process.ResourceUsageStats → ℕ → Std.Format | null | true |
Set.Ico._proof_2 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), {x | b < x ∧ x ≤ a} = {x | x ≤ a ∧ b < x} | null | false |
Expr.instZero | Mathlib.Algebra.Expr | {u : Lean.Level} → (α : Q(Type u)) → Q(Zero «$α») → Zero Q(«$α») | Produce a `Zero` instance for `Q($α)` such that `0 : Q($α)` is `q(0 : $α)`. | true |
Quantale.mk.sizeOf_spec | Mathlib.Algebra.Order.Quantale | ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : CompleteLattice α] [inst_2 : IsQuantale α] [inst_3 : SizeOf α],
sizeOf { } = 1 | null | true |
Lean.resetTraceState | Lean.Util.Trace | {m : Type → Type} → [Lean.MonadTrace m] → m Unit | null | true |
Turing.TM2.Stmt.halt | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} → {Γ : K → Type u_2} → {Λ : Type u_3} → {σ : Type u_4} → Turing.TM2.Stmt Γ Λ σ | null | true |
MvPolynomial.aeval_injective_iff_of_isEmpty._simp_1 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [IsEmpty σ] [inst_2 : CommSemiring S₁]
[inst_3 : Algebra R S₁] {f : σ → S₁},
Function.Injective ⇑(MvPolynomial.aeval f) = Function.Injective ⇑(algebraMap R S₁) | null | false |
CategoryTheory.typesCartesianMonoidalCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Types.Basic | ∀ (X₁ X₂ : Type u_1),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ X₂) | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.contains'.match_1.splitter | Std.Data.DTreeMap.Internal.WF.Lemmas | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.gt) → (Unit → motive Ordering.eq) → motive x | null | true |
ContinuousMap.unitsLift_apply_inv_apply | Mathlib.Topology.ContinuousMap.Units | ∀ {X : Type u_1} {M : Type u_2} [inst : TopologicalSpace X] [inst_1 : Monoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousMul M] (f : C(X, Mˣ)) (x : X), ↑(ContinuousMap.unitsLift f)⁻¹ x = ↑(f x)⁻¹ | null | true |
Std.Sat.AIG.relabel_unsat_iff | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
{idx : ℕ} {invert : Bool} {aig : Std.Sat.AIG α} {r : α → β} {hidx1 : idx < (Std.Sat.AIG.relabel r aig).decls.size}
{hidx2 : idx < aig.decls.size},
(∀ (x y : α), x ∈ aig → y ∈ aig → r x = r y → x = y... | `relabel` preserves unsatisfiablility.
| true |
tsum_sq_fourierCoeffOn | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} {f : ℝ → ℂ} (hab : a < b),
MeasureTheory.MemLp f 2 (MeasureTheory.volume.restrict (Set.Ioc a b)) →
∑' (i : ℤ), ‖fourierCoeffOn hab f i‖ ^ 2 = (b - a)⁻¹ • ∫ (x : ℝ) in a..b, ‖f x‖ ^ 2 | null | true |
IsLocalRing.ResidueField.mapAlgEquiv'_residue | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsLocalRing S]
[inst_3 : CommRing T] [inst_4 : IsLocalRing T] [inst_5 : Algebra R S] [inst_6 : Algebra R T]
[inst_7 : IsLocalHom (algebraMap R S)] [inst_8 : IsLocalHom (algebraMap R T)] [inst_9 : IsLocalRing R] (e : S... | null | true |
_aux_Mathlib_Algebra_Module_Equiv_Defs___unexpand_LinearEquiv_1 | Mathlib.Algebra.Module.Equiv.Defs | Lean.PrettyPrinter.Unexpander | null | false |
Polynomial.eval₂RingHom | Mathlib.Algebra.Polynomial.Eval.Defs | {R : Type u} → {S : Type v} → [inst : Semiring R] → [inst_1 : CommSemiring S] → (R →+* S) → S → Polynomial R →+* S | `eval₂` as a `RingHom` | true |
Mathlib.Meta.NormNum.proveAscFactorial._unsafe_rec | Mathlib.Tactic.NormNum.NatFactorial | ℕ → ℕ → (en el : Q(ℕ)) → ℕ × (eresult : Q(ℕ)) × Q(«$en».ascFactorial «$el» = «$eresult») | null | false |
Std.Http.Transport.recvSelector | Std.Http.Transport | {α : Type} → [self : Std.Http.Transport α] → α → UInt64 → Std.Async.Selector (Option ByteArray) | Get a selector for receiving data asynchronously.
| true |
Lean.Lsp.CodeActionOptions.resolveProvider? | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionOptions → Option Bool | The server provides support to resolve additional information for a code action. | true |
Quaternion.normSq_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), Quaternion.normSq (star a) = Quaternion.normSq a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.