name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
String.utf8EncodeChar_eq_cons_cons_cons_cons | Init.Data.String.Decode | ∀ {c : Char},
c.utf8Size = 4 →
String.utf8EncodeChar c =
[(c.val >>> 18).toUInt8 &&& 7 ||| 240, (c.val >>> 12).toUInt8 &&& 63 ||| 128,
(c.val >>> 6).toUInt8 &&& 63 ||| 128, c.val.toUInt8 &&& 63 ||| 128] | null | true |
LipschitzWith.isBounded_image | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ {s : Set α}, Bornology.IsBounded s → Bornology.IsBounded (f '' s) | The image of a bounded set under a Lipschitz map is bounded. | true |
CategoryTheory.Limits.WalkingMulticospan.Hom.snd.elim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : (x x_1 : CategoryTheory.Limits.WalkingMulticospan J) → x.Hom x_1 → Sort u} →
{x x_1 : CategoryTheory.Limits.WalkingMulticospan J} →
(t : x.Hom x_1) →
t.ctorIdx = 2 →
((b : J.R) →
motive (CategoryTheory.Limits.WalkingMul... | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.InjectiveDimension.0.ModuleCat.injectiveDimension_eq_of_semiLinearEquiv._simp_1_3 | Mathlib.Algebra.Category.ModuleCat.InjectiveDimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C) (n : ℕ),
(CategoryTheory.injectiveDimension X ≤ ↑n) = CategoryTheory.HasInjectiveDimensionLE X n | null | false |
List.disjoint_of_disjoint_append_right_left | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l l₁ l₂ : List α}, l.Disjoint (l₁ ++ l₂) → l.Disjoint l₁ | null | true |
QuotientAddGroup.sound | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : AddGroup G] (N : AddSubgroup G) [nN : N.Normal] (U : Set (G ⧸ N)) (g : ↥N.op),
g +ᵥ ⇑(QuotientAddGroup.mk' N) ⁻¹' U = ⇑(QuotientAddGroup.mk' N) ⁻¹' U | null | true |
Std.Time.TimeZone.convertTZifV2 | Std.Time.Zoned.Database.Basic | Std.Time.TimeZone.TZif.TZifV2 → String → Except String Std.Time.TimeZone.ZoneRules | Converts a `TZif.TZifV2` structure to a `ZoneRules` structure, extending transitions beyond
the last stored entry using the POSIX TZ footer string when present.
| true |
Batteries.AssocList.any._sunfold | Batteries.Data.AssocList.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → Batteries.AssocList α β → Bool | null | false |
_private.Mathlib.Tactic.Lift.0.Mathlib.Tactic.Lift.main.match_5 | Mathlib.Tactic.Lift | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(hUsing : Option (Lean.TSyntax `term)) →
((hUsingStx : Lean.TSyntax `term) → motive (some hUsingStx)) →
((x : Option (Lean.TSyntax `term)) → motive x) → motive hUsing | null | false |
NonUnitalSubsemiring.coe_center | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ (R : Type u) [inst : NonUnitalNonAssocSemiring R], ↑(NonUnitalSubsemiring.center R) = Set.center R | null | true |
Lean.ImportM.Context.ctorIdx | Lean.Environment | Lean.ImportM.Context → ℕ | null | false |
AddSubgroup.upperCentralSeries_isAscendingCentralSeries | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : AddGroup G], AddSubgroup.IsAscendingCentralSeries (AddSubgroup.upperCentralSeries G) | The upper central series of an additive group is an ascending central series. | true |
Finset.measurable_restrict_apply | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace γ] (s : Finset α) {f : α → γ},
Measurable f → Measurable (s.restrict f) | null | true |
Mathlib.Tactic.superscriptTerm.parenthesizer | Mathlib.Util.Superscript | Lean.PrettyPrinter.Parenthesizer | null | true |
ONote.repr_opow | Mathlib.SetTheory.Ordinal.Notation | ∀ (o₁ o₂ : ONote) [o₁.NF] [o₂.NF], (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr | null | true |
Seminorm.closedBall_finset_sup | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} {ι : Type u_11} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ},
0 ≤ r → (s.sup p).closedBall x r = s.inf fun i => (p i).closedBall x r | null | true |
Polynomial.eval₂AlgHom_apply | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (b : B) (hf : ∀ (a : A), Commute (f a) b)
(p : Polynomial A), (Polynomial.eval₂AlgHom f b hf) p = Polynomial.eval₂ (↑f) b p | null | true |
mersenne_odd._simp_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p : ℕ}, Odd (mersenne p) = (p ≠ 0) | null | false |
instPosSMulStrictMonoIntOfIsOrderedAddMonoid | Mathlib.Algebra.Order.Module.Defs | ∀ {G : Type u_3} [inst : PartialOrder G] [inst_1 : AddCommGroup G] [IsOrderedAddMonoid G], PosSMulStrictMono ℤ G | null | true |
Aesop.Frontend.Feature.builderOption.sizeOf_spec | Aesop.Frontend.RuleExpr | ∀ (o : Aesop.Frontend.BuilderOption), sizeOf (Aesop.Frontend.Feature.builderOption o) = 1 + sizeOf o | null | true |
Filter.mul_neBot_iff | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Mul α] {f g : Filter α}, (f * g).NeBot ↔ f.NeBot ∧ g.NeBot | null | true |
Set.initialSegIic._proof_2 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (j : α) (x x_1 : ↑(Set.Iic j)),
(fun j_1 => ↑j_1) x = (fun j_1 => ↑j_1) x_1 → x = x_1 | null | false |
DifferentiableWithinAt.fun_const_smul | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} {R : Type u_4} [inst_5 : Monoid R] [inst_6 : DistribMulAction R F] [SMulCommClas... | Eta-expanded form of `DifferentiableWithinAt.const_smul` | true |
_private.Mathlib.Combinatorics.Nullstellensatz.0.MvPolynomial.Alon.P.eq_1 | Mathlib.Combinatorics.Nullstellensatz | ∀ {R : Type u_1} [inst : CommRing R] {σ : Type u_2} (S : Finset R) (i : σ),
MvPolynomial.Alon.P✝ S i = ∏ r ∈ S, (MvPolynomial.X i - MvPolynomial.C r) | null | true |
CategoryTheory.Functor.isoWhiskerLeft_refl | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E), F.isoWhiskerLeft (CategoryTheory.Iso.refl G) = CategoryTheory.Iso.ref... | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_5 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
SimpleGraph.disjoint_sdiff_neighborFinset_image | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) {s t : V} [inst : DecidableEq V] [inst_1 : Fintype V]
[inst_2 : DecidableRel G.Adj],
Disjoint (G.edgeFinset \ G.incidenceFinset t) (Finset.image (fun x => s(x, t)) (G.neighborFinset s)) | null | true |
Array.mkSlice_roc_eq_mkSlice_roo_min | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo hi : ℕ},
Std.Roc.Sliceable.mkSlice xs (lo<...=hi) =
Std.Rco.Sliceable.mkSlice xs (min (lo + 1) (min (hi + 1) xs.size)...min (hi + 1) xs.size) | null | true |
Lean.Omega.LinearCombo.sub_eq_add_neg | Init.Omega.LinearCombo | ∀ (l₁ l₂ : Lean.Omega.LinearCombo), l₁ - l₂ = l₁ + -l₂ | null | true |
Std.ExtTreeMap.self_le_maxKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | null | true |
_private.Mathlib.Algebra.Ring.Int.Defs.0.Int.cast_mul_eq_zsmul_cast._simp_1_2 | Mathlib.Algebra.Ring.Int.Defs | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | false |
Real.hasStrictDerivAt_sqrt | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x | null | true |
Std.DTreeMap.Internal.Impl.get_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {h' : a ∈ (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.get a h' = t.get a ⋯ | null | true |
Int.mul_self_lt_mul_self | Init.Data.Int.Order | ∀ {a b : ℤ}, 0 ≤ a → a < b → a * a < b * b | null | true |
Complex.UnitClosedDisc.instCanLiftCoeLeRealNormOfNat | Mathlib.Analysis.Complex.UnitDisc.Basic | CanLift ℂ Complex.UnitClosedDisc Complex.UnitClosedDisc.coe fun x => ‖x‖ ≤ 1 | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_fin_Icc_eq_prod_nat_Icc._proof_1_1 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} (a_1 : ℕ), a_1 + 1 ≤ n → a_1 < n | null | false |
VectorFourier.fourierPowSMulRight_apply | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} {v : V} {n : ℕ} {m : Fin n → W},
(VectorFourier.fourierP... | null | true |
Cubic.natDegree_of_zero | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} [inst : Semiring R], (Cubic.toPoly 0).natDegree = 0 | null | true |
MulRingNorm.ofAbsoluteValue._proof_2 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : Ring R] (v : AbsoluteValue R ℝ) (x y : R), v.toFun (x + y) ≤ v.toFun x + v.toFun y | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.0.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.SectionSubring.mul_mem'._simp_1_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} {x : Submonoid A}
(f g : HomogeneousLocalization 𝒜 x), (f = g) = (f.val = g.val) | null | false |
CategoryTheory.Limits.coker_map | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] {f g : CategoryTheory.Arrow C} (u : f ⟶ g),
(CategoryTheory.Limits.coker C).map u =
CategoryTheory.Limits.cokernel.desc f.hom
(CategoryTheory.Categor... | null | true |
LinearMap.IsSymmetric.adjoint_eq | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {A : E →ₗ[𝕜] E}, A.IsSymmetric → LinearMap.adjoint A = A | null | true |
Complex.normSq._proof_1 | Mathlib.Basic.Complex.Basic | Complex.re 0 * Complex.re 0 + Complex.im 0 * Complex.im 0 = 0 | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.takeWhile_eq_toSlice_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String},
s.takeWhile pat = s.toSlice.takeWhile pat | null | false |
_private.Mathlib.Order.CompleteLattice.Defs.0.sSup_lt_iff.match_1_1 | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {l : α} (motive : (∃ b < l, b ∈ upperBounds s) → Prop)
(x : ∃ b < l, b ∈ upperBounds s), (∀ (w : α) (hbl : w < l) (hbs : w ∈ upperBounds s), motive ⋯) → motive x | null | false |
CategoryTheory.Functor.IsStronglyCartesian.mk | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {a' : 𝒳} (g : p.obj a' ⟶ R) (φ' : a' ⟶ b) [p.IsHomLift (CategoryTheory.Cat... | null | true |
SelectInsertParamsClass.mk.noConfusion | Mathlib.Tactic.Widget.SelectInsertParamsClass | {α : Type} →
{P : Sort u} →
{pos : α → Lean.Lsp.Position} →
{goals : α → Array Lean.Widget.InteractiveGoal} →
{selectedLocations : α → Array Lean.SubExpr.GoalsLocation} →
{replaceRange : α → Lean.Lsp.Range} →
{pos' : α → Lean.Lsp.Position} →
{goals' : α → Array Le... | null | false |
Lean.Parser.Tactic.MRefinePat.stateful | Std.Tactic.Do.Syntax | Lean.TSyntax `Lean.binderIdent → Lean.Parser.Tactic.MRefinePat | null | true |
DFinsupp.mapRange.linearEquiv._proof_3 | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_4} [inst : Semiring R] {β₁ : ι → Type u_2} {β₂ : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (β₁ i)] [inst_2 : (i : ι) → AddCommMonoid (β₂ i)]
[inst_3 : (i : ι) → Module R (β₁ i)] [inst_4 : (i : ι) → Module R (β₂ i)] (e : (i : ι) → β₁ i ≃ₗ[R] β₂ i) (m : R)
(x : Π₀ (i : ι), β₁ i),
... | null | false |
Std.IterM.toArray_mapWithPostcondition_mapWithPostcondition | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o] [LawfulMonad o] [inst_6 : MonadLiftT m n]
[inst_7 : MonadLiftT n o] [LawfulMonadLiftT m n] [LawfulMonadLiftT n o] [inst : Std.Iterator α... | null | true |
Hamming.instMetricSpace._proof_1 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)], T0Space (Hamming β) | null | false |
AddUnits.instInhabited | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → Inhabited (AddUnits α) | Additive units of an additive monoid are inhabited because `0` is an additive unit. | true |
QuotientGroup.instInhabitedQuotientSubgroup | Mathlib.GroupTheory.Coset.Defs | {α : Type u_1} → [inst : Group α] → (s : Subgroup α) → Inhabited (α ⧸ s) | null | true |
SetLike.coe_subset_coe | Mathlib.Basic.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {p q : A}, ↑p ⊆ ↑q ↔ p ≤ q | null | true |
Std.Sat.AIG.RefVec.map.go_le_size | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig : Std.Sat.AIG α} (idx : ℕ) (hidx : idx ≤ len)
(s : aig.RefVec idx) (input : aig.RefVec len) (f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [inst_3 : Std.Sat.AIG.RefVec... | null | true |
ContinuousMultilinearMap.map_piecewise_add | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f : ContinuousMultilinear... | null | true |
add_lt_of_lt_sub_right | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, a < c - b → a + b < c | **Alias** of the forward direction of `lt_sub_iff_add_lt`. | true |
MeasureTheory.IsAddFundamentalDomain.setIntegral_eq | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s t : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α]
[MeasureTheory.VAddInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
Measur... | null | true |
CategoryTheory.Enriched.FunctorCategory.isLimitConeFunctorEnrichedHom | Mathlib.CategoryTheory.Enriched.FunctorCategory | (V : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] →
{J : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} J] →
[inst_4 : CategoryTheory.En... | The limit of `functorEnrichedHom V F₁ F₂` is `enrichedHom V F₁ F₂`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
MvPolynomial.algebraTensorAlgEquiv_symm_map | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(x : MvPolynomial σ R),
(MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.map (algebraMap R A)) x) = 1 ⊗ₜ[R] x | null | true |
Lean.ConstantKind.axiom | Lean.Environment | Lean.ConstantKind | null | true |
Finsupp.smul_single' | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {R : Type u_6} {x : Semiring R} (c : R) (a : α) (b : R), (c • fun₀ | a => b) = fun₀ | a => c * b | null | true |
PowerSeries.degree_trunc_lt | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_1} [inst : Semiring R] (f : PowerSeries R) (n : ℕ), ((PowerSeries.trunc n) f).degree < ↑n | null | true |
CategoryTheory.NatTrans.comp_app_map_assoc | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H) (X : C) {D_1 : Type u_1}
[_instD : CategoryTheory.Category.{u_2, u_1} D_1] (F_1 : CategoryTheory.Functor D D_1) {Z : D_1}
(h : F_1.ob... | null | true |
Equiv.nonUnitalCommSemiring._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β] (x y : α),
e (e.symm (e.toFun x * e.toFun y)) = e.toFun x * e.toFun y | null | false |
LieSubmodule.Quotient.lieQuotientLieAlgebra._proof_1 | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(t : R) (x' y' : L ⧸ I), ⁅x', t • y'⁆ = t • ⁅x', y'⁆ | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr.0.Std.Tactic.BVDecide.BVExpr.bitblast.go.match_9.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ (motive : Std.Tactic.BVDecide.BVBinOp → Sort u_1) (h_1 : Unit → motive Std.Tactic.BVDecide.BVBinOp.and)
(h_2 : Unit → motive Std.Tactic.BVDecide.BVBinOp.or) (h_3 : Unit → motive Std.Tactic.BVDecide.BVBinOp.xor)
(h_4 : Unit → motive Std.Tactic.BVDecide.BVBinOp.add) (h_5 : Unit → motive Std.Tactic.BVDecide.BVBinOp.... | null | true |
Std.ExtDTreeMap.filterMap._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {γ : α → Type u_3} {cmp : α → α → Ordering} (f : (a : α) → β a → Option (γ a))
(x x_1 : Std.DTreeMap α β cmp),
x.Equiv x_1 → Std.ExtDTreeMap.mk (Std.DTreeMap.filterMap f x) = Std.ExtDTreeMap.mk (Std.DTreeMap.filterMap f x_1) | null | false |
CategoryTheory.InjectivePresentation.mk.noConfusion | Mathlib.CategoryTheory.Preadditive.Injective.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X : C} →
{P : Sort u} →
{J : C} →
{injective :
autoParam (CategoryTheory.Injective J) CategoryTheory.InjectivePresentation.injective._autoParam} →
{f : X ⟶ J} →
{mono : autoParam (Categor... | null | false |
RegularExpression.epsilon.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 1 → motive RegularExpression.epsilon → motive t | null | false |
Lean.Lsp.InitializeResult.serverInfo? | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializeResult → Option Lean.Lsp.ServerInfo | null | true |
CategoryTheory.Limits.Types.Small.productLimitCone._proof_1 | Mathlib.CategoryTheory.Limits.Types.Products | ∀ {J : Type u_2} (F : J → Type u_1) [Small.{u_1, u_2} J], Small.{u_1, max u_1 u_2} ((a : J) → F a) | null | false |
_private.Mathlib.Data.Nat.Factorization.LCM.0.Nat.factorizationLCMRight_dvd_right._simp_1_2 | Mathlib.Data.Nat.Factorization.LCM | ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), (a ∣ 0) = True | null | false |
SSet.Subcomplex.Pairing.RankFunction.Cell.preimage_filtration_map | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι)
[inst_1 : P.IsProper] {j : ι} (c : f.Cell j), (f.filtration j).preimage c.map = c.horn | null | true |
Lean.Data.Trie.upsert | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α → String → (Option α → α) → Lean.Data.Trie α | Insert or update the value at the given key `s`. | true |
OrderIso.toInitialSeg_toFun | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) (a : α), f.toInitialSeg a = f a | null | true |
AlgHom.val_comp_codRestrict | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (S : Subalgebra R B) (hf : ∀ (x : A), f x ∈ S),
S.val.comp (f.codRestrict S hf) = f | null | true |
Mathlib.Tactic.TermCongr.hasCHole | Mathlib.Tactic.TermCongr | ℕ → Lean.Expr → Option Lean.Expr | Returns any subexpression that is a recent congruence hole. | true |
Lean.Meta.Match.Alt | Lean.Meta.Match.Basic | Type | `Match` alternative | true |
UInt8.toFin_val | Init.Data.UInt.Lemmas | ∀ (x : UInt8), ↑x.toFin = x.toNat | null | true |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.BoundedFormula.restrictFreeVar.match_1.eq_3 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u_3} {β : Type u_5} [inst : DecidableEq α]
(motive : (x : ℕ) → (x_1 : L.BoundedFormula α x) → (↥x_1.freeVarFinset → β) → Sort u_4) (_n l : ℕ) (R : L.Relations l)
(ts : Fin l → L.Term (α ⊕ Fin _n)) (f : ↥(FirstOrder.Language.BoundedFormula.rel R ts).freeVarFinset → β)
(h_1 :
... | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffOn_infty._simp_1_2 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {p : Prop} {q : p → Prop} (h : p), (∀ (h' : p), q h') = q h | null | false |
CategoryTheory.CosimplicialObject.truncation | Mathlib.AlgebraicTopology.SimplicialObject.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(n : ℕ) →
CategoryTheory.Functor (CategoryTheory.CosimplicialObject C) (CategoryTheory.CosimplicialObject.Truncated C n) | The truncation functor from cosimplicial objects to truncated cosimplicial objects. | true |
_private.Mathlib.Order.Atoms.0.SetLike.isAtom_iff._simp_1_2 | Mathlib.Order.Atoms | ∀ {A : Type u_1} {B : Type u_2} [inst : Membership B A] [inst_1 : LE A] [IsConcreteLE A B] {p q : A},
(¬p ≤ q) = ∃ x ∈ p, x ∉ q | null | false |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvType.match_1 | Lean.Compiler.LCNF.AlphaEqv | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(e₁ e₂ : Lean.Expr) →
((f₁ a₁ f₂ a₂ : Lean.Expr) → motive (f₁.app a₁) (f₂.app a₂)) →
((fvarId₁ fvarId₂ : Lean.FVarId) → motive (Lean.Expr.fvar fvarId₁) (Lean.Expr.fvar fvarId₂)) →
((binderName : Lean.Name) →
(d₁ b₁ : Lean.Expr) →
... | null | false |
WithZero.lift_symm_apply | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : AddZeroClass β] (f : WithZero α →+ β) (x : α),
(WithZero.lift.symm f) x = f ↑x | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doUnless._regBuiltin.Lean.Parser.Term.doUnless.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
_private.Mathlib.RingTheory.Flat.Basic.0.LinearMap.rTensor_injective_of_fg._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (g : P →ₗ[R] Q)
(... | null | false |
_private.Mathlib.Algebra.ContinuedFractions.Euler.0.GenContFract.IsEuler.toEuler.match_1_1 | Mathlib.Algebra.ContinuedFractions.Euler | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n' : ℕ), motive n'.succ) → motive n | null | false |
Relation.reflTransGen_swap | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, Relation.ReflTransGen (Function.swap r) a b ↔ Relation.ReflTransGen r b a | null | true |
_private.Mathlib.AlgebraicGeometry.Birational.Composition.0.AlgebraicGeometry.Scheme.PartialMap.comp_assoc._simp_1_2 | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.TuranDensity.0.SimpleGraph.antitoneOn_extremalNumber_div_choose_two._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Extremal.TuranDensity | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), Finset.univ \ s = sᶜ | null | false |
Std.Http.Method.rebind.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} → (t : Std.Http.Method) → t.ctorIdx = 29 → motive Std.Http.Method.rebind → motive t | null | false |
Lean.Elab.Command.ElabHeaderResult.mk.inj | Lean.Elab.MutualInductive | ∀ {toPreElabHeaderResult : Lean.Elab.Command.PreElabHeaderResult} {indFVar : Lean.Expr}
{toPreElabHeaderResult_1 : Lean.Elab.Command.PreElabHeaderResult} {indFVar_1 : Lean.Expr},
{ toPreElabHeaderResult := toPreElabHeaderResult, indFVar := indFVar } =
{ toPreElabHeaderResult := toPreElabHeaderResult_1, indFVa... | null | true |
_private.Mathlib.Data.Fin.Embedding.0.Fin.range_natAdd_castLEEmb._proof_1_6 | Mathlib.Data.Fin.Embedding | ∀ {n m : ℕ}, n ≤ m → ∀ (x : Fin n), m ≤ ↑x + (m - n) + n | null | false |
LawfulMonadStateOf.set_bind_modify_bind | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α : Type u_1} (s : σ) (f : σ → σ) (mx : PUnit.{u_1 + 1} → m α),
(do
set s
let u ← modify f
mx u) =
do
set (f s)
mx PUnit.unit | null | true |
CategoryTheory.Functor.RightExtension.coneAtFunctor | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} H] →
(L : CategoryTheory.Functor C D) →
(F : CategoryTheory.Functor C ... | The cones for `StructuredArrow.proj Y L ⋙ F`, as a functor from `RightExtension L F`. | true |
_private.Lean.Elab.ConfigEval.DeriveEvalExpr.0.Lean.Elab.ConfigEval.ensureEvalExpr.getIndType._sparseCasesOn_1 | Lean.Elab.ConfigEval.DeriveEvalExpr | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
instIsRightCancelMulMonoidHom | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} [inst : MulOneClass M] [inst_1 : CommMonoid N] [IsRightCancelMul N],
IsRightCancelMul (M →* N) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.