name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsLowerSet.disjoint_upperClosure_left._simp_2 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, IsLowerSet t → Disjoint (↑(upperClosure s)) t = Disjoint s t | null | false |
Lean.Elab.Info.stx | Lean.Elab.InfoTree.Basic | Lean.Elab.Info → Lean.Syntax | null | true |
FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.Free R M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M'] [Module.Free R M'] [StrongRankCondition R]
[Module.Finite R M] [Module.Finite R M'], Nonempty (M ≃ₗ[R] M') ↔ Module.finrank R M = Modul... | Two finite and free modules are isomorphic if and only if they have the same (finite) rank. | true |
Ideal.span_singleton_le_span_singleton | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, Ideal.span {x} ≤ Ideal.span {y} ↔ y ∣ x | null | true |
Complex.differentiableOn_dslope | Mathlib.Analysis.Complex.RemovableSingularity | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {s : Set ℂ}
{c : ℂ}, s ∈ nhds c → (DifferentiableOn ℂ (dslope f c) s ↔ DifferentiableOn ℂ f s) | null | true |
PFunctor.M.IsPath.brecOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : PFunctor.Approx.Path F) → (a_1 : F.M) → PFunctor.M.IsPath a a_1 → Prop}
{a : PFunctor.Approx.Path F} {a_1 : F.M} (t : PFunctor.M.IsPath a a_1),
(∀ (a : PFunctor.Approx.Path F) (a_2 : F.M) (t : PFunctor.M.IsPath a a_2),
PFunctor.M.IsPath.below t → motive a a_2 t) →
... | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiff_succ_iff_fderiv._simp_1_4 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞},
UniqueDiffOn 𝕜 s →
ContDiffOn 𝕜 (n + 1) f s =
(Differentiabl... | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabForallBinders | Lean.PrettyPrinter.Delaborator.Builtins | Bool →
(Array Lean.Syntax → Bool → Lean.Syntax → Lean.PrettyPrinter.Delaborator.Delab) →
optParam (Array Lean.Syntax) #[] → optParam Bool false → Lean.PrettyPrinter.Delaborator.Delab | Similar to `delabBinders`, but tracking whether `forallE` is dependent or not.
See issue #1571
| true |
CategoryTheory.Functor.reflectsEpimorphisms_comp | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {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.ReflectsEpimorphisms] [G.ReflectsEpimorphisms], (F.comp G).Reflects... | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.cast_eq_cast._proof_1_1 | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ}, n = m → Fin n = Fin m | null | false |
Lean.Elab.Command.InductiveElabStep1._sizeOf_1 | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep1 → ℕ | null | false |
Lean.LibrarySuggestions.Config.maxSuggestions | Lean.LibrarySuggestions.Basic | Lean.LibrarySuggestions.Config → ℕ | The maximum number of suggestions to return.
| true |
Lean.Elab.DocElabInfo.mk.injEq | Lean.Elab.InfoTree.Types | ∀ (toElabInfo : Lean.Elab.ElabInfo) (name : Lean.Name) (kind : Lean.Elab.DocElabKind)
(toElabInfo_1 : Lean.Elab.ElabInfo) (name_1 : Lean.Name) (kind_1 : Lean.Elab.DocElabKind),
({ toElabInfo := toElabInfo, name := name, kind := kind } =
{ toElabInfo := toElabInfo_1, name := name_1, kind := kind_1 }) =
(to... | null | true |
MLList.head? | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → MLList m α → m (Option α) | Return the head of a monadic lazy list if it exists, as an `Option` in the monad. | true |
CategoryTheory.Functor.Elements.costructuredArrowULiftYonedaEquivalenceFunctorCompProjIso_inv_app | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type (max w v)))
(X : F.Elementsᵒᵖ),
(CategoryTheory.Functor.Elements.costructuredArrowULiftYonedaEquivalenceFunctorCompProjIso F).inv.app X =
CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.unop X).1) | null | true |
SchwartzMap.compSubConstCLM._proof_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (a : E),
Function.HasTemperateGrowth fun x => x - a | null | false |
AddCommute.neg_left | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a b : G}, AddCommute a b → AddCommute (-a) b | **Alias** of the reverse direction of `AddCommute.neg_left_iff`. | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (a a_1 : List α),
List.MergeSort.Internal.mergeTR.go✝ le [] a a_1 = a_1.reverseAux a | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionMopMonoidal._proof_6 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ (C : Type u_2) (D : Type u_3) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_4, u_3} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {X Y : C} (X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(Cat... | null | false |
AlgCat.limitSemiring._proof_18 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (... | null | false |
Vector.finRange_succ._proof_2 | Init.Data.Vector.FinRange | ∀ {n : ℕ}, 1 + n = n + 1 | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_239 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
_private.Mathlib.Algebra.Order.Algebra.0.isOrderedModule_iff_algebraMap_mono._simp_1_1 | Mathlib.Algebra.Order.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : Preorder α]
[inst_4 : Preorder β] [inst_5 : MulOneClass β] [ZeroLEOneClass β] [PosMulMono β] [MulPosMono β] [IsScalarTower α β β],
IsOrderedModule α β = Monotone fun x => x • 1 | null | false |
MultilinearMap.dfinsupp_ext | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type uι} {κ : ι → Type uκ} {R : Type uR} {M : (i : ι) → κ i → Type uM} {N : Type uN} [Finite ι]
[inst : Semiring R] [inst_1 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_2 : AddCommMonoid N]
[inst_3 : (i : ι) → (k : κ i) → Module R (M i k)] [inst_4 : Module R N] [inst_5 : (i : ι) → DecidableEq (κ i)]
... | Two multilinear maps from finitely supported functions are equal if they agree on the
generators.
This is a multilinear version of `DFinsupp.lhom_ext'`. | true |
Filter.tendsto_neg_atBot_atTop | Mathlib.Order.Filter.AtTopBot.Group | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G],
Filter.Tendsto Neg.neg Filter.atBot Filter.atTop | null | true |
_private.Mathlib.Topology.MetricSpace.UniformConvergence.0.UniformFun.instBoundedSpace._simp_2 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
ENNReal.toReal_prod | Mathlib.Basic.ENNReal.BigOperators | ∀ {ι : Type u_1} (s : Finset ι) (f : ι → ENNReal), (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal | null | true |
_private.Mathlib.Topology.ContinuousMap.Compact.0.ContinuousMap.instNontrivialTopologyOfNonemptyOfNontrivial._simp_1 | Mathlib.Topology.ContinuousMap.Compact | ∀ {E : Type u_4} [inst : SeminormedAddGroup E], NontrivialTopology E = ∃ x, ‖x‖ ≠ 0 | null | false |
Bornology.IsCobounded.closedBall_compl_subset | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α},
Bornology.IsCobounded s → ∀ (c : α), ∃ r, (Metric.closedBall c r)ᶜ ⊆ s | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.step_filterMapM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {β' : Type u_1} {f : β → n (Option β')} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) none)
(h_1 : (hf : MonadAttach.CanReturn (f out) none) → motive ⟨none, hf⟩)
(h_2 : (out' : β') → (hf... | null | true |
Lean.Grind.CommRing.Mon.denote'.go.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α)
(motive : Lean.Grind.CommRing.Mon → α → α → Prop),
(∀ (acc : α), motive Lean.Grind.CommRing.Mon.unit acc acc) →
(∀ (acc : α) (p : Lean.Grind.CommRing.Power) (m : Lean.Grind.CommRing.Mon),
motive m (acc * Lean.Grind.Com... | null | true |
Lean.Grind.Linarith.Poly.below | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Poly → Sort u} → Lean.Grind.Linarith.Poly → Sort (max 1 u) | null | false |
Mathlib.Tactic.LibraryRewrite.Rewrite.makesNewMVars | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.Rewrite → Bool | Whether the rewrite introduces a new metavariable in the replacement expression. | true |
SimplexCategoryGenRel.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ i.castSucc) (SimplexCategoryGenRel.σ j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.σ j) (SimplexCategoryGenRel.δ i) | null | true |
SSet.chainComplex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.Homology.HomologyZero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X X_1 : SSet),
X = X_1 → ∀ (R R_1 : C), R = R_1 → X.chainComplex R = X_1.chainComplex R_1 | null | true |
BoxIntegral.Prepartition.sum_ofWithBot | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {M : Type u_2} [inst : AddCommMonoid M]
(boxes : Finset (WithBot (BoxIntegral.Box ι))) (le_of_mem : ∀ J ∈ boxes, J ≤ ↑I)
(pairwise_disjoint : (↑boxes).Pairwise Disjoint) (f : BoxIntegral.Box ι → M),
∑ J ∈ (BoxIntegral.Prepartition.ofWithBot boxes le_of_mem pairwise_disjoin... | null | true |
_private.Init.Data.SInt.Lemmas.0.Int8.ofNat_sub._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int8.ofNat n = Int8.ofInt ↑n | null | false |
_private.Mathlib.Algebra.Module.Torsion.PrimaryComponent.0.Ideal.primaryComponent_torsionBySet_of_isCoprime._simp_1_13 | Mathlib.Algebra.Module.Torsion.PrimaryComponent | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p p' : Submodule R M}, Disjoint p p' = ∀ x ∈ p, x ∈ p' → x = 0 | null | false |
NNRat.cast_one | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_2} [inst : DivisionSemiring α], ↑1 = 1 | null | true |
groupCohomology.cocyclesIso₀._proof_2 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) 0).HasHomology | null | false |
DifferentiableWithinAt.mono_of_mem_nhdsWithin | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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} {x : E} {s : Set E},
DifferentiableWithinAt 𝕜 f s x → ∀ {t ... | null | true |
AdjoinRoot.mapAlgEquiv._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S ≃ₐ[R] T) (p : Polynomial S) (q : Polynomial T)
(h : Associated (Polynomial.map (↑f) p) q),
(AdjoinRoot.mapAlgHom (↑f) p q ⋯).comp (AdjoinRoot.mapAlgHo... | null | false |
GaloisInsertion.liftCompleteLattice | Mathlib.Order.GaloisConnection.Basic | {α : Type u_1} →
{β : Type u_2} →
{l : α → β} →
{u : β → α} → [inst : PartialOrder β] → [inst_1 : CompleteLattice α] → GaloisInsertion l u → CompleteLattice β | Lift all suprema and infima along a Galois insertion | true |
Std.DTreeMap.Internal.instSliceableImplRcoSlice | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] → Std.Rco.Sliceable (Std.DTreeMap.Internal.Impl α β) α (Std.DTreeMap.Internal.RcoSlice α β) | null | true |
Complex.norm_log_one_sub_inv_sub_self_le | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {z : ℂ}, ‖z‖ < 1 → ‖Complex.log (1 - z)⁻¹ - z‖ ≤ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 | The difference `log (1-z)⁻¹ - z` is bounded by `‖z‖^2/(2*(1-‖z‖))` when `‖z‖ < 1`. | true |
Polynomial.SplittingField.instCommRing._proof_17 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), a * 1 = a | null | false |
Std.HashMap.Raw.isEmpty_diff_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 → m₁.isEmpty = true → (m₁ \ m₂).isEmpty = true | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Deligne.0.Complex.Gammaℝ_add_two._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.neg_bmod._proof_1_11 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} (c : ℕ), ¬1 < 2 → False | null | false |
ite_self_left._simp_1 | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then p else q) = (¬p → q) | null | false |
NormedAddGroupHom.Equalizer.ι_normNoninc | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
{f g : NormedAddGroupHom V W}, (NormedAddGroupHom.Equalizer.ι f g).NormNoninc | null | true |
MeasureTheory.integral_indicator_const | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure X} [CompleteSpace E] (e : E) ⦃s : Set X⦄,
MeasurableSet s → ∫ (x : X), s.indicator (fun x => e) x ∂μ = μ.real s • e | null | true |
Representation.subrepresentation._proof_2 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (W : Submodule k V)
(le_comap : ∀ (g : G), W ≤ Submodule.comap (ρ g) W) (x x_1 : G),
(ρ (x * x_1)).restrict ⋯ = (ρ x).restrict ⋯ * (ρ x_1).restrict ⋯ | null | false |
Matrix.kroneckerTMul_diagonal | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ (R : Type u_1) {α : Type u_3} {β : Type u_5} {l : Type u_9} {m : Type u_10} {n : Type u_11} [inst : CommSemiring R]
[inst_1 : AddCommMonoid α] [inst_2 : AddCommMonoid β] [inst_3 : Module R α] [inst_4 : Module R β]
[inst_5 : DecidableEq n] (A : Matrix l m α) (b : n → β),
Matrix.kroneckerMap (TensorProduct.tmul R... | null | true |
Finset.sum_smul_vsub_const_eq_weightedVSubOfPoint_sub | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p₁ : ι → P) (p₂ b : P),
∑ i ∈ s, w i • (p₁ i -ᵥ p₂) = (s.weightedVSubOfPoint p₁ b) w - (∑ i ∈ s, w i) • (p₂ -ᵥ b) | A weighted sum of pairwise subtractions, where the point on the right is constant,
expressed as a subtraction involving a `weightedVSubOfPoint` expression. | true |
NumberField.RingOfIntegers.instIsIntegralClosureIntWithVal | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {K : Type u_3} [inst_1 : Field K] (v : Valuation K Γ₀)
(R : Type u_4) [inst_2 : CommRing R] [inst_3 : Algebra R K] [IsIntegralClosure R ℤ K],
IsIntegralClosure R ℤ (WithVal v) | null | true |
Rat.cast_pos._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {q : ℚ} {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], (0 < ↑q) = (0 < q) | null | false |
CategoryTheory.Iso.hom_inv_id_eval_assoc | Mathlib.CategoryTheory.GradedObject | ∀ {C : Type u_1} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : CategoryTheory.GradedObject J C}
(e : X ≅ Y) (j : J) {Z : C} (h : X j ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.hom j) (CategoryTheory.CategoryStruct.comp (e.inv j) h) = h | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_get_aux._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ} (idx : ℕ)
(_x :
(aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) ×'
(_ : ℕ) ×' (curr : ℕ) ×' (_ : curr ≤ w) ×' (_ : aig.RefVec curr) ×' idx < curr)
(hfoo :
_x.1.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go _x.1 w _x.2.1 _x.2.2.1 _x.2.2.2.2.1 ⋯).aig.decls.size),
(Std.Tac... | null | false |
TopCat.discrete | Mathlib.Topology.Category.TopCat.Basic | CategoryTheory.Functor (Type u) TopCat | The discrete topology on any type. | true |
Multiset.powerset_injective | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1}, Function.Injective Multiset.powerset | null | true |
Array.unattach_flatten | Init.Data.Array.Attach | ∀ {α : Type u_1} {p : α → Prop} {xs : Array (Array { x // p x })},
xs.flatten.unattach = (Array.map Array.unattach xs).flatten | null | true |
Lean.MetavarContext.casesOn | Lean.MetavarContext | {motive : Lean.MetavarContext → Sort u} →
(t : Lean.MetavarContext) →
((depth levelAssignDepth lmvarCounter mvarCounter : ℕ) →
(lDecls : Lean.PersistentHashMap Lean.LMVarId Lean.LevelMetavarDecl) →
(decls : Lean.PersistentHashMap Lean.MVarId Lean.MetavarDecl) →
(userNames : Lean.Pers... | null | false |
Commute.zpow_left₀ | Mathlib.Algebra.GroupWithZero.Semiconj | ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {a b : G₀}, Commute a b → ∀ (m : ℤ), Commute (a ^ m) b | null | true |
Additive.instUniqueOrderAddMonoidIso | Mathlib.Algebra.Order.Hom.TypeTags | {G : Type u_1} →
{H : Type u_2} →
[inst : CommMonoid G] →
[inst_1 : PartialOrder G] →
[inst_2 : CommMonoid H] → [inst_3 : PartialOrder H] → [Unique (G ≃*o H)] → Unique (Additive G ≃+o Additive H) | null | true |
Function.Injective.idemSemiring | Mathlib.Algebra.Order.Kleene | {α : Type u_1} →
{β : Type u_2} →
[inst : IdemSemiring α] →
[inst_1 : LE β] →
[inst_2 : LT β] →
[inst_3 : Zero β] →
[inst_4 : One β] →
[inst_5 : Add β] →
[inst_6 : Mul β] →
[inst_7 : Pow β ℕ] →
[inst_8 : SMul ℕ... | Pullback an `IdemSemiring` instance along an injective function. | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_24 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(size + 0 ≤ 1 ∨ size ≤ 3 * 0 ∧ 0 ≤ 3 * size) ∧ ls = size + 1 + 0 →
(3 * (l.size + 1 +... | null | false |
UInt64.ofNat_size | Init.Data.UInt.Lemmas | UInt64.ofNat UInt64.size = 0 | null | true |
continuousOn_zpow₀ | Mathlib.Topology.Algebra.GroupWithZero | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀] [ContinuousInv₀ G₀] [ContinuousMul G₀]
(m : ℤ), ContinuousOn (fun x => x ^ m) {0}ᶜ | null | true |
Path.Homotopy.pathCast.eq_1 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x x' y y' : X} {p q : Path x y} (F : p.Homotopy q) (hx : x' = x)
(hy : y' = y), F.pathCast hx hy = F | null | true |
HasFDerivWithinAt.unique_on | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {F : Type u_3} [inst_6 : AddCommGroup F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [ContinuousAdd F] [ContinuousSMul ... | If `f'` and `f₁'` are two derivatives of `f` within `s` at `x`, then they are equal on the
tangent cone to `s` at `x` | true |
_private.Batteries.Data.List.Lemmas.0.List.disjoint_take_drop.match_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {m n : ℕ} (motive : (x : List α) → x.Nodup → m ≤ n → Prop) (x : List α) (x_1 : x.Nodup) (x_2 : m ≤ n),
(∀ (x : [].Nodup) (x_3 : m ≤ n), motive [] x x_3) →
(∀ (x : α) (xs : List α) (hl : (x :: xs).Nodup) (h : m ≤ n), motive (x :: xs) hl h) → motive x x_1 x_2 | null | false |
UInt32.ofNat_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : ℕ), b < 32 → UInt32.ofNat (a <<< b) = UInt32.ofNat a <<< UInt32.ofNat b | null | true |
SSet.RelativeMorphism.HomotopyClass.eq_homotopyClass | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet}
(x : SSet.RelativeMorphism.HomotopyClass A B φ), ∃ f, f.homotopyClass = x | null | true |
Mul.gMul | Mathlib.Algebra.GradedMonoid | (ι : Type u_1) → {R : Type u_2} → [inst : Add ι] → [Mul R] → GradedMonoid.GMul fun x => R | null | true |
Projectivization.isCollinear_pair | Mathlib.LinearAlgebra.Projectivization.Collinear | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(a b : Projectivization K V), Projectivization.IsCollinear {a, b} | null | true |
MeasureTheory.lpNorm_fun_natCast_mul | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {m : MeasurableSpace α} {𝕜 : Type u_3} [inst : NormedField 𝕜] [NormedSpace ℝ 𝕜] (n : ℕ) (f : α → 𝕜)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.lpNorm (fun x => ↑n * f x) p μ = ↑n * MeasureTheory.lpNorm f p μ | null | true |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.evalFinsetIccNat._unary._proof_1 | Mathlib.Tactic.Simproc.FinsetInterval | ∀ (en em : Q(ℕ)), «$em» =Q «$en» | null | false |
DedekindCut.instCompleteLinearOrder._proof_12 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : DedekindCut α), a ≤ b ⇨ c ↔ min a b ≤ c | null | false |
contDiff_mul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸], ContDiff 𝕜 n fun p => p.1 * p.2 | null | true |
ONote.repr._f | Mathlib.SetTheory.Ordinal.Notation | (x : ONote) → ONote.below x → Ordinal.{0} | null | false |
PositiveContinuousLinearMap.ofClass | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | {R : Type u_1} →
{E₁ : Type u_2} →
{E₂ : Type u_3} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E₁] →
[inst_2 : PartialOrder E₁] →
[inst_3 : AddCommMonoid E₂] →
[inst_4 : PartialOrder E₂] →
[inst_5 : Module R E₁] →
[inst_6 : Mo... | Reinterpret an element of a type of positive continuous linear maps as
a positive continuous linear map. | true |
Lean.Compiler.LCNF.Simp.inlineApp? | Lean.Compiler.LCNF.Simp.Main | Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Simp.SimpM (Option (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure)) | If the value of the given let-declaration is an application that can be inlined,
inline it and simplify the result.
`k` is the "continuation" for the let declaration, if the application is inlined,
it will also be simplified.
Note: `inlineApp?` did not use to be in this mutually recursive declaration.
It used to be i... | true |
CategoryTheory.MonObj.mul_def | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.MonObj.mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | null | true |
KummerExtension.«_aux_Mathlib_FieldTheory_KummerExtension___delab_app_KummerExtension_termK[_√_]_1» | Mathlib.FieldTheory.KummerExtension | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Lean.EnvExtension.AsyncMode.ctorElim | Lean.Environment | {motive : Lean.EnvExtension.AsyncMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.EnvExtension.AsyncMode) →
ctorIdx = t.ctorIdx → Lean.EnvExtension.AsyncMode.ctorElimType ctorIdx → motive t | null | false |
Finsupp.instNonUnitalCommRing._proof_3 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalCommRing β] (f g : α →₀ β), ⇑(f + g) = ⇑f + ⇑g | null | false |
MulAction.stabilizer_subgroupOf | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] (H : Subgroup G) (a : α),
(MulAction.stabilizer G a).subgroupOf H = MulAction.stabilizer (↥H) a | null | true |
Int16.toBitVec_max | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a ⊔ b).toBitVec = if a.toBitVec.sle b.toBitVec = true then b.toBitVec else a.toBitVec | null | true |
List.dropPrefix?._unsafe_rec | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → List α → Option (List α) | null | false |
_private.Mathlib.RingTheory.Ideal.Quotient.Nilpotent.0.Ideal.Quotient.isUnit_mk_pow_iff_isUnit_mk._simp_1_1 | Mathlib.RingTheory.Ideal.Quotient.Nilpotent | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F) (I : Ideal R) (n : ℕ), Ideal.map f I ^ n = Ideal.map f (I ^ n) | null | false |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.Disjoint.isConj_mul._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
AddSubgroup.index_eq_two_iff' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 2 ↔ ∃ a, ∀ (b : G), Xor (a + b ∈ H) (b ∈ H) | An additive subgroup has index two if and only if there exists `a` such that
for all `b`, exactly one of `a + b` and `b` belong to `H`. | true |
CategoryTheory.Span.id_r | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] (c : C),
(CategoryTheory.Span.id c).r = CategoryTheory.CategoryStruct.id c | null | true |
Fin.consLinearEquiv._proof_5 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u_2) {n : ℕ} (M : Fin n.succ → Type u_1) [inst : Semiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : (i : Fin n.succ) → Module R (M i)] (c : R)
(x : M 0 × ((i : Fin n) → M i.succ)), (Fin.consEquiv M).toFun (c • x) = (RingHom.id R) c • (Fin.consEquiv M).toFun x | null | false |
PowerSeries.intValuation_eq_of_coe | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K] (P : Polynomial K),
(Polynomial.idealX K).intValuation P = (PowerSeries.idealX K).intValuation ↑P | null | true |
FractionalIdeal.adjoinIntegral_eq_one_of_isUnit | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_2} {K : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [IsDomain A] (x : K) (hx : IsIntegral A x),
IsUnit (FractionalIdeal.adjoinIntegral (nonZeroDivisors A) x hx) →
FractionalIdeal.adjoinIntegral (nonZeroDivisors A) x hx = 1 | null | true |
TopologicalSpace.Opens.comap_id | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α],
TopologicalSpace.Opens.comap (ContinuousMap.id α) = FrameHom.id (TopologicalSpace.Opens α) | null | true |
_private.Init.Data.List.Sublist.0.List.cons_subset._simp_1_2 | Init.Data.List.Sublist | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
le_nhds_add | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M] (a b : M),
nhds a + nhds b ≤ nhds (a + b) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.