name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SetRel.isSymm_inv_comp | Mathlib.Basic.Rel | ∀ {α : Type u_1} {R : SetRel α α}, (R.inv.comp R).IsSymm | null | true |
Matrix.single_mul_apply_of_ne | Mathlib.Data.Matrix.Basis | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq l] [inst_1 : DecidableEq m]
[inst_2 : Fintype m] [inst_3 : NonUnitalNonAssocSemiring α] (c : α) (i : l) (j : m) (a : l) (b : n),
a ≠ i → ∀ (M : Matrix m n α), (Matrix.single i j c * M) a b = 0 | null | true |
Std.HashSet.get!_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∉ m₁ → (m₁ \ m₂).get! k = default | null | true |
Finset.weightedVSubOfPoint_subtype_eq_filter | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P) (b : P) (pred : ι → Prop)
[inst_3 : DecidablePred pred],
(((Finset.subtype pred s).weightedVSubOfPoint (fun i => p ↑i) b) fun i =... | A weighted sum over `s.subtype pred` equals one over `{x ∈ s | pred x}`. | true |
Algebra.WeaklyEtale.recOn | Mathlib.RingTheory.Etale.Weakly | {R : Type u_3} →
{S : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{motive : Algebra.WeaklyEtale R S → Sort u} →
(t : Algebra.WeaklyEtale R S) →
((flat : Module.Flat R S) → (flat_lmul' : (Algebra.TensorProduct.lmul' R).Flat) →... | null | false |
_private.Mathlib.Basic.Rel.0.SetRel.cod_eq_empty_iff._simp_1_3 | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Lean.Lsp.CompletionItem.label | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItem → String | null | true |
AddConstMapClass.map_fract | Mathlib.Algebra.AddConstMap.Basic | ∀ {F : Type u_1} {H : Type u_3} {b : H} {R : Type u_4} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R]
[inst_3 : AddGroup H] [inst_4 : FunLike F R H] [AddConstMapClass F R H 1 b] (f : F) (x : R),
f (Int.fract x) = f x - ⌊x⌋ • b | null | true |
_private.Mathlib.FieldTheory.RatFunc.Degree.0.RatFunc.intDegree_mul._simp_1_2 | Mathlib.FieldTheory.RatFunc.Degree | ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c d : G}, (a - b = c - d) = (a + d = c + b) | null | false |
IsSelfAdjoint.map' | Mathlib.Algebra.Order.Star.Basic | ∀ {F : Type u_6} {E : Type u_7} {R : Type u_8} [inst : AddCommGroup E] [inst_1 : PartialOrder E]
[inst_2 : StarAddMonoid E] [inst_3 : NonUnitalRing R] [inst_4 : PartialOrder R] [inst_5 : StarRing R]
[StarOrderedRing R] [SelfAdjointDecompose E] [inst_8 : FunLike F E R] [OrderHomClass F E R] [AddMonoidHomClass F E R]... | While `IsSelfAdjoint.map` assumes the map is star-preserving, this lemma instead assumes the
map is an order-preserving additive map from a space where self-adjoint elements can be expressed as
differences of nonnegative elements, and whose codomain is a star-ordered ring. When such maps are
linear over `ℂ`, they are a... | true |
Complex.norm_eqOn_of_isPreconnected_of_isMaxOn | Mathlib.Analysis.Complex.AbsMax | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {F : Type v} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] {f : E → F} {U : Set E} {c : E},
IsPreconnected U →
IsOpen U → DifferentiableOn ℂ f U → c ∈ U → IsMaxOn (norm ∘ f) U c → Set.EqOn (norm ∘ f) (Function.const E ‖f c‖) U | **Maximum modulus principle** on a connected set. Let `U` be a (pre)connected open set in a
complex normed space. Let `f : E → F` be a function that is complex differentiable on `U`. Suppose
that `‖f x‖` takes its maximum value on `U` at `c ∈ U`. Then `‖f x‖ = ‖f c‖` for all `x ∈ U`. | true |
Preorder.ofStd._proof_2 | Mathlib.Order.Std | ∀ (α : Type u_1) (args : Preorder.OfStdArgs α) (a b c : α), a ≤ b → b ≤ c → a ≤ c | null | false |
Matrix.blockDiag'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_11} [inst : Zero α], Matrix.blockDiag' 0 = 0 | null | true |
CategoryTheory.IsPushout.of_forall_isPushout_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F₁ F₂ F₃ F₄ : CategoryTheory.Functor C D} {f₁ : F₁ ⟶ F₂} {f₂ : F₁ ⟶ F₃} {f₃ : F₂ ⟶ F₄} {f₄ : F₃ ⟶ F₄},
(∀ (X : C), CategoryTheory.IsPushout (f₁.app X) (f₂.app X) (f₃.app X) (f₄.app X)) →
Cate... | null | true |
_private.Batteries.Data.Int.0.Int.testBit_ofBits_ge._proof_1_5 | Batteries.Data.Int | ∀ {n : ℕ} {i : ℕ} {f : Fin n → Bool}, Nat.ofBits f < 2 ^ n → ¬2 ^ n - Nat.ofBits f - 1 < 2 ^ n → False | null | false |
Finset.pairwise_sort._simp_1 | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} (s : Finset α) (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r]
[inst_2 : Std.Antisymm r] [inst_3 : Std.Total r], List.Pairwise r (s.sort r) = True | null | false |
extDerivWithin | Mathlib.Analysis.Calculus.DifferentialForm.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] → {n : ℕ} → (E → E [⋀^Fin n]→L[𝕜] F) → Set E → ... | Exterior derivative of a differential form within a set.
There are a few competing definitions of the exterior derivative of a differential form
that differ from each other by a normalization factor.
We use the following one:
$$
dω(x; v_0, \dots, v_n) = \sum_{i=0}^n (-1)^i D_x ω(x; v_0, \dots, \widehat{v_i}, \dots, v... | true |
star_left_conjugate_pos | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a : R}, 0 < a → ∀ {c : R}, IsRegular c → 0 < star c * a * c | null | true |
_private.Init.Data.String.PosRaw.0.String.Pos.Raw.lt_of_le_of_lt._simp_1_2 | Init.Data.String.PosRaw | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
FreeAlgebra.instNontrivial | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [Nontrivial R], Nontrivial (FreeAlgebra R X) | `FreeAlgebra R X` is nontrivial when `R` is. | true |
BoolAlg.ofHom_comp | Mathlib.Order.Category.BoolAlg | ∀ {X Y Z : Type u} [inst : BooleanAlgebra X] [inst_1 : BooleanAlgebra Y] [inst_2 : BooleanAlgebra Z]
(f : BoundedLatticeHom X Y) (g : BoundedLatticeHom Y Z),
BoolAlg.ofHom (g.comp f) = CategoryTheory.CategoryStruct.comp (BoolAlg.ofHom f) (BoolAlg.ofHom g) | null | true |
_private.Mathlib.MeasureTheory.SpecificCodomains.WithLp.0.MeasureTheory.integrable_prodLp_iff._simp_1_1 | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε}, MeasureTheory.Integrable f μ = MeasureTheory.MemLp f 1 μ | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (r : Std.DTreeMap.Internal.Impl α β),
r.size = Std.DTreeMap.Internal.Impl.leaf.size + r.size | null | false |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.ParentGeChildren.swap_parent._proof_1_21 | Batteries.Data.BinaryHeap.WF | ∀ {α : Type u_1} {sz : ℕ} [inst : Ord α] [Std.TransOrd α] {a : Vector α sz} {i : Fin sz},
(compare a[i] a[(↑i - 1) / 2]).isGE = true →
∀ (hside : 2 * ↑⟨(↑i - 1) / 2, ⋯⟩ + 1 + 1 < sz),
((↑i - 1) / 2 ≠ ↑i →
∀ (hpos : 0 < (↑i - 1) / 2), (compare a[((↑i - 1) / 2 - 1) / 2] a[(↑i - 1) / 2]).isGE = true)... | null | false |
Lean.Syntax.StrLit | Init.Meta.Defs | Type | Syntax that represents a string literal.
| true |
NNRat.coe_indicator._simp_1 | Mathlib.Data.NNRat.Lemmas | ∀ {α : Type u_1} (s : Set α) (f : α → ℚ≥0) (a : α), s.indicator (fun x => ↑(f x)) a = ↑(s.indicator f a) | null | false |
Stream'.WSeq.indexesOf | Mathlib.Data.WSeq.Defs | {α : Type u} → [DecidableEq α] → α → Stream'.WSeq α → Stream'.WSeq ℕ | Get the indexes of occurrences of `a` in `s` | true |
TannakaDuality.FiniteGroup.mulRepHom._proof_2 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k], SMulCommClass k (G → k) (G → k) | null | false |
UniformConvergenceCLM.uniformSpace_eq | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGr... | null | true |
FDRep.forget₂HomLinearEquiv._proof_9 | Mathlib.RepresentationTheory.FDRep | ∀ {R : Type u_1} {G : Type u_2} [inst : CommRing R] [inst_1 : Monoid G] (X Y : FDRep R G) (x : R)
(x_1 :
(CategoryTheory.forget₂ (FDRep R G) (Rep.{u_1, u_1, u_2} R G)).obj X ⟶
(CategoryTheory.forget₂ (FDRep R G) (Rep.{u_1, u_1, u_2} R G)).obj Y),
{ hom := CategoryTheory.InducedCategory.homMk (ModuleCat.of... | null | false |
StandardBorelSpace.instMeasurableEq | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [StandardBorelSpace α], MeasurableEq α | null | true |
DiffeologicalSpace.le_iff | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {d₁ d₂ : DiffeologicalSpace X},
d₁ ≤ d₂ ↔ ∀ (n : ℕ), DiffeologicalSpace.plots n ⊆ DiffeologicalSpace.plots n | null | true |
_private.Batteries.Lean.LawfulMonadLift.0.EIO.toBaseIO.match_1.splitter | Batteries.Lean.LawfulMonadLift | {ε α : Type} →
(motive : EST.Out ε IO.RealWorld α → Sort u_1) →
(x : EST.Out ε IO.RealWorld α) →
((a : α) → (s : Void IO.RealWorld) → motive (EST.Out.ok a s)) →
((ex : ε) → (s : Void IO.RealWorld) → motive (EST.Out.error ex s)) → motive x | null | true |
CategoryTheory.Limits.HasCountableCoproducts | Mathlib.CategoryTheory.Limits.Shapes.Countable | (C : Type u_1) → [CategoryTheory.Category.{v_1, u_1} C] → Prop | A category has countable coproducts if it has all coproducts indexed by countable types. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_minKey._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
ContDiffOn.continuousOn_iteratedDerivWithin | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {s : Set 𝕜} {n : WithTop ℕ∞} {m : ℕ},
ContDiffOn 𝕜 n f s → ↑m ≤ n → UniqueDiffOn 𝕜 s → ContinuousOn (iteratedDerivWithin m f s) s | On a set with unique derivatives, a `C^n` function has derivatives up to `n` which are
continuous. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.boxProdAssoc._simp_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u} {β : Type v} {x y : α × β}, (x = y) = (x.1 = y.1 ∧ x.2 = y.2) | null | false |
Parser.Attr.rclike_simps_proc | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | Simplification procedure | true |
SemilinearEquivClass.map_smulₛₗ | Mathlib.Algebra.Module.Equiv.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} {inst : Semiring R} {inst_1 : Semiring S}
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} {inst_2 : RingHomInvPair σ σ'} {inst_3 : RingHomInvPair σ' σ}
{M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} {inst_4 : AddCommMonoid M} {inst_5... | Applying a semilinear equivalence `f` over `σ` to `r • x` equals `σ r • f x`. | true |
Lake.ComputeHash.recOn | Lake.Build.Trace | {α : Type u} →
{m : Type → Type v} →
{motive : Lake.ComputeHash α m → Sort u_1} →
(t : Lake.ComputeHash α m) → ((computeHash : α → m Lake.Hash) → motive { computeHash := computeHash }) → motive t | null | false |
Lean.Parser.Term.doLoopInvariant | Lean.Parser.Do | Lean.Parser.Parser | The optional `invariant` clause of a loop, written like a `fun`: the invariant annotates the loop so
`vcgen` reads it from the program, and mutable variables are referenced by name.
On a `for` loop the clause is `invariant pref suff a b c => e`, with `pref` bound to the elements
consumed so far and `suff` to the eleme... | true |
_private.Lean.Compiler.LCNF.Simp.InlineCandidate.0.Lean.Compiler.LCNF.Simp.inlineCandidate?._sparseCasesOn_18 | Lean.Compiler.LCNF.Simp.InlineCandidate | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.DeclValue pu → Sort u} →
(t : Lean.Compiler.LCNF.DeclValue pu) →
((code : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.DeclValue.code code)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.AdjMatrix.0.Matrix.compl_of_one_sub_one._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ (α : Type u_1) (V : Type u_2) [inst : AddGroup α] [inst_1 : One α] [inst_2 : DecidableEq V],
Matrix.of 1 - 1 = SimpleGraph.adjMatrix α (SimpleGraph.completeGraph V) | null | false |
CliffordAlgebra.reverseOp | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {Q : QuadraticForm R M} → CliffordAlgebra Q →ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ | `CliffordAlgebra.reverse` as an `AlgHom` to the opposite algebra | true |
QuotientGroup.quotientKerEquivOfSurjective | Mathlib.GroupTheory.QuotientGroup.Basic | {G : Type u} →
[inst : Group G] → {H : Type v} → [inst_1 : Group H] → (φ : G →* H) → Function.Surjective ⇑φ → G ⧸ φ.ker ≃* H | The canonical isomorphism `G/(ker φ) ≃* H` induced by a surjection `φ : G →* H`.
For a `computable` version, see `QuotientGroup.quotientKerEquivOfRightInverse`.
| true |
IsContinuousRiemannianBundle | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_1} →
[inst : TopologicalSpace B] →
(F : Type u_2) →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ F] →
(E : B → Type u_3) →
[inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_4 : (x : B) → NormedAddCommGroup (E x)] →
... | Consider a real vector bundle in which each fiber is endowed with an inner product.
We say that the bundle is *Riemannian* if the inner product depends continuously on the base point.
This assumption is spelled `IsContinuousRiemannianBundle F E` where `F` is the model fiber,
and `E : B → Type*` is the bundle. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.offset_add_slice._proof_1_3 | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos},
p₀.offset.byteIdx ≤ p₁.offset.byteIdx →
¬p₀.offset.byteIdx + (p₁.offset.byteIdx - p₀.offset.byteIdx) = p₁.offset.byteIdx → False | null | false |
CategoryTheory.Equivalence.instMonoidalInverseTrans._proof_22 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_4} [inst_4 : CategoryTheory.Category.{u_3, u_4} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
Std.RecursiveMutex._sizeOf_inst | Std.Sync.RecursiveMutex | (α : Type) → [SizeOf α] → SizeOf (Std.RecursiveMutex α) | null | false |
Nat.le_step | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n ≤ m → n ≤ m.succ | null | true |
Lean.Expr.ctorIdx | Lean.Expr | Lean.Expr → ℕ | null | false |
QuadraticAlgebra.instCommSemiring._proof_6 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (a_1 : QuadraticAlgebra R a b), a_1 * 1 = a_1 | null | false |
_private.Lean.Meta.Tactic.Assert.0.Lean.MVarId.note.match_1 | Lean.Meta.Tactic.Assert | (motive : Option Lean.Expr → Sort u_1) →
(t? : Option Lean.Expr) → ((t : Lean.Expr) → motive (some t)) → (Unit → motive none) → motive t? | null | false |
UInt32.mod | Init.Data.UInt.Basic | UInt32 → UInt32 → UInt32 | The modulo operator for 32-bit unsigned integers, which computes the remainder when dividing one
integer by another. Usually accessed via the `%` operator.
When the divisor is `0`, the result is the dividend rather than an error.
This function is overridden at runtime with an efficient implementation.
Examples:
* `U... | true |
Polynomial.ofFinsupp_single | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (r : R),
{ toFinsupp := AddMonoidAlgebra.single n r } = (Polynomial.monomial n) r | null | true |
CategoryTheory.ObjectProperty.localEpi_essImage | Mathlib.CategoryTheory.MorphismProperty.LocalEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) [G.Faithful] [G.Full],
G.essImage.localEpi = (CategoryTheory.MorphismProperty.epimorphisms D).inverseImage F | null | true |
Finset.powerset.eq_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} (s : Finset α), s.powerset = { val := Multiset.pmap Finset.mk s.val.powerset ⋯, nodup := ⋯ } | null | true |
JoinedIn | Mathlib.Topology.Connected.PathConnected | {X : Type u_1} → [TopologicalSpace X] → Set X → X → X → Prop | The relation "being joined by a path in `F`". Not quite an equivalence relation since it's not
reflexive for points that do not belong to `F`. | true |
NoZeroDivisors.to_isDomain | Mathlib.Algebra.Ring.Basic | ∀ (α : Type u_3) [inst : Ring α] [h : Nontrivial α] [NoZeroDivisors α], IsDomain α | null | true |
Group.IsPerfect.derivedSeries_eq_top._f | Mathlib.GroupTheory.IsPerfect | ∀ (G : Type u_1) [inst : Group G] [Group.IsPerfect G] (n : ℕ) (f : Nat.below n), derivedSeries G n = ⊤ | null | false |
HasDerivWithinAt.eventually_notMem | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {s : Set 𝕜} {x : 𝕜},
HasDerivWithinAt f f' s x →
f' ≠ 0 → ∀ (t : Set F), ¬AccPt (f x) (Filter.principal t) → ∀ᶠ (z : 𝕜) in nhdsWithin x (s \ {x}), f z ∉ t | null | true |
Mathlib.Tactic.Linarith.Sum.pow._unsafe_rec | Mathlib.Tactic.Linarith.Parsing | Mathlib.Tactic.Linarith.Sum → ℕ → Mathlib.Tactic.Linarith.Sum | null | false |
CategoryTheory.Equivalence.induced._proof_1 | Mathlib.CategoryTheory.EqToHom | ∀ {D : Type u_1} {T : Type u_2} (e : T ≃ D) {X : D}, e (e.symm X) = X | null | false |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.searchPProd._sparseCasesOn_5 | Lean.Elab.PreDefinition.Structural.BRecOn | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Function.iterate_pred_comp_of_pos | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α) {n : ℕ}, 0 < n → f^[n.pred] ∘ f = f^[n] | null | true |
AlgebraicTopology.DoldKan.compatibility_Γ₂N₁_Γ₂N₂_natTrans | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (X : CategoryTheory.SimplicialObject C),
AlgebraicTopology.DoldKan.Γ₂N₁.natTrans.app X =
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Γ₂N... | null | true |
Array.replicate_succ_ne_empty._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α}, (Array.replicate (n + 1) a = #[]) = False | null | false |
AddEquiv.congr_arg | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f : M ≃+ N} {x x' : M}, x = x' → f x = f x' | null | true |
Lean.Meta.Grind.SplitInfo.ctorElimType | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SplitInfo → Sort u} → ℕ → Sort (max 1 u) | null | false |
Submodule.sup_orthogonal_of_hasOrthogonalProjection | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [K.HasOrthogonalProjection], K ⊔ Kᗮ = ⊤ | If `K` admits an orthogonal projection, then `K` and `Kᗮ` span the whole space. | true |
Lean.Quote.recOn | Init.Meta.Defs | {α : Type} →
{k : Lean.SyntaxNodeKind} →
{motive : Lean.Quote α k → Sort u} →
(t : Lean.Quote α k) → ((quote : α → Lean.TSyntax k) → motive { quote := quote }) → motive t | null | false |
WithZero.instAddMonoid._proof_9 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u_1} [inst : AddSemigroup α] (a : WithZero α), a + 0 = a | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceAbs._regBuiltin.Int.reduceAbs.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1548991167._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
Lean.Grind.CommRing.Poly.mul.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ p₂ : Lean.Grind.CommRing.Poly), p₁.mul p₂ = Lean.Grind.CommRing.Poly.mul.go p₂ p₁ (Lean.Grind.CommRing.Poly.num 0) | null | true |
CategoryTheory.ShortComplex.Hom.comm₁₂_assoc | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (self : S₁.Hom S₂) {Z : C} (h : S₂.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp self.τ₁ (CategoryTheory.CategoryStruct.comp S₂.f h) =
CategoryTheory.CategoryS... | the left commutative square of a morphism in `ShortComplex` | true |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (X : CategoryTheory.Arrow (Type u_1)),
(TypeCat.ofHom fun y =>
⟨(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Arrow.Hom.right (CategoryTheory.CategoryStruct.id X))) ↑y,
⋯⟩) =
CategoryTheory.CategoryStruct.id ↑(Set.range ⇑(TypeCat.Hom.hom X.hom)) | null | false |
CategoryTheory.EnrichedOrdinaryCategory.noConfusionType | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | Sort u_1 →
{V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
CategoryTheory.EnrichedOrdinaryCategory V C →
{V' : Type u'} →
[ins... | null | false |
Std.Iter.toList_flatMap | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α α₂ β γ : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] [inst : Std.Iterator α Id β] [inst_2 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] {f : β → Std.Iter γ} {it₁ : Std.Iter β},
(Std.Iter.flatM... | null | true |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.Const.get?.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Raw α fun x => β) (a : α),
Std.DHashMap.Raw.Const.get? m a =
if h : 0 < m.buckets.size then Std.DHashMap.Internal.Raw₀.Const.get? ⟨m, h⟩ a else none | null | true |
Lean.Compiler.LCNF.FindUsed.Context._sizeOf_1 | Lean.Compiler.LCNF.ReduceArity | Lean.Compiler.LCNF.FindUsed.Context → ℕ | null | false |
CategoryTheory.cosimplicialSimplicialEquiv | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
(CategoryTheory.CosimplicialObject C)ᵒᵖ ≌ CategoryTheory.SimplicialObject Cᵒᵖ | The anti-equivalence between cosimplicial objects and simplicial objects. | true |
AddSubgroup.isComplement'_top_right | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ ↔ H = ⊥ | null | true |
LinearEquiv.coe_toLinearMap | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂), ... | null | true |
CanLift.prf | Mathlib.Tactic.Lift | ∀ {α : Sort u_1} {β : Sort u_2} {coe : outParam (β → α)} {cond : outParam (α → Prop)} [self : CanLift α β coe cond]
(x : α), cond x → ∃ y, coe y = x | An element of `α` that satisfies `cond` belongs to the range of `coe`. | true |
UInt64.recOn._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.282 | Mathlib.Util.CompileInductive | {motive : UInt64 → Sort u} → (t : UInt64) → ((toBitVec : BitVec 64) → motive { toBitVec := toBitVec }) → motive t | null | false |
Mathlib.Tactic.Ring.RatCoeff.casesOn | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{e : Q(«$α»)} →
{motive : Mathlib.Tactic.Ring.RatCoeff e → Sort u} →
(t : Mathlib.Tactic.Ring.RatCoeff e) →
((value : ℚ) → (hyp : Option Lean.Expr) → motive { value := value, hyp := hyp }) → motive t | null | false |
Quaternion.star_mul_self | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), star a * a = ↑(Quaternion.normSq a) | null | true |
Equiv.heytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : HeytingAlgebra β] {x y : α}, e x < e y ↔ e x < e y | null | false |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.createImportedEnvironmentSeq.go._unary._proof_1 | Lean.Meta.LazyDiscrTree | ∀ {α : Type} (stop : ℕ) (tree : Lean.Meta.LazyDiscrTree.PreDiscrTree α),
∀ start < stop,
∀ (tree_1 : Lean.Meta.LazyDiscrTree.PreDiscrTree α),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun tree start => stop - start) ⟨tree_1, start + 1⟩
⟨tree, start⟩ | null | false |
_private.Aesop.Script.Util.0.Aesop.Script.findFirstStep?.match_1 | Aesop.Script.Util | {α β : Type} →
(motive : Option (ℕ × α × β) → Sort u_1) →
(firstStep? : Option (ℕ × α × β)) →
((fst : ℕ) → (fst_1 : α) → (currentFirstStep : β) → motive (some (fst, fst_1, currentFirstStep))) →
((x : Option (ℕ × α × β)) → motive x) → motive firstStep? | null | false |
HomotopicalAlgebra.instWeakEquivalencePCofibrationsTrivialFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
{X Y : C} (f : X ⟶ Y)
(h : (HomotopicalAlgebra.cofibrations C).MapFactorizationData ... | null | true |
Lean.Lsp.LocationLink.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} → {t t' : Lean.Lsp.LocationLink} → t = t' → Lean.Lsp.LocationLink.noConfusionType P t t' | null | false |
AddAction.stabilizerEquivStabilizerOfOrbitRel.eq_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a b : α}
(h : (AddAction.orbitRel G α) a b),
AddAction.stabilizerEquivStabilizerOfOrbitRel h = (AddAction.stabilizerEquivStabilizer ⋯).symm | null | true |
Matrix.transposeRingEquiv_symm_apply | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_2) (α : Type u_8) [inst : AddCommMonoid α] [inst_1 : CommMagma α] [inst_2 : Fintype m]
(a : (Matrix m m α)ᵐᵒᵖ), (Matrix.transposeRingEquiv m α).symm a = (MulOpposite.unop a).transpose | null | true |
WithZero.unzero | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → {x : WithZero α} → x ≠ 0 → α | Deconstruct an `x : WithZero α` to the underlying value in `α`, given a proof that `x ≠ 0`. | true |
Equiv.piEquivPiSubtypeProd._proof_13 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_2} (p : α → Prop) (β : α → Type u_1) [inst : DecidablePred p],
Function.RightInverse (fun f x => if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩) fun f => (fun x => f ↑x, fun x => f ↑x) | null | false |
_private.Mathlib.Order.Cover.0.Prod.mk_covBy_mk_iff_right._simp_1_3 | Mathlib.Order.Cover | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a : α} {b₁ b₂ : β},
((a, b₁) < (a, b₂)) = (b₁ < b₂) | null | false |
Std.DTreeMap.Internal.Const.RoiSliceData.treeMap | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RoiSliceData α β → Std.DTreeMap.Internal.Impl α fun x => β | null | true |
_private.Mathlib.Analysis.Calculus.LogDeriv.0.logDeriv_fun_zpow._simp_1_7 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Init.Data.Array.Lemmas.0.Array.foldrM_start_stop._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {start stop : ℕ}, start ≤ xs.size → stop < start → ¬0 < min start xs.size - stop → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.