name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown₄.match_1_1 | Mathlib.CategoryTheory.Filtered.Basic | (motive : Fin 0 → Sort u_1) → (a : Fin 0) → motive a | null | false |
Lean.Lsp.TextDocumentEdit.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentEdit → ℕ | null | false |
Vector.instDecidableExistsVectorZero | Init.Data.Vector.Lemmas | {α : Type u_1} → (P : Vector α 0 → Prop) → [Decidable (P #v[])] → Decidable (∃ xs, P xs) | null | true |
AddCommGrpCat.hasColimit_of_small_quot | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J], Small.{w, max u w} (AddCommGrpCat.Colimits.Quot F) → CategoryTheory.Limits.HasColimit F | null | true |
_private.Mathlib.Topology.Inseparable.0.inseparable_prod._simp_1_2 | Mathlib.Topology.Inseparable | ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [f₁.NeBot] [g₁.NeBot],
(f₁ ×ˢ g₁ = f₂ ×ˢ g₂) = (f₁ = f₂ ∧ g₁ = g₂) | null | false |
Subsemigroup.comap_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N), Subsemigroup.comap f ⊤ = ⊤ | null | true |
MeasureTheory.SimpleFunc.instNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocSemiring β],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
_private.Mathlib.RingTheory.Polynomial.Bernstein.0.bernsteinPolynomial.variance._simp_1_2 | Mathlib.RingTheory.Polynomial.Bernstein | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
normalize_eq_zero._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, (normalize x = 0) = (x = 0) | null | false |
CategoryTheory.Functor.mapCoconeWhisker_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C}
{E : Cat... | null | true |
Polynomial.orderOf_root_cyclotomic_dvd | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {n : ℕ} (hpos : 0 < n) {p : ℕ} [inst : Fact (Nat.Prime p)] {a : ℕ}
(hroot : (Polynomial.cyclotomic n (ZMod p)).IsRoot ((Nat.castRingHom (ZMod p)) a)),
orderOf (ZMod.unitOfCoprime a ⋯) ∣ n | If `(a : ℕ)` is a root of `cyclotomic n (ZMod p)`, then the multiplicative order of `a` modulo
`p` divides `n`. | true |
_private.Lean.Elab.Tactic.Rewrite.0.Lean.Elab.Tactic.foldRWRulesSeq._sparseCasesOn_1 | Lean.Elab.Tactic.Rewrite | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Equiv.setCongr | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {β : Type u_4} → α ≃ β → Set α ≃ Set β | If `α` is equivalent to `β`, then `Set α` is equivalent to `Set β`.
See also `Equiv.finsetCongr`. | true |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.instDecidableEqDihedralGroup.decEq.match_1.eq_4 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (motive : DihedralGroup n → DihedralGroup n → Sort u_1) (a b : ZMod n)
(h_1 : (a b : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.r b))
(h_2 : (a a_1 : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.sr a_1))
(h_3 : (a a_1 : ZMod n) → motive (DihedralGroup.sr a) (DihedralGroup.r a_1))
(h_4 ... | null | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Ordinal.0.Ordinal.exists_ord_cof_eq._simp_1_2 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (↑a = ↑b) = (a = b) | null | false |
Nat.getD_toList_ric_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i fallback : ℕ}, n < i → (*...=n).toList.getD i fallback = fallback | null | true |
_private.Mathlib.Topology.UniformSpace.Compact.0.IsClosed.relPreimage_of_isCompact._simp_1_1 | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
SSet.instFiniteObjOppositeSimplexCategoryTensorObj | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ (X Y : SSet) (n : SimplexCategoryᵒᵖ) [Finite (X.obj n)] [Finite (Y.obj n)],
Finite ((CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).obj n) | null | true |
antitone_toDual_comp_iff | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone (⇑OrderDual.toDual ∘ f) ↔ Monotone f | null | true |
MulEquiv.piMultiplicative._proof_2 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {ι : Type u_1} (K : ι → Type u_2),
Function.RightInverse (fun x => Multiplicative.ofAdd fun i => Multiplicative.toAdd (x i)) fun x i =>
Multiplicative.ofAdd (Multiplicative.toAdd x i) | null | false |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Basic.0.Pi.opensMeasurableSpace_of_subsingleton._simp_2 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s = (s ∈ Set.preimage f '' {s | IsOpen s}) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_eq_concat_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ}, ∀ i < w, ¬i < n → ¬i - n < w → False | null | false |
ModelWithCorners.MfldCat.Hom._mkInternal.injEq | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | ∀ {𝕜 : 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} {n : WithTop ℕ∞}
{M N : I.MfldCat n} (hom' hom'_1 : ContMDiffMap I I (↑M) (↑N) n),
({ hom' := hom' } = { hom' ... | null | false |
ContDiffMapSupportedIn._sizeOf_inst | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | (E : Type u_2) →
(F : Type u_3) →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} →
(n : ℕ∞) →
(K : TopologicalSpace.Compacts E) → [SizeOf E] → [SizeOf F] → SizeOf (ContDiffMapSupportedIn E ... | null | false |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₃._sparseCasesOn_3 | Aesop.Util.EqualUpToIds | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → (Nat.hasNotBit 1029 t.ctorIdx → motive t) → ... | null | false |
RingCon.instNonAssocCommRingQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : NonAssocCommRing R] → (c : RingCon R) → NonAssocCommRing c.Quotient | null | true |
Rep.indCoindIso | Mathlib.RepresentationTheory.FiniteIndex | {k : Type u} →
{G : Type v} →
[inst : CommRing k] →
[inst_1 : Group G] →
{S : Subgroup G} →
[DecidableRel ⇑(QuotientGroup.rightRel S)] →
[S.FiniteIndex] →
(A : Rep.{max w u, u, v} k ↥S) → Rep.ind S.subtype A ≅ Rep.coind.{u, v, v, max u w} S.subtype A | Let `S ≤ G` be a finite index subgroup, `g₁, ..., gₙ` a set of right coset representatives of
`S`, and `A` a `k`-linear `S`-representation. This is an isomorphism `Ind_S^G(A) ≅ Coind_S^G(A)`.
The forward map sends `(⟦g ⊗ₜ[k] a⟧, sg) ↦ ρ(s)(a)`, and the inverse sends `f : G → A` to
`∑ᵢ ⟦gᵢ ⊗ₜ[k] f(gᵢ)⟧` for `1 ≤ i ≤ n`.... | true |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.sups_aux | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α},
a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure ↑s ∧ a ∈ upperClosure ↑t | null | true |
List.reverseAux_reverseAux_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {as bs : List α}, (as.reverseAux bs).reverseAux [] = bs.reverseAux as | null | true |
Rep.instAdditiveResFunctor | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u} [inst : Semiring k] {G : Type v1} {H : Type v2} [inst_1 : Monoid G] [inst_2 : Monoid H] (f : H →* G),
(Rep.resFunctor f).Additive | null | true |
ContinuousAt.fun_nsmul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : AddMonoid M]
[ContinuousAdd M] {f : X → M} {x : X}, ContinuousAt f x → ∀ (n : ℕ), ContinuousAt (fun i => n • f i) x | null | true |
Std.TreeSet.size_toArray | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.toArray.size = t.size | null | true |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (e e_1 : Lean.Expr),
(Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1) = (e = e_1) | null | true |
CategoryTheory.eHom_whisker_cancel_inv | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y Y₁ Z : C}
(α : Y ≅ Y₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCat... | null | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.Forall.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → ((Fin x → α) → Prop) → Sort u_1) (P : (Fin 0 → α) → Prop)
(h_1 : (P : (Fin 0 → α) → Prop) → motive 0 P) (h_2 : (n : ℕ) → (P : (Fin (n + 1) → α) → Prop) → motive n.succ P),
(match 0, P with
| 0, P => h_1 P
| n.succ, P => h_2 n P) =
h_1 P | null | true |
CategoryTheory.Abelian.SpectralObject.zero₁_assoc | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ n... | null | true |
Module.Basis.range_extend | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), Set.range ⇑(Module.Basis.extend hs) = hs.extend ⋯ | null | true |
NonUnitalSubsemiring.prodEquiv | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
(s : NonUnitalSubsemiring R) → (t : NonUnitalSubsemiring S) → ↥(s.prod t) ≃+* ↥s × ↥t | Product of non-unital subsemirings is isomorphic to their product as semigroups. | true |
Std.TreeMap.Raw.contains_iff_mem._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {k : α},
(t.contains k = true) = (k ∈ t) | null | false |
Lean.Elab.Command.InductiveElabStep2 | Lean.Elab.MutualInductive | Type | An intermediate step for mutual inductive elaboration. See `InductiveElabDescr`. | true |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.mkUnusedName.loop | Mathlib.Tactic.CategoryTheory.Elementwise | List Lean.Name → Lean.Name → optParam ℕ 0 → Lean.Name | null | true |
GradedAlgHom.mk.injEq | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
Lean.Parser.Module.prelude | Lean.Parser.Module.Syntax | Lean.Parser.Parser | null | true |
AlgebraicGeometry.specOrderIsoPrimeSpectrum_apply | Mathlib.AlgebraicGeometry.Scheme | ∀ (R : CommRingCat) (x : ↥(AlgebraicGeometry.Spec R)),
(AlgebraicGeometry.specOrderIsoPrimeSpectrum R) x = OrderDual.toDual x | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Symmetric.0.Submodule.isSymmetric_projection_iff._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E}, (inner 𝕜 x y = 0) = (inner 𝕜 y x = 0) | null | false |
Array.getElem_toList | Init.Data.Array.Basic | ∀ {α : Type u} {xs : Array α} {i : ℕ} (h : i < xs.toList.length), xs.toList[i] = xs[i] | null | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iter.atIdxSlow?.match_1.eq_2 | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β)
(motive :
(n : ℕ) →
((a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, n⟩ →... | null | true |
Aesop.PatSubstSource.casesOn | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) → motive Aesop.PatSubstSource.target → motive t | null | false |
LieHom.mem_idealRange_iff._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'),
f.IsIdealMorphism → ∀ {y : L'}, (y ∈ f.idealRange) = ∃ x, f x = y | null | false |
MeasureTheory.innerRegular_map_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.InnerRegular] (g : G),
(MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular | The image of an inner regular measure under left addition is again inner regular. | true |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | null | false |
ENat.toENNReal_le_natCast | Mathlib.Basic.Real.ENatENNReal | ∀ {m : ℕ∞} {n : ℕ}, ↑m ≤ ↑n ↔ m ≤ ↑n | null | true |
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.strictLimitsOfShape J ≤ Q.strictLimitsOfShape J | null | true |
List.eraseIdx_modify_of_eq | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i : ℕ) (l : List α), (l.modify i f).eraseIdx i = l.eraseIdx i | null | true |
ULift.ring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Ring R] (n : ℕ) (a : ULift.{u_1, u_2} R), ↑n.succ • a = ↑n • a + a | null | false |
AEMeasurable.cexp | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℂ},
AEMeasurable f μ → AEMeasurable (fun x => Complex.exp (f x)) μ | null | true |
Sym2.hrec._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {motive : Sym2 α → Sort u_2} (f : (a b : α) → motive s(a, b)),
(∀ (a b : α), f a b ≍ f b a) →
∀ (a b : α × α),
Sym2.Rel α a b →
(match a with
| (a, b) => f a b) ≍
match b with
| (a, b) => f a b | null | false |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_2} {D : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))),
(CategoryTheory.MonoidalCateg... | null | false |
Lean.EnvironmentHeader._proof_1 | Lean.Environment | ∀ (modules : Array Lean.EffectiveImport), ∀ idx ∈ [:modules.size], idx < modules.size | null | false |
_private.Init.WFComputable.0.Acc.recC._unary._proof_6 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} (y : (a : α) ×' Acc r a), Acc r y.1 | null | false |
Lean.MonadFileMap.noConfusion | Lean.Data.Position | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadFileMap m} →
{m' : Type → Type} → {t' : Lean.MonadFileMap m'} → m = m' → t ≍ t' → Lean.MonadFileMap.noConfusionType P t t' | null | false |
String.Slice.Subslice.noConfusionType | Init.Data.String.Subslice | Sort u → {s : String.Slice} → s.Subslice → {s' : String.Slice} → s'.Subslice → Sort u | null | false |
Polynomial.aeval.eq_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Polynomial.aeval x = (Polynomial.aevalEquiv R A) x | null | true |
CategoryTheory.JointlyFaithful.map_injective | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
CategoryTheory.JointlyFaithful F → ∀ {X Y : C} {f g : X ⟶ Y}, (∀ (i : I), (F i).map f = (F i).map g) → f = g | null | true |
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Mathlib.Topology.Sheaves.PUnit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : TopCat.Presheaf C ↧PUnit.{u_1 + 1}),
F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥))) | null | true |
CategoryTheory.ShortComplex.homologyMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : S₂.HasHomology],
CategoryTheory.ShortCo... | null | true |
Nat.gcd_mul_left_sub_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, n ≤ m * k → m.gcd (m * k - n) = m.gcd n | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue_filter_not_contains._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | null | false |
Cardinal.add_nat_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), α + ↑n = β + ↑n ↔ α = β | null | true |
TopologicalSpace.OpenNhdsOf.rec | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
[inst : TopologicalSpace α] →
{x : α} →
{motive : TopologicalSpace.OpenNhdsOf x → Sort u} →
((toOpens : TopologicalSpace.Opens α) →
(mem' : x ∈ toOpens.carrier) → motive { toOpens := toOpens, mem' := mem' }) →
(t : TopologicalSpace.OpenNhdsOf x) → motive t | null | false |
ImportGraph.Shake.instOrdNeedsKind | ImportGraph.Shake.Core | Ord ImportGraph.Shake.NeedsKind | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.specializes_iff_of_t1Space._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α}, s ⤳ t = ((∀ x ∈ s, ∃ y ∈ t, x ⤳ y) ∧ t ⊆ closure s) | null | false |
HomologicalComplex.Hom.comm_from | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁.Hom C₂) (i : ι),
CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.ne... | null | true |
StarMonoidHom.coe_one | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} [inst : Monoid A] [inst_1 : Star A], ⇑1 = id | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.finrank.eq_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (s : ↥S),
AlgebraicGeometry.Scheme.Hom.finrank f s =
AlgebraicGeometry.IsAffine.finrank✝
(CategoryTheory.Limits.pullback.snd f (S.affineOpenCover.f (S.affineOpenCover.idx s))) (Exists.choose ⋯) | null | true |
CategoryTheory.Bicategory.leftAdjointSquare.comp_hvcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e f x y z : B} {g₁ : a ⟶ d} {h₁ : b ⟶ e} {k₁ : c ⟶ f}
{g₂ : d ⟶ x} {h₂ : e ⟶ y} {k₂ : f ⟶ z} {l₁ : a ⟶ b} {l₂ : b ⟶ c} {l₃ : d ⟶ e} {l₄ : e ⟶ f} {l₅ : x ⟶ y} {l₆ : y ⟶ z}
(α : CategoryTheory.CategoryStruct.comp g₁ l₃ ⟶ CategoryTheory.CategoryStruct.comp l... | Horizontal and vertical composition of squares commutes. | true |
LieAlgebra.Basis.root_mem_or_mem_neg | Mathlib.Algebra.Lie.Basis.Base | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} {ι : Type u_3} [inst_5 : Fintype ι]
(b : LieAlgebra.Basis ι H) [inst_6 : LieModule.IsTriangularizable K (↥H) L] [inst_7 : LieAlgebra.IsKillin... | null | true |
PowerSeries.derivative_invOf | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] (f : PowerSeries R) [inst_1 : Invertible f],
PowerSeries.derivative ⅟f = -⅟f ^ 2 * PowerSeries.derivative f | null | true |
DerivedCategory.triangleOfSESδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (i : ℤ),
(HomologicalComplex.sc (CochainComplex.mappingCone S.f) i).HasHomology | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.State✝ → Array (Lean.Expr × Lean.Expr) | null | true |
Std.DHashMap.contains_of_contains_insertIfNew' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_of_contains_insertIfNew` that is written to exactly match the proof
obligation in the statement of `get_insertIfNew`. | true |
Perfection.instCommMonoid | Mathlib.RingTheory.Perfection | (M : Type u_1) → [inst : CommMonoid M] → (p : ℕ) → CommMonoid (Perfection M p) | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestRevMatchAt_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat pos₁ pos₂ =
∃ (h : pos₁ ≤ pos₂), String.Slice.Pattern.Model.IsLongestRevMatch pat (pos₂.sliceTo pos₁ h) | null | false |
Finite.equivFinOfCardEq | Mathlib.SetTheory.Cardinal.NatCard | {α : Type u_1} → [Finite α] → {n : ℕ} → Nat.card α = n → α ≃ Fin n | Similar to `Finite.equivFin` but with control over the term used for the cardinality. | true |
NonUnitalSubring.center.instNonUnitalCommRing._proof_11 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (a : ↥(NonUnitalSubring.center R)), 0 * a = 0 | null | false |
WithTop.le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithTop α}, x ≤ ↑a ↔ ∃ b, x = ↑b ∧ b ≤ a | null | true |
IsNowhereDense.closure | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsNowhereDense (closure s) | If a set `s` is nowhere dense, so is its closure. | true |
CategoryTheory.SimplicialObject.Homotopy.h_succ_comp_δ_castSucc_succ_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (j : Fin (n + 1)) {Z : C}
(h : Y.obj (Opposite.op { len := n + 1 }) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.h j.succ) (CategoryTheor... | null | true |
Real.«term√_» | Mathlib.Analysis.Real.Sqrt | Lean.ParserDescr | The square root of a real number. This returns 0 for negative inputs.
This has notation `√x`. Note that `√x⁻¹` is parsed as `√(x⁻¹)`. | true |
UniformSpace.Completion.map_comp | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
[inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
UniformContinuous g →
UniformContinuous f →
UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) | null | true |
MeasureTheory.Measure.join_zero | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.join 0 = 0 | null | true |
Std.Internal.List.getValueCast_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
{h : Std.Internal.List.containsKey a (Std.Internal.List.eraseKey k l) = true} (hl : Std.Internal.List.DistinctKeys l),
Std.Internal.List.getValueCast a (Std.Internal.List.eraseKey k l) h = Std.Internal.List.ge... | null | true |
continuous_cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
Int16.ne_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a < b → a ≠ b | null | true |
Lean.Meta.Try.Collector.OrdSet.rec | Lean.Meta.Tactic.Try.Collect | {α : Type} →
[inst : Hashable α] →
[inst_1 : BEq α] →
{motive : Lean.Meta.Try.Collector.OrdSet α → Sort u} →
((elems : Array α) → (set : Std.HashSet α) → motive { elems := elems, set := set }) →
(t : Lean.Meta.Try.Collector.OrdSet α) → motive t | null | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.isDone | Lean.Meta.Match.SimpH | Lean.Meta.Match.SimpH.M✝ Bool | null | true |
CategoryTheory.Functor.IsCardinalAccessible.recOn | Mathlib.CategoryTheory.Presentable.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.IsCardinalAccessible κ → Sort u} →
... | null | false |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_5 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
IsScalarTower R A (TensorProduct A A A) | null | false |
_private.Lean.Meta.Match.CaseValues.0.Lean.Meta.caseValues.loop._sparseCasesOn_3 | Lean.Meta.Match.CaseValues | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Omega.IntList.0.List.getElem?_zipWith.match_1.splitter | Init.Omega.IntList | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → Option β → Sort u_3) →
(x : Option α) →
(x_1 : Option β) →
((a : α) → (b : β) → motive (some a) (some b)) →
((x : Option α) →
(x_2 : Option β) → (∀ (a : α) (b : β), x = some a → x_2 = some b → False) → motiv... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.