name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EReal.neTopBotEquivReal | Mathlib.Data.EReal.Basic | ↑{⊥, ⊤}ᶜ ≃ ℝ | The set of numbers in `EReal` that are not equal to `±∞` is equivalent to `ℝ`. | true |
Nat.factorization_factorial_eq_zero_of_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n : ℕ}, n < p → n.factorial.factorization p = 0 | null | true |
Function.Injective.addSemigroup._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Add M₁] [inst_1 : AddSemigroup M₂] (f : M₁ → M₂),
(∀ (x y : M₁), f (x + y) = f x + f y) → ∀ (x y z : M₁), f (x + y + z) = f (x + (y + z)) | null | false |
inv_le_of_inv_le' | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] [MulRightMono α] {a b : α}, a⁻¹ ≤ b → b⁻¹ ≤ a | **Alias** of the forward direction of `inv_le'`. | true |
AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_hom | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f g : X ⟶ Y) (hfg : f = g) (x : ↑X.toTopCat),
AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯)
(AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap g x) | null | true |
AdjoinPthRoots.algebraMap_root_symm | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | ∀ {k : Type u_1} [inst : Field k] (p : ℕ) [ExpChar k p] (x : AdjoinPthRoots k),
(algebraMap k (AdjoinPthRoots k)) ((AdjoinPthRoots.root k).symm x) = x ^ p | null | true |
AlgebraicGeometry.Scheme.instEpiTopCatPullbackComparisonForgetToTop | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S),
CategoryTheory.Epi (CategoryTheory.Limits.pullbackComparison AlgebraicGeometry.Scheme.forgetToTop f g) | null | true |
Left.mul_lt_one_of_lt_of_le | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftMono α], b < c → a ≤ 1 → b * a < c | Assumes left covariance.
The lemma assuming right covariance is `Right.mul_lt_one_of_lt_of_le`. | true |
Option.map_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Lean.Meta.RefinedDiscrTree.ImportFailure✝ → ℕ | null | false |
CategoryTheory.Lax.StrongTrans.mkOfLax'._proof_4 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.LaxTrans F G)
[inst_2 : ∀ (a b : B) (f : a ⟶ b), CategoryTheory.IsIso (η.naturality f)] (a : B),
CategoryTheory.CategoryStruct.comp (CategoryThe... | null | false |
Lean.instDecidableEqLocalDeclKind._proof_2 | Lean.LocalContext | ∀ (x y : Lean.LocalDeclKind), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
Lean.Meta.Grind.CasesTypes.eraseDecl | Lean.Meta.Tactic.Grind.Cases | Lean.Meta.Grind.CasesTypes → Lean.Name → Lean.CoreM Lean.Meta.Grind.CasesTypes | null | true |
PrimeSpectrum.isIdempotentElemEquivClopens_symm_top | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommRing R], PrimeSpectrum.isIdempotentElemEquivClopens.symm ⊤ = ⟨1, ⋯⟩ | null | true |
Polynomial.integralNormalization_mul_C_leadingCoeff | Mathlib.RingTheory.Polynomial.IntegralNormalization | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
p.integralNormalization * Polynomial.C p.leadingCoeff = p.scaleRoots p.leadingCoeff | null | true |
ExceptCpsT.run_throw | Init.Control.ExceptCps | ∀ {m : Type u_1 → Type u_2} {ε β : Type u_1} {e : ε} [inst : Monad m], (throw e).run = pure (Except.error e) | null | true |
_private.Mathlib.CategoryTheory.Join.Pseudofunctor.0.CategoryTheory.Join.id.match_1.eq_2 | Mathlib.CategoryTheory.Join.Pseudofunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (motive : CategoryTheory.Join C D → Sort u_5) (x : D)
(h_1 : (x : C) → motive (CategoryTheory.Join.left x)) (h_2 : (x : D) → motive (CategoryTheory.Join.right x)),
(match CategoryTheory.Jo... | null | true |
ContDiffAt.prodMap | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{E' : Type u_3} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E'] {F' : Type u_4}
[... | The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. | true |
Lean.Meta.Grind.Result.failure? | Lean.Meta.Tactic.Grind.Main | Lean.Meta.Grind.Result → Option Lean.Meta.Grind.Goal | null | true |
Lean.Linter.UnusedVariables.FVarDefinition.noConfusionType | Lean.Linter.UnusedVariables | Sort u → Lean.Linter.UnusedVariables.FVarDefinition → Lean.Linter.UnusedVariables.FVarDefinition → Sort u | null | false |
Sym2.congr_left | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {a b c : α}, s(b, a) = s(c, a) ↔ b = c | null | true |
UInt32.toUInt16_shiftLeft_mod | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), (a <<< (b % 16)).toUInt16 = a.toUInt16 <<< b.toUInt16 | null | true |
BoxIntegral.BoxAdditiveMap.instIsNegApplyBox | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {ι : Type u_1} {I₀ : WithTop (BoxIntegral.Box ι)} {M : Type u_4} [inst : AddCommGroup M],
IsNegApply (BoxIntegral.BoxAdditiveMap ι M I₀) (BoxIntegral.Box ι) M | null | true |
_private.Mathlib.Lean.CoreM.0.CoreM.withImportModules.match_1 | Mathlib.Lean.CoreM | (motive : Option Lean.SearchPath → Sort u_1) →
(searchPath : Option Lean.SearchPath) →
((sp : Lean.SearchPath) → motive (some sp)) → ((x : Option Lean.SearchPath) → motive x) → motive searchPath | null | false |
_private.Mathlib.AlgebraicGeometry.ValuativeCriterion.0.AlgebraicGeometry.ValuativeCriterion.Existence.of_specializingMap._simp_1_3 | Mathlib.AlgebraicGeometry.ValuativeCriterion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f g) g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f g) f | null | false |
ContDiffMapSupportedIn.integralAgainstBilinCLM_eq_integral | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {m : MeasurableSpace E}
[inst_3 : OpensMeasurableSpace E] {F₁ : Type u_5} {F₂ : Type u_6} {F₃ : Type u_7} [inst_4 : NormedAddCommGroup F₁]
[ins... | null | true |
Filter.le_smul_iff._simp_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f : Filter α} {g h : Filter β},
(h ≤ f • g) = ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s • t ∈ h | null | false |
Asymptotics.isBigO_const_mul_right_iff' | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {E : Type u_2} {R : Type u_4} [inst : Norm E] [inst_1 : SeminormedRing R] {f : α → E} {l : Filter α}
{g : α → R} {c : R}, IsUnit c → ((f =O[l] fun x => c * g x) ↔ f =O[l] g) | null | true |
Asymptotics.transIsLittleOEventuallyEq | Mathlib.Analysis.Asymptotics.Basic | {α : Type u_1} →
{E : Type u_3} →
{F : Type u_4} →
[inst : Norm E] →
[inst_1 : Norm F] →
{l : Filter α} → Trans (fun x1 x2 => x1 =o[l] x2) (fun x1 x2 => x1 =ᶠ[l] x2) fun x1 x2 => x1 =o[l] x2 | null | true |
latticeClosure_constructibleTopologySubbasis | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] [CompactSpace X] [QuasiSeparatedSpace X],
latticeClosure (constructibleTopologySubbasis X) = {s | Topology.IsConstructible s} | null | true |
Algebra.TensorProduct.basisAux._proof_1 | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
CategoryTheory.Limits.pointwiseBinaryBicone | Mathlib.CategoryTheory.Limits.FunctorCategory.BinaryBiproducts | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasBinaryBiproducts C] →
{D : Type u_2} →
[inst_3 : CategoryTheory.Category.{v_2, u_2} D] →
(F G : CategoryTheory.Functor D C) → Categor... | The binary bicone associated to the biproduct of functors `F` and `G` | true |
CategoryTheory.LocallySmall.mk._flat_ctor | Mathlib.CategoryTheory.EssentiallySmall | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
autoParam (∀ (X Y : C), Small.{w, v} (X ⟶ Y)) CategoryTheory.LocallySmall.hom_small._autoParam →
CategoryTheory.LocallySmall.{w, v, u} C | null | false |
gal_prod_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F] {s : Multiset (Polynomial F)},
(∀ p ∈ s, Group.IsSolvable p.Gal) → Group.IsSolvable s.prod.Gal | null | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.norm_le_norm_add_norm_inv_mul._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
Turing.TM1to1.writes.eq_def | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} [inst : Fintype Γ] (x : Turing.TM1.Stmt Γ Λ σ),
Turing.TM1to1.writes x =
match x with
| Turing.TM1.Stmt.move a q => Turing.TM1to1.writes q
| Turing.TM1.Stmt.write a q =>
Finset.image (fun a => Turing.TM1to1.Λ'.write a q) Finset.univ ∪ Turing.TM1to1.writ... | null | true |
AffineEquiv.val_equivUnitsAffineMap_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (e : P₁ ≃ᵃ[k] P₁), ↑(AffineEquiv.equivUnitsAffineMap e) = ↑e | null | true |
Lean.Grind.Fin.instCommRingFinOfNeZeroNat._proof_8 | Init.GrindInstances.Ring.Fin | ∀ (n : ℕ) [inst : NeZero n] (x : ℕ) (x_1 : Fin n), ↑x • x_1 = ↑x • x_1 | null | false |
cfc_comp_pow | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
RingCone.instSetLike | Mathlib.Algebra.Order.Ring.Cone | (R : Type u_1) → [inst : Ring R] → SetLike (RingCone R) R | null | true |
Std.Time.TimeZone.RecurringRule.dst._default | Std.Time.Zoned.RecurringRule | Option Std.Time.TimeZone.DaylightSavingRule | null | false |
FinBddDistLat.hom_comp | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y Z : FinBddDistLat} (f : X ⟶ Y) (g : Y ⟶ Z),
FinBddDistLat.Hom.hom (CategoryTheory.CategoryStruct.comp f g) =
(FinBddDistLat.Hom.hom g).comp (FinBddDistLat.Hom.hom f) | null | true |
_private.Mathlib.Analysis.Normed.Group.RadialFunction.0.Function.IsRadial.comp_right._proof_1_1 | Mathlib.Analysis.Normed.Group.RadialFunction | ∀ {D : Type u_1} {E : Type u_3} {F : Type u_2} [inst : Norm D] {f : D → E} {g : E → F},
Function.IsRadial f → Function.IsRadial (g ∘ f) | null | false |
AlgebraicGeometry.Proj.basicOpenToSpec.eq_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A),
AlgebraicGeometry.Proj.basicOpenToSpec 𝒜 f =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Proj.basicOpen 𝒜 f).toSpecΓ
(AlgebraicGeometry.Spec.m... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_2 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Basic.0.MeasureTheory.VectorMeasure.variation_map_le._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ : MeasureTheory.Measure α), (0 ≤ μ) = True | null | false |
IsEvenlyCovered.comp_homeomorph | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {I : Type u_3}
[inst_2 : TopologicalSpace I] {x : X},
IsEvenlyCovered f x I → ∀ {E' : Type u_4} [inst_3 : TopologicalSpace E'] (g : E' ≃ₜ E), IsEvenlyCovered (f ∘ ⇑g) x I | null | true |
Turing.ToPartrec.Code.comp | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code → Turing.ToPartrec.Code → Turing.ToPartrec.Code | null | true |
Batteries.Tactic.«command#help_Term+____» | Batteries.Tactic.HelpCmd | Lean.ParserDescr | The command `#help term` shows all term syntaxes that have been defined in the current environment.
See `#help cat` for more information.
| true |
SSet.Truncated.Edge.CompStruct.noConfusion | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {P : Sort u_1} →
{X : SSet.Truncated 2} →
{x₀ x₁ x₂ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge._proof_1 })} →
{e₀₁ : SSet.Truncated.Edge x₀ x₁} →
{e₁₂ : SSet.Truncated.Edge x₁ x₂} →
{e₀₂ : SSet.Truncated.Edge x₀ x₂} →
{t : e₀₁.CompStruct e₁₂ e₀₂... | null | false |
Lean.Meta.Grind.ExprWithAnchor.mk.injEq | Lean.Meta.Tactic.Grind.Anchor | ∀ (e : Lean.Expr) (anchor : UInt64) (e_1 : Lean.Expr) (anchor_1 : UInt64),
({ e := e, anchor := anchor } = { e := e_1, anchor := anchor_1 }) = (e = e_1 ∧ anchor = anchor_1) | null | true |
AddAut.applyAddDistribAddAction._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_1} [inst : AddMonoid M] (f : AddAut M) (x y : M), f (x + y) = f x + f y | null | false |
String.Slice.Pos.prevAux.go.congr_simp | Init.Data.String.Basic | ∀ {s s_1 : String.Slice} (e_s : s = s_1) (off off_1 : ℕ) (e_off : off = off_1) (h₁ : off < s.utf8ByteSize),
String.Slice.Pos.prevAux.go off h₁ = String.Slice.Pos.prevAux.go off_1 ⋯ | null | true |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_62 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (l' : List α),
1 < l'.length →
l' <:+: l →
∀ (l₁ l₂ : List α), l₁ ++ l' ++ l₂ = l → l₁.length + (l'.length - 1) - l₁.length < (l₁ ++ l' ++ l₂).length | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl._proof_1_9 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} {s : Set α},
s.ncard < sᶜ.ncard → s.ncard + sᶜ.ncard = Nat.card α → 4 < Nat.card α → s.ncard + 1 ≤ Nat.card α - 2 | null | false |
intervalIntegral.norm_integral_le_abs_of_norm_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f : ℝ → E}
{μ : MeasureTheory.Measure ℝ} {g : ℝ → ℝ},
(∀ᵐ (t : ℝ) ∂μ.restrict (Set.uIoc a b), ‖f t‖ ≤ g t) →
IntervalIntegrable g μ a b → ‖∫ (t : ℝ) in a..b, f t ∂μ‖ ≤ |∫ (t : ℝ) in a..b, g t ∂μ| | null | true |
Nat.giCountNth | Mathlib.Data.Nat.Nth | {p : ℕ → Prop} → [inst : DecidablePred p] → (Set.ofPred p).Infinite → GaloisInsertion (Nat.count p) (Nat.nth p) | If a predicate `p : ℕ → Prop` is true for infinitely many numbers, then `Nat.count p` and
`Nat.nth p` form a Galois insertion. | true |
UniformContinuousOn.eq_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] (f : α → β) (s : Set α),
UniformContinuousOn f s =
Filter.Tendsto (fun x => (f x.1, f x.2)) (uniformity α ⊓ Filter.principal (s ×ˢ s)) (uniformity β) | null | true |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.toArray_mkSlice_rci._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | null | false |
TypeVec.const | Mathlib.Data.TypeVec | {β : Type u_1} → β → {n : ℕ} → (α : TypeVec.{u_2} n) → α.Arrow (TypeVec.repeat n β) | `const x α` is an arrow that ignores its source and constructs a `TypeVec` that
contains nothing but `x` | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Digamma.0.Complex.digamma_two_mul._proof_1_3 | Mathlib.Analysis.SpecialFunctions.Gamma.Digamma | ContinuousSMul ℂ ℂ | null | false |
_private.Lean.Compiler.LCNF.Toposort.0.Lean.Compiler.LCNF.toposort.visitConsts._sparseCasesOn_4 | Lean.Compiler.LCNF.Toposort | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive_4 (Lean.Compiler.LCNF.Code.let decl k)) →
(Nat.hasNotBit 1 t.ctorIdx → motive_4 t) → ... | null | false |
IsTopologicalAddGroup.tendstoLocallyUniformlyOn_iff | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : AddGroup G] [u : UniformSpace G]
[inst_1 : IsTopologicalAddGroup G] [inst_2 : TopologicalSpace α] (F : ι → α → G) (f : α → G) (p : Filter ι)
(s : Set α),
IsTopologicalAddGroup.rightUniformSpace G = u →
(TendstoLocallyUniformlyOn F f p s ↔
∀ u_1 ∈ nh... | null | true |
_private.Lean.Meta.Tactic.Injection.0.Lean.Meta.injectionIntro.go._unsafe_rec | Lean.Meta.Tactic.Injection | Bool → ℕ → Lean.MVarId → Array Lean.FVarId → List Lean.Name → Lean.MetaM Lean.Meta.InjectionResult | null | false |
_private.Init.Omega.Constraint.0.Lean.Omega.instAppendString | Init.Omega.Constraint | Append String | null | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.app_inv_app'_assoc | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
(U : TopologicalSpace.Opens ↑Y.toTopCat) (hU : ↑U ⊆ Set.range ⇑(CategoryTheory.ConcreteCategory.hom f.base))
{Z : CommRingCat}
(h :
Y.presheaf.obj
(Opposite.op
((AlgebraicG... | A variant of `app_inv_app` that gives an `eqToHom` instead of `homOfLe`. | true |
MeasureTheory.OuterMeasure.isCaratheodory_sum | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α},
(∀ (i : ℕ), m.IsCaratheodory (s i)) →
Pairwise (Function.onFun Disjoint s) →
∀ {t : Set α} {n : ℕ}, ∑ i ∈ Finset.range n, m (t ∩ s i) = m (t ∩ ⋃ i, ⋃ (_ : i < n), s i) | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.add_univ.match_1_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (hs : s.Nonempty),
(∀ (a : α) (ha : a ∈ s), motive ⋯) → motive hs | null | false |
_private.Mathlib.RingTheory.Ideal.Colon.0.Submodule.mem_colon_iff_le._simp_1_1 | Mathlib.RingTheory.Ideal.Colon | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {p q : A}, (↑p ⊆ ↑q) = (p ≤ q) | null | false |
ProbabilityTheory.BrownianReal.projectiveFamily._proof_1 | Mathlib.Probability.BrownianMotion.GaussianProjectiveFamily | (1 + 1).AtLeastTwo | null | false |
Matrix.transpose_eq_intCast | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddGroupWithOne α] {M : Matrix n n α} {d : ℤ},
M.transpose = ↑d ↔ M = ↑d | null | true |
analyticAt_cexp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {z : ℂ}, AnalyticAt ℂ Complex.exp z | The function `Complex.exp` is complex analytic. | true |
IntermediateField.adjoin_insert_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E) (x : E),
IntermediateField.adjoin F (insert x ↑(IntermediateField.adjoin F S)) = IntermediateField.adjoin F (insert x S) | null | true |
AddConjClasses.mk_eq_mk_iff_isAddConj | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : AddMonoid α] {a b : α}, AddConjClasses.mk a = AddConjClasses.mk b ↔ IsAddConj a b | null | true |
Finset.nsmul_subset_nsmul_right | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α} {m n : ℕ}, 0 ∈ s → m ≤ n → m • s ⊆ n • s | null | true |
CategoryTheory.PrelaxFunctor.mapFunctor_map | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) (a b : B) {X Y : a ⟶ b} (η : X ⟶ Y), (F.mapFunctor a b).map η = F.map₂ η | null | true |
_private.Mathlib.Algebra.Order.Floor.Extended.0.ENat.le_ceil._proof_1_4 | Mathlib.Algebra.Order.Floor.Extended | ∀ (n : ℕ), ¬n = 0 → 1 ≤ n | null | false |
Module.Invertible.linearEquiv.congr_simp | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) (M : Type v) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Invertible R M], Module.Invertible.linearEquiv R M = Module.Invertible.linearEquiv R M | null | true |
CategoryTheory.Functor.Elements.shrinkYoneda_map_app_coconeπOpCompShrinkYonedaObj_ι_app | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
(F : CategoryTheory.Functor C (Type w)) {X₁ X₂ : C} (f : X₁ ⟶ X₂) (u : F.Elements),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shrinkYoneda.{w, v₁, u₁}.map f).app (Opposite.op u.obj))
(Typ... | null | true |
Set.powersetCard.mulActionHom_of_embedding_surjective | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] {n : ℕ} [inst_2 : DecidableEq α],
Function.Surjective ⇑(Set.powersetCard.mulActionHom_of_embedding G α n) | null | true |
Quiver.Path.decidableEqBddPathsOfDecidableEq.match_5 | Mathlib.Combinatorics.Quiver.Path | {V : Type u_1} →
[inst : Quiver V] →
(n : ℕ) →
(v w : V) →
(motive : Quiver.Path.BoundedPaths v w (n + 1) → Sort u_3) →
(x : Quiver.Path.BoundedPaths v w (n + 1)) →
((q : Quiver.Path v w) → (hq : q.length ≤ n + 1) → motive ⟨q, hq⟩) → motive x | null | false |
Manifold.pathELength_eq_lintegral_mfderivWithin_Icc | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : (x : M) → ENorm (TangentSpace I x)] {a b : ℝ} {γ : ℝ → M},
Manifold.pathELength I γ... | null | true |
Lean.Linter.CodeQuality.Source.ctorElim | Lean.Linter.CodeQuality.Basic | {motive : Lean.Linter.CodeQuality.Source → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Linter.CodeQuality.Source) →
ctorIdx = t.ctorIdx → Lean.Linter.CodeQuality.Source.ctorElimType ctorIdx → motive t | null | false |
Mathlib.Tactic.Monoidal.mor₁OfExpr | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Lean.Expr → Mathlib.Tactic.Monoidal.MonoidalM Mathlib.Tactic.BicategoryLike.Mor₁ | Construct a `Mor₁` expression from a Lean expression. | true |
Int.negOfNat_mul_negSucc | Init.Data.Int.Lemmas | ∀ (m n : ℕ), Int.negOfNat n * Int.negSucc m = Int.ofNat (n * m.succ) | null | true |
instBooleanAlgebraAsBoolAlg._proof_12 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (x : AsBoolAlg α), x ⊓ xᶜ ≤ ⊥ | null | false |
List.IsSuffix.eq_of_length | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁.length = l₂.length → l₁ = l₂ | null | true |
CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₃ | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)),
(CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₃ = f.left.hom | null | true |
Lean.PrettyPrinter.Delaborator.appFieldNotationCandidate? | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.DelabM (Option (ℕ × Lean.Name)) | If `e` is an application that is a candidate for using field notation,
returns the parameter index and the field name to use.
Checks that there are enough arguments.
| true |
AlgebraicGeometry.basicOpenIsoSpecAway_inv_homOfLE | Mathlib.AlgebraicGeometry.Restrict | ∀ {R : CommRingCat} (f g x : ↑R) (hx : x = f * g),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.basicOpenIsoSpecAway x).inv
((AlgebraicGeometry.Spec R).homOfLE ⋯) =
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (IsLocalization.Away.awayToAwayRight f g)))
... | null | true |
LinearEquiv.restrictScalars._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {S : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module S M] [inst_4 : Module S M₂] (f : M ≃ₗ[S] M₂),
Function.RightInverse f.invFun (↑f).toFun | null | false |
LinearMap.IsSymmetric.directSumDecomposition._proof_4 | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [hT : Fact T.IsSymmetric],
OrthogonalFamily 𝕜 (fun μ => ↥(Module.End.eigenspace T (↑T 1 μ))) fun μ =>
(Module.End.eigenspace T (↑T 1 μ)).subtypeₗᵢ | null | false |
IsSMulRegular.nat_of_hasUniqueDiv | Mathlib.Algebra.Regular.SMul | ∀ {M : Type u_3} [inst : AddMonoid M] [HasUniqueDiv M] {n : ℕ}, n ≠ 0 → IsSMulRegular M n | null | true |
AffineEquiv.ofEq._proof_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_2} {V₁ : Type u_3} {P₁ : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (S₁ S₂ : AffineSubspace k P₁) [inst_4 : Nonempty ↥S₁] [inst_5 : Nonempty ↥S₂] (h : S₁ = S₂)
(x : ↥S₁) (x_1 : ↥S₁.direction),
(Set.equivOfEq ⋯) (x_1 +ᵥ x) = (LinearEquiv.ofE... | null | false |
IsLUB.mul_right | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {a b : α} [IsStrictOrderedRing α]
{s : Set α}, 0 ≤ a → IsLUB s b → IsLUB ((fun b => b * a) '' s) (b * a) | null | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.hasSum_sq_mul_geometric_of_norm_lt_one'._abel_1_1 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {R : Type u_1} [inst : NormedRing R] {r : R},
r * (Ring.inverse (1 + -r) * (Ring.inverse (1 + -r) * Ring.inverse (1 + -r))) +
r * (r * (Ring.inverse (1 + -r) * (Ring.inverse (1 + -r) * Ring.inverse (1 + -r)))) =
r * (Ring.inverse (1 + -r) * (Ring.inverse (1 + -r) * Ring.inverse (1 + -r))) +
-(r * ... | null | false |
AffineSubspace.mk.inj | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} {inst : Ring k} {inst_1 : AddCommGroup V} {inst_2 : Module k V}
{inst_3 : AddTorsor V P} {carrier : Set P}
{smul_vsub_vadd_mem' :
∀ (c : k) {p₁ p₂ p₃ : P}, p₁ ∈ carrier → p₂ ∈ carrier → p₃ ∈ carrier → c • (p₁ -ᵥ p₂) +ᵥ p₃ ∈ carrier}
{carrier_1 : Set P}
{smul_vs... | null | true |
SimpleGraph.girth_le_two_mul_ediam_add_one | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α}, ↑G.girth ≤ 2 * G.ediam + 1 | null | true |
Subtype.coe_inj | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, ↑a = ↑b ↔ a = b | null | true |
CFC.eq_one_of_spectrum_subset_one._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.