name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ContDiffOn.div_const | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {𝕜' : Type u_6} [inst_3 : NormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜']
{f : E → 𝕜'} {n : WithTop ℕ∞}, ContDiffOn 𝕜 n f s → ∀ (c : 𝕜'), ContDiffOn 𝕜 n (fun x => f x / c) s |
CategoryTheory.ShortComplex.QuasiIso.mk | Mathlib.Algebra.Homology.ShortComplex.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] {φ : S₁ ⟶ S₂},
CategoryTheory.IsIso (CategoryTheory.ShortComplex.homologyMap φ) → CategoryTheory.ShortComplex.QuasiIso φ |
Fin.findSome?_eq_findSome?_finRange | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → Option α), Fin.findSome? f = List.findSome? f (List.finRange n) |
List.chain_map | Mathlib.Data.List.Chain | ∀ {α : Type u} {β : Type v} {R : α → α → Prop} (f : β → α) {l : List β} {b : β},
List.IsChain R (f b :: List.map f l) ↔ List.IsChain (fun a b => R (f a) (f b)) (b :: l) |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.splitConjunctions.aux._sparseCasesOn_1 | Mathlib.Tactic.Linarith.Preprocessing | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) [inst_2 : S.HasLeftHomology] {Z : C} (h_1 : S.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv (CategoryTheory.CategoryStruct.comp S.iCycles h_1) =
CategoryTheory.CategoryStruct.comp h.i h_1 |
Std.CancellationReason.cancel.elim | Std.Sync.CancellationToken | {motive : Std.CancellationReason → Sort u} →
(t : Std.CancellationReason) → t.ctorIdx = 2 → motive Std.CancellationReason.cancel → motive t |
FirstOrder.Language.ElementarilyEquivalent | Mathlib.ModelTheory.Semantics | (L : FirstOrder.Language) → (M : Type w) → (N : Type u_1) → [L.Structure M] → [L.Structure N] → Prop |
Lean.Compiler.LCNF.LCtx.mk | Lean.Compiler.LCNF.LCtx | Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.impure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.LCtx |
MeasureTheory.Measure.measure_isAddInvariant_eq_smul_of_isCompact_closure_of_innerRegularCompactLTTop | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLeftInvariant]
[μ.InnerRegularCompactLTTop] {s : Set G},
MeasurableSet s → IsCompact (closure s) → μ' s = μ'.addHaarScalarFactor μ • μ s |
Polynomial.mem_degreeLT | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} {f : Polynomial R}, f ∈ Polynomial.degreeLT R n ↔ f.degree < ↑n |
CategoryTheory.MonoidalCategory.prodMonoidal.match_1 | Mathlib.CategoryTheory.Monoidal.Category | (C₁ : Type u_1) →
(C₂ : Type u_2) → (motive : C₁ × C₂ → Sort u_3) → (x : C₁ × C₂) → ((X₁ : C₁) → (X₂ : C₂) → motive (X₁, X₂)) → motive x |
Set.ncard_image_le._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax |
Std.DHashMap.Internal.Raw₀.interSmallerFn | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[BEq α] →
[Hashable α] →
Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β → α → Std.DHashMap.Internal.Raw₀ α β |
Lean.Lsp.CompletionItem._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItem → ℕ |
ZeroHom.recOn | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Zero M] →
[inst_1 : Zero N] →
{motive : ZeroHom M N → Sort u} →
(t : ZeroHom M N) →
((toFun : M → N) → (map_zero' : toFun 0 = 0) → motive { toFun := toFun, map_zero' := map_zero' }) → motive t |
Antitone.tendstoLocallyUniformly_of_forall_tendsto | Mathlib.Topology.UniformSpace.Dini | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
[inst_2 : NormedAddCommGroup G] [inst_3 : Lattice G] [HasSolidNorm G] [IsOrderedAddMonoid G] {F : ι → α → G}
{f : α → G},
(∀ (i : ι), Continuous (F i)) →
Antitone F →
Continuous f →
(∀ (x : α), Filter.Tendsto (fun x_1 => F x_1 x) Filter.atTop (nhds (f x))) →
TendstoLocallyUniformly F f Filter.atTop |
Measurable.fst | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
{f : α → β × γ}, Measurable f → Measurable fun a => (f a).1 |
Language.reverse_add | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α), (l + m).reverse = l.reverse + m.reverse |
Lean.Server.References.recOn | Lean.Server.References | {motive : Lean.Server.References → Sort u} →
(t : Lean.Server.References) →
((ileans : Lean.Server.ILeanMap) →
(workers : Lean.Server.WorkerRefMap) → motive { ileans := ileans, workers := workers }) →
motive t |
Std.Rxc.Iterator.Monadic.isPlausibleIndirectOutput_iff | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerable α] {it : Std.IterM Id α} {out : α},
it.IsPlausibleIndirectOutput out ↔
∃ n, (it.internalState.next.bind fun x => Std.PRange.succMany? n x) = some out ∧ out ≤ it.internalState.upperBound |
Finsupp.restrictSupportEquiv._proof_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} (s : Set α) (M : Type u_2) [inst : AddCommMonoid M] (f : { f // ↑f.support ⊆ s }),
↑(Finsupp.subtypeDomain (fun x => x ∈ s) ↑f).extendDomain.support ⊆ {x | x ∈ s} |
ContDiffMapSupportedIn.noConfusion | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {P : Sort u} →
{E : Type u_2} →
{F : Type u_3} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{t : ContDiffMapSupportedIn E F n K} →
{E' : Type u_2} →
{F' : Type u_3} →
{inst' : NormedAddCommGroup E'} →
{inst'_1 : NormedSpace ℝ E'} →
{inst'_2 : NormedAddCommGroup F'} →
{inst'_3 : NormedSpace ℝ F'} →
{n' : ℕ∞} →
{K' : TopologicalSpace.Compacts E'} →
{t' : ContDiffMapSupportedIn E' F' n' K'} →
E = E' →
F = F' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
n = n' →
K ≍ K' → t ≍ t' → ContDiffMapSupportedIn.noConfusionType P t t' |
CharP.ringChar_ne_one | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [Nontrivial R], ringChar R ≠ 1 |
TensorProduct.instNormedAddCommGroup._proof_6 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x y : TensorProduct 𝕜 E F), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y |
CochainComplex.HomComplex.Cocycle.toSingleMk_coe | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' : ℤ) (hp' : p' + 1 = p) (hf : CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0),
↑(CochainComplex.HomComplex.Cocycle.toSingleMk f h p' hp' hf) = CochainComplex.HomComplex.Cochain.toSingleMk f h |
CategoryTheory.nerve.homEquiv_edgeMk_map_nerveMap | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u} [inst_1 : CategoryTheory.Category.{v, u} D]
{x y : C} (f : x ⟶ y) (F : CategoryTheory.Functor C D),
CategoryTheory.nerve.homEquiv ((CategoryTheory.nerve.edgeMk f).map (CategoryTheory.nerveMap F)) = F.map f |
Std.Iterators.Types.Zip.instFinitenessRelation₁ | Std.Data.Iterators.Combinators.Monadic.Zip | {m : Type w → Type w'} →
{α₁ β₁ : Type w} →
[inst : Std.Iterator α₁ m β₁] →
{α₂ β₂ : Type w} →
[inst_1 : Std.Iterator α₂ m β₂] →
[inst_2 : Monad m] →
[Std.Iterators.Finite α₁ m] →
[Std.Iterators.Productive α₂ m] → Std.Iterators.FinitenessRelation (Std.Iterators.Types.Zip α₁ m α₂ β₂) m |
QuadraticModuleCat.forget₂_map_associator_inv | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Invertible 2] (X Y Z : QuadraticModuleCat R),
(CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).map
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv =
(CategoryTheory.MonoidalCategoryStruct.associator X.toModuleCat Y.toModuleCat Z.toModuleCat).inv |
_private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.isAlgebraic.match_1 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (z : AlgebraicClosure k)
(motive : (∃ a, (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) a = z) → Prop)
(x : ∃ a, (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) a = z),
(∀ (p : MvPolynomial (AlgebraicClosure.Vars k) k) (hp : (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) p = z),
motive ⋯) →
motive x |
BitVec.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc |
«_aux_ImportGraph_Tools_ImportDiff___elabRules_command#import_diff__1» | ImportGraph.Tools.ImportDiff | Lean.Elab.Command.CommandElab |
Complex.norm_exp_ofReal_mul_I | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), ‖Complex.exp (↑x * Complex.I)‖ = 1 |
EuclideanGeometry.Concyclic.subset | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {ps₁ ps₂ : Set P},
ps₁ ⊆ ps₂ → EuclideanGeometry.Concyclic ps₂ → EuclideanGeometry.Concyclic ps₁ |
Nat.toArray_roc_add_succ_right_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=m + n + 1).toArray = (m<...=m + n).toArray.push (m + n + 1) |
Subfield.map_le_iff_le_comap | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] {f : K →+* L} {s : Subfield K}
{t : Subfield L}, Subfield.map f s ≤ t ↔ s ≤ Subfield.comap f t |
Complex.re_le_norm | Mathlib.Analysis.Complex.Norm | ∀ (z : ℂ), z.re ≤ ‖z‖ |
Lean.Meta.Simp.isBuiltinSimproc | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Lean.CoreM Bool |
_private.Mathlib.Data.FinEnum.Option.0.FinEnum.recEmptyOption.match_1.eq_1 | Mathlib.Data.FinEnum.Option | ∀ (motive : ℕ → Sort u_1) (h_1 : 0 = 0 → motive 0) (h_2 : (n : ℕ) → 0 = n.succ → motive n.succ),
(match cardeq : 0 with
| 0 => h_1 cardeq
| n.succ => h_2 n cardeq) =
h_1 ⋯ |
CategoryTheory.Limits.imageSubobject_iso_comp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasEqualizers C] {X' : C}
(h : X' ⟶ X) [inst_2 : CategoryTheory.IsIso h] (f : X ⟶ Y) [inst_3 : CategoryTheory.Limits.HasImage f],
CategoryTheory.Limits.imageSubobject (CategoryTheory.CategoryStruct.comp h f) = CategoryTheory.Limits.imageSubobject f |
NonUnitalSubring.mk._flat_ctor | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} →
[inst : NonUnitalNonAssocRing R] →
(carrier : Set R) →
(∀ {a b : R}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) →
0 ∈ carrier →
(∀ {a b : R}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
(∀ {x : R}, x ∈ carrier → -x ∈ carrier) → NonUnitalSubring R |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_iff_tendstoUniformlyOnFilter._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {p : α × β → Prop} {s : Set β},
(∀ᶠ (x : α × β) in f ×ˢ Filter.principal s, p x) = ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y) |
ContMDiffMap.coeFnMonoidHom.eq_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'} {N : Type u_6} [inst_7 : TopologicalSpace N] [inst_8 : ChartedSpace H N]
{n : WithTop ℕ∞} {G : Type u_10} [inst_9 : Monoid G] [inst_10 : TopologicalSpace G] [inst_11 : ChartedSpace H' G]
[inst_12 : ContMDiffMul I' n G], ContMDiffMap.coeFnMonoidHom = { toFun := DFunLike.coe, map_one' := ⋯, map_mul' := ⋯ } |
Set.forall_subset_range_iff._simp_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : Set β → Prop}, (∀ s ⊆ Set.range f, p s) = ∀ (s : Set α), p (f '' s) |
CategoryTheory.ExponentiableMorphism.OverMkHom | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J : C} →
{f : I ⟶ J} →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
[CategoryTheory.ExponentiableMorphism f] → CategoryTheory.ExponentiableMorphism (CategoryTheory.Over.mk f).hom |
AlgebraicGeometry.Scheme.Pullback.openCoverOfBase'._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Z.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
(i :
(AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰) f
g).I₀),
CategoryTheory.Limits.HasPullback f (𝒰.f i) |
MeasureTheory.lintegral_add_mul_meas_add_le_le_lintegral | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
f ≤ᵐ[μ] g → AEMeasurable g μ → ∀ (ε : ENNReal), ∫⁻ (a : α), f a ∂μ + ε * μ {x | f x + ε ≤ g x} ≤ ∫⁻ (a : α), g a ∂μ |
Aesop.Hyp | Aesop.Forward.State | Type |
Lean.LocalDecl.setNondep | Lean.LocalContext | Lean.LocalDecl → Bool → Lean.LocalDecl |
Lean.Compiler.LCNF.UnreachableBranches.Value.ctorElimType | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} → ℕ → Sort (max 1 u) |
Lean.Parser.Term.unreachable._regBuiltin.Lean.Parser.Term.unreachable_1 | Lean.Parser.Term | IO Unit |
Lean.Elab.InfoTree.context.elim | Lean.Elab.InfoTree.Types | {motive_1 : Lean.Elab.InfoTree → Sort u} →
(t : Lean.Elab.InfoTree) →
t.ctorIdx = 0 →
((i : Lean.Elab.PartialContextInfo) → (t : Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.context i t)) →
motive_1 t |
Lean.Compiler.LCNF.Simp.Config.noConfusionType | Lean.Compiler.LCNF.Simp.Config | Sort u → Lean.Compiler.LCNF.Simp.Config → Lean.Compiler.LCNF.Simp.Config → Sort u |
ThreeGPFree.prod | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] {s : Set α} {t : Set β},
ThreeGPFree s → ThreeGPFree t → ThreeGPFree (s ×ˢ t) |
contMDiffWithinAt_of_notMem_mulTSupport | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {f : M → M'}
[inst_11 : One M'] {x : M}, x ∉ mulTSupport f → ∀ (n : WithTop ℕ∞) (s : Set M), ContMDiffWithinAt I I' n f s x |
Bool.beq_eq_decide_eq | Init.Data.Bool | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] [inst_2 : DecidableEq α] (a b : α), (a == b) = decide (a = b) |
Lean.NameGenerator.noConfusionType | Init.MetaTypes | Sort u → Lean.NameGenerator → Lean.NameGenerator → Sort u |
MeasureTheory.Measure.addHaar_preimage_continuousLinearEquiv | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] (f : E ≃L[ℝ] E) (s : Set E),
μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑↑f.symm| * μ s |
Lists.Equiv.decidable._mutual._proof_4 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (b : Bool) (a : Lists' α b) (l₁ l₂ : Lists' α true),
sizeOf ⟨b, a⟩ < 1 + 1 + sizeOf a + sizeOf l₁ →
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun l₁ l₂ => sizeOf l₁ + sizeOf l₂) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun l₁ l₂ => sizeOf l₁ + sizeOf l₂) fun _x =>
PSigma.casesOn _x fun a l => sizeOf a + sizeOf l)
(PSum.inr (PSum.inr ⟨⟨b, a⟩, l₂⟩)) (PSum.inr (PSum.inl ⟨a.cons' l₁, l₂⟩)) |
Finpartition.sparsePairs_mono | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
(P : Finpartition A) (G : SimpleGraph α) [inst_3 : DecidableRel G.Adj] {ε ε' : 𝕜},
ε ≤ ε' → P.sparsePairs G ε ⊆ P.sparsePairs G ε' |
Std.DHashMap.Const.mem_alter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
k' ∈ Std.DHashMap.Const.alter m k f ↔
if (k == k') = true then (f (Std.DHashMap.Const.get? m k)).isSome = true else k' ∈ m |
ApproximatesLinearOn.toHomeomorph._proof_3 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (↑f') Set.univ c)
(hc : Subsingleton E ∨ c < ‖↑f'.symm‖₊⁻¹),
(ApproximatesLinearOn.toOpenPartialHomeomorph f Set.univ hf hc ⋯).target = Set.univ |
Lean.Expr.binderInfoEx | Lean.Expr | Lean.Expr → Lean.BinderInfo |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.transfiniteCompositionOfShapeMapFromBot | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : C} →
[inst_1 : CategoryTheory.Abelian C] →
(hG : CategoryTheory.IsSeparator G) →
{X : C} →
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] →
(A₀ : CategoryTheory.Subobject X) →
{J : Type w} →
[inst_3 : LinearOrder J] →
[inst_4 : OrderBot J] →
[inst_5 : SuccOrder J] →
[inst_6 : WellFoundedLT J] →
(j : J) →
(CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms
G).pushouts.TransfiniteCompositionOfShape
(↑(Set.Iic j))
((CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor hG A₀ J).map
(CategoryTheory.homOfLE ⋯)) |
covBy_sup_of_inf_covBy_of_inf_covBy_left | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] [IsWeakUpperModularLattice α] {a b : α}, a ⊓ b ⋖ a → a ⊓ b ⋖ b → a ⋖ a ⊔ b |
CategoryTheory.StructuredArrow.subobjectEquiv._proof_2 | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {S : D} {T : CategoryTheory.Functor C D}
[inst_2 : CategoryTheory.Limits.HasFiniteLimits C] [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits T]
(A : CategoryTheory.StructuredArrow S T)
(P : { P // ∃ q, CategoryTheory.CategoryStruct.comp q (T.map P.arrow) = A.hom }),
↑((fun P => ⟨CategoryTheory.StructuredArrow.projectSubobject P, ⋯⟩)
((fun P => CategoryTheory.StructuredArrow.liftSubobject ↑P ⋯) P)) =
↑P |
LinearMap.rTensor_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P) (m : M) (n : N), (LinearMap.rTensor M f) (n ⊗ₜ[R] m) = f n ⊗ₜ[R] m |
strictAnti_of_hasDerivAt_neg | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {f f' : ℝ → ℝ}, (∀ (x : ℝ), HasDerivAt f (f' x) x) → (∀ (x : ℝ), f' x < 0) → StrictAnti f |
LieModuleHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup P] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : LieRingModule L M] [inst_9 : LieRingModule L N]
[inst_10 : LieRingModule L P] (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N), ↑f ∘ₗ ↑g = ↑(f.comp g) |
Lean.Elab.Tactic.ElimApp.Alt.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Alt → ℕ |
FP.Float._sizeOf_1 | Mathlib.Data.FP.Basic | {C : FP.FloatCfg} → FP.Float → ℕ |
WithLp.unitization_addEquiv_prod | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → WithLp 1 (Unitization 𝕜 A) ≃+ WithLp 1 (𝕜 × A) |
SimpleGraph.maxDegree.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj],
G.maxDegree = WithBot.unbotD 0 (Finset.image (fun v => G.degree v) Finset.univ).max |
Finset.prod_Ico_succ_div_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {m n : ℕ} [inst : CommGroup M],
m ≤ n → (∏ i ∈ Finset.Ico m (n + 1), f i) / f n = ∏ i ∈ Finset.Ico m n, f i |
BitVec.ushiftRight | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → ℕ → BitVec n |
Polygon.noConfusionType | Mathlib.Geometry.Polygon.Basic | Sort u → {P : Type u_1} → {n : ℕ} → Polygon P n → {P' : Type u_1} → {n' : ℕ} → Polygon P' n' → Sort u |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.shouldExtractLetValue.match_6 | Lean.Compiler.LCNF.ExtractClosed | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) → motive x) → motive __do_lift |
PowerSeries.order_le | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R} (n : ℕ), (PowerSeries.coeff n) φ ≠ 0 → φ.order ≤ ↑n |
Matroid.delete_isBasis'_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {M : Matroid α} {I D X : Set α}, (M.delete D).IsBasis' I X ↔ M.IsBasis' I (X \ D) |
Finset.mem_bipartiteBelow | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {b : β} [inst : (a : α) → Decidable (r a b)] {a : α},
a ∈ Finset.bipartiteBelow r s b ↔ a ∈ s ∧ r a b |
Function.Surjective.valuationRing | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [PreValuationRing R] [inst_2 : CommRing S]
[inst_3 : IsDomain S] (f : R →+* S), Function.Surjective ⇑f → ValuationRing S |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.coe_eq_zero_iff_of_mem_Ico._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a ∈ Set.Ico a b) = (a < b) |
closure_Iio' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Iio a).Nonempty → closure (Set.Iio a) = Set.Iic a |
LightProfinite.limitConeIsLimit | Mathlib.Topology.Category.LightProfinite.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[inst_1 : CategoryTheory.CountableCategory J] →
(F : CategoryTheory.Functor J LightProfinite) → CategoryTheory.Limits.IsLimit (LightProfinite.limitCone F) |
CategoryTheory.LiftableCocone.noConfusion | Mathlib.CategoryTheory.Limits.Creates | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
{c : CategoryTheory.Limits.Cocone (K.comp F)} →
{t : CategoryTheory.LiftableCocone K F c} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{D' : Type u₂} →
{inst'_1 : CategoryTheory.Category.{v₂, u₂} D'} →
{J' : Type w} →
{inst'_2 : CategoryTheory.Category.{w', w} J'} →
{K' : CategoryTheory.Functor J' C'} →
{F' : CategoryTheory.Functor C' D'} →
{c' : CategoryTheory.Limits.Cocone (K'.comp F')} →
{t' : CategoryTheory.LiftableCocone K' F' c'} →
C = C' →
inst ≍ inst' →
D = D' →
inst_1 ≍ inst'_1 →
J = J' →
inst_2 ≍ inst'_2 →
K ≍ K' →
F ≍ F' →
c ≍ c' →
t ≍ t' →
CategoryTheory.LiftableCocone.noConfusionType P t t' |
SimpleGraph.degMatrix.congr_simp | Mathlib.Combinatorics.SimpleGraph.LapMatrix | ∀ {V : Type u_1} (R : Type u_2) [inst : Fintype V] (G G_1 : SimpleGraph V),
G = G_1 →
∀ {inst_1 : DecidableRel G.Adj} [inst_2 : DecidableRel G_1.Adj] {inst_3 : DecidableEq V} [inst_4 : DecidableEq V]
[inst_5 : AddMonoidWithOne R] (a a_1 : V),
a = a_1 → ∀ (a_2 a_3 : V), a_2 = a_3 → SimpleGraph.degMatrix R G a a_2 = SimpleGraph.degMatrix R G_1 a_1 a_3 |
ArchimedeanClass.orderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : LinearOrder N] [inst_5 : IsOrderedAddMonoid N] (f : M →+o N) (a : M),
(ArchimedeanClass.orderHom f) (ArchimedeanClass.mk a) = ArchimedeanClass.mk (f a) |
Real.sinh_add_cosh | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sinh x + Real.cosh x = Real.exp x |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.congr_simp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(homEquiv homEquiv_1 : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (e_homEquiv : homEquiv = homEquiv_1)
(unit unit_1 : CategoryTheory.Functor.id C ⟶ F.comp G) (e_unit : unit = unit_1)
(counit counit_1 : G.comp F ⟶ CategoryTheory.Functor.id D) (e_counit : counit = counit_1)
(homEquiv_unit :
∀ {X : C} {Y : D} {f : F.obj X ⟶ Y}, (homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (unit.app X) (G.map f))
(homEquiv_counit :
∀ {X : C} {Y : D} {g : X ⟶ G.obj Y},
(homEquiv X Y).symm g = CategoryTheory.CategoryStruct.comp (F.map g) (counit.app Y)),
{ homEquiv := homEquiv, unit := unit, counit := counit, homEquiv_unit := homEquiv_unit,
homEquiv_counit := homEquiv_counit } =
{ homEquiv := homEquiv_1, unit := unit_1, counit := counit_1, homEquiv_unit := ⋯, homEquiv_counit := ⋯ } |
CategoryTheory.Functor.mapBifunctorHomologicalComplexObj | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : 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} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂] →
[inst_5 : CategoryTheory.Limits.HasZeroMorphisms D] →
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)) →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{c₁ : ComplexShape I₁} →
(c₂ : ComplexShape I₂) →
[F.PreservesZeroMorphisms] →
[∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] →
HomologicalComplex C₁ c₁ →
CategoryTheory.Functor (HomologicalComplex C₂ c₂) (HomologicalComplex₂ D c₁ c₂) |
MeasureTheory.IntegrableOn.add_measure | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ ν : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] [TopologicalSpace.PseudoMetrizableSpace ε],
MeasureTheory.IntegrableOn f s μ → MeasureTheory.IntegrableOn f s ν → MeasureTheory.IntegrableOn f s (μ + ν) |
Polynomial.degree_freeMonic | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ) [Nontrivial R], (Polynomial.freeMonic R n).degree = ↑n |
IsLocalRing.ResidueField.mapEquiv._proof_6 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R ≃+* S), IsLocalHom ↑f.symm |
Circle.argEquiv | Mathlib.Analysis.SpecialFunctions.Complex.Circle | Circle ≃ ↑(Set.Ioc (-Real.pi) Real.pi) |
Mathlib.Tactic.Widget.StringDiagram.Node.id | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.IdNode → Mathlib.Tactic.Widget.StringDiagram.Node |
DirichletCharacter.delta_mul | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {n : ℕ} (χ : DirichletCharacter ℂ n), (LSeries.delta * fun n_1 => χ ↑n_1) = LSeries.delta |
IsManifold.instOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I 3 M], IsManifold I 2 M |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_5 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : AddSubmonoid M}
{x : M} (h : ∀ (c : R) {x : M}, x ∈ S.carrier → c • x ∈ S.carrier),
(x ∈ { toAddSubmonoid := S, smul_mem' := h }) = (x ∈ S) |
Localization.isLocalization_range_mapToFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_3) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A),
IsLocalization S ↥(Localization.mapToFractionRing K S B hS).range |
RelSeries.toList_getElem | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) {i : ℕ} (hi : i < p.toList.length), p.toList[i] = p.toFun ⟨i, ⋯⟩ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.