name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.minSqFacAux_has_prop._unary | Mathlib.Data.Nat.Squarefree | ∀ (_x : (n : ℕ) ×' (k : ℕ) ×' (_ : 0 < n) ×' (i : ℕ) ×' (_ : k = 2 * i + 3) ×' ∀ (m : ℕ), Nat.Prime m → m ∣ n → k ≤ m),
_x.1.MinSqFacProp (_x.1.minSqFacAux _x.2.1) | null | false |
Order.pred_lt | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a < a | null | true |
UInt8.xor_comm | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), a ^^^ b = b ^^^ a | null | true |
TopologicalSpace.Compacts.ext | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : TopologicalSpace.Compacts α}, ↑s = ↑t → s = t | null | true |
SheafOfModules.Submodule.toSubmodule | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → {M : SheafOfModules R} → M.Submodule → M.val.Submodule | null | true |
CategoryTheory.Limits.reflectsFiniteLimits_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.ReflectsFiniteColimits F.leftOp],
CategoryTheory.Limits.ReflectsFiniteLimits F | If `F.leftOp : Cᵒᵖ ⥤ D` reflects finite colimits, then `F : C ⥤ Dᵒᵖ` reflects finite
limits. | true |
CategoryTheory.Functor.IsCartesian | Mathlib.CategoryTheory.FiberedCategory.Cartesian | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
CategoryTheory.Functor 𝒳 𝒮 → {R S : 𝒮} → {a b : 𝒳} → (R ⟶ S) → (a ⟶ b) → Prop | A morphism `φ : a ⟶ b` in `𝒳` lying over `f : R ⟶ S` in `𝒮` is Cartesian if for all
morphisms `φ' : a' ⟶ b`, also lying over `f`, there exists a unique morphism `χ : a' ⟶ a` lifting
`𝟙 R` such that `φ' = χ ≫ φ`.
See SGA 1 VI 5.1. | true |
Mathlib.Meta.NormNum.minFacHelper_2 | Mathlib.Tactic.NormNum.Prime | ∀ {n k k' : ℕ},
k + 2 = k' → ¬Nat.Prime k → Mathlib.Meta.NormNum.MinFacHelper n k → Mathlib.Meta.NormNum.MinFacHelper n k' | null | true |
Std.TreeMap.Raw.filter | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → (α → β → Bool) → Std.TreeMap.Raw α β cmp → Std.TreeMap.Raw α β cmp | Removes all mappings of the map for which the given function returns `false`. | true |
finprod_cond_eq_right | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {a : α}, ∏ᶠ (i : α) (_ : a = i), f i = f a | null | true |
CategoryTheory.ShortComplex.quasiIso_unopMap | 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]
[inst_4 : S₁.unop.HasHomology] [inst_5 : S₂.unop.HasHomology] (φ : S₁ ⟶ S₂) [CategoryTheory.ShortComplex.Qu... | null | true |
Set.Ioc_disjoint_Ioi._simp_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b c : α}, b ≤ c → Disjoint (Set.Ioc a b) (Set.Ioi c) = True | null | false |
LinearMap.normDet_codRestrict | Mathlib.Analysis.InnerProductSpace.NormDet | ∀ {𝕜 : Type u_1} {U : Type u_2} {V : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup U]
[inst_2 : InnerProductSpace 𝕜 U] [inst_3 : FiniteDimensional 𝕜 U] [inst_4 : NormedAddCommGroup V]
[inst_5 : InnerProductSpace 𝕜 V] {p : Submodule 𝕜 V} {f : U →ₗ[𝕜] V} (h : ∀ (c : U), f c ∈ p),
(LinearMap.codRes... | null | true |
EuclideanDomain.div_dvd_of_dvd | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {p q : R}, q ∣ p → p / q ∣ p | null | true |
MagmaCat.inv_hom_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N : MagmaCat} (e : M ≅ N) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
IsPrimitiveRoot.embeddingsEquivPrimitiveRoots.congr_simp | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] {K : Type u} {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ ζ_1 : L} (e_ζ : ζ = ζ_1) (hζ : IsPrimitiveRoot ζ n)
(C : Type u_1) [inst_6 : CommRing C] [inst_7 : IsDomain C] [inst_8 : Algebra K C... | null | true |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.exists_true | Init.Grind.Module.Envelope | ∀ (α : Type u) [Lean.Grind.NatModule α], ∃ x, True | null | true |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarSubalgebra.mem_centralizer_iff._simp_1_4 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.propagateForallPropUp.match_1 | Lean.Meta.Tactic.Grind.ForallProp | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (p q : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.forallE n p q bi)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
Module.finrank_div_finrank_cancel_left | Mathlib.LinearAlgebra.Dimension.Free | ∀ (F : Type u) (K : Type v) (A : Type w) [inst : Semiring F] [inst_1 : Semiring K] [inst_2 : AddCommMonoid A]
[inst_3 : Module F K] [inst_4 : Module K A] [inst_5 : Module F A] [IsScalarTower F K A] [StrongRankCondition F]
[StrongRankCondition K] [Module.Free F K] [Module.Free K A],
Module.finrank F K ≠ 0 → Module... | null | true |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.HasMFDerivAt.prodMap._simp_1_2 | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
min_left_comm | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : α), min a (min b c) = min b (min a c) | null | true |
ContinuousMap.HomotopyEquiv.trans._proof_2 | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h₁ : ContinuousMap.HomotopyEquiv X Y) (h₂ : ContinuousMap.HomotopyEquiv Y Z),
((h₂.toFun.comp h₁.toFun).comp (h₁.invFun.comp h₂.invFun)).Homotopic (ContinuousMap.id Z) | null | false |
LinearMap.mul_toMatrix₂_mul | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {M₁' : Type u_8} {M₂' : Type u_9} {n : Type u_11} {m : Type u_12}
{n' : Type u_13} {m' : Type u_14} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] [inst_5 : Fintype n] [inst_6 : Fintype m]... | null | true |
TestFunction.monoCLM_apply | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω₁ Ω₂ : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n₁ n₂ : ℕ∞} [inst_6 : Algebra ℝ 𝕜]
[inst_7 : Is... | null | true |
Lean.Elab.Level.instMonadRefLevelElabM | Lean.Elab.Level | Lean.MonadRef Lean.Elab.Level.LevelElabM | null | true |
MeasureTheory.VectorMeasure.enorm_setIntegral_le_lintegral_enorm | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.VectorMeasure X F} {f : X → E}
{s : Set X} [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpa... | null | true |
DivisibleHull.instLinearOrder._proof_7 | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedCancelAddMonoid M]
(a b : DivisibleHull M), (if a ≤ b then b else a) = if a ≤ b then b else a | null | false |
Subring.closure_union | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s t : Set R), Subring.closure (s ∪ t) = Subring.closure s ⊔ Subring.closure t | null | true |
_private.Mathlib.RingTheory.Depth.Basic.0.ModuleCat.subsingleton_ext_of_lt_depth._simp_1_2 | Mathlib.RingTheory.Depth.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (⊤ ≤ a) = (a = ⊤) | null | false |
LinearEquiv.funCongrLeft._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | ∀ (R : Type u_3) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : Type u_2}
{n : Type u_4} (e : m ≃ n), LinearMap.funLeft R M ⇑e ∘ₗ LinearMap.funLeft R M ⇑e.symm = LinearMap.id | null | false |
Quiver.FreeGroupoid.lift_spec | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | ∀ {V : Type u} [inst : Quiver V] {V' : Type u'} [inst_1 : CategoryTheory.Groupoid V'] (φ : V ⥤q V'),
Quiver.FreeGroupoid.of V ⋙q (Quiver.FreeGroupoid.lift φ).toPrefunctor = φ | null | true |
_private.Mathlib.NumberTheory.Padics.Measure.Basic.0.AbstractMeasure.dirac._proof_6 | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : TopologicalSpace R] [IsTopologicalRing R], ContinuousSMul R R | null | false |
Int.one_bmod | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℕ}, 3 ≤ b → Int.bmod 1 b = 1 | null | true |
Std.Sat.AIG.RefVec.get_push_ref_eq' | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {len : ℕ} (s : aig.RefVec len)
(ref : aig.Ref) (idx : ℕ) (hidx : idx = len), (s.push ref).get idx ⋯ = ref | null | true |
Finset.prod_finset_product_right' | Mathlib.Algebra.BigOperators.Group.Finset.Sigma | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommMonoid β] (r : Finset (α × γ)) (s : Finset γ)
(t : γ → Finset α),
(∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) → ∀ {f : α → γ → β}, ∏ p ∈ r, f p.1 p.2 = ∏ c ∈ s, ∏ a ∈ t c, f a c | null | true |
_private.Mathlib.Order.WithBot.0.WithBot.forall_coe_le_iff_le._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Preorder α] {x : WithBot α} [NoBotOrder α], (x = ⊥) = ∀ (b : α), x ≤ ↑b | null | false |
CategoryTheory.Bimon.ofMonComonObj_comon_counit_hom | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon (CategoryTheory.Comon C)),
CategoryTheory.ComonObj.counit.hom = CategoryTheory.ComonObj.counit | null | true |
Aesop.Goal.traceTreeCore | Aesop.Tree.Tracing | Aesop.Goal → Aesop.TraceOption → Lean.MetaM Unit | null | true |
CategoryTheory.Functor.ShiftSequence.shiftIso_zero | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_3} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_3, u_3} A} {F : CategoryTheory.Functor C A} {M : Type u_4} {inst_2 : AddMonoid M}
{inst_3 : CategoryTheory.HasShift C M} [self : F.ShiftSequence M] (a : M),
CategoryTheory.Functor.ShiftSequence.shift... | null | true |
Mathlib.Tactic.Monoidal.instMonadMor₂MonoidalM.match_3 | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | (motive : Option Mathlib.Tactic.BicategoryLike.IsoLift → Sort u_1) →
(x : Option Mathlib.Tactic.BicategoryLike.IsoLift) →
((η_iso : Mathlib.Tactic.BicategoryLike.IsoLift) → motive (some η_iso)) →
((x : Option Mathlib.Tactic.BicategoryLike.IsoLift) → motive x) → motive x | null | false |
Option.get_bind | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : Option α} {f : α → Option β} (h : (x.bind f).isSome = true),
(x.bind f).get h = (f (x.get ⋯)).get ⋯ | null | true |
Lean.Server.Reference.mk.noConfusion | Lean.Server.References | {P : Sort u} →
{ident : Lean.Lsp.RefIdent} →
{aliases : Array Lean.Lsp.RefIdent} →
{range : Lean.Lsp.Range} →
{stx : Lean.Syntax} →
{ci : Lean.Elab.ContextInfo} →
{info : Lean.Elab.Info} →
{isBinder : Bool} →
{ident' : Lean.Lsp.RefIdent} →
... | null | false |
Algebra.cardinalMk_adjoin_le | Mathlib.Algebra.FreeAlgebra.Cardinality | ∀ (R : Type u) [inst : CommSemiring R] {A : Type u} [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A),
Cardinal.mk ↥(Algebra.adjoin R s) ≤ max (max (Cardinal.mk R) (Cardinal.mk ↑s)) Cardinal.aleph0 | null | true |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_snd | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Su... | null | true |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.continuous_pow._simp_1_5 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {a : ENNReal} {n : ℕ}, (a ^ n = ⊤) = (a = ⊤ ∧ n ≠ 0) | null | false |
OrderDual.instRightCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : RightCancelSemigroup α], IsRightCancelMul αᵒᵈ | null | false |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
(𝒰 : S.OpenCover) →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] → Type (max (max (u + 1) u_1) u_2) | A relative gluing datum over a locally directed cover `𝒰` of `S` is a scheme `Xᵢ` for every
`i : 𝒰.I₀` and natural maps `Xᵢ ⟶ Uᵢ` such that for every `i ⟶ j`, the diagram
```
Xᵢ --> Uᵢ
| |
v v
Xⱼ --> Uⱼ
```
is a pullback square. We bundle this in the form of a functor and an equifibered natural
transformati... | true |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.properSMul_iff_continuousSMul_ultrafilter_tendsto.match_1_1 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : Group G] [inst_1 : MulAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X]
(motive :
(ContinuousSMul G X ∧
∀ (𝒰 : Ultrafilter (G × X)) (x₁ x₂ : X),
Filter.Tendsto (fun gx => (gx.1 • gx.2, gx.2)) (↑𝒰) (nhds (x₁, x₂)) →
∃ g... | null | false |
StrictMono.orderIso.congr_simp | Mathlib.SetTheory.Cardinal.Cofinality.Enum | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] (f : α → β) (h_mono : StrictMono f),
StrictMono.orderIso f h_mono = StrictMono.orderIso f h_mono | null | true |
Lean.Grind.Field.mk.noConfusion | Init.Grind.Ring.Field | {α : Type u} →
{P : Sort u_1} →
{toCommRing : Lean.Grind.CommRing α} →
{toInv : Inv α} →
{toDiv : Div α} →
{zpow : HPow α ℤ α} →
{div_eq_mul_inv : ∀ (a b : α), a / b = a * b⁻¹} →
{zero_ne_one : 0 ≠ 1} →
{inv_zero : 0⁻¹ = 0} →
{mul... | null | false |
Valued.valueGroup₀_equiv_extensionValuation | Mathlib.Topology.Algebra.Valued.ValuedField | {K : Type u_1} →
[inst : Field K] →
{Γ₀ : Type u_2} →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
[hv : Valued K Γ₀] → (↑Valued.v).ValueGroup₀ ≃* (↑Valued.extensionValuation).ValueGroup₀ | The zero-preserving monoid homomorphism from the `ValueGroup₀` of the valuation on `K` to
that of the extension to its completion. | true |
CStarMatrix.instTopologicalSpace._aux_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {A : Type u_1} → [NonUnitalCStarAlgebra A] → {m : Type u_3} → {n : Type u_2} → TopologicalSpace (CStarMatrix m n A) | null | false |
PrimeSpectrum.piLocalizationToMaximal_bijective | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} [inst : CommSemiring R],
(∀ (I : Ideal R), I.IsPrime → I.IsMaximal) → Function.Bijective ⇑(PrimeSpectrum.piLocalizationToMaximal R) | null | true |
Lean.Elab.Command.ElabHeaderResult.indFVar | Lean.Elab.MutualInductive | Lean.Elab.Command.ElabHeaderResult → Lean.Expr | null | true |
Lean.Order.ReverseImplicationOrder.instCompleteLattice | Init.Internal.Order.Basic | Lean.Order.CompleteLattice Lean.Order.ReverseImplicationOrder | null | true |
BoxIntegral.Prepartition.iUnion_disjUnion | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (h : Disjoint π₁.iUnion π₂.iUnion),
(π₁.disjUnion π₂ h).iUnion = π₁.iUnion ∪ π₂.iUnion | null | true |
CFC.exp_log | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : NormedAlgebra ℝ A]
[inst_3 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_4 : PartialOrder A] [StarOrderedRing A]
[NonnegSpectrumClass ℝ A] (a : A),
autoParam (IsStrictlyPositive a) CFC.exp_log._auto_1 → NormedSpace.exp (CFC.log a) = ... | null | true |
Primrec.option_guard | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : α → β → Prop}
[inst_2 : DecidableRel p],
PrimrecRel p → ∀ {f : α → β}, Primrec f → Primrec fun a => Option.guard (fun b => decide (p a b)) (f a) | null | true |
Subsemigroup.centerCongr_symm_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N) (s : ↥(Subsemigroup.center N)),
↑((Subsemigroup.centerCongr e).symm s) = e.symm ↑s | null | true |
TopologicalSpace.ext_iff_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u_2} {t t' : TopologicalSpace X}, t = t' ↔ ∀ (x : X), nhds x = nhds x | null | true |
Lean.KeyedDeclsAttribute.AttributeEntry.mk.sizeOf_spec | Lean.KeyedDeclsAttribute | ∀ {γ : Type} [inst : SizeOf γ] (toOLeanEntry : Lean.KeyedDeclsAttribute.OLeanEntry) (isBuiltin : Bool) (value : γ),
sizeOf { toOLeanEntry := toOLeanEntry, isBuiltin := isBuiltin, value := value } =
1 + sizeOf toOLeanEntry + sizeOf isBuiltin + sizeOf value | null | true |
Stream'.cons.match_1 | Mathlib.Data.Stream.Defs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
IsValuativeTopology.instIsLinearTopologySubtypeMemSubringIntegerValueGroupWithZeroValuation_1 | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R],
IsLinearTopology (↥(ValuativeRel.valuation R).integer) R | The topology on a ring `R` carrying a valuative topology is linear over its ring of integers:
the open balls `Valuation.ltSubmodule (valuation R) γ` form a basis of neighborhoods of zero
made of `(valuation R).integer`-submodules. | true |
HomologicalComplex.truncGEXIsoOpcycles | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.truncGE e).X i' ≅ K.opcycles i'` when `e.f i = i'`
and `e.BoundaryGE i` holds. | true |
CircleDeg1Lift.strictMono_iff_injective | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), StrictMono ⇑f ↔ Function.Injective ⇑f | null | true |
AddEquiv.toIntLinearEquiv_refl | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_5} [inst : AddCommGroup M] {modM : Module ℤ M}, (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M | null | true |
AddEquiv.isSimpleAddGroup | Mathlib.GroupTheory.Subgroup.Simple | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_3} [inst_1 : AddGroup H] [IsSimpleAddGroup H] (e : G ≃+ H),
IsSimpleAddGroup G | null | true |
CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_2} (J' : Type u_1) (h : J ≃ J') (val : J'),
((CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h.invFun j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h.invFun j)).comp
(CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some ... | null | false |
WithTop.orderIsoSumLexPUnit_toLex | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} [inst : LE α] (a : α), WithTop.orderIsoSumLexPUnit ↑a = toLex (Sum.inl a) | null | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.Const.insertListₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_2} {β : Type u_1} (motive : List (α × β) → Sort u_3) (h_1 : Unit → motive [])
(h_2 : (hd : α × β) → (tl : List (α × β)) → motive (hd :: tl)),
(match [] with
| [] => h_1 ()
| hd :: tl => h_2 hd tl) =
h_1 () | null | true |
BitVec.rotateRight | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → ℕ → BitVec w | Rotates the bits in a bitvector to the right.
All the bits of `x` are shifted to lower positions, with the bottom `n` bits wrapping around to fill
the vacated high bits.
SMT-LIB name: `rotate_right`, except this operator uses a `Nat` shift amount.
Example:
* `rotateRight 0b01001#5 1 = 0b10100`
| true |
nhdsSet | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → Set X → Filter X | The filter of neighborhoods of a set in a topological space. | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit),
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂ c = Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂ c_1) =
(c = c_1) | null | true |
Lean.Meta.KExprMap.insert | Lean.Meta.KExprMap | {α : Type} → Lean.Meta.KExprMap α → Lean.Expr → α → Lean.MetaM (Lean.Meta.KExprMap α) | Insert `e ↦ v` into `m` | true |
CharTwo.sum_sq | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} {ι : Type u_2} [inst : CommSemiring R] [CharP R 2] (s : Finset ι) (f : ι → R),
(∑ i ∈ s, f i) ^ 2 = ∑ i ∈ s, f i ^ 2 | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_lt_ediv_iff_of_dvd_of_pos_of_neg._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a < b → (a = b) = False | null | false |
Std.Do._aux_Std_Do_PostCond___unexpand_Std_Do_ExceptConds_imp_1 | Std.Do.PostCond | Lean.PrettyPrinter.Unexpander | null | false |
HasFibers.Fib.isoMk._proof_1 | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] {p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {S : 𝒮}
{a b : HasFibers.Fib p S} (Φ : (HasFibers.ι S).obj a ≅ (HasFibers.ι S).obj b),
p.IsHomLift (CategoryTheory.CategorySt... | null | false |
Lean.Core.mkFreshUserName | Lean.CoreM | Lean.Name → Lean.CoreM Lean.Name | Creates a name from `n` that is guaranteed to be unique.
This is intended to be used for creating inaccessible user names for free variables and constants.
It works by adding a fresh macro scope to `n`.
Applying `Lean.Name.eraseMacroScopes` to the resulting name yields `n`.
See also `Lean.LocalContext.getUnusedName` ... | true |
CategoryTheory.PreZeroHypercover.inv_inv_h₀_comp_f | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀), CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (e.inv.h₀ i)) (F.f i) = E.f (e.inv.s₀ i) | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites.0.CategoryTheory.Limits.createsLimitOfRightOp._proof_1 | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
(K : CategoryTheory.Functor J Cᵒᵖ) (F : CategoryTheory.Functor Cᵒᵖ D)
[CategoryTheory.CreatesColimit K.leftOp F.rightOp], Cat... | null | false |
IsLocalization.algEquivOfAlgEquiv._proof_4 | Mathlib.RingTheory.Localization.Basic | ∀ {A : Type u_5} [inst : CommSemiring A] {R : Type u_3} [inst_1 : CommSemiring R] [inst_2 : Algebra A R]
{M : Submonoid R} (S : Type u_2) [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : IsLocalization M S]
{P : Type u_4} [inst_6 : CommSemiring P] [inst_7 : Algebra A P] {T : Submonoid P} (Q : Type u_1)
... | null | false |
LinearPMap.HasCore.recOn | Mathlib.Topology.Algebra.Module.LinearPMap | {R : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup E] →
[inst_2 : AddCommGroup F] →
[inst_3 : Module R E] →
[inst_4 : Module R F] →
[inst_5 : TopologicalSpace E] →
[inst_6 : Topological... | null | false |
AlexDisc._sizeOf_inst | Mathlib.Topology.Order.Category.AlexDisc | SizeOf AlexDisc | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{F : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone F) → {X Y : C} → (X ⟶ Y) → (F.obj ⊥ ⟶ X) → (c.pt ⟶ Y) → J → Type v | Given a cocone `c` for a functor `F : J ⥤ C` from a well-ordered type,
and maps `p : X ⟶ Y`, `f : F.obj ⊥ ⟶ X`, `g : c.pt ⟶ Y`, this structure
contains the data of a map `F.obj j ⟶ X` such that `F.map (homOfLE bot_le) ≫ f' = f`
and `f' ≫ p = c.ι.app j ≫ g`. (This implies that the outer square below
commutes, see `SqStr... | true |
NONote.instMul._proof_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (x y : NONote), (↑x * ↑y).NF | null | false |
String.Pos.toSlice_lt_toSlice_iff | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, p.toSlice < q.toSlice ↔ p < q | null | true |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZLattice.comap_equiv._simp_6 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
Diffeomorph.prodCongr_symm | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : 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'] {F : Type u_4}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_5} [inst_7 : Topologic... | null | true |
IsSimpleOrder.bot_lt_iff_eq_top._simp_2 | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [IsSimpleOrder α] {a : α}, (⊥ < a) = (a = ⊤) | null | false |
ProbabilityTheory.integrable_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
MeasureTheory.Integrable (fun a => ↑(ProbabilityTheory.condCDF ρ a) x) ρ.fst | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ}, i < (List.filter p []).length → i < (List.filter p []).length | null | false |
Lean.Grind.IntModule | Init.Grind.Module.Basic | Type u → Type u | A module over the integers, i.e. a type with zero, addition, negation, subtraction, and scalar multiplication by integers,
satisfying appropriate compatibilities.
Equivalently, an additive commutative group.
| true |
CategoryTheory.epi_comp' | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.Epi f → CategoryTheory.Epi g → CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) | The composition of epimorphisms is again an epimorphism. This version takes `Epi f` and `Epi g`
as explicit arguments. For a version taking them as typeclass arguments, see `epi_comp`. | true |
List.isChain_split | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {c : α} {l₁ l₂ : List α},
List.IsChain R (l₁ ++ c :: l₂) ↔ List.IsChain R (l₁ ++ [c]) ∧ List.IsChain R (c :: l₂) | null | true |
MeasureTheory.stronglyMeasurable_zero | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β],
MeasureTheory.StronglyMeasurable 0 | null | true |
Order.Ideal.instInhabited | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → [Inhabited P] → Inhabited (Order.Ideal P) | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Extension.addEMatchAttr.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) →
(Unit → motive Lean.ConstantKind.thm) →
(Unit → motive Lean.ConstantKind.ctor) →
(Unit → motive Lean.ConstantKind.axiom) → ((x : Lean.ConstantKind) → motive x) → motive x | null | false |
Subtype.semilatticeInf._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] {P : α → Prop} (x x_1 : { x // P x }), ↑x ⊓ ↑x_1 ≤ ↑x_1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.