name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.DocString.Markdown.0.Lean.Doc.escape | Lean.DocString.Markdown | String → String |
_private.Lean.Elab.Do.PatternVar.0.Lean.Elab.Do.getExprPatternVarsEx.match_1 | Lean.Elab.Do.PatternVar | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(var? : Option (Lean.TSyntax `ident)) →
((var : Lean.TSyntax `ident) → motive (some var)) → (Unit → motive none) → motive var? |
CategoryTheory.IsSplitCoequalizer.map._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z}
(q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D),
CategoryTheory.CategoryStruct.comp (F.map q.rightSection) (F.map π) = CategoryTheory.CategoryStruct.id (F.obj Z) |
Std.DTreeMap.Internal.Impl.minEntry?.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} (x : Std.DTreeMap.Internal.Impl α β),
x.minEntry? =
match x with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r => some ⟨k, v⟩
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1 =>
l.minEntry? |
Nat.zeckendorf.eq_2 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.succ.zeckendorf = n.succ.greatestFib :: (n.succ - Nat.fib n.succ.greatestFib).zeckendorf |
Batteries.RBNode.RedRed.casesOn | Batteries.Data.RBMap.WF | ∀ {p : Prop} {α : Type u_1} {motive : (a : Batteries.RBNode α) → (a_1 : ℕ) → Batteries.RBNode.RedRed p a a_1 → Prop}
{a : Batteries.RBNode α} {a_1 : ℕ} (t : Batteries.RBNode.RedRed p a a_1),
(∀ {t : Batteries.RBNode α} {c : Batteries.RBColor} {n : ℕ} (a : t.Balanced c n), motive t n ⋯) →
(∀ {a : Batteries.RBNode α} {c₁ : Batteries.RBColor} {n : ℕ} {b : Batteries.RBNode α} {c₂ : Batteries.RBColor}
{x : α} (a_2 : p) (a_3 : a.Balanced c₁ n) (a_4 : b.Balanced c₂ n),
motive (Batteries.RBNode.node Batteries.RBColor.red a x b) n ⋯) →
motive a a_1 t |
MonoidHom.ergodic_of_dense_iUnion_preimage_one | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [SecondCountableTopology G]
[inst_4 : MeasurableSpace G] [BorelSpace G] [CompactSpace G] {μ : MeasureTheory.Measure G} [μ.IsHaarMeasure]
(f : G →* G), Dense (⋃ n, (⇑f)^[n] ⁻¹' 1) → Continuous ⇑f → Function.Surjective ⇑f → Ergodic (⇑f) μ |
Ideal.mulQuot._proof_2 | Mathlib.RingTheory.OrderOfVanishing | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R |
ContDiffMapSupportedIn.withSeminorms' | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] (n : ℕ∞) (K : TopologicalSpace.Compacts E),
WithSeminorms (ContDiffMapSupportedIn.supSeminorm 𝕜 E F n K) |
Std.DHashMap.Raw.Const.alter.congr_simp | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] [inst_2 : Hashable α] {β : Type v}
(m m_1 : Std.DHashMap.Raw α fun x => β),
m = m_1 →
∀ (a a_1 : α),
a = a_1 →
∀ (f f_1 : Option β → Option β),
f = f_1 → Std.DHashMap.Raw.Const.alter m a f = Std.DHashMap.Raw.Const.alter m_1 a_1 f_1 |
AlgebraicGeometry.LocallyRingedSpace.Γ_def | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | AlgebraicGeometry.LocallyRingedSpace.Γ =
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.op.comp AlgebraicGeometry.SheafedSpace.Γ |
CategoryTheory.Lax.LaxTrans.noConfusionType | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
CategoryTheory.Lax.LaxTrans F G →
{B' : Type u₁} →
[inst' : CategoryTheory.Bicategory B'] →
{C' : Type u₂} →
[inst'_1 : CategoryTheory.Bicategory C'] →
{F' G' : CategoryTheory.LaxFunctor B' C'} → CategoryTheory.Lax.LaxTrans F' G' → Sort u |
CategoryTheory.IsSplitEqualizer.casesOn | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{W : C} →
{ι : W ⟶ X} →
{motive : CategoryTheory.IsSplitEqualizer f g ι → Sort u_1} →
(t : CategoryTheory.IsSplitEqualizer f g ι) →
((leftRetraction : X ⟶ W) →
(rightRetraction : Y ⟶ X) →
(condition : CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g) →
(ι_leftRetraction :
CategoryTheory.CategoryStruct.comp ι leftRetraction = CategoryTheory.CategoryStruct.id W) →
(bottom_rightRetraction :
CategoryTheory.CategoryStruct.comp g rightRetraction =
CategoryTheory.CategoryStruct.id X) →
(top_rightRetraction :
CategoryTheory.CategoryStruct.comp f rightRetraction =
CategoryTheory.CategoryStruct.comp leftRetraction ι) →
motive
{ leftRetraction := leftRetraction, rightRetraction := rightRetraction,
condition := condition, ι_leftRetraction := ι_leftRetraction,
bottom_rightRetraction := bottom_rightRetraction,
top_rightRetraction := top_rightRetraction }) →
motive t |
Lean.Loop._sizeOf_1 | Init.While | Lean.Loop → ℕ |
CategoryTheory.CatEnriched.instBicategory._proof_4 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c : CategoryTheory.CatEnriched C}
(f : a ⟶ b) {g h i : b ⟶ c} (η : g ⟶ h) (θ : h ⟶ i),
CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) η)
(CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) θ) |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.card_support_eq_one._simp_1_2 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α},
(f.support = {a}) = (f a ≠ 0 ∧ f = fun₀ | a => f a) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_eq_self_of_mem._simp_1_1 | 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) |
Std.ExtTreeMap.getKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k a fallback : α} {v : β},
(t.insertIfNew k v).getKeyD a fallback = if cmp k a = Ordering.eq ∧ k ∉ t then k else t.getKeyD a fallback |
LinearMap.const_apply | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M₂ : Type w} {ι : Type x} [inst : Semiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂]
(x : M₂), LinearMap.const x = Function.const ι x |
Lean.Meta.RefinedDiscrTree.ExprInfo.mk.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{expr : Lean.Expr} →
{bvars : List Lean.FVarId} →
{lctx : Lean.LocalContext} →
{localInsts : Lean.LocalInstances} →
{cfg : Lean.Meta.Config} →
{expr' : Lean.Expr} →
{bvars' : List Lean.FVarId} →
{lctx' : Lean.LocalContext} →
{localInsts' : Lean.LocalInstances} →
{cfg' : Lean.Meta.Config} →
{ expr := expr, bvars := bvars, lctx := lctx, localInsts := localInsts, cfg := cfg } =
{ expr := expr', bvars := bvars', lctx := lctx', localInsts := localInsts', cfg := cfg' } →
(expr = expr' → bvars = bvars' → lctx = lctx' → localInsts = localInsts' → cfg = cfg' → P) → P |
List.forA | Init.Data.List.Control | {m : Type u → Type v} → [Applicative m] → {α : Type w} → List α → (α → m PUnit.{u + 1}) → m PUnit.{u + 1} |
CategoryTheory.FreeBicategory.inclusion | Mathlib.CategoryTheory.Bicategory.Coherence | (B : Type u) →
[inst : Quiver B] →
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Paths B))
(CategoryTheory.FreeBicategory B) |
Matrix.coe_units_inv | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : (Matrix n n α)ˣ),
↑A⁻¹ = (↑A)⁻¹ |
_private.Mathlib.Data.Int.Interval.0.Finset.Icc_succ_succ._simp_1_1 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Icc a b) = (a ≤ x ∧ x ≤ b) |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_21 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length},
(List.findIdxs (fun x_1 => x_1 == x) (head :: tail))[n] + 1 ≤ (head :: tail).length →
(List.findIdxs (fun x_1 => x_1 == x) (head :: tail))[n] < (head :: tail).length |
Lean.Meta.Grind.Arith.CommRing.CommRing.subFn?._inherited_default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Option Lean.Expr |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffAt_one_iff._simp_1_1 | 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] {f : E → F}
{x : E} {n : ℕ},
ContDiffAt 𝕜 (↑n + 1) f x = ∃ f', (∃ u ∈ nhds x, ∀ x ∈ u, HasFDerivAt f (f' x) x) ∧ ContDiffAt 𝕜 (↑n) f' x |
AdicCompletion.piEquivOfFintype | Mathlib.RingTheory.AdicCompletion.Functoriality | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
{ι : Type u_6} →
(M : ι → Type u_7) →
[inst_1 : (i : ι) → AddCommGroup (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[DecidableEq ι] →
[Fintype ι] → AdicCompletion I ((j : ι) → M j) ≃ₗ[AdicCompletion I R] (j : ι) → AdicCompletion I (M j) |
Padic.instNontriviallyNormedField | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → NontriviallyNormedField ℚ_[p] |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_12 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), (↑x).1 * 1 = (↑x).1 |
Mathlib.Tactic.Sat.Clause.mk.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} →
{lits : Array ℤ} →
{expr proof : Lean.Expr} →
{lits' : Array ℤ} →
{expr' proof' : Lean.Expr} →
{ lits := lits, expr := expr, proof := proof } = { lits := lits', expr := expr', proof := proof' } →
(lits = lits' → expr = expr' → proof = proof' → P) → P |
instDifferentialAlgebra | Mathlib.RingTheory.Derivation.DifferentialRing | ∀ (A : Type u_1) [inst : CommRing A] [inst_1 : Differential A], DifferentialAlgebra A A |
Matrix.conjTranspose_circulant | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : Star α] [inst_1 : SubtractionMonoid n] (v : n → α),
(Matrix.circulant v).conjTranspose = Matrix.circulant (star fun i => v (-i)) |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
IsUniformInducing f = (UniformSpace.comap f inst_1 = inst) |
BoxIntegral.Prepartition.eq_of_boxes_subset_iUnion_superset | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I},
π₁.boxes ⊆ π₂.boxes → π₂.iUnion ⊆ π₁.iUnion → π₁ = π₂ |
AlgebraicGeometry.Scheme.Cover.trans_map | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀} (hij : i ⟶ j),
CategoryTheory.CategoryStruct.comp (𝒰.trans hij) (𝒰.f j) = 𝒰.f i |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.map_eq_top_of_not_subset._simp_1_1 | Mathlib.RingTheory.Localization.Ideal | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t |
DFinsupp.extendWith_single_zero | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {α : Option ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : Option ι) → Zero (α i)] (i : ι)
(x : α (some i)), (DFinsupp.extendWith 0 fun₀ | i => x) = fun₀ | some i => x |
Int.sub_mul | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), (a - b) * c = a * c - b * c |
Lean.Meta.Grind.AttrKind.infer.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | sizeOf Lean.Meta.Grind.AttrKind.infer = 1 |
Std.DTreeMap.Internal.RooSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.RooSliceData α β} →
{α' : Type u} →
{β' : α' → Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.RooSliceData α' β'} →
α = α' → β ≍ β' → inst ≍ inst' → t ≍ t' → Std.DTreeMap.Internal.RooSliceData.noConfusionType P t t' |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.exists_decomposition_of_monotoneOn_hasDerivWithinAt._simp_1_4 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) |
Finset.union_subset_right | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, s ∪ t ⊆ u → t ⊆ u |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.SimpleFunc.exists_le_lowerSemicontinuous_lintegral_ge._simp_1_5 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) |
_private.Mathlib.Analysis.Normed.Operator.BanachSteinhaus.0.banach_steinhaus_iSup_nnnorm._simp_1_2 | Mathlib.Analysis.Normed.Operator.BanachSteinhaus | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) |
Algebra.FormallySmooth.iff_injective_cotangentComplexBaseChange | Mathlib.RingTheory.Smooth.Local | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsLocalRing S]
[inst_3 : Algebra R S] (P : Type u_3) (K : Type u_4) [inst_4 : Field K] [inst_5 : CommRing P] [inst_6 : Algebra R P]
[inst_7 : Algebra P S] [IsScalarTower R P S] [inst_9 : Algebra S K] [inst_10 : Algebra P K]
[inst_11 : IsScalarTower P S K] [Algebra.FormallySmooth R P] [Module.Free P Ω[P⁄R]] [Module.Finite P Ω[P⁄R]],
Function.Surjective ⇑(algebraMap P S) →
(RingHom.ker (algebraMap P S)).FG →
IsLocalRing.maximalIdeal S ≤ RingHom.ker (algebraMap S K) →
(Algebra.FormallySmooth R S ↔ Function.Injective ⇑(KaehlerDifferential.cotangentComplexBaseChange R S P K)) |
WithAbs.instIsSeparable_1 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R] {T : Type u_3}
[inst_3 : Field T] (v : AbsoluteValue R S) [inst_4 : Algebra T R] [Algebra.IsSeparable T R],
Algebra.IsSeparable T (WithAbs v) |
Valuation.map_sub_lt | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R} {g : Γ₀}, v x < g → v y < g → v (x - y) < g |
PosNum.minFac.eq_3 | Mathlib.Data.Num.Prime | ∀ (n : PosNum), n.bit1.minFac = n.bit1.minFacAux (↑n) 1 |
Matrix.submatrix_id_id | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (A : Matrix m n α), A.submatrix id id = A |
Turing.ToPartrec.instDecidableEqCode.decEq | Mathlib.Computability.TuringMachine.Config | (x x_1 : Turing.ToPartrec.Code) → Decidable (x = x_1) |
Mathlib.Tactic.Abel.NormalExpr.zero.sizeOf_spec | Mathlib.Tactic.Abel | ∀ (e : Lean.Expr), sizeOf (Mathlib.Tactic.Abel.NormalExpr.zero e) = 1 + sizeOf e |
CategoryTheory.PreGaloisCategory.endMulEquivAutGalois_pi | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F]
(f : CategoryTheory.End F) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.ConcreteCategory.hom
(F.map
((CategoryTheory.PreGaloisCategory.AutGalois.π F A)
(MulOpposite.unop ((CategoryTheory.PreGaloisCategory.endMulEquivAutGalois F) f))).hom))
A.pt =
(CategoryTheory.ConcreteCategory.hom (f.app A.obj)) A.pt |
IsDedekindDomain.HeightOneSpectrum.noConfusionType | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | Sort u →
{R : Type u_1} →
[inst : CommRing R] →
IsDedekindDomain.HeightOneSpectrum R →
{R' : Type u_1} → [inst' : CommRing R'] → IsDedekindDomain.HeightOneSpectrum R' → Sort u |
CategoryTheory.Adjunction.lim_preservesLimits | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C], CategoryTheory.Limits.PreservesLimits CategoryTheory.Limits.lim |
SheafOfModules.freeFunctor | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[J.WEqualsLocallyBijective AddCommGrpCat] →
[J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
CategoryTheory.Functor (Type u) (SheafOfModules R) |
Std.LawfulBEqCmp.compare_beq_eq_beq | Init.Data.Order.Ord | ∀ {α : Type u} [inst : BEq α] {cmp : α → α → Ordering} [Std.LawfulBEqCmp cmp] {a b : α},
(cmp a b == Ordering.eq) = (a == b) |
Int.pos_of_neg_neg | Init.Data.Int.Order | ∀ {a : ℤ}, -a < 0 → 0 < a |
OrderEmbedding.ltEmbedding_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) (x : α), f.ltEmbedding x = f x |
Std.DHashMap.Internal.Raw₀.Const.get_filterMap | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w}
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Option γ}
{k : α} (h : (↑m).WF) {h' : (Std.DHashMap.Internal.Raw₀.filterMap f m).contains k = true},
Std.DHashMap.Internal.Raw₀.Const.get (Std.DHashMap.Internal.Raw₀.filterMap f m) k h' =
(f (m.getKey k ⋯) (Std.DHashMap.Internal.Raw₀.Const.get m k ⋯)).get ⋯ |
_private.Mathlib.Topology.Inseparable.0.inseparable_iff_forall_isClosed._simp_1_3 | Mathlib.Topology.Inseparable | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x |
Complex.tendsto_exp_nhds_zero_iff | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f : α → ℂ},
Filter.Tendsto (fun x => Complex.exp (f x)) l (nhds 0) ↔ Filter.Tendsto (fun x => (f x).re) l Filter.atBot |
CommGrpCat | Mathlib.Algebra.Category.Grp.Basic | Type (u + 1) |
Lean.Language.SnapshotTask.ReportingRange.some.injEq | Lean.Language.Basic | ∀ (range range_1 : Lean.Syntax.Range),
(Lean.Language.SnapshotTask.ReportingRange.some range = Lean.Language.SnapshotTask.ReportingRange.some range_1) =
(range = range_1) |
_private.Mathlib.RingTheory.Algebraic.Integral.0.IsAlgebraic.of_mul.match_1_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {y : S}
(motive : (∃ t ∈ Algebra.adjoin R {y}, ∃ r, r ≠ 0 ∧ y * t = (algebraMap R S) r) → Prop)
(x : ∃ t ∈ Algebra.adjoin R {y}, ∃ r, r ≠ 0 ∧ y * t = (algebraMap R S) r),
(∀ (t : S) (ht : t ∈ Algebra.adjoin R {y}) (r : R) (hr : r ≠ 0) (eq : y * t = (algebraMap R S) r), motive ⋯) →
motive x |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_5 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
(l₁.bagInter l₂).Sublist l₁ → (l₁.bagInter l₂).Sublist (a :: l₁) |
Polynomial.not_dvd_of_degree_lt | Mathlib.Algebra.Polynomial.Degree.Domain | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R}, q ≠ 0 → q.degree < p.degree → ¬p ∣ q |
CategoryTheory.MonoOver.isColimitCoconeOfHasStrongEpiMonoFactorisation | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y : C} →
[inst_1 : CategoryTheory.Limits.HasCoproducts C] →
[inst_2 : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] →
{J : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor J (CategoryTheory.MonoOver Y)) →
CategoryTheory.Limits.IsColimit (CategoryTheory.MonoOver.coconeOfHasStrongEpiMonoFactorisation F) |
PrespectralSpace.exists_isCompact_and_isOpen_between | Mathlib.Topology.Spectral.Prespectral | ∀ {X : Type u_1} [inst : TopologicalSpace X] [PrespectralSpace X] {K U : Set X},
IsCompact K → IsOpen U → K ⊆ U → ∃ W, IsCompact W ∧ IsOpen W ∧ K ⊆ W ∧ W ⊆ U |
AddEquiv.map_add' | Mathlib.Algebra.Group.Equiv.Defs | ∀ {A : Type u_9} {B : Type u_10} [inst : Add A] [inst_1 : Add B] (self : A ≃+ B) (x y : A),
self.toFun (x + y) = self.toFun x + self.toFun y |
ConcaveOn.le_slope_of_hasDerivAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ}, ConcaveOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivAt f f' y → f' ≤ slope f x y |
AddGroupTopology.instBoundedOrder | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : AddGroup α] → BoundedOrder (AddGroupTopology α) |
isRegular_op | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Mul R] {a : R}, IsRegular (MulOpposite.op a) ↔ IsRegular a |
_private.Mathlib.Topology.MetricSpace.HausdorffDimension.0.intrinsicInterior.eq_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ (𝕜 : Type u_1) {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] (s : Set P),
intrinsicInterior 𝕜 s = Subtype.val '' interior (Subtype.val ⁻¹' s) |
CompactlySupportedContinuousMap.comp | Mathlib.Topology.ContinuousMap.CompactlySupported | {β : Type u_3} →
{γ : Type u_4} →
{δ : Type u_5} →
[inst : TopologicalSpace β] →
[inst_1 : TopologicalSpace γ] →
[inst_2 : TopologicalSpace δ] →
[inst_3 : Zero δ] →
CompactlySupportedContinuousMap γ δ → CocompactMap β γ → CompactlySupportedContinuousMap β δ |
Aesop.ForwardInstantiationStats.rec | Aesop.Stats.Basic | {motive : Aesop.ForwardInstantiationStats → Sort u} →
((«matches» hyps : ℕ) → motive { «matches» := «matches», hyps := hyps }) →
(t : Aesop.ForwardInstantiationStats) → motive t |
mabs_eq_inv_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a : G}, |a|ₘ = a⁻¹ ↔ a ≤ 1 |
HomologicalComplex₂.instHasTotalIntObjUpCompShiftFunctor₁ShiftFunctor₂ | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x y : ℤ) [K.HasTotal (ComplexShape.up ℤ)],
(((HomologicalComplex₂.shiftFunctor₁ C x).comp (HomologicalComplex₂.shiftFunctor₂ C y)).obj K).HasTotal
(ComplexShape.up ℤ) |
CategoryTheory.Functor.IsDenseSubsite.sheafifyOfIsEquivalenceCompIso | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(G : CategoryTheory.Functor C D) →
(A : Type u_4) →
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] →
[inst_3 : CategoryTheory.Functor.IsDenseSubsite J K G] →
[inst_4 : CategoryTheory.HasWeakSheafify J A] →
[inst_5 : (G.sheafPushforwardContinuous A J K).IsEquivalence] →
(CategoryTheory.Functor.IsDenseSubsite.sheafifyOfIsEquivalence J K G A).comp
(G.sheafPushforwardContinuous A J K) ≅
((CategoryTheory.Functor.whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).comp
(CategoryTheory.presheafToSheaf J A) |
Lean.Elab.Tactic.BVDecide.Frontend.UnsatProver.Result.mk | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LratCert → Lean.Elab.Tactic.BVDecide.Frontend.UnsatProver.Result |
CategoryTheory.Enriched.FunctorCategory.functorEnrichedOrdinaryCategory._proof_2 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
(C : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} C] (J : Type u_3)
[inst_3 : CategoryTheory.Category.{u_1, u_3} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
[inst_5 :
∀ (F₁ F₂ : CategoryTheory.Functor J C), CategoryTheory.Enriched.FunctorCategory.HasFunctorEnrichedHom V F₁ F₂]
[inst_6 : ∀ (F₁ F₂ : CategoryTheory.Functor J C), CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂]
{X Y Z : CategoryTheory.Functor J C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.Enriched.FunctorCategory.functorHomEquiv V) (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor J V))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom ((CategoryTheory.Enriched.FunctorCategory.functorHomEquiv V) f)
((CategoryTheory.Enriched.FunctorCategory.functorHomEquiv V) g))
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedComp V X Y Z)) |
Lean.Grind.ConfigInteractive.instances._inherited_default | Init.Grind.Config | ℕ |
CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_termᘁ__1» | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.Macro |
AddSubgroup.quotientEquivProdOfLE'_symm_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s t : AddSubgroup α} (h_le : s ≤ t) (f : α ⧸ t → α)
(hf : Function.RightInverse f QuotientAddGroup.mk) (a : (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t),
(AddSubgroup.quotientEquivProdOfLE' h_le f hf).symm a = Quotient.map' (fun b => f a.1 + ↑b) ⋯ a.2 |
Sym.append_inj_left | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n n' : ℕ} {s s' : Sym α n} (t : Sym α n'), s.append t = s'.append t ↔ s = s' |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.send | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Unbounded✝ α → α → BaseIO (Task (Except Std.CloseableChannel.Error Unit)) |
Std.Time.instTransOrdPlainDate | Std.Time.Date.PlainDate | Std.TransOrd Std.Time.PlainDate |
Std.DTreeMap.Raw.mem_of_get_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.LawfulEqCmp cmp]
{k : α} {v : β k} {w : k ∈ t}, t.get k w = v → k ∈ t |
Function.not_lt_argminOn | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] (s : Set α) {a : α} (ha : a ∈ s),
¬f a < f (Function.argminOn f s ⋯) |
MulAction.equivSubgroupOrbitsSetoidComap._proof_3 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : MulAction α β] (ω : Quotient (MulAction.orbitRel α β))
(x : ↑(MulAction.orbitRel.Quotient.orbit ω)), ↑x ∈ Quotient.mk (MulAction.orbitRel α β) ⁻¹' {ω} |
CategoryTheory.Pseudofunctor.StrongTrans.associator_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Pseudo | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.Pseudofunctor B C} (I : CategoryTheory.Pseudofunctor B C) (η : F ⟶ G) (θ : G ⟶ H) (ι : H ⟶ I)
(a : B),
(CategoryTheory.Bicategory.associator η θ ι).inv.as.app a =
(CategoryTheory.Bicategory.associator (η.app a) (θ.app a) (ι.app a)).inv |
Rep.barComplex.d_single | Mathlib.RepresentationTheory.Homological.Resolution | ∀ {k G : Type u} [inst : CommRing k] (n : ℕ) [inst_1 : Group G] (x : Fin (n + 1) → G),
((CategoryTheory.ConcreteCategory.hom (Rep.barComplex.d k G n).hom) fun₀ | x => fun₀ | 1 => 1) =
(fun₀ | fun i => x i.succ => fun₀ | x 0 => 1) +
∑ j, fun₀ | j.contractNth (fun x1 x2 => x1 * x2) x => fun₀ | 1 => (-1) ^ (↑j + 1) |
CategoryTheory.MonoidalCoherence.tensor_right_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
[inst_2 : CategoryTheory.MonoidalCoherence (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y],
CategoryTheory.MonoidalCoherence.iso =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).symm ≪≫
CategoryTheory.MonoidalCategory.whiskerLeftIso X CategoryTheory.MonoidalCoherence.iso |
mabs.eq_1 | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] (a : α), |a|ₘ = a ⊔ a⁻¹ |
Lean.Lsp.OpenNamespace.rec | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.OpenNamespace → Sort u} →
((«namespace» : Lean.Name) →
(exceptions : Array Lean.Name) → motive (Lean.Lsp.OpenNamespace.allExcept «namespace» exceptions)) →
((«from» «to» : Lean.Name) → motive (Lean.Lsp.OpenNamespace.renamed «from» «to»)) →
(t : Lean.Lsp.OpenNamespace) → motive t |
tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s ↔
∀ x ∈ s, Filter.Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ nhdsWithin x s) (uniformity β) |
_private.Init.Data.UInt.Bitwise.0.UInt16.shiftLeft_add_of_toNat_lt._proof_1_3 | Init.Data.UInt.Bitwise | ∀ {b c : UInt16}, b.toNat + c.toNat < 16 → ¬c.toNat < 16 → False |
CompletePartialOrder | Mathlib.Order.CompletePartialOrder | Type u_4 → Type u_4 |
InfClosed.image | Mathlib.Order.SupClosed | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {s : Set α}
[inst_2 : FunLike F α β] [InfHomClass F α β], InfClosed s → ∀ (f : F), InfClosed (⇑f '' s) |
InnerProductSpace.rankOne_one_right_eq_toSpanSingleton | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_4} {F : Type u_6} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
(x : F), ((InnerProductSpace.rankOne 𝕜) x) 1 = ContinuousLinearMap.toSpanSingleton 𝕜 x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.