name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSimpa?__1_1 | Init.Tactics | Lean.Macro | null | false |
Frm.Hom.recOn | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | null | false |
Polynomial.one_le_cauchyBound._simp_1 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (p : Polynomial K), (1 ≤ p.cauchyBound) = True | null | false |
FormalMultilinearSeries.ofScalars_radius_eq_inv_of_tendsto_ENNReal | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing E] [inst_2 : NormedAlgebra 𝕜 E]
(c : ℕ → 𝕜) [NormOneClass E] {r : ENNReal},
Filter.Tendsto (fun n => ENNReal.ofReal ‖c n.succ‖ / ENNReal.ofReal ‖c n‖) Filter.atTop (nhds r) →
(FormalMultilinearSeries.ofScalars E c).radiu... | This theorem combines the results of the special cases above, using `ENNReal` division to remove
the requirement that the ratio is eventually non-zero. | true |
CategoryTheory.Limits.pushout.instIsIsoCodiagonalOfEpi | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f] [CategoryTheory.Epi f],
CategoryTheory.IsIso (CategoryTheory.Limits.pushout.codiagonal f) | null | true |
Std.ExtTreeMap.getKey!_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α}, cmp k k' = Ordering.eq → t.getKey! k = t.getKey! k' | null | true |
Algebra.QuasiFiniteAt.of_isOpen_singleton_fiber | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S] (q : PrimeSpectrum S), IsOpen {⟨q, ⋯⟩} → Algebra.QuasiFiniteAt R q.asIdeal | null | true |
Membership.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → {γ : Type v} → Membership α γ → {α' : Type u} → {γ' : Type v} → Membership α' γ' → Sort u_1 | null | false |
LinearIsometryEquiv.instEquivLike._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_3} {E₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.prod_one_div_prime_den_coprime._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.SmallConstruction.Witness.restrict | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{ι : C → Type w} →
{X Y : C} →
(X ⟶ Y) →
CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι Y →
CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι X | null | true |
HahnSeries.SummableFamily.instModule._proof_10 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_4} {R : Type u_2} {V : Type u_5} {α : Type u_3} [inst : AddCommMonoid Γ]
[inst_1 : PartialOrder Γ] [inst_2 : PartialOrder Γ'] [inst_3 : AddAction Γ Γ'] [inst_4 : IsOrderedCancelVAdd Γ Γ']
[inst_5 : Semiring R] [inst_6 : AddCommMonoid V] [inst_7 : Module R V] (x : HahnSeries Γ R)
(x_1... | null | false |
SSet.relativeCellComplexOfMono_F | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) [inst : CategoryTheory.Mono i],
(SSet.relativeCellComplexOfMono i).F = ⋯.functor.comp SSet.Subcomplex.toSSetFunctor | null | true |
CategoryTheory.ShortComplex.Homotopy.sub | 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₂} →
CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ →
CategoryTheory.ShortComplex.Homotopy φ₃ φ₄ → CategoryTheor... | Homotopy between morphisms of short complexes is compatible with subtraction. | true |
Batteries.CodeAction.TacticCodeActionEntry.mk.inj | Batteries.CodeAction.Attr | ∀ {declName : Lean.Name} {tacticKinds : Array Lean.Name} {declName_1 : Lean.Name} {tacticKinds_1 : Array Lean.Name},
{ declName := declName, tacticKinds := tacticKinds } = { declName := declName_1, tacticKinds := tacticKinds_1 } →
declName = declName_1 ∧ tacticKinds = tacticKinds_1 | null | true |
Bipointed.toProd | Mathlib.CategoryTheory.Category.Bipointed | (self : Bipointed) → self.X × self.X | The two points of a bipointed type, bundled together as a pair. | true |
String.Pos.Raw.offsetOfPos | Init.Data.String.Basic | String → String.Pos.Raw → ℕ | Returns the character index that corresponds to the provided position (i.e. UTF-8 byte index) in a
string.
If the position is at the end of the string, then the string's length in characters is returned. If
the position is invalid due to pointing at the middle of a UTF-8 byte sequence, then the character
index of the ... | true |
CategoryTheory.Limits.limitCompCoyonedaIsoCone._proof_2 | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor J C) (X : C),
CategoryTheory.Limits.HasLimit (F.comp (CategoryTheory.coyoneda.obj (Opposite.op X))) | null | false |
Mathlib.Tactic.IntervalCases.Methods.roundDown | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given `a, b, b', p` where `p` proves `a ≱ b` and `b' := b-1`, prove `a ≤ b'`. | true |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocsExt.match_3 | Lean.Linter.MissingDocs | (motive : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler) →
((n k : Lean.Name) → (h : Lean.Linter.MissingDocs.Handler) → motive (n, k, h)) → motive x | null | false |
CentroidHom.applyModule._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), f 0 = 0 | null | false |
Finset.min'_eq_sorted_zero | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {h : s.Nonempty}, s.min' h = (s.sort fun a b => a ≤ b)[0] | null | true |
SheafOfModules.Presentation.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCo... | null | false |
SubmodulesRingBasis.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
{B : ι → Submodule R A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (a : A) (i : ι), ∃ j, a • B j ≤ B i) → (∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) → SubmodulesRingBasis B | null | false |
instFieldCyclotomicField._proof_64 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K], 0⁻¹ = 0 | null | false |
RingCon.coe_zsmul._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (z : ℤ) (x : R), z • ↑x = ↑(z • x) | null | false |
Function.update_comp_eq_of_forall_ne' | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α}
(a : β i), (∀ (x : α'), f x ≠ i) → (fun j => Function.update g i a (f j)) = fun j => g (f j) | null | true |
String.Slice.Pos.get_skipWhile_char_ne | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos} {h : pos.skipWhile c ≠ s.endPos}, (pos.skipWhile c).get h ≠ c | null | true |
Module.Finite.exists_fin_quot_equiv | Mathlib.RingTheory.Finiteness.Cardinality | ∀ (R : Type u_3) (M : Type u_4) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
∃ n S, Nonempty (((Fin n → R) ⧸ S) ≃ₗ[R] M) | A finite module can be realised as a quotient of `Fin n → R` (i.e. `R^n`). | true |
_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 |
RelSeries.last_drop | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length + 1)), (p.drop i).last = p.last | null | true |
CategoryTheory.MorphismProperty.Arrow.isoMk_inv_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q W : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] [inst_3 : Q.RespectsIso] [inst_4 : W.RespectsIso]
{A B : P.Arrow Q W} (f : A.left ≅ B.left) (g : A.right ≅ B.right)
(w :
autoParam (CategoryThe... | null | true |
Function.locallyFinsuppWithin.addSubgroup._proof_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] (U : Set X) {Y : Type u_2} [inst_1 : AddGroup Y] {f : X → Y},
f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} →
-f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} | 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 |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
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.Lean.Server.CodeActions.Basic.0.Lean.Server.handleCodeActionResolve.match_3 | Lean.Server.CodeActions.Basic | (motive : Option (IO Lean.Lsp.CodeAction) → Sort u_1) →
(x : Option (IO Lean.Lsp.CodeAction)) →
((lazy : IO Lean.Lsp.CodeAction) → motive (some lazy)) →
((x : Option (IO Lean.Lsp.CodeAction)) → motive x) → motive x | null | false |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn._regBuiltin._private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn.docString_1._@.Lean.Meta.Constructions.CtorElim.299025572._hygCtx._hyg.2 | Lean.Meta.Constructions.CtorElim | IO Unit | 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 |
Lean.Syntax.TSepArray.mk | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → {sep : String} → Array Lean.Syntax → Lean.Syntax.TSepArray ks sep | null | true |
Lean.Int.mkInstHPow | Lean.Expr | Lean.Expr | null | true |
normalize_eq_zero._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [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 |
ContMDiffSection.toFun | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
... | the underlying function of this section | true |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.hsum._simp_1 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | null | false |
Finsupp.mapRange.equiv._proof_2 | Mathlib.Data.Finsupp.Defs | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : Zero N] (e : M ≃ N) (hf : e 0 = 0)
(x : ι →₀ M), Finsupp.mapRange ⇑e.symm ⋯ (Finsupp.mapRange (⇑e) hf x) = x | null | false |
WithTop.instMulZeroOneClass._proof_2 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] [Nontrivial α] (x : WithTop α), x * 1 = x | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_324 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
2 ≤ List.count w [a, g a, g (g a)] →
¬[g a, g (g a)].Nodup →
∀ (w_1 : α) (h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] ... | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.MorL | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Month.Ordinal | null | true |
Std.TreeMap.getKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α}
{v : β} {h₁ : a ∈ t.insert k v}, (t.insert k v).getKey a h₁ = if h₂ : cmp k a = Ordering.eq then k else t.getKey a ⋯ | 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 |
alternatingGroup.normal_subgroup_eq_bot_or_eq_top_of_card_ne_six | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
5 ≤ Nat.card α → Nat.card α ≠ 6 → ∀ {N : Subgroup ↥(alternatingGroup α)} [N.Normal], N = ⊥ ∨ N = ⊤ | If `α` has at least 5 elements, but not 6,
then the only nontrivial normal subgroup of `alternatingGroup α`
is `⊤`. | true |
Equiv.setCongr | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {s t : Set α} → s = t → ↑s ≃ ↑t | The subtypes corresponding to equal sets are equivalent. | 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 |
Submodule.toLocalized' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
(S : Type u_2) →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | The localization map of a submodule. | true |
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 |
le_sup_iff._simp_3 | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | null | false |
SimpleGraph.neighborFinset_nonempty._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)],
(G.neighborFinset v).Nonempty = ¬G.IsIsolated v | null | false |
isGLB_ciInf_set | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → s.Nonempty → IsGLB (f '' s) (⨅ i, f ↑i) | null | true |
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 |
Fin.one_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n], 1 = 0 ↔ n = 1 | null | true |
Finset.attach_empty | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1}, ∅.attach = ∅ | 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 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.filter_equiv_self_iff._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
Finset.exists_subsuperset_card_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s t : Finset α} {n : ℕ}, s ⊆ t → s.card ≤ n → n ≤ t.card → ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.card = n | Given a subset `s` of a set `t`, of sizes at most and at least `n` respectively, there exists a
set `u` of size `n` which is both a superset of `s` and a subset of `t`. | true |
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.Mathlib.Data.Set.Lattice.0.Set.pi_sdiff_pi_subset._simp_1_3 | Mathlib.Data.Set.Lattice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
SheafOfModules.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{P : Sort u_1} →
{val : PresheafOfModules R.obj} →
{isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf} →
{val'... | null | false |
Orientation.rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)), o.rotation ↑(Real.pi / 2) = o.rightAngleRotation | Rotation by π / 2 is the "right-angle-rotation" map `J`. | true |
MeasureTheory.Measure.isAddLeftInvariant_eq_smul_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLe... | null | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ring.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) →
t.ctorIdx = 2 →
((c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr) →
(lhs : Lean.Meta.Grind.Arith.Linear.LinExpr) →
motive_4 (Lean.Meta.Grind.Arith.Linear.IneqCnstrPro... | null | false |
LaurentPolynomial.trunc | Mathlib.Algebra.Polynomial.Laurent | {R : Type u_1} → [inst : Semiring R] → LaurentPolynomial R →+ Polynomial R | `trunc : R[T;T⁻¹] →+ R[X]` maps a Laurent polynomial `f` to the polynomial whose terms of
nonnegative degree coincide with the ones of `f`. The terms of negative degree of `f` "vanish".
`trunc` is a left-inverse to `Polynomial.toLaurent`. | true |
String.posGE_eq_posGE_toSlice | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} (h : p ≤ s.rawEndPos), s.posGE p h = String.Pos.ofToSlice (s.toSlice.posGE p ⋯) | null | true |
CategoryTheory.Oplax.OplaxTrans.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Hom η θ} →
{B' : Type u₁} ... | null | false |
RingCon.instNonAssocCommRingQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : NonAssocCommRing R] → (c : RingCon R) → NonAssocCommRing c.Quotient | null | true |
_private.Mathlib.Order.Filter.FilterProduct.0.Filter.Germ.coe_lt._simp_1_4 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {f : Ultrafilter α} {p : α → Prop}, (∀ᶠ (x : α) in ↑f, ¬p x) = ¬∀ᶠ (x : α) in ↑f, p x | null | false |
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 |
CategoryTheory.mateEquiv_conjugateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : Ca... | The mates equivalence commutes with this composition, essentially by `mateEquiv_vcomp`. | true |
NumberField.mixedEmbedding.unitSMul_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ) (x : NumberField.mixedEmbedding.mixedSpace K),
u • x = (NumberField.mixedEmbedding K) ((algebraMap (NumberField.RingOfIntegers K) K) ↑u) * x | null | 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 |
BitVec.smod_eq | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w),
x.smod y =
match x.msb, y.msb with
| false, false => x.umod y
| false, true =>
have u := x.umod (-y);
if u = 0#w then u else u + y
| true, false =>
have u := (-x).umod y;
if u = 0#w then u else y - u
| true, true => -(-x).umod (-y) | Equation theorem for `smod` in terms of `umod`. | true |
List.reverseAux_reverseAux_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {as bs : List α}, (as.reverseAux bs).reverseAux [] = bs.reverseAux as | null | true |
spectrum.subset_subalgebra | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubringClass S A] [inst_5 : SMulMemClass S R A] {s : S} (a : ↥s),
spectrum R ↑a ⊆ spectrum R a | 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 |
IsPrimitiveRoot.isIntegral | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K}, IsPrimitiveRoot μ n → 0 < n → IsIntegral ℤ μ | `μ` is integral over `ℤ`. | true |
Equiv.nonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β], e (e.symm 0) = 0 | null | false |
QPF.fixToW._proof_1 | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u_1 → Type u_1} [q : QPF F] (x y : (QPF.P F).W),
QPF.Wequiv x y → QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) x = QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) y | null | false |
FiberBundleCore.localTrivAsPartialEquiv_target | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι), (Z.localTrivAsPartialEquiv i).target = (Z.localTriv i).target | null | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Constructions.0.contMDiffWithinAt_pi_space._simp_1_4 | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
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 |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.cocone_nonempty._simp_1_4 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.