name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.IsCofiltered.IsEventuallyConstant.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C},
(∃ j, F.IsEventuallyConstantTo j) → CategoryTheory.IsCofiltered.IsEventuallyConstant F | null | false |
Set.ncard_sdiff._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax | null | false |
instInhabitedState_mathlib | Mathlib.Lean.EnvExtension | {σ : Type} → [Inhabited σ] → Inhabited (Lean.ScopedEnvExtension.State σ) | null | true |
Aesop.ElabRuleTerm.noConfusionType | Aesop.RuleTac.RuleTerm | Sort u → Aesop.ElabRuleTerm → Aesop.ElabRuleTerm → Sort u | null | false |
_private.Mathlib.Topology.Algebra.Group.Neighborhood.0.ContinuousInv.of_nhds_one._simp_1_1 | Mathlib.Topology.Algebra.Group.Neighborhood | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | null | false |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.Bounded.to_lt.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] (motive : (x : Ordnode α) → (x_1 x_2 : α) → x.Bounded ↑x_1 ↑x_2 → Prop)
(x : Ordnode α) (x_1 x_2 : α) (x_3 : x.Bounded ↑x_1 ↑x_2),
(∀ (x x_4 : α) (h : Ordnode.nil.Bounded ↑x ↑x_4), motive Ordnode.nil x x_4 h) →
(∀ (size : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α) (x_4 x_5 :... | null | false |
CategoryTheory.IsPushout.isoIsPushout.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z : C} (X Y : C) {P : C} {f f_1 : Z ⟶ X} (e_f : f = f_1)
{g g_1 : Z ⟶ Y} (e_g : g = g_1) {inl inl_1 : X ⟶ P} (e_inl : inl = inl_1) {inr inr_1 : Y ⟶ P} (e_inr : inr = inr_1)
{P' : C} {inl' inl'_1 : X ⟶ P'} (e_inl' : inl' = inl'_1) {inr' inr'_1 : Y ⟶ P'} (e... | null | true |
Lean.Elab.Term.ToParserDescrContext.catName | Lean.Elab.Syntax | Lean.Elab.Term.ToParserDescrContext → Lean.Name | null | true |
AlgebraicGeometry.opensDiagram._proof_1 | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u_1} [inst : CategoryTheory.Category.{u_1, u_1} I] (D : CategoryTheory.Functor I AlgebraicGeometry.Scheme)
(i : I) (U : (D.obj i).Opens) {j k : CategoryTheory.Over i} (f : j ⟶ k),
(TopologicalSpace.Opens.map (D.map j.hom).base).obj U ≤
(TopologicalSpace.Opens.map (D.map (CategoryTheory.Over.Hom.left... | null | false |
CategoryTheory.Limits.HasZeroObject.uniqueFrom.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C),
CategoryTheory.Limits.HasZeroObject.uniqueFrom X = ⋯.some | null | true |
Lean.Meta.Match.MkMatcherInput._sizeOf_inst | Lean.Meta.Match.Match | SizeOf Lean.Meta.Match.MkMatcherInput | null | false |
_private.Mathlib.Data.List.Dedup.0.List.mem_dedup._simp_1_2 | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} {a : α} {l : List α}, (∀ a' ∈ l, ¬a = a') = (a ∉ l) | null | false |
List.prefix_append_right_inj | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α} (l : List α), l ++ l₁ <+: l ++ l₂ ↔ l₁ <+: l₂ | null | true |
equicontinuousWithinAt_iff_continuousWithinAt | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α}
{S : Set X} {x₀ : X}, EquicontinuousWithinAt F S x₀ ↔ ContinuousWithinAt (⇑UniformFun.ofFun ∘ Function.swap F) S x₀ | A family `𝓕 : ι → X → α` is equicontinuous at `x₀` within `S` iff the function
`swap 𝓕 : X → ι → α` is continuous at `x₀` within `S`
*when `ι → α` is equipped with the topology of uniform convergence*. This is very useful for
developing the equicontinuity API, but it should not be used directly for other purposes. | true |
Std.DTreeMap.Const.getD_filterMap | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {γ : Type w} {t : Std.DTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] {f : α → β → Option γ} {k : α} {fallback : γ},
Std.DTreeMap.Const.getD (Std.DTreeMap.filterMap f t) k fallback =
((Std.DTreeMap.Const.get? t k).pbind fun x h' => f (t.getKey k ⋯) x).... | null | true |
CategoryTheory.Iso.hom_inv_id_app_app_assoc._to_dual_1 | Mathlib.CategoryTheory.NatIso | ∀ {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 G : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (e : F ≅ G) (X₁ : C) (X₂ : D) {Z : E}
(h : Z ⟶ (F.obj X₁).obj X₂),
Cat... | null | false |
isLUB_univ | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α], IsLUB Set.univ ⊤ | null | true |
MeasureTheory.integrable_rnDeriv_smul_iff | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {E : Type u_4} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [μ.HaveLebesgueDecomposition ν] [MeasureTheory.SigmaFinite μ] {f : α → E},
μ.AbsolutelyContinuous ν →
(MeasureTheory.Integrable (fun x => (μ.rnDeriv ν x).toReal • f x)... | null | true |
Std.Time.Second.instAddOffset._aux_1 | Std.Time.Time.Unit.Second | Std.Time.Second.Offset → Std.Time.Second.Offset → Std.Time.Second.Offset | null | false |
Module.Flat.recOn | Mathlib.RingTheory.Flat.Basic | {R : Type u} →
{M : Type v} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{motive : Module.Flat R M → Sort u_1} →
(t : Module.Flat R M) →
((out :
∀ ⦃P : Type u⦄ [inst_3 : AddCommMonoid P] [inst_4 : Module R P]... | null | false |
_private.Mathlib.Order.Interval.Finset.Defs.0.Fintype.toLocallyFiniteOrder._simp_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
Laplacian.recOn | Mathlib.Analysis.Distribution.DerivNotation | {E : Type v} →
{F : Type w} →
{motive : Laplacian E F → Sort u} →
(t : Laplacian E F) → ((laplacian : E → F) → motive { laplacian := laplacian }) → motive t | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.one_le_finrank_iff_surjective._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {R S : CommRingCat} (f : R ⟶ S),
AlgebraicGeometry.IsFinite (AlgebraicGeometry.Spec.map f) = (CommRingCat.Hom.hom f).Finite | null | false |
CategoryTheory.AddGrp.trivial_addGrp_zero | Mathlib.CategoryTheory.Monoidal.Grp | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.AddMonObj.zero = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
Subrepresentation.coe_sup | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (ρ₁ ρ₂ : Subrepresentation ρ), ↑(ρ₁ ⊔ ρ₂) = ↑ρ₁ + ↑ρ₂ | null | true |
Std.Time.instHAddOffsetOffset_16 | Std.Time.Date.Basic | HAdd Std.Time.Second.Offset Std.Time.Day.Offset Std.Time.Second.Offset | null | true |
Matrix.toLinearMapₛₗ₂ | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | {R : Type u_1} →
{M₁ : Type u_6} →
{M₂ : Type u_7} →
{N₂ : Type u_10} →
{n : Type u_11} →
{m : Type u_12} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : Module R M₁] →
[inst_3 : AddCommMonoid M₂] →
... | `Matrix.toLinearMapₛₗ₂ b₁ b₂` is the equivalence between `R`-sesquilinear maps
`M₁ →ₛₗ[σ₁] M₂ →ₗ[R] N₂` and `n`-by-`m` matrices with entries in `N₂`,
if `b₁` and `b₂` are `R`-bases for `M₁` and `M₂`,
respectively; this is the reverse direction of `LinearMap.toMatrix₂ b₁ b₂`. | true |
map_inj_right | Init.Control.Lawful.Lemmas | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Monad m] [LawfulMonad m] {f : α → β},
(∀ {x y : α}, f x = f y → x = y) → ∀ {x y : m α}, f <$> x = f <$> y ↔ x = y | null | true |
MeasureTheory.Lp.fourier_toTemperedDistribution_eq | Mathlib.Analysis.Fourier.LpSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
[inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℂ F] [inst_5 : CompleteSpace F]
[inst_6 : InnerProductSpace ℝ E] [inst_7 : FiniteDimensional ℝ E] (f : ↥(MeasureTheory.Lp F 2 MeasureTheory.v... | The `𝓢'`-Fourier transform and the `L2`-Fourier transform coincide on `L2`. | true |
IsometryEquiv.addRight.eq_1 | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c : G),
IsometryEquiv.addRight c = { toEquiv := Equiv.addRight c, isometry_toFun := ⋯ } | null | true |
DFinsupp.coe_smul | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : (i : ι) → SMulZeroClass γ (β i)]
(b : γ) (v : Π₀ (i : ι), β i), ⇑(b • v) = b • ⇑v | null | true |
ENNReal.coe_ofNat | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ) [inst : n.AtLeastTwo], ↑(OfNat.ofNat n) = OfNat.ofNat n | null | true |
Lean.Doc.Parser.OrderedListType.ofNat_ctorIdx | Lean.DocString.Parser | ∀ (x : Lean.Doc.Parser.OrderedListType), Lean.Doc.Parser.OrderedListType.ofNat x.ctorIdx = x | null | true |
isHomeomorph_iff_continuous_isClosedMap_bijective | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f ↔ Continuous f ∧ IsClosedMap f ∧ Function.Bijective f | A map is a homeomorphism iff it is continuous, closed and bijective. | true |
Aesop.UnsafeRuleInfo.mk.noConfusion | Aesop.Rule | {P : Sort u} →
{successProbability successProbability' : Aesop.Percent} →
{ successProbability := successProbability } = { successProbability := successProbability' } →
(successProbability = successProbability' → P) → P | null | false |
CategoryTheory.Limits.isLimitOfHasProductOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Products | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
{J : Type w} →
(f : J → C) →
[inst_2 : CategoryTheory.Limits.HasProduct f] →
[CategoryT... | If `G` preserves products and `C` has them, then the fan constructed of the mapped projection of a
product is a limit.
| true |
CategoryTheory.LocalizerMorphism.leftDerivedFunctorComparison_fac_app_assoc | Mathlib.CategoryTheory.Localization.DerivabilityStructure.PointwiseLeftDerived | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {H : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5}
[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} H] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheory.Category.{v_5, ... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.pairwise_cons_cons._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α},
List.Pairwise R (a :: b :: l) ↔ R a b ∧ List.Pairwise R (a :: l) ∧ List.Pairwise R (b :: l) | null | false |
Mathlib.Tactic.FieldSimp.qNF.split._unsafe_rec | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(l : Mathlib.Tactic.FieldSimp.qNF M) →
Lean.MetaM
((l_n : Mathlib.Tactic.FieldSimp.qNF M) ×
(l_d : Mathlib.Tactic.FieldSimp.qNF M) ×
let a := l_d.toNF;
let a_1 := l_n.toNF;
... | null | false |
NonUnitalSeminormedCommRing.induced._proof_11 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NonUnitalSeminormedCommRing S] (f : F),
((Filter.comap (fun p => (f p.1, f p.2)) (uniformity S)).lift' fun s => SetRel.comp s s) ≤
Filter.comap (fun p => (f p.1, f p.2)) (uniformity S) | null | false |
AlgebraicGeometry.Flat.generalizingMap | Mathlib.AlgebraicGeometry.Morphisms.UniversallyOpen | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Flat f], GeneralizingMap ⇑f | Any flat morphism is generalizing. | true |
Lean.Elab.Tactic.TacticFinishedSnapshot.state? | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.TacticFinishedSnapshot → Option Lean.Elab.Tactic.SavedState | State saved for reuse, if no fatal exception occurred. | true |
List.foldr._sunfold | Init.Data.List.Basic | {α : Type u} → {β : Type v} → (α → β → β) → β → List α → β | null | false |
Representation.LinearizeMonoidal.μ_leftUnitor | Mathlib.RepresentationTheory.Action | ∀ {G : Type v} [inst : Monoid G] (X : Action (Type w) G) {k : Type u} [inst_1 : CommSemiring k],
↑(Representation.TensorProduct.lid k (Representation.linearize k G X)) =
((Representation.linearizeMap (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom).comp
(Representation.LinearizeMonoidal.μ (Cate... | null | true |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.instTransOrd._proof_1 | Std.Time.Date.Unit.Weekday | Std.TransOrd Std.Time.Weekday | null | false |
WeakBilin.instIsTopologicalAddGroup | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | ∀ {𝕜 : Type u_2} {E : Type u_4} {F : Type u_5} [inst : TopologicalSpace 𝕜] [inst_1 : CommRing 𝕜]
[inst_2 : AddCommGroup E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
(B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) [ContinuousAdd 𝕜], IsTopologicalAddGroup (WeakBilin B) | `WeakBilin B` is a `IsTopologicalAddGroup`, meaning that addition and negation are
continuous. | true |
CategoryTheory.Iso.coreWhiskerRight | Mathlib.CategoryTheory.Core | ∀ {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 G : CategoryTheory.Functor C D} (η : F ≅ G)
(H : CategoryTheory.Functor D E),
(CategoryTheory.Functor.isoWhiskerRight η H).core =
... | null | true |
Batteries.Tactic.Lint.SimpTheoremInfo._sizeOf_inst | Batteries.Tactic.Lint.Simp | SizeOf Batteries.Tactic.Lint.SimpTheoremInfo | null | false |
CoheytingHom.cancel_left | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β]
[inst_2 : CoheytingAlgebra γ] {f₁ f₂ : CoheytingHom α β} {g : CoheytingHom β γ},
Function.Injective ⇑g → (g.comp f₁ = g.comp f₂ ↔ f₁ = f₂) | null | true |
Computability.Γ'.casesOn | Mathlib.Computability.Encoding | {motive : Computability.Γ' → Sort u} →
(t : Computability.Γ') →
motive Computability.Γ'.blank →
((b : Bool) → motive (Computability.Γ'.bit b)) →
motive Computability.Γ'.bra → motive Computability.Γ'.ket → motive Computability.Γ'.comma → motive t | null | false |
Std.ExtDHashMap.contains_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (m.modify k f).contains k' = m.contains k' | null | true |
Set.involutiveNeg.eq_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveNeg α], Set.involutiveNeg = { toNeg := Set.neg, neg_neg := ⋯ } | null | true |
Lean.Elab.Tactic.ElimApp.Result.rec | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimApp.Result → Sort u} →
((elimApp : Lean.Expr) →
(elimArgs : Array Lean.Expr) →
(motive_1 : Lean.MVarId) →
(alts : Array Lean.Elab.Tactic.ElimApp.Alt) →
(others : Array Lean.MVarId) →
(complexArgs : Array Lean.Expr) →
moti... | null | false |
TopHomClass.toTopHom | Mathlib.Order.Hom.Bounded | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} → [inst : FunLike F α β] → [inst_1 : Top α] → [inst_2 : Top β] → [TopHomClass F α β] → F → TopHom α β | Turn an element of a type `F` satisfying `TopHomClass F α β` into an actual
`TopHom`. This is declared as the default coercion from `F` to `TopHom α β`. | true |
Condensed.lanCondensedSet._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (X : CompHausᵒᵖ),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.StructuredArrow X profiniteToCompHaus.op) (Type (u_1 + 1)) | null | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Quasispectrum.0.NonnegSpectrumClass.iff_spectrum_nonneg.match_1_1 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : Ring A]
[inst_3 : PartialOrder A] [inst_4 : Algebra 𝕜 A] (motive : NonnegSpectrumClass 𝕜 A → Prop)
(x : NonnegSpectrumClass 𝕜 A), (∀ (h : ∀ (a : A), 0 ≤ a → ∀ x ∈ quasispectrum 𝕜 a, 0 ≤ x), motive ⋯) → motive x | null | false |
Std.DHashMap.Internal.Raw₀.size_expandIfNecessary | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Internal.Raw₀ α β},
(↑m.expandIfNecessary).size = (↑m).size | null | true |
Tactic.ReduceModChar.normIntNumeral | Mathlib.Tactic.ReduceModChar | {u : Lean.Level} →
{α : Q(Type u)} →
(n : Q(ℕ)) → (e : Q(«$α»)) → (x : Q(Ring «$α»)) → Q(CharP «$α» «$n») → Lean.MetaM (Mathlib.Meta.NormNum.Result e) | Given an integral expression `e : t` such that `t` is a ring of characteristic `n`,
reduce `e` modulo `n`. | true |
LinOrd.ofHom_hom | Mathlib.Order.Category.LinOrd | ∀ {X Y : LinOrd} (f : X ⟶ Y), LinOrd.ofHom (LinOrd.Hom.hom f) = f | null | true |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.isStoppingTime_of_measurableSet_lt_of_isRightContinuous'._simp_1_4 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
MeasureTheory.exists_measurable_superset_of_null | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
μ s = 0 → ∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = 0 | null | true |
MeasureTheory.crossing_eq_crossing_of_upperCrossingTime_lt | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω} {M : ℕ},
N ≤ M →
MeasureTheory.upperCrossingTime a b f N (n + 1) ω < N →
MeasureTheory.upperCrossingTime a b f M (n + 1) ω = MeasureTheory.upperCrossingTime a b f N (n + 1) ω ∧
MeasureTheory.lowerCrossingTime a b f M n ω = MeasureTheory.lo... | null | true |
ContinuousMultilinearMap.instAddCommGroup._proof_8 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {M₂ : Type u_1} [inst : AddCommGroup M₂] [inst_1 : TopologicalSpace M₂] [IsTopologicalAddGroup M₂],
ContinuousConstSMul ℤ M₂ | null | false |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.samePatternsVariables._proof_1 | Lean.Elab.PatternVar | ∀ (startingAt : ℕ) (s₁ : Lean.Elab.Term.CollectPatternVars.State), ∀ i ∈ startingAt...s₁.vars.size, i < s₁.vars.size | null | false |
_private.Init.Data.List.Lemmas.0.List.getElem?_append_right.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : (x : List α) → List α → (x_2 : ℕ) → x.length ≤ x_2 → Prop) (x x_1 : List α) (x_2 : ℕ)
(x_3 : x.length ≤ x_2),
(∀ (x : List α) (x_4 : ℕ) (x_5 : [].length ≤ x_4), motive [] x x_4 x_5) →
(∀ (a : α) (l x : List α) (i : ℕ) (h₁ : (a :: l).length ≤ i + 1), motive (a :: l) x i.succ h₁) →
... | null | false |
ContinuousWithinAt.image_closure | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
(∀ x ∈ closure s, ContinuousWithinAt f s x) → f '' closure s ⊆ closure (f '' s) | null | true |
CategoryTheory.Pseudofunctor.DescentData'.noConfusion | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{sq : (i j : ι... | null | false |
CategoryTheory.Subgroupoid.mul_mem_cancel_right | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d e : C} {f : c ⟶ d}
{g : d ⟶ e}, g ∈ S.arrows d e → (CategoryTheory.CategoryStruct.comp f g ∈ S.arrows c e ↔ f ∈ S.arrows c d) | null | true |
TopCat.isOpen_iff_of_isColimit_cofork | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X Y : TopCat} {f g : X ⟶ Y} (c : CategoryTheory.Limits.Cofork f g) (hc : CategoryTheory.Limits.IsColimit c)
(U : Set ↑c.pt), IsOpen U ↔ IsOpen (⇑(CategoryTheory.ConcreteCategory.hom c.π) ⁻¹' U) | null | true |
_private.Mathlib.LinearAlgebra.JordanChevalley.0.Module.End.isNilpotent_isSemisimple_unique._proof_1_1 | Mathlib.LinearAlgebra.JordanChevalley | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V], SMulCommClass K K V | null | false |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.Folder.mkUnary.match_3 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
((fvarId : Lean.FVarId) → motive #[Lean.Compiler.LCNF.Arg.fvar fvarId]) →
((x : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) → moti... | null | false |
CategoryTheory.Bicategory.Lan.CommuteWith.isKan.congr_simp | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : a ⟶ c)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanExtension f g] {x : B} (h : c ⟶ x)
[inst_2 : CategoryTheory.Bicategory.Lan.CommuteWith f g h],
CategoryTheory.Bicategory.Lan.CommuteWith.isKan f g h = CategoryTheory.Bicategory.Lan... | null | true |
Ring.HasFiniteQuotients.mk._flat_ctor | Mathlib.RingTheory.Ideal.Quotient.HasFiniteQuotients.Basic | ∀ {R : Type u_1} [inst : CommRing R], (∀ {I : Ideal R}, I ≠ ⊥ → Finite (R ⧸ I)) → Ring.HasFiniteQuotients R | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.sineTerm_bound_aux._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar.derive.match_1 | Mathlib.Tactic.ReduceModChar | (motive : Option Lean.Meta.SimpExtension → Sort u_1) →
(ext? : Option Lean.Meta.SimpExtension) →
((ext : Lean.Meta.SimpExtension) → motive (some ext)) → (Unit → motive none) → motive ext? | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (w : ℕ) (input : aig.RefVec w)
(newWidth curr : ℕ) (s : aig.RefVec curr), ∀ idx < curr, curr < newWidth → ¬idx < curr + 1 → False | null | false |
MeasureTheory.VectorMeasure.instPartialOrder._proof_3 | Mathlib.MeasureTheory.VectorMeasure.Order | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_2} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
[inst_2 : PartialOrder M] (x x_1 x_2 : MeasureTheory.VectorMeasure α M),
(∀ (i : Set α), MeasurableSet i → x i ≤ x_1 i) →
(∀ (i : Set α), MeasurableSet i → x_1 i ≤ x_2 i) → ∀ (i : Set α), MeasurableSet... | null | false |
Std.DHashMap.Equiv.of_forall_get?_eq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [inst : LawfulBEq α],
(∀ (k : α), m₁.get? k = m₂.get? k) → m₁.Equiv m₂ | null | true |
exists_nat_bool_continuous_surjective_of_compact | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | ∀ (X : Type u_1) [Nonempty X] [inst : MetricSpace X] [CompactSpace X], ∃ f, Continuous f ∧ Function.Surjective f | **Hausdorff–Alexandroff theorem**: every nonempty compact metric space is a continuous image
of the Cantor set. | true |
IsRelPrime.mul_sub_right_left_iff._simp_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime (z * y - x) y = IsRelPrime x y | null | false |
ProperCone.hyperplane_separation_of_notMem | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
[inst_2 : CompleteSpace E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F] [inst_5 : CompleteSpace F]
(K : ProperCone ℝ E) {f : E →L[ℝ] F} {b : F},
b ∉ ProperCone.map f K → ∃ y, (ContinuousLinearMap.adj... | null | true |
HasFDerivAtFilter.isBigO_sub | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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}
{f' : E →L[𝕜] F} {L : Filter (E × E)}, HasFDerivAtFilter f f' L → (fun p => f p.1 - f p.2) =O[L] fu... | null | true |
IsWellFounded.mk._flat_ctor | Mathlib.Order.RelClasses | ∀ {α : Type u} {r : α → α → Prop}, WellFounded r → IsWellFounded α r | null | false |
Module.Basis.ne_zero | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) [Nontrivial R] (i : ι), b i ≠ 0 | null | true |
ProbabilityTheory.Kernel.iIndepSets.precomp | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {π : ι → Set (Set Ω)} {ι' : Type u_5} {g : ι' → ι},
Function.Injective g → ProbabilityTheory.Kernel.iIndepSets π κ μ → ProbabilityTheory.Kernel.iIndepSe... | null | true |
RootedTree.ctorIdx | Mathlib.Order.SuccPred.Tree | RootedTree → ℕ | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_neg_eq_of_msb.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : (w : ℕ) → {x : BitVec w} → x.msb = false → Prop) (w : ℕ) {x : BitVec w} (h : x.msb = false),
(∀ (x : BitVec 0) (h : x.msb = false), motive 0 h) →
(∀ (w' : ℕ) (x : BitVec (w' + 1)) (h : x.msb = false), motive w'.succ h) → motive w h | null | false |
AlgEquiv.instCoeOutAlgHom | Mathlib.Algebra.Algebra.Equiv | {R : Type uR} →
{A₁ : Type uA₁} →
{A₂ : Type uA₂} →
[inst : CommSemiring R] →
[inst_1 : Semiring A₁] →
[inst_2 : Semiring A₂] →
[inst_3 : Algebra R A₁] → [inst_4 : Algebra R A₂] → CoeOut (A₁ ≃ₐ[R] A₂) (A₁ →ₐ[R] A₂) | null | true |
_private.Mathlib.CategoryTheory.Limits.Sifted.0.CategoryTheory.IsSifted.instIsSiftedOrEmptyOfHasBinaryCoproducts._simp_3 | Mathlib.CategoryTheory.Limits.Sifted | ∀ {α : Type u_1} (a : α) (l : List α), (a :: l = l) = False | null | false |
CategoryTheory.ShortComplex.homologyMap_neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.ShortComplex.homologyMap (-φ) = -CategoryTheory.ShortComplex.homologyMap φ | null | true |
Mathlib.Tactic.BicategoryLike.MonadWhiskerLeft.mk | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[toMonadHorizontalComp : Mathlib.Tactic.BicategoryLike.MonadHorizontalComp m] →
(Mathlib.Tactic.BicategoryLike.Atom₁ →
Mathlib.Tactic.BicategoryLike.WhiskerLeft → m Mathlib.Tactic.BicategoryLike.WhiskerLeft) →
Mathlib.Tactic.BicategoryLike.MonadWhiskerLeft m | null | true |
GradedAlgHom.coe_one | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {ι : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] {𝒜 : ι → Submodule R A} [inst_5 : GradedAlgebra 𝒜], ⇑1 = id | null | true |
AddSubgroup.mem_closure_pair | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {C : Type u_2} [inst : AddCommGroup C] {x y z : C}, z ∈ AddSubgroup.closure {x, y} ↔ ∃ m n, m • x + n • y = z | null | true |
CategoryTheory.PreZeroHypercover.saturate_p₁ | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(x x_1 : E.I₀) (r : E.Relation x x_1), E.saturate.p₁ r = r.fst | null | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_push._proof_1_4 | Init.Data.String.Basic | ∀ {s : String} {c : Char} {p : String.Pos.Raw},
s.utf8ByteSize ≤ p.byteIdx →
p.byteIdx - s.utf8ByteSize = c.utf8Size →
¬(String.Pos.Raw.IsValid s p ∨ p.byteIdx = s.utf8ByteSize + c.utf8Size) → False | null | false |
_private.Aesop.BuiltinRules.Subst.0.Aesop.BuiltinRules.matchSubstitutableIff?._sparseCasesOn_1 | Aesop.BuiltinRules.Subst | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.RingObjCat.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{R₁ R₂ : CategoryTheory.RingObjCat C} →
{motive : R₁.Hom R₂ → Sort u_1} →
(t : R₁.Hom R₂) →
((hom : R₁.... | null | false |
ContinuousMulEquiv.recOn | Mathlib.Topology.Algebra.ContinuousMonoidHom | {G : Type u} →
[inst : TopologicalSpace G] →
{H : Type v} →
[inst_1 : TopologicalSpace H] →
[inst_2 : Mul G] →
[inst_3 : Mul H] →
{motive : G ≃ₜ* H → Sort u_1} →
(t : G ≃ₜ* H) →
((toMulEquiv : G ≃* H) →
(continuous_toFun : Conti... | null | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM'._proof_2 | Mathlib.MeasureTheory.Integral.SetToL1.SimpleFunc | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T : Set α → E →L[ℝ] F} {C : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C →
∀ (f g : ↥(α ... | null | false |
MonCat.instCategory._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : MonCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := MonoidHom.id ↑X }.hom' } = f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.