name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y | null | true |
CategoryTheory.Limits.image.fac | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ι f) = f | null | true |
DomAddAct.instAddCommMonoidOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [AddCommMonoid Mᵃᵒᵖ] → AddCommMonoid Mᵈᵃᵃ | null | true |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_le_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) (TypeCat.ofHom fun f => F.map f) =
Category... | null | false |
Metric.PiNatEmbed.recOn | Mathlib.Topology.MetricSpace.PiNat | {ι : Type u_2} →
{X : Type u_5} →
{Y : ι → Type u_6} →
{f : (i : ι) → X → Y i} →
{motive : Metric.PiNatEmbed X Y f → Sort u} →
(t : Metric.PiNatEmbed X Y f) → ((ofPiNat : X) → motive { ofPiNat := ofPiNat }) → motive t | null | false |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.generatorIndex.congr_simp | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E E_1 : IntermediateField K (RatFunc K)} (e_E : E = E_1) (h : E ≠ ⊥),
RatFunc.Luroth.generatorIndex✝ h = RatFunc.Luroth.generatorIndex✝ ⋯ | null | true |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P | A (noncomputable) element of a cofinal set lying above a given element. | true |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t | null | false |
jacobiSym.mul_right' | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b₁ b₂ : ℕ}, b₁ ≠ 0 → b₂ ≠ 0 → jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂ | The Jacobi symbol is multiplicative in its second argument. | true |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r | A rewrite lemma for `padicValRat p (q / r)` with conditions `q ≠ 0`, `r ≠ 0`. | true |
TopCommRingCat.hasForgetToTopCat | Mathlib.Topology.Category.TopCommRingCat | CategoryTheory.HasForget₂ TopCommRingCat TopCat | The forgetful functor to `TopCat`. | true |
Equiv.Perm.coe_pow._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} (f : Equiv.Perm α) (n : ℕ), (⇑f)^[n] = ⇑(f ^ n) | null | false |
CategoryTheory.ShiftMkCore.casesOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.ShiftMkCore C A → Sort u_2} →
(t : CategoryTheory.ShiftMkCore C A) →
((F : A → CategoryTheory.Functor C C) →
(zero : F 0 ≅ CategoryTheor... | null | false |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ | null | true |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.SimpM.run.match_1 | Lean.Meta.Tactic.Simp.Types | {α : Type} →
(motive : α × Lean.Meta.Simp.State → Sort u_1) →
(x : α × Lean.Meta.Simp.State) → ((r : α) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive x | null | false |
Bundle.ContinuousAlternatingMap.instVectorBundle | Mathlib.Topology.VectorBundle.ContinuousAlternatingMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : Fintype ι] {B : Type u_3}
[inst_2 : TopologicalSpace B] {F₁ : Type u_4} [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
{E₁ : B → Type u_5} [inst_5 : (x : B) → AddCommGroup (E₁ x)] [inst_6 : (x : B) → Module 𝕜 (E₁ x)]
[i... | The continuous `σ`-semilinear maps between two vector bundles form a vector bundle. | true |
Batteries.Tactic.PrintPrefixConfig.imported._default | Batteries.Tactic.PrintPrefix | Bool | null | false |
Qq.unpackParensIdent | Qq.Match | Lean.Syntax → Option Lean.Syntax | null | true |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip | null | true |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P | null | false |
Int.instAdd | Init.Data.Int.Basic | Add ℤ | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting'._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | Debug `grind` by identifying places where it does not yet supersede `linarith`. | true |
Homeomorph.funUnique_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ (ι : Type u_7) (X : Type u_8) [inst : Unique ι] [inst_1 : TopologicalSpace X],
⇑(Homeomorph.funUnique ι X) = fun f => f default | null | true |
Finmap.lookup_eq_none | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Finmap β}, Finmap.lookup a s = none ↔ a ∉ s | null | true |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__x : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __x | null | false |
even_neg._simp_1 | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
PowerSeries.constantCoeff_substInvOfIsUnit | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (P : PowerSeries R) (hP' : IsUnit ((PowerSeries.coeff 1) P)),
PowerSeries.constantCoeff (P.substInvOfIsUnit hP') = 0 | null | true |
Lean.Elab.Info.format | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.Info → IO Std.Format | null | true |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 | null | false |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | null | true |
Turing.TM0.Cfg.q | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ | The current machine state. | true |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions.0.SimpleGraph.cycleGraph.bicoloring_of_even._simp_3 | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Int64.toISize_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ^^^ b).toISize = a.toISize ^^^ b.toISize | null | true |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax | null | false |
CategoryTheory.Limits.coprod.inl_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct X Y] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doLetArrow._regBuiltin.Lean.Parser.Term.doLetArrow.formatter_15 | Lean.Parser.Do | IO Unit | null | false |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m | null | true |
_private.Mathlib.Algebra.Module.Submodule.Invariant.0.Module.End.invtSubmodule_inf_invtSubmodule_le_invtSubmodule_add.match_1_1 | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.End R M) (p : Submodule R M) (motive : p ∈ f.invtSubmodule ⊓ g.invtSubmodule → Prop)
(x : p ∈ f.invtSubmodule ⊓ g.invtSubmodule),
(∀ (hfp : p ∈ ↑f.invtSubmodule) (hgp : p ∈ ↑g.invtSubmodule), motive ... | null | false |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp
(SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (SemimoduleCat.of R R)) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (... | null | true |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph | **Vertical line test** for monoid homomorphisms.
Let `f : G → H × I` be a homomorphism to a product of monoids. Assume that `f` is surjective on the
first factor and that the image of `f` intersects every "vertical line" `{(h, i) | i : I}` at most
once. Then the image of `f` is the graph of some monoid homomorphism `f... | true |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.restrict_fixedField._simp_1_6 | Mathlib.FieldTheory.Galois.Infinite | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Bool.not_eq_eq_eq_not | Init.SimpLemmas | ∀ {a b : Bool}, (!a) = b ↔ a = !b | We move `!` from the left hand side of an equality to the right hand side.
This helps confluence, and also helps combining pairs of `!`s.
| true |
MeasureTheory.OuterMeasure.map._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (m : MeasureTheory.OuterMeasure α) (s : ℕ → Set β),
m (f ⁻¹' ⋃ i, s i) ≤ ∑' (i : ℕ), m (f ⁻¹' s i) | null | false |
_private.Lean.Elab.Do.Control.0.Lean.Elab.Do.ControlStack.exceptT.stM | Lean.Elab.Do.Control | Lean.Elab.Do.MonadInfo → Lean.Elab.Do.DoElabM Lean.Elab.Do.ReturnCont → Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr | null | true |
MeasureTheory.Measure.restrict_apply_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α), (μ.restrict s) s = μ s | null | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) (α : Type u_1) (A : α → PSet.{u_1}) (motive : x ∈ PSet.mk α A → Prop) (x_1 : x ∈ PSet.mk α A),
(∀ (a : (PSet.mk α A).Type) (ha : x.Equiv ((PSet.mk α A).Func a)), motive ⋯) → motive x_1 | null | false |
AlgebraicTopology.DoldKan.degeneraciesVanish_iff_QInfty_f_comp | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {n : ℕ} {T : C} (f : X.obj (Opposite.op { len := n }) ⟶ T),
AlgebraicTopology.DoldKan.DegeneraciesVanish f ↔
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKa... | null | true |
Array.filter_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool}, Array.filter p #[] = #[] | null | true |
CategoryTheory.ShortComplex.leftHomologyOpIso | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
[inst_2 : S.HasRightHomology] → S.op.leftHomology ≅ Opposite.op S.rightHomology | The left homology in the opposite category of the opposite of a short complex identifies
to the right homology of this short complex. | true |
instIsPartialOrderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], IsPartialOrder α fun x1 x2 => x1 ≤ x2 | null | true |
_private.Lean.Data.Json.Basic.0.Lean.Json.beq'._sparseCasesOn_7 | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible._simp_1_3 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | null | false |
CategoryTheory.hasExt_iff_small_ext | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C],
CategoryTheory.HasExt C ↔ ∀ (X Y : C) (n : ℕ), Small.{w', w} (CategoryTheory.Abelian.Ext X Y n) | null | true |
instIsInertiaFieldOfIsGaloisGroupSubtypeAlgEquivMemSubgroupInertia | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (K : Type u_2) (L : Type u_3) {B : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : CommRing B] (P : Ideal B) (E : Type u_6) [inst_4 : Field E] [inst_5 : Algebra E L]
[inst_6 : MulSemiringAction Gal(L/K) B] [h : IsGaloisGroup (↥(Ideal.inertia Gal(L/K) P)) E L], IsInertiaField K L P E | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.initFn._@.Mathlib.Tactic.Linter.TextBased.2403359285._hygCtx._hyg.4 | Mathlib.Tactic.Linter.TextBased | IO (Lean.Option Bool) | null | false |
AlgebraicGeometry.Scheme.Hom.normalizationObjIso_hom_val | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U : Y.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationObjIso f hU).hom
(CommRingCat.ofHom
... | null | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_15 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashMap α (Task Dynamic) → NonScalar | null | true |
_private.Plausible.Gen.0.Plausible.Gen.permutationOf._proof_7 | Plausible.Gen | ∀ {α : Type u_1} (ys : List α), ¬0 ≤ ys.length → False | null | false |
WithTop.bot_eq_coe._simp_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Bot α] {a : α}, (⊥ = ↑a) = (⊥ = a) | null | false |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.initFn._sparseCasesOn_5._@.Mathlib.Tactic.GCongr.Core.4134784601._hygCtx._hyg.2 | Mathlib.Tactic.GCongr.Core | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
SemicontinuousAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] (r : α → β → Prop) (x : α),
SemicontinuousAt r x = ∀ (y : β), r x y → ∀ᶠ (x' : α) in nhds x, r x' y | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.SpectralNorm.0.spectralNorm.spectralMulAlgNorm_eq_of_mem_roots._simp_1_3 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) | null | false |
HurwitzZeta.hasSum_int_oddKernel | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : ℝ) {x : ℝ},
0 < x → HasSum (fun n => (↑n + a) * Real.exp (-Real.pi * (↑n + a) ^ 2 * x)) (HurwitzZeta.oddKernel (↑a) x) | null | true |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.eraseDecl.match_1 | Lean.Meta.Tactic.Grind.Theorems | (motive : Option (Array Lean.Name) → Sort u_1) →
(__do_lift : Option (Array Lean.Name)) →
((eqns : Array Lean.Name) → motive (some eqns)) → ((x : Option (Array Lean.Name)) → motive x) → motive __do_lift | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceSLE.declare_293._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.2045894262._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
CategoryTheory.PreZeroHypercover.pullbackCoverOfLeftIsoPullback₁._proof_3 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
{Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst f g) (E.f i)]
[inst_3 : ∀... | null | false |
Algebra.Extension.noConfusion | Mathlib.RingTheory.Extension.Basic | {P : Sort u_1} →
{R : Type u} →
{S : Type v} →
{inst : CommRing R} →
{inst_1 : CommRing S} →
{inst_2 : Algebra R S} →
{t : Algebra.Extension R S} →
{R' : Type u} →
{S' : Type v} →
{inst' : CommRing R'} →
{inst'... | null | false |
Lean.Omega.Fin.lt_of_not_le | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, ¬i ≤ j → j < i | null | true |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheor... | null | true |
Localization.mapToFractionRing._proof_1 | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_3} (K : Type u_1) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_2) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A) (a : A),
(↑↑(IsLocalization.lift ⋯)).toFun ((algeb... | null | false |
NormedField.edist._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(dist : α → α → ℝ) →
(∀ (x : α), dist x x = 0) →
(∀ (x y : α), dist x y = dist y x) → (∀ (x y z : α), dist x z ≤ dist x y + dist y z) → α → α → ENNReal | null | false |
CategoryTheory.Limits.coproductIsCoproduct'._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }] (s : CategoryTheory.Limits.Cocone X)
(m : (CategoryTheory.Limits.Sigma.cocone X).pt ⟶ s.pt),
(∀ (j : C... | null | false |
Finset.inter_singleton_of_mem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → s ∩ {a} = {a} | null | true |
CategoryTheory.Limits.MultispanShape.prod_R | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ (ι : Type w), (CategoryTheory.Limits.MultispanShape.prod ι).R = ι | null | true |
Northcott.finite_le | Mathlib.Order.Northcott | ∀ {α : Type u_1} {β : Type u_2} {h : α → β} {inst : LE β} [self : Northcott h] (b : β), {a | h a ≤ b}.Finite | null | true |
CircularPartialOrder.ctorIdx | Mathlib.Order.Circular | {α : Type u_1} → CircularPartialOrder α → ℕ | null | false |
Set.mul_iInter₂_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : Mul α] (s : Set α) (t : (i : ι) → κ i → Set α),
s * ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s * t i j | null | true |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal.match_3 | Aesop.Tree.ExtractProof | (motive : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment) → Sort u_1) →
(__discr : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) →
((postNormGoal : Lean.MVarId) →
(children : Array Aesop.RappRef) →
(postNormEnv : Lean.Environment) → motive (some (postNormGoal, chil... | null | false |
QuotientGroup.fintypeQuotientRightRel | Mathlib.GroupTheory.Coset.Card | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → [Fintype (α ⧸ s)] → Fintype (Quotient (QuotientGroup.rightRel s)) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.reify?.isOfNatZero | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Bool | null | true |
Int.getElem?_toList_roc_eq_none_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m<...=n).toList[i]? = none) = ((n - m).toNat ≤ i) | null | false |
Lean.Omega.IntList.mul_get | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList) (i : ℕ), (xs * ys).get i = xs.get i * ys.get i | null | true |
_private.Mathlib.Algebra.Polynomial.CoeffList.0.Polynomial.coeffList_eraseLead._proof_1_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] {P : Polynomial R},
¬P.natDegree = 0 →
P.eraseLead.degree.succ = P.eraseLead.natDegree + 1 →
P.eraseLead.natDegree ≤ P.natDegree - 1 →
P.natDegree = P.eraseLead.natDegree + 1 + (P.natDegree - P.eraseLead.natDegree - 1) ∧
P.natDegree - P.eraseLead.natDeg... | null | false |
Lean.Elab.MonadAutoImplicits.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t | null | false |
Set.preimage_const_mul_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b c : α),
(fun x => a * x) ⁻¹' Set.Ioo b c = Set.Ioo (b / a) (c / a) | null | true |
HomologicalComplex.evalCompCoyonedaCorepresentative._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {ι : Type u_1} (c : ComplexShape ι) (j : ι) (hj : ∃ k, c.Rel j k), c.Rel j hj.choose | null | false |
Quiver.SingleObj.pathToList._sunfold | Mathlib.Combinatorics.Quiver.SingleObj | {α : Type u_1} → {x : Quiver.SingleObj α} → Quiver.Path (Quiver.SingleObj.star α) x → List α | null | false |
AlgebraicGeometry.Scheme.Opens.mem_basicOpen_toScheme._simp_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} {V : (↑U).Opens} {r : ↑((↑U).presheaf.obj (Opposite.op V))} {x : ↥U},
(x ∈ (↑U).basicOpen r) = (↑x ∈ X.basicOpen r) | null | false |
lift_nhds_left | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {x : α} {g : Set α → Filter β},
Monotone g → (nhds x).lift g = (uniformity α).lift fun s => g (UniformSpace.ball x s) | null | true |
IsUltrametricDist.algNormOfAlgEquiv_extends | Mathlib.Analysis.Normed.Unbundled.InvariantExtension | ∀ {K : Type u_1} [inst : NormedField K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hu : IsUltrametricDist K] (σ : Gal(L/K)) (x : K),
(IsUltrametricDist.algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ | The algebra norm `algNormOfAlgEquiv` extends the norm on `K`. | true |
Option.get!_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α], none.get! = default | null | true |
ULift.instT5Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T5Space X], T5Space (ULift.{u_3, u_1} X) | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.0.AlgebraicGeometry.homogeneousLocalizationToStalk_stalkToFiberRingHom._simp_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
RelIso.mk.sizeOf_spec | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_5} {β : Type u_6} {r : α → α → Prop} {s : β → β → Prop} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : (a a_1 : α) → SizeOf (r a a_1)] [inst_3 : (a a_1 : β) → SizeOf (s a a_1)] (toEquiv : α ≃ β)
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b),
sizeOf { toEquiv := toEquiv, map_rel_if... | null | true |
OrderedFinpartition.eraseLeft._proof_7 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (i : Fin (c.length - 1)), 0 < c.partSize (Fin.cast ⋯ i.succ) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.