name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ZMod.smul_mem | Mathlib.Algebra.Module.ZMod | ∀ {n : ℕ} {M : Type u_1} {S : Type u_4} [inst : AddCommGroup M] [inst_1 : Module (ZMod n) M] [inst_2 : SetLike S M]
[AddSubgroupClass S M] {x : M} {K : S}, x ∈ K → ∀ (c : ZMod n), c • x ∈ K | null | true |
CategoryTheory.skeleton_skeletal | Mathlib.CategoryTheory.Skeletal | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C], CategoryTheory.Skeletal (CategoryTheory.Skeleton C) | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.glue.match_1.splitter | Std.Data.DTreeMap.Internal.Operations | {α : Type u_1} →
{β : α → Type u_2} →
(sz : ℕ) →
(k : α) →
(v : β k) →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot (Std.D... | null | true |
Pi.instNeg.eq_1 | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Neg (G i)], Pi.instNeg = { neg := fun f i => -f i } | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hamiltonian.0.SimpleGraph.Walk.isHamiltonianCycle_isCycle_and_isHamiltonian_tail.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a}
(motive : p.IsHamiltonianCycle → Prop) (x : p.IsHamiltonianCycle),
(∀ (h : p.IsCycle) (h' : p.tail.IsHamiltonian), motive ⋯) → motive x | null | false |
RingHom.compLeft._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {α : Type u_3} {β : Type u_1} [inst : NonAssocSemiring α] [inst_1 : NonAssocSemiring β] (f : α →+* β) (I : Type u_2),
(↑((↑f).compLeft I)).toFun 1 = 1 | null | false |
Function.isFixedPt_piMap._simp_1 | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i},
Function.IsFixedPt (Pi.map f) x = ∀ (i : ι), Function.IsFixedPt (f i) (x i) | null | false |
CategoryTheory.Localization.functor_additive | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
(L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions], L.Ad... | null | true |
Ideal.idealProdEquiv | Mathlib.RingTheory.Ideal.Prod | {R : Type u} → {S : Type v} → [inst : Semiring R] → [inst_1 : Semiring S] → Ideal (R × S) ≃o Ideal R × Ideal S | Ideals of `R × S` are in one-to-one correspondence with pairs of ideals of `R` and ideals of
`S`. | true |
CategoryTheory.Comon.mkIso._auto_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.Syntax | null | false |
BitVec.and_or_distrib_left | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y z : BitVec w}, x &&& (y ||| z) = x &&& y ||| x &&& z | null | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.packingNumber_two_mul_le_externalCoveringNumber._simp_1_3 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.neg_φH | 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₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
(γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂), γ.neg.φH = -γ.φH | null | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.not_nontrivial_singleton.match_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u_1} {x : α} (motive : (∃ y ∈ {x}, y ≠ x) → Prop) (H : ∃ y ∈ {x}, y ≠ x),
(∀ (y : α) (hy : y ∈ {x}) (hya : y ≠ x), motive ⋯) → motive H | null | false |
Matroid.eRk_union_le_encard_add_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ Y) ≤ X.encard + M.eRk Y | null | true |
MeasureTheory.Lp.instModule._proof_4 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (a : 𝕜)
(x y : ↥(MeasureTheory.Lp E p μ)), a • (x + y) = a • x + a • y | null | false |
Int.mem_divisors_self | Mathlib.NumberTheory.Divisors | ∀ {z : ℤ}, z ≠ 0 → z ∈ z.divisors | null | true |
centralBinom_factorization_small | Mathlib.NumberTheory.Bertrand | ∀ (n : ℕ),
2 < n →
(∀ (p : ℕ), Nat.Prime p → n < p → 2 * n < p) →
n.centralBinom = ∏ p ∈ Finset.range (2 * n / 3 + 1), p ^ n.centralBinom.factorization p | A lemma that tells us that, in the case where Bertrand's postulate does not hold, the prime
factorization of the central binomial coefficient only has factors at most `2 * n / 3 + 1`.
| true |
Lean.Lsp.Ipc.readRequestAs | Lean.Data.Lsp.Ipc | String → (α : Type) → [Lean.FromJson α] → Lean.Lsp.Ipc.IpcM (Lean.JsonRpc.Request α) | null | true |
CategoryTheory.Oplax.StrongTrans.homCategory._proof_6 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {W X Y Z : F ⟶ G} (f : CategoryTheory.Oplax.StrongTrans.Hom W X)
(g : CategoryTheory.Oplax.StrongTrans.Hom X Y) (h : CategoryTheory.Oplax.StrongTrans.Hom Y Z),
{ as :... | null | false |
StarMonoidHom.instFunLike._proof_2 | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_1} {B : Type u_2} [inst : Monoid A] [inst_1 : Star A] [inst_2 : Monoid B] [inst_3 : Star B]
(f g : A →⋆* B), (fun f => (↑f.toMonoidHom).toFun) f = (fun f => (↑f.toMonoidHom).toFun) g → f = g | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorElim | Mathlib.Tactic.TacticAnalysis.Declarations | {motive : Mathlib.TacticAnalysis.TerminalReplacementOutcome✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Mathlib.TacticAnalysis.TerminalReplacementOutcome✝) →
ctorIdx = Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorIdx✝ t →
Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorElimType✝ ctorIdx → motiv... | null | false |
CategoryTheory.Endofunctor.Adjunction.Algebra.toCoalgebraOf._proof_1 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(X : CategoryTheory.Endofunctor.Algebra F),
{ f := (CategoryTheory.CategoryStruct.id X).f, h := ⋯ } =
CategoryTheory.CategoryStruct.id { V := X.a, str := (adj.homEquiv X.a X.a).toFun X.str } | null | false |
Std.HashMap.isEmpty_insertMany_list | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{l : List (α × β)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty) | null | true |
Std.DTreeMap.Internal.Impl.ordered_updateCell | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α}
{f : Std.DTreeMap.Internal.Cell α β (compare k) → Std.DTreeMap.Internal.Cell α β (compare k)}
{l : Std.DTreeMap.Internal.Impl α β} (hlb : l.Balanced),
l.Ordered → (Std.DTreeMap.Internal.Impl.updateCell k f l hlb).impl.Ordered | null | true |
Lean.getDelayedMVarRoot | Lean.MetavarContext | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → Lean.MVarId → m Lean.MVarId | Given a sequence of delayed assignments
```
mvarId₁ := fun ... => mvarId₂;
...
mvarIdₙ := fun ... => mvarId_root -- where `mvarId_root` is not delayed assigned
```
in `mctx`, `getDelayedRoot mctx mvarId₁` return `mvarId_root`.
If `mvarId₁` is not delayed assigned then return `mvarId₁` | true |
Ctop.ctorIdx | Mathlib.Data.Analysis.Topology | {α : Type u_1} → {σ : Type u_2} → Ctop α σ → ℕ | null | false |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.Prod.upAddHom.eq_1 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ (G : Type u) (H : Type v) [inst : Add G] [inst_1 : Add H],
Prod.upAddHom✝ G H = { toFun := fun x t => Bool.rec { down := x.1 } { down := x.2 } t, map_add' := ⋯ } | null | true |
StarAlgEquiv.rec | Mathlib.Algebra.Star.StarAlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : Add A] →
[inst_1 : Add B] →
[inst_2 : Mul A] →
[inst_3 : Mul B] →
[inst_4 : SMul R A] →
[inst_5 : SMul R B] →
[inst_6 : Star A] →
[inst_7 : Star B] →
... | null | false |
_private.Mathlib.Algebra.Group.Subgroup.Lattice.0.Subgroup.mem_iSup_of_directed._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {α : Sort u} {p : PLift α → Prop}, (∃ x, p x) = ∃ x, p { down := x } | null | false |
CategoryTheory.MorphismProperty.LeftFraction₂.mk._flat_ctor | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y Y' : C} → (X ⟶ Y') → (X ⟶ Y') → (s : Y ⟶ Y') → W s → W.LeftFraction₂ X Y | null | false |
Group.Presentation.lift_ker_eq_normalClosure | Mathlib.GroupTheory.Presentation | ∀ {G : Type u_3} {ι : Type u_4} [inst : Group G] (self : Group.Presentation G ι),
self.lift.ker = Subgroup.normalClosure self.rel | The kernel of the canonical surjection is equal to the normal closure of the relators. | true |
CategoryTheory.MonoidalClosed.pre | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A B : C} →
[inst_2 : CategoryTheory.Closed A] →
[inst_3 : CategoryTheory.Closed B] → (B ⟶ A) → (CategoryTheory.ihom A ⟶ CategoryTheory.ihom B) | Pre-compose an internal hom with an external hom. | true |
SemidirectProduct.map | Mathlib.GroupTheory.SemidirectProduct | {N₁ : Type u_4} →
{G₁ : Type u_5} →
{N₂ : Type u_6} →
{G₂ : Type u_7} →
[inst : Group N₁] →
[inst_1 : Group G₁] →
[inst_2 : Group N₂] →
[inst_3 : Group G₂] →
{φ₁ : G₁ →* MulAut N₁} →
{φ₂ : G₂ →* MulAut N₂} →
(f... | Define a map from `N₁ ⋊[φ₁] G₁` to `N₂ ⋊[φ₂] G₂` given maps `N₁ →* N₂` and `G₁ →* G₂` that
satisfy a commutativity condition `∀ n g, fn (φ₁ g n) = φ₂ (fg g) (fn n)`. | true |
Std.IsLinearOrder.mk._flat_ctor | Init.Data.Order.Classes | ∀ {α : Type u} [inst : LE α],
(∀ (a : α), a ≤ a) →
(∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c) →
(∀ (a b : α), a ≤ b → b ≤ a → a = b) → (∀ (a b : α), a ≤ b ∨ b ≤ a) → Std.IsLinearOrder α | null | false |
MultipliableLocallyUniformlyOn.multipliable | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {x : β} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
MultipliableLocallyUniformlyOn f s → x ∈ s → Multipliable fun x_1 => f x_1 x | null | true |
_private.Mathlib.Analysis.Convex.Combination.0.convexHull_sub._simp_1_1 | Mathlib.Analysis.Convex.Combination | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), -(convexHull 𝕜) s = (convexHull 𝕜) (-s) | null | false |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_9 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
AdicCompletion.instAlgebra._proof_4 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (I : Ideal R) [inst_2 : Algebra S R],
⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) 1, ⋯⟩ = 1 | null | false |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : ModuleCat R) [inst_1 : CategoryTheory.MonObj A] (r : R) (a : ↑A),
(let __src := ModuleCat.Hom.hom CategoryTheory.MonObj.one;
{ toFun := __src.toFun, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ })
r *
a =
a *
(let __src := Module... | null | false |
Mathlib.Tactic.BicategoryLike.MkAtom₁.ctorIdx | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} → Mathlib.Tactic.BicategoryLike.MkAtom₁ m → ℕ | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_42 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lidx l r : ℕ) (lhs : Std.Tactic.BVDecide.BVExpr l) (rhs : Std.Tactic.BVDecide.BVExpr r) (h : w = l + r),
¬Std.Tactic.BVDecide.BVExpr.var lidx = lhs.append rhs h | null | false |
IsMIntegralCurveOn.continuousWithinAt | Mathlib.Geometry.Manifold.IntegralCurve.Basic | ∀ {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] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {s : Set ℝ} {t₀ : ℝ}, IsMIntegralCurveOn γ v s → t... | null | true |
_private.Mathlib.Order.Filter.Map.0.Set.LeftInvOn.filter_map_Iic._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u} {β : Type v} {s : Set α} {f g : α → β}, (f =ᶠ[Filter.principal s] g) = Set.EqOn f g s | null | false |
LowerHemicontinuous.lowerHemicontinuousWithinAt | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β},
LowerHemicontinuous f → ∀ (s : Set α) (x : α), LowerHemicontinuousWithinAt f s x | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_17 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, a = a' ∧ p a) = p a' | null | false |
ultrafilter_isOpen_basic | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} (s : Set α), IsOpen {u | s ∈ u} | The basic open sets for the topology on ultrafilters are open. | true |
Std.ExtDHashMap.contains_insert | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k}, (m.insert k v).contains a = (k == a || m.contains a) | null | true |
HasDerivAt.cexp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {f : 𝕜 → ℂ} {f' : ℂ} {x : 𝕜},
HasDerivAt f f' x → HasDerivAt (fun x => Complex.exp (f x)) (Complex.exp (f x) * f') x | null | true |
CategoryTheory.SimplicialObject.Homotopy.precomp._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(H : CategoryTheory.SimplicialObject.Homotopy f g) {X' : CategoryTheory.SimplicialObject C} (p : X' ⟶ X) {n : ℕ}
(i : Fin (n + 2)) (j : Fin (n + 1)),
i ≤ j.castSucc →
CategoryTheory.CategoryS... | null | false |
FunLike.addMonoidWithOne._proof_1 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Zero F] [inst_2 : AddMonoidWithOne β]
[IsZeroApply F α β], ⇑0 = 0 | null | false |
CategoryTheory.CostructuredArrow.w_prod_snd_assoc | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C' : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D'] (S : CategoryTheory.Functor C D) (S' : CategoryTheory.Functor C' D')
(... | null | true |
Aesop.Frontend.DBuilderName.instToString.match_1 | Aesop.Frontend.RuleExpr | (motive : Aesop.Frontend.DBuilderName → Sort u_1) →
(x : Aesop.Frontend.DBuilderName) →
((b : Aesop.BuilderName) → motive (Aesop.Frontend.DBuilderName.regular b)) →
(Unit → motive Aesop.Frontend.DBuilderName.default) → motive x | null | false |
Set.restrict_dite | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} [inst : (x : α) → Decidable (x ∈ s)] (f : (a : α) → a ∈ s → β)
(g : (a : α) → a ∉ s → β), (s.domRestrict fun a => if h : a ∈ s then f a h else g a h) = fun a => f ↑a ⋯ | **Alias** of `Set.domRestrict_dite`. | true |
instModuleTensorProductMop | Mathlib.Algebra.Azumaya.Defs | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → Module (TensorProduct R A Aᵐᵒᵖ) A | `A` as a `A ⊗[R] Aᵐᵒᵖ`-module (or equivalently, an `A`-`A` bimodule). | true |
IsPrimitiveRoot.toInteger_cube_eq_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3), hζ.toInteger ^ 3 = 1 | null | true |
Metric.eball_ofReal | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.eball x (ENNReal.ofReal ε) = Metric.ball x ε | Balls defined using the distance or the edistance coincide | true |
AddUnits.ofNSMul.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (x : M) {n : ℕ} (hn : n ≠ 0) (hu : n • x = ↑u),
u.ofNSMul x hn hu = u.leftOfAdd x ((n - 1) • x) ⋯ ⋯ | null | true |
Asymptotics.IsEquivalent.congr_right | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v w : α → β} {l : Filter α},
Asymptotics.IsEquivalent l u v → v =ᶠ[l] w → Asymptotics.IsEquivalent l u w | null | true |
_private.Lean.Environment.0.Lean.AsyncConst._sizeOf_inst | Lean.Environment | SizeOf Lean.AsyncConst✝ | null | false |
_private.Mathlib.LinearAlgebra.FreeModule.ModN.0.ModN.basis._simp_3 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {R : Type u_1} [inst : Zero R] (n : R) [h : NeZero n], (n = 0) = False | null | false |
SetRel.rightDual_leftDual_le_of_le | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_1} {β : Type u_2} (R : SetRel α β) {J J' : Set α},
J' ∈ R.leftFixedPoints → J ⊆ J' → R.rightDual (R.leftDual J) ⊆ J' | null | true |
AlgebraicGeometry.Surjective.instSndScheme | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.Surjective f],
AlgebraicGeometry.Surjective (CategoryTheory.Limits.pullback.snd f g) | null | true |
IntermediateField.Lifts.noConfusion | Mathlib.FieldTheory.Extension | {P : Sort u} →
{F : Type u_1} →
{E : Type u_2} →
{K : Type u_3} →
{inst : Field F} →
{inst_1 : Field E} →
{inst_2 : Field K} →
{inst_3 : Algebra F E} →
{inst_4 : Algebra F K} →
{t : IntermediateField.Lifts F E K} →
... | null | false |
Int16.toInt64_div_of_ne_right | Init.Data.SInt.Lemmas | ∀ (a b : Int16), b ≠ -1 → (a / b).toInt64 = a.toInt64 / b.toInt64 | null | true |
Polynomial.X_sub_C_mul_removeFactor | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K),
f.natDegree ≠ 0 →
(Polynomial.X - Polynomial.C (AdjoinRoot.root f.factor)) * f.removeFactor =
Polynomial.map (AdjoinRoot.of f.factor) f | null | true |
ReprTuple | Init.Data.Repr | Type u → Type u | null | true |
_private.Lean.Meta.CollectFVars.0.Lean.CollectFVars.State.addDependencies.go._sparseCasesOn_1 | Lean.Meta.CollectFVars | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
IsRightContinuous.fun_mul | Mathlib.Topology.Order.Cadlag | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f g : X → Y} [inst_1 : Preorder X]
[inst_2 : TopologicalSpace Y] [inst_3 : Mul Y] [ContinuousMul Y],
IsRightContinuous f → IsRightContinuous g → IsRightContinuous fun i => f i * g i | Eta-expanded form of `IsRightContinuous.mul` | true |
InnerProductSpace.Core.normSq_eq_zero_of_eq_zero | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] {x : F}, x = 0 → InnerProductSpace.Core.normSq x = 0 | null | true |
Order.Ideal.isPrime_iff_mem_or_compl_mem | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : BooleanAlgebra P] {I : Order.Ideal P} [I.IsProper], I.IsPrime ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₂_eq_some_iff_utf8EncodeChar_eq.match_1_1 | Init.Data.String.Decode | ∀ {x y : UInt8} {c : Char}
(motive :
ByteArray.utf8DecodeChar?.parseFirstByte x = ByteArray.utf8DecodeChar?.FirstByte.oneMore ∧
ByteArray.utf8DecodeChar?.assemble₂ x y = some c →
Prop)
(x_1 :
ByteArray.utf8DecodeChar?.parseFirstByte x = ByteArray.utf8DecodeChar?.FirstByte.oneMore ∧
ByteA... | null | false |
Std.toList_roc_eq_toList_rcc_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {lo hi : α} (h : (Std.PRange.succ? lo).isSome = true),
(lo<...=hi).toList = ((Std.PRange.succ? l... | null | true |
InformationTheory.klFun_eq_zero_iff | Mathlib.InformationTheory.KullbackLeibler.KLFun | ∀ {x : ℝ}, 0 ≤ x → (InformationTheory.klFun x = 0 ↔ x = 1) | null | true |
_private.Init.Data.Array.Sort.Lemmas.0.List.mergeSort.match_1.eq_3 | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a b : α) (xs : List α) (le : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match a :: b :: xs, le with
... | null | true |
Finsupp.mapRange_eq_zero._simp_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] {a : α →₀ M} {f : M → N},
Function.Injective f → ∀ (h : f 0 = 0), (Finsupp.mapRange f h a = 0) = (a = 0) | null | false |
_private.Lean.Elab.ConfigEval.Basic.0.Lean.Elab.ConfigEval.ConfigItem.throwInvalidOption.match_1 | Lean.Elab.ConfigEval.Basic | (motive : Option Lean.Name → Sort u_1) →
(structName? : Option Lean.Name) →
((structName : Lean.Name) → motive (some structName)) → ((x : Option Lean.Name) → motive x) → motive structName? | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_some_iff_getKey?_eq_some_and_get?_eq_some._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Con.correspondence | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} → [inst : Mul M] → {c : Con M} → { d // c ≤ d } ≃o Con c.Quotient | Given a congruence relation `c` on a type `M` with a multiplication, the order-preserving
bijection between the set of congruence relations containing `c` and the congruence relations
on the quotient of `M` by `c`. | true |
_private.Mathlib.Data.List.Rotate.0.List.IsRotated.dropLast_tail._simp_1_3 | Mathlib.Data.List.Rotate | ∀ {α : Type u} (L : List α) (hL : L ≠ []), (L.getLast hL :: L.dropLast ~r L) = True | null | false |
NumberField.Units.instFiniteSubtypeUnitsRingOfIntegersMemSubgroupTorsion | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Finite ↥(NumberField.Units.torsion K) | The torsion subgroup is finite. | true |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoo.decEq._proof_2 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a a_1 b : α), ¬a_1 = b → a<...a_1 = a<...b → False | null | false |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.succ_mod_two_eq_zero_iff._proof_1_1 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ}, (m + 1) % 2 = 0 ↔ m % 2 = 1 | null | false |
Finset.wellFoundedOn_bUnion._simp_1 | Mathlib.Order.WellFoundedSet | ∀ {ι : Type u_1} {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α},
(⋃ i ∈ s, f i).WellFoundedOn r = ∀ i ∈ s, (f i).WellFoundedOn r | null | false |
CategoryTheory.Subobject.Classifier._sizeOf_inst | Mathlib.CategoryTheory.Subobject.Classifier.Defs | (C : Type u) → {inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (CategoryTheory.Subobject.Classifier C) | null | false |
_private.Mathlib.Topology.EMetricSpace.VariationOnFromTo.0.variationOnFromTo.eq_left_iff._simp_1_1 | Mathlib.Topology.EMetricSpace.VariationOnFromTo | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a = a + b) = (b = 0) | null | false |
Vector.toArray_scanlM | Batteries.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {n : ℕ} {init : β} [inst : Monad m] [LawfulMonad m]
{f : β → α → m β} {as : Vector α n}, Vector.toArray <$> Vector.scanlM f init as = Array.scanlM f init as.toArray | null | true |
_private.Mathlib.Analysis.Matrix.Spectrum.0.Matrix.IsHermitian.conjStarAlgAut_star_eigenvectorUnitary._simp_1_1 | Mathlib.Analysis.Matrix.Spectrum | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalSemiring α] [inst_1 : Fintype n]
[inst_2 : Fintype o] (v : o → α) (M : Matrix m n α) (N : Matrix n o α), (M * N).mulVec v = M.mulVec (N.mulVec v) | null | false |
Std.HashSet.Raw.getD_insert | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → ∀ {k a fallback : α}, (m.insert k).getD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getD a fallback | null | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.Balanced.del.match_1_6 | Batteries.Recycling.RBTree.WF | ∀ (motive : RBTree.RBColor.black = RBTree.RBColor.red → Prop) (a : RBTree.RBColor.black = RBTree.RBColor.red), motive a | null | false |
CategoryTheory.simplicialToCosimplicialAugmented_map_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y : (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ}
(f : X ⟶ Y),
((CategoryTheory.simplicialToCosimplicialAugmented C).map f).right = CategoryTheory.NatTrans.rightOp f.unop.left | null | true |
IsFractionRing.semilinearEquivOfRingEquiv._proof_4 | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B], RingHomClass (B ≃+* A) B A | null | false |
Real.cos_antiperiodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Function.Antiperiodic Real.cos Real.pi | null | true |
Filter.IsCountablyGenerated.rec | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{f : Filter α} →
{motive : f.IsCountablyGenerated → Sort u} →
((out : ∃ s, s.Countable ∧ f = Filter.generate s) → motive ⋯) → (t : f.IsCountablyGenerated) → motive t | null | false |
CategoryTheory.Limits.IsColimit.uniqueUpToIso._proof_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} C] {F : CategoryTheory.Functor J C}
{s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t),
CategoryTheory.CategoryStruct.com... | null | false |
CategoryTheory.GrothendieckTopology.plusCompIso_inv_eq_plusLift | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.Multicospan... | null | true |
AddHom.le_map_tsub | Mathlib.Algebra.Order.Sub.Unbundled.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Add α] [inst_2 : Sub α] [OrderedSub α]
[inst_4 : Preorder β] [inst_5 : Add β] [inst_6 : Sub β] [OrderedSub β] (f : α →ₙ+ β),
Monotone ⇑f → ∀ (a b : α), f a - f b ≤ f (a - b) | null | true |
Int.sub_modulus_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, a - n ≡ b [ZMOD n] ↔ a ≡ b [ZMOD n] | null | true |
_private.Mathlib.Data.Set.Image.0.Set.forall_subtype_range_iff._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {ι : Sort u_2} {f : ι → α} {p : ↑(Set.range f) → Prop},
(∀ (a : { x // x ∈ Set.range f }), p a) ↔ ∀ (i : ι), p ⟨f i, ⋯⟩ | null | false |
tsum_ite_eq | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
[inst_2 : DecidablePred fun x => x = b] (a : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop],
(∑'[L] (b' : β), if b' = b then a b' else 0) = a b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.