name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.SetTheory.Cardinal.Pigeonhole.0.Cardinal.le_range_of_union_finset_eq_univ._simp_1_1 | Mathlib.SetTheory.Cardinal.Pigeonhole | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Localization.mkHom_surjective | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Function.Surjective ⇑Localization.mkHom | null | true |
MonoidHom.toAdditive._proof_5 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_2} {β : Type u_1} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : Additive α →+ Additive β), f 0 = 0 | null | false |
Nat.RecursiveIn.left | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)}, Nat.RecursiveIn O fun n => ↑(some (Nat.unpair n).1) | null | true |
AddGroupSeminormClass.toSeminormedAddGroup.congr_simp | Mathlib.Analysis.Normed.Order.Hom.Ultra | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f f_1 : F), f = f_1 → AddGroupSeminormClass.toSeminormedAddGroup f = AddGroupSeminormClass.toSeminormedAddGroup f_1 | null | true |
instFinitePresentation | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R], Module.FinitePresentation R R | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {P : Sort u} →
{t t' : Lean.Meta.Simp.Arith.Int.ToLinear.State} →
t = t' → Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusionType P t t' | null | false |
Std.Sat.CNF.entails_add_of_entails_clause | Std.Sat.CNF.Entails | ∀ {α : Type u_1} (f : Std.Sat.CNF α) (c : Std.Sat.CNF.Clause α), f.EntailsClause c → f.Entails (f.add c) | null | true |
Std.TreeSet.get?_eq_some_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k k' : α},
t.get? k = some k' ↔ ∃ (h : k ∈ t), t.get k h = k' | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | null | false |
FirstOrder.Language.LHom.realize_onBoundedFormula | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'}
[inst_1 : L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ} (ψ : L.BoundedFormula α n) {v : α → M}
{xs : Fin n → M}, (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs | null | true |
Submodule.singleton_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (a : A)
(M : Submodule R A), Set.up {a} • M = Submodule.map (LinearMap.mulLeft R a) M | null | true |
intervalIntegral.intervalIntegrable_log'._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b : ℝ}, IntervalIntegrable Real.log MeasureTheory.volume a b = True | null | false |
Lean.Server.FileWorker.SemanticTokensState.recOn | Lean.Server.FileWorker.SemanticHighlighting | {motive : Lean.Server.FileWorker.SemanticTokensState → Sort u} →
(t : Lean.Server.FileWorker.SemanticTokensState) → motive { } → motive t | null | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [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₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.lt_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
(p₀.sliceTo q h ≤ p) = (q ≤ String.Pos.ofSliceTo p) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < w - target.distance % w → idx - (w - target.distance % w) < w | null | false |
Algebra.TensorProduct.basis_apply | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (i : ι),
(Algebra.TensorProduct.basis A b) i = 1 ⊗ₜ[R] b i | null | true |
Finset.surjOn_of_injOn_of_card_le | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (f : α → β),
Set.MapsTo f ↑s ↑t → Set.InjOn f ↑s → t.card ≤ s.card → Set.SurjOn f ↑s ↑t | Given an injective map `f` from a finite set `s` to another finite set `t`, if `t` is no larger
than `s`, then `f` is surjective to `t` when restricted to `s`.
See `Finset.surj_on_of_inj_on_of_card_le` for the version where `f` is a dependent function.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.not_cliqueFree_of_isTuranMaximal._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Std.ExtDTreeMap.getKey!_erase_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, (t.erase k).getKey! k = default | null | true |
CategoryTheory.Bicategory.Adj.Hom₂.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
{τl : α.l ⟶ β.l} {τr : β.r ⟶ α.r}
{conjugateEquiv_τl :
autoParam ((CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) τl = τr)
CategoryTheory.Bicategory.Adj.Hom₂.conjugateEquiv_τl._autoParam}
{τl... | null | true |
CategoryTheory.OplaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.OplaxFunctor B C) | null | false |
List.foldl_nil | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : α}, List.foldl f b [] = b | null | true |
DomMulAct.smul_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : SMul M α] [inst_3 : MeasurableConstSMul M α]
[inst_4 : MeasureTheory.SMulInvariantMeasure M α μ] (c : Mᵈᵐᵃ) (b : β),
c • MeasureTheory.AEEqFun.const α b = MeasureTheory.A... | null | true |
ListSlice.toArray_toList | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, (Std.Slice.toList xs).toArray = Std.Slice.toArray xs | null | true |
CategoryTheory.Abelian.SpectralObject.E._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_projective.match_1_1 | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id) → Prop)
(x : ∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id),
(∀ (_n : ℕ) (_f : (Fin _n → R) ... | null | false |
CategoryTheory.Bicategory.toNatTrans_conjugateEquiv | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C D : CategoryTheory.Cat} {L₁ L₂ : C ⟶ D} {R₁ R₂ : D ⟶ C} (adj₁ : CategoryTheory.Bicategory.Adjunction L₁ R₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction L₂ R₂) (f : L₂ ⟶ L₁),
((CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₂) f).toNatTrans =
(CategoryTheory.conjugateEquiv (CategoryTheory.Adjunction.ofCa... | null | true |
SheafOfModules.Presentation.mapRelations._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {C' : Type u_3} [inst_3 : CategoryTheory.Category.{u_5, u_3} C']
... | null | false |
Con.subgroup._proof_3 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G), c 1 1 | null | false |
Std.Internal.List.getKey?_minKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {fallback : α},
Std.Internal.List.getKey? (Std.Internal.List.minKeyD l fallback) l = some (Std.Internal.List.mi... | null | true |
Subgroup.instMulActionLeftTransversal | Mathlib.GroupTheory.Complement | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
{F : Type u_2} →
[inst_1 : Group F] → [inst_2 : MulAction F G] → [MulAction.QuotientAction F H] → MulAction F H.LeftTransversal | null | true |
CategoryTheory.Limits.createsFiniteColimitsLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C Dᵒᵖ) →
[CategoryTheory.Limits.CreatesFiniteLimits F] → CategoryTheory.Limits.CreatesFiniteColimits F.leftOp | If `F : C ⥤ Dᵒᵖ` creates finite limits, then `F.leftOp : Cᵒᵖ ⥤ D` creates finite
colimits. | true |
Lean.Lsp.CancelParams.mk._flat_ctor | Lean.Data.Lsp.CancelParams | Lean.JsonRpc.RequestID → Lean.Lsp.CancelParams | null | false |
AddHom.srangeRestrict.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Add M] {N : Type u_5} [inst_1 : Add N] (f : M →ₙ+ N),
f.srangeRestrict = f.codRestrict f.srange ⋯ | null | true |
Lean.Grind.AC.Context.noConfusionType | Init.Grind.AC | Sort u_1 → {α : Sort u} → Lean.Grind.AC.Context α → {α' : Sort u} → Lean.Grind.AC.Context α' → Sort u_1 | null | false |
Decidable.and_iff_not_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a] [Decidable b], a ∧ b ↔ ¬(¬a ∨ ¬b) | null | true |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → {s : String.Slice} → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s → ℕ | null | false |
Set.piecewise | Mathlib.Logic.Function.Basic | {α : Type u} →
{β : α → Sort v} → (s : Set α) → ((i : α) → β i) → ((i : α) → β i) → [(j : α) → Decidable (j ∈ s)] → (i : α) → β i | `s.piecewise f g` is the function equal to `f` on the set `s`, and to `g` on its complement. | true |
Lean.Elab.Term.Do.Code._sizeOf_5_eq | Lean.Elab.Do.Legacy | ∀ (x : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)), Lean.Elab.Term.Do.Code._sizeOf_5 x = sizeOf x | null | false |
Std.Async.Selectable.case.injEq | Std.Async.Select | ∀ {α β : Type} (selector : Std.Async.Selector β) (cont : β → Std.Async.Async α) (β_1 : Type)
(selector_1 : Std.Async.Selector β_1) (cont_1 : β_1 → Std.Async.Async α),
({ β := β, selector := selector, cont := cont } = { β := β_1, selector := selector_1, cont := cont_1 }) =
(β = β_1 ∧ selector ≍ selector_1 ∧ cont... | null | true |
ArithmeticFunction.instCommRing._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ), (↑n).castDef = ↑n | null | false |
Std.ExtHashMap.mem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → γ} {k : α}, k ∈ Std.ExtHashMap.map f m ↔ k ∈ m | null | true |
ULift.algebra._proof_4 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x y : R),
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun (x + y) =
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun x +
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap ... | null | false |
Mathlib.CrossRef.Tag.mk.sizeOf_spec | Mathlib.Tactic.CrossRefAttribute | ∀ (declName : Lean.Name) (database : Mathlib.CrossRef.Database) (tag comment : String),
sizeOf { declName := declName, database := database, tag := tag, comment := comment } =
1 + sizeOf declName + sizeOf database + sizeOf tag + sizeOf comment | null | true |
_private.Mathlib.RingTheory.Valuation.IsTrivialOn.0.Polynomial.valuation_aeval_monomial_eq_valuation_pow._simp_1_1 | Mathlib.RingTheory.Valuation.IsTrivialOn | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | null | false |
CategoryTheory.Functor.ReflectsMonomorphisms | Mathlib.CategoryTheory.Functor.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | A functor reflects monomorphisms if morphisms that are mapped to monomorphisms are themselves
monomorphisms. | true |
_private.Init.Data.Array.Attach.0.Array.attachWithImpl | Init.Data.Array.Attach | {α : Type u_1} → (xs : Array α) → (P : α → Prop) → (∀ x ∈ xs, P x) → Array { x // P x } | Unsafe implementation of `attachWith`, taking advantage of the fact that the representation of
`Array {x // P x}` is the same as the input `Array α`.
| true |
Valuation.RankOne.mk | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → [toRankLeOne : v.RankLeOne] → [toIsNontrivial : v.IsNontrivial] → v.RankOne | null | true |
Lean.Compiler.LCNF.Closure.State.mk.injEq | Lean.Compiler.LCNF.Closure | ∀ (visited : Lean.FVarIdHashSet) (params : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) (visited_1 : Lean.FVarIdHashSet)
(params_1 : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls_1 : Array (L... | null | true |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.recOn | Mathlib.Tactic.ClickSuggestions.TryPremises | {motive : Mathlib.Tactic.ClickSuggestions.Candidates✝ → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.Candidates✝) →
((i : Mathlib.Tactic.ClickSuggestions.RwInfo) →
(arr : Array Mathlib.Tactic.ClickSuggestions.RwLemma) →
motive (Mathlib.Tactic.ClickSuggestions.Candidates.rw✝ i arr)) →
((i... | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.sum_pow_filter_eq_faulhaber._simp_1_7 | Mathlib.NumberTheory.Bernoulli | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
IsCompactOpenCovered.empty | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)],
IsCompactOpenCovered f ∅ | null | true |
Real.cauchy_intCast | Mathlib.Basic.Real.Basic | ∀ (z : ℤ), (↑z).cauchy = ↑z | null | true |
map_inv₀ | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), f a⁻¹ = (f a)⁻¹ | A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. | true |
Lean.Linter.LintEntry.file | Lean.Linter.PersistentLintLog | Lean.Linter.LintEntry → String | null | true |
Pentagonal.tprod_one_sub_pow | Mathlib.Combinatorics.Enumerative.Pentagonal.Ring | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : TopologicalSpace R] [IsTopologicalRing R] [T2Space R] {x : R},
IsTopologicallyNilpotent x →
(∀ (k : ℕ), Summable fun n => x ^ ((k + 1) * n) * ∏ i ∈ Finset.range (n + 1), (1 - x ^ (k + i + 1))) →
(∀ (k : ℕ), Multipliable fun n => 1 - x ^ (n + k + 1)) →
(... | **Pentagonal number theorem**, assuming appropriate multipliability and summability.
$$ \prod_{n = 0}^{\infty} (1 - x^{n + 1}) =
\sum_{k=0}^{\infty} (-1)^k \left(x^{k(3k+1)/2} - x^{(k+1)(3k+2)/2}\right) $$ | true |
IsLocalization.Away.mapₐ.congr_simp | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_5} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {B : Type u_6}
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (Aₚ : Type u_7) [inst_5 : CommSemiring Aₚ] [inst_6 : Algebra A Aₚ]
[inst_7 : Algebra R Aₚ] [inst_8 : IsScalarTower R A Aₚ] (Bₚ : Type u_8) [inst_9 ... | null | true |
Int16.sub_right_inj._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16} (c : Int16), (c - a = c - b) = (a = b) | null | false |
RootPairing.rootSpan_eq_top_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Field R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[P.IsAnisotropic], P.rootSpan R = ⊤ ↔ P.corootSpan R = ⊤ | null | true |
Lean.Meta.FunInd.Collector.saveFunInd | Lean.Meta.Tactic.FunIndCollect | Lean.Expr → Lean.Meta.FunIndInfo → Array Lean.Expr → Lean.Meta.FunInd.Collector.M Unit | null | true |
_private.Mathlib.Algebra.Lie.Subalgebra.0.LieSubalgebra.comap_incl_eq_top._simp_1_4 | Mathlib.Algebra.Lie.Subalgebra | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
CharP.subsemiring | Mathlib.Algebra.CharP.Subring | ∀ (R : Type u) [inst : Semiring R] (p : ℕ) [CharP R p] (S : Subsemiring R), CharP (↥S) p | null | true |
_private.Mathlib.RingTheory.ChainOfDivisors.0.pow_image_of_prime_by_factor_orderIso_dvd._simp_1_1 | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : Monoid M], 1 = ⊥ | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_316 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
TopPair.Homotopy._sizeOf_inst | Mathlib.Topology.Category.TopPair | {X Y : TopPair} → (f g : X ⟶ Y) → SizeOf (TopPair.Homotopy f g) | null | false |
Std.HashMap.getElem!_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
[inst : Inhabited β] {f : Option β → Option β}, (m.alter k f)[k]! = (f m[k]?).get! | null | true |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{f₁... | Given a `PushoutObjObj` of `f₁ : Arrow C₁` and `f₂ : Arrow C₂`, a `PushoutObjObj` of `f₁'` and
`f₂ : Arrow C₂`, and an isomorphism `f₁ ≅ f₁'`, this defines an isomorphism of the induced
pushout maps. | true |
_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.rec | Lean.Meta.MethodSpecs | {motive : Lean.MethodSpecsInfo✝ → Sort u} →
((clsName : Lean.Name) →
(privateSpecs : Bool) →
(fieldImpls : Array (Lean.Name × Lean.Name)) →
(thms : Array Lean.MethodSpecTheorem✝) →
motive { clsName := clsName, privateSpecs := privateSpecs, fieldImpls := fieldImpls, thms := thms }) ... | null | false |
Pi.nonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (a b : (i : I) → f i),
a + b = b + a | null | false |
CategoryTheory.Limits.Multiequalizer.lift_ι_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasMultiequalizer I] (W : C)
(k : (a : J.L) → W ⟶ I.left a)
(h :
∀ (b : J.R),
CategoryTheory.CategoryStruct.comp (k (J.fs... | null | true |
tsum_descFactorial_mul_geometric_of_norm_lt_one | Mathlib.Analysis.SpecificLimits.Normed | ∀ {𝕜 : Type u_5} [inst : NormedDivisionRing 𝕜] (j : ℕ) {r : 𝕜},
‖r‖ < 1 → ∑' (n : ℕ), ↑(n.descFactorial j) * r ^ n = ↑j.factorial * r ^ j / (1 - r) ^ (j + 1) | If `‖r‖ < 1`, then `∑' n : ℕ, n.descFactorial j * r ^ n = j ! * r ^ j / (1 - r) ^ (j + 1)`. | true |
Array.ne_push_self._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (xs = xs.push a) = False | null | false |
Set.add_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s : Set α}, s.Nonempty → s + Set.univ = Set.univ | null | true |
ContinuousMap.compAddMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : AddZeroClass γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | null | false |
Mathlib.Tactic.Bound._aux_Mathlib_Tactic_Bound_Attribute___macroRules_Mathlib_Tactic_Bound_attrBound_forward_1 | Mathlib.Tactic.Bound.Attribute | Lean.Macro | Attribute for `forward` rules for the `bound` tactic.
`@[bound_forward]` lemmas should produce inequalities given other hypotheses that might be in the
context. A typical example is exposing an inequality field of a structure, such as
`HasPowerSeriesOnBall.r_pos`. | false |
Lean.Doc.Block.dl | Lean.DocString.Types | {i : Type u} → {b : Type v} → Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Lean.Doc.Block i b | A description list that associates explanatory text with shorter items.
| true |
Set.mem_mulAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Mul α] {s t : Set α} {a : α} {x : α × α},
x ∈ s.mulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 * x.2 = a | null | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_eq_zero_of_notMem_ball._simp_1_4 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Std.ExtTreeMap.ne_empty_of_erase_ne_empty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → t ≠ ∅ | null | true |
AddMonoid.Coprod.map._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_1} {N' : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass M'] [inst_3 : AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x y : N),
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map (Sum.map ⇑f ⇑g))) (FreeAddMonoid.of (Sum.inr (x + y))) =
(Ad... | null | false |
or_iff_right_iff_imp._simp_1 | Init.SimpLemmas | ∀ {a b : Prop}, (a ∨ b ↔ b) = (a → b) | null | false |
Turing.BlankRel.refl | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), Turing.BlankRel l l | null | true |
CategoryTheory.Limits.DiagramOfCocones.mk.inj | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} J}
{inst_1 : CategoryTheory.Category.{v_2, u_2} K} {C : Type u_3} {inst_2 : CategoryTheory.Category.{v_3, u_3} C}
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {obj : (j : J) → CategoryTheory.Limits.Cocone (F.obj j)}
{map : {... | null | true |
Functor.Comp.instPure | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Pure (Functor.Comp F G) | null | true |
Sylow.card_normalizer_modEq_card | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] {p n : ℕ} [hp : Fact (Nat.Prime p)] {H : Subgroup G},
Nat.card ↥H = p ^ n → Nat.card ↥(Subgroup.normalizer ↑H) ≡ Nat.card G [MOD p ^ (n + 1)] | If `H` is a subgroup of `G` of cardinality `p ^ n`, then the cardinality of the
normalizer of `H` is congruent mod `p ^ (n + 1)` to the cardinality of `G`. | true |
Lean.Meta.Grind.AC.EqCnstr.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {lhs rhs : Lean.Grind.AC.Seq} {h : Lean.Meta.Grind.AC.EqCnstrProof} {id : ℕ} {lhs_1 rhs_1 : Lean.Grind.AC.Seq}
{h_1 : Lean.Meta.Grind.AC.EqCnstrProof} {id_1 : ℕ},
{ lhs := lhs, rhs := rhs, h := h, id := id } = { lhs := lhs_1, rhs := rhs_1, h := h_1, id := id_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ h = h_1 ∧ id = id... | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_23 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, a ∈ l → l ≠ [] → List.idxOf a l < l.length | null | false |
_private.Lean.Meta.Match.AltTelescopes.0.Lean.Meta.Match.forallAltVarsTelescope.isNamedPatternProof | Lean.Meta.Match.AltTelescopes | Lean.Expr → Lean.Expr → Bool | null | true |
Lean.ReducibilityHints.ctorElim | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.ReducibilityHints) → ctorIdx = t.ctorIdx → Lean.ReducibilityHints.ctorElimType ctorIdx → motive t | null | false |
PadicInt.instMetricSpace._aux_20 | Mathlib.NumberTheory.Padics.PadicIntegers | (p : ℕ) → [hp : Fact (Nat.Prime p)] → Filter ℤ_[p] | null | false |
CategoryTheory.Grothendieck.map_obj_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat} (α : F ⟶ G)
(X : CategoryTheory.Grothendieck F),
((CategoryTheory.Grothendieck.map α).obj X).fiber = (α.app X.base).toFunctor.obj X.fiber | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.«term𝒰(_,_,_)» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.ParserDescr | null | true |
_private.Batteries.Data.List.Basic.0.List.swap_eq_swapTR.go.match_1 | Batteries.Data.List.Basic | ∀ (α : Type u_1) (motive : List α → ℕ → ℕ → Array α → Prop) (x : List α) (x_1 x_2 : ℕ) (x_3 : Array α),
(∀ (x x_4 : ℕ) (x_5 : Array α), motive [] x x_4 x_5) →
(∀ (head : α) (tail : List α) (x : Array α), motive (head :: tail) 0 0 x) →
(∀ (head : α) (tail : List α) (n : ℕ) (x : Array α), motive (head :: tail... | null | false |
AddCon.addCommMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : AddCommMagma M] → (c : AddCon M) → AddCommMagma c.Quotient | The quotient of an `AddCommMagma` by an additive congruence relation is
an `AddCommMagma`. | true |
instSTWorldEST | Init.System.ST | {ε σ : Type} → STWorld σ (EST ε σ) | null | true |
CategoryTheory.Abelian.SpectralObject.iCycles_δ | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {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 : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.Sp... | null | true |
Aesop.getGoalsToCopy | Aesop.Tree.AddRapp | Aesop.UnorderedArraySet Lean.MVarId → Aesop.GoalRef → Aesop.TreeM (Array Aesop.GoalRef) | null | true |
String.Slice.Pattern.Model.PatternModel.noConfusion | Init.Data.String.Lemmas.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{t : String.Slice.Pattern.Model.PatternModel pat} →
{ρ' : Type} →
{pat' : ρ'} →
{t' : String.Slice.Pattern.Model.PatternModel pat'} →
ρ = ρ' → pat ≍ pat' → t ≍ t' → String.Slice.Pattern.Model.PatternModel.noConfusionType P t... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.