name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Valuation.Uniformizer.ne_zero | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] {v : Valuation A Γ}
[hv : v.IsRankOneDiscrete] (π : v.Uniformizer), ↑π.val ≠ 0 | true |
Std.ExtTreeSet.max_erase_eq_iff_not_compare_eq_max | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : t.erase k ≠ ∅}, (t.erase k).max he = t.max ⋯ ↔ ¬cmp k (t.max ⋯) = Ordering.eq | true |
Mathlib.Meta.FunProp.Context.constToUnfold | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Context → Std.TreeSet Lean.Name Lean.Name.quickCmp | true |
Lean.Compiler.nospecializeAttr | Lean.Compiler.Specialize | Lean.TagAttribute | true |
Std.Slice.Internal.ListSliceData | Init.Data.Slice.List.Basic | Type u → Type u | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero_inv_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero C).inv.app X).hom₃ =
(CategoryTheory.shiftFunctorZero C ℤ).inv.app X... | true |
CategoryTheory.GlueData'.mk.noConfusion | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
{inst : CategoryTheory.Category.{v, u₁} C} →
{P : Sort u} →
{J : Type v} →
{U : J → C} →
{V : (i j : J) → i ≠ j → C} →
{f : (i j : J) → (h : i ≠ j) → V i j h ⟶ U i} →
{f_mono :
autoParam (∀ (i j : J) (h : i ≠ j), CategoryTheory.Mo... | false |
lt_of_mul_lt_mul_of_nonneg_left | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [PosMulReflectLT α],
a * b < a * c → 0 ≤ a → b < c | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ElabFootnote.recOn | Lean.Elab.DocString | {motive : Lean.Doc.ElabFootnote✝ → Sort u} →
(t : Lean.Doc.ElabFootnote✝) → ((name : Lean.StrLit) → motive { name := name }) → motive t | false |
_private.Mathlib.Order.Bounds.Basic.0.IsLUB.exists_between._to_dual_1.match_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {b : α} (motive : (∃ c ∈ s, c < b) → Prop) (x : ∃ c ∈ s, c < b),
(∀ (c : α) (hcs : c ∈ s) (hbc : c < b), motive ⋯) → motive x | false |
constantCoeff_wittStructureInt | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ (p : ℕ) {idx : Type u_2} [hp : Fact (Nat.Prime p)] (Φ : MvPolynomial idx ℤ),
MvPolynomial.constantCoeff Φ = 0 → ∀ (n : ℕ), MvPolynomial.constantCoeff (wittStructureInt p Φ n) = 0 | true |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.variance_le_sub_mul_sub._simp_1_2 | Mathlib.Probability.Moments.Variance | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {L : Type u_6} [inst : RCLike L] (r : L)
(f : α → L), r * ∫ (a : α), f a ∂μ = ∫ (a : α), r * f a ∂μ | false |
LinearPMap.adjointDomain | Mathlib.Analysis.InnerProductSpace.LinearPMap | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : InnerProductSpace 𝕜 F] → (E →ₗ.[𝕜] F) → Submodule 𝕜 F | true |
AdjoinRoot.mk_ne_zero_of_degree_lt | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R},
f.Monic → ∀ {g : Polynomial R}, g ≠ 0 → g.degree < f.degree → (AdjoinRoot.mk f) g ≠ 0 | true |
SimpleGraph.isEdgeReachable_add_one | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} {u v : V},
k ≠ 0 → (G.IsEdgeReachable (k + 1) u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).IsEdgeReachable k u v) | true |
_private.Std.Data.String.ToNat.0.noRepetition_cons_append_append_iff._simp_1_5 | Std.Data.String.ToNat | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
Lean.Elab.Term.elabTypeOf | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | true |
Lean.Lsp.instFromJsonDeleteFile.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.DeleteFile | true |
CategoryTheory.Limits.Types.Small.limitConeIsLimit_lift | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
[inst_1 : Small.{u, max u v} ↑F.sections] (s : CategoryTheory.Limits.Cone F) (v : s.pt),
(CategoryTheory.Limits.Types.Small.limitConeIsLimit F).lift s v = (equivShrink ↑F.sections) ⟨fun j => s.π.app j v, ⋯⟩ | true |
FrameHom.id | Mathlib.Order.Hom.CompleteLattice | (α : Type u_2) → [inst : CompleteLattice α] → FrameHom α α | true |
Finsupp.embDomain._proof_3 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {β : Type u_3} {M : Type u_2} [inst : Zero M] (f : α ↪ β) (v : α →₀ M),
∀ a₂ ∈ Finset.map f v.support, ∃! a, a ∈ v.support ∧ (fun a₁ => f a₁ = a₂) a | false |
second_derivative_symmetric | Mathlib.Analysis.Calculus.FDeriv.Symmetric | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
[IsRCLikeNormedField 𝕜] {f' : E → E →L[𝕜] F} {f'' : E →L[𝕜] E →L[𝕜] F} {x : E},
(∀ (y : E), Ha... | true |
instBooleanRingBool | Mathlib.Algebra.Ring.BooleanRing | BooleanRing Bool | true |
Valuation.coeff_zero_minpoly | Mathlib.RingTheory.Valuation.Minpoly | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
(L : Type u_3) [inst_2 : Field L] [inst_3 : Algebra K L] (x : K), v ((minpoly K ((algebraMap K L) x)).coeff 0) = v x | true |
PairReduction.exists_radius_le | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a : ENNReal} (t : T) (V : Finset T),
1 < a → ∀ (c : ENNReal), ∃ r, 1 ≤ r ∧ ↑{x ∈ V | edist t x ≤ ↑r * c}.card ≤ a ^ r | true |
_private.Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization.0.HomogeneousLocalization.map._simp_6 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] {𝒜 : ι → σ}
[inst_5 : GradedRing 𝒜] (x : Submonoid A) (i j : HomogeneousLocalization.NumDenSameDeg 𝒜 x),
HomogeneousLocalization.mk i * H... | false |
_private.Mathlib.Combinatorics.SimpleGraph.DeleteEdges.0.SimpleGraph.card_support_deleteIncidenceSet._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {α : Type u_4} (s : Set α) [inst : Fintype ↑s], Fintype.card ↑s = s.toFinset.card | false |
MulMemClass.toCommSemigroup.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_5} [inst : CommSemigroup M] {A : Type u_4} [inst_1 : SetLike A M] [inst_2 : MulMemClass A M] (S : A),
MulMemClass.toCommSemigroup S = { toSemigroup := MulMemClass.toSemigroup S, mul_comm := ⋯ } | true |
_private.Mathlib.CategoryTheory.Iso.0.CategoryTheory.IsIso.mk'._simp_1_1 | Mathlib.CategoryTheory.Iso | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
Submodule.quotientPi_aux.invFun._proof_1 | Mathlib.LinearAlgebra.Quotient.Pi | ∀ {ι : Type u_3} {R : Type u_2} [inst : CommRing R] {Ms : ι → Type u_1} [inst_1 : (i : ι) → AddCommGroup (Ms i)]
[inst_2 : (i : ι) → Module R (Ms i)] (p : (i : ι) → Submodule R (Ms i)) [inst_3 : DecidableEq ι] (x : ι),
p x ≤ Submodule.comap (LinearMap.single R Ms x) (Submodule.pi Set.univ p) | false |
Lean.withoutModifyingState | Lean.Util.MonadBacktrack | {m : Type → Type} → {s α : Type} → [Monad m] → [MonadFinally m] → [Lean.MonadBacktrack s m] → m α → m α | true |
Multiplicative.monoid | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [h : AddMonoid α] → Monoid (Multiplicative α) | true |
CategoryTheory.PreZeroHypercover.presieve₀_mem_of_iso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} [J.RespectsIso] {S : C}
{E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F), E.presieve₀ ∈ J.coverings S → F.presieve₀ ∈ J.coverings S | true |
BitVec.not_cast | Init.Data.BitVec.Lemmas | ∀ {w w' : ℕ} {x : BitVec w} (h : w = w'), ~~~BitVec.cast h x = BitVec.cast h (~~~x) | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.AlgHom._aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_AlgHom_termσ_1 | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | false |
Nat.log.go._sunfold | Mathlib.Data.Nat.Log | ℕ → ℕ → ℕ → ℕ × ℕ | false |
CategoryTheory.PresheafOfGroups.OneCocycle.mk.sizeOf_spec | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : CategoryTheory.Functor Cᵒᵖ GrpCat} {I : Type w'}
{U : I → C} [inst_1 : SizeOf C] [inst_2 : SizeOf I] (toOneCochain : CategoryTheory.PresheafOfGroups.OneCochain G U)
(ev_trans :
autoParam
(∀ (i j k : I) ⦃T : C⦄ (a : T ⟶ U i) (b : T ⟶ U j) (c : T... | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.liftHom._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y}
{f : F.obj ⊥ ⟶ X} {g : c.pt ⟶ Y} {j : J}
(s : ↑(⋯.functor.op.comp (CategoryTheory.HasLiftingPrope... | false |
instAddCommGroupKaehlerDifferential._aux_8 | Mathlib.RingTheory.Kaehler.Basic | (R : Type u_1) →
(S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → ℕ → Ω[S⁄R] → Ω[S⁄R] | false |
Prod.isCompl_iff | Mathlib.Order.Disjoint | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] {x y : α × β}, IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2 | true |
Lean.Grind.IntInterval.wrap_add | Init.Grind.ToInt | ∀ {i : Lean.Grind.IntInterval}, i.isFinite = true → ∀ (x y : ℤ), i.wrap (x + y) = i.wrap (i.wrap x + i.wrap y) | true |
Rep.FiniteCyclicGroup.groupHomologyπOdd_eq_iff | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] [inst_3 : DecidableEq G] (g : G)
(hg : ∀ (x : G), x ∈ Subgroup.zpowers g) (A : Rep.{u, u, u} k G) (i : ℕ) (hi : Odd i)
(x y : ↥(Rep.Hom.hom (A.applyAsHom g - CategoryTheory.CategoryStruct.id A)).ker),
(CategoryTheory.ConcreteCategory... | true |
Std.DTreeMap.Internal.Impl.applyPartition_go_step | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {δ : Type w} [inst : Ord α] {k : α → Ordering} {init : δ} (l₁ l₂ : List ((a : α) × β a))
(l l' : Std.DTreeMap.Internal.Impl α β)
(h : Std.DTreeMap.Internal.Impl.contains' k l' = true → Std.DTreeMap.Internal.Impl.contains' k l = true)
(f : δ → Std.DTreeMap.Internal.Impl.ExplorationS... | true |
MeasureTheory.hittingAfter_mono | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] (u : ι → Ω → β) (s : Set β),
Monotone (MeasureTheory.hittingAfter u s) | true |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.SFinite.0.MeasureTheory.Measure.exists_ae_subset_biUnion_countable_of_isFiniteMeasure._proof_1_6 | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {C : Set (Set α)},
(∀ s ∈ C, MeasurableSet s) → ∀ D ∈ {D | D ⊆ C ∧ D.Countable}, ∀ t ∈ D, MeasurableSet t | false |
Std.IteratorLoop.mk | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{n : Type x → Type x'} →
(((γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ) →
(γ : Type x) →
(plausible_forInStep : β → γ → ForInStep γ → Prop) →
(it : S... | true |
CategoryTheory.MorphismProperty.rlp_eq_of_le_rlp_of_hasFactorization_of_isStableUnderRetracts | Mathlib.CategoryTheory.MorphismProperty.RetractArgument | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
[W₁.HasFactorization W₂] [W₂.IsStableUnderRetracts], W₂ ≤ W₁.rlp → W₁.rlp = W₂ | true |
CategoryTheory.Functor.mapBifunctorHomologicalComplex._proof_2 | Mathlib.Algebra.Homology.Bifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_6} {D : Type u_3} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_5, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_2, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : Categ... | false |
_private.Mathlib.Topology.ContinuousMap.StoneWeierstrass.0.ContinuousMapZero.mul_nonUnitalStarAlgHom_apply_eq_zero._simp_1_1 | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
Std.ExtDTreeMap.minKeyD_eq_iff_mem_and_forall | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t ≠ ∅ → ∀ {km fallback : α}, t.minKeyD fallback = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | true |
BoxIntegral.Prepartition.splitMany.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)),
BoxIntegral.Prepartition.splitMany I s = s.inf fun p => BoxIntegral.Prepartition.split I p.1 p.2 | true |
continuousLinearMapOfTendsto | Mathlib.Analysis.LocallyConvex.Barrelled | {α : Type u_1} →
{𝕜₁ : Type u_4} →
{𝕜₂ : Type u_5} →
{E : Type u_6} →
{F : Type u_7} →
[inst : NontriviallyNormedField 𝕜₁] →
[inst_1 : NontriviallyNormedField 𝕜₂] →
{σ₁₂ : 𝕜₁ →+* 𝕜₂} →
[RingHomIsometric σ₁₂] →
[inst_3 : AddC... | true |
Lean.AsyncConstantInfo.mk.sizeOf_spec | Lean.Environment | ∀ (name : Lean.Name) (kind : Lean.ConstantKind) (sig : Task Lean.ConstantVal) (constInfo : Task Lean.ConstantInfo),
sizeOf { name := name, kind := kind, sig := sig, constInfo := constInfo } =
1 + sizeOf name + sizeOf kind + sizeOf sig + sizeOf constInfo | true |
Lean.Meta.ArgsPacker.Unary.unpack | Lean.Meta.ArgsPacker | ℕ → Lean.Expr → Option (Array Lean.Expr) | true |
Lean.instInhabitedRecursorRule.default | Lean.Declaration | Lean.RecursorRule | true |
ZMod.cast_sub | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] {m : ℕ} [CharP R m], m ∣ n → ∀ (a b : ZMod n), (a - b).cast = a.cast - b.cast | true |
Batteries.ByteSubarray.mk.noConfusion | Batteries.Data.ByteSlice | {P : Sort u} →
{array : ByteArray} →
{start stop : ℕ} →
{start_le_stop : start ≤ stop} →
{stop_le_array_size : stop ≤ array.size} →
{array' : ByteArray} →
{start' stop' : ℕ} →
{start_le_stop' : start' ≤ stop'} →
{stop_le_array_size' : stop' ≤ array... | false |
Std.DTreeMap.Raw.mem_alter_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF → ∀ {k : α} {f : Option (β k) → Option (β k)}, k ∈ t.alter k f ↔ (f (t.get? k)).isSome = true | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁_trans._proof_1_14 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {q₁ : Turing.TM1.Stmt Γ Λ σ} ⦃q₀ : Turing.TM1.Stmt Γ Λ σ⦄ (a : Γ → σ → σ)
(q : Turing.TM1.Stmt Γ Λ σ),
(q₁ ∈ Turing.TM1.stmts₁ q → q₀ ∈ Turing.TM1.stmts₁ q) →
q₁ ∈ Turing.TM1.stmts₁ q → q₀ ∈ insert (Turing.TM1.Stmt.load a q) (Turing.TM1.stmts₁ q) | false |
DiscreteConvolution.ConvolutionExists.add_distrib | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {S : Type u_2} {E : Type u_3} {E' : Type u_4} {F : Type u_6} [inst : Monoid M]
[inst_1 : CommSemiring S] [inst_2 : AddCommMonoid E] [inst_3 : AddCommMonoid E'] [inst_4 : AddCommMonoid F]
[inst_5 : Module S E] [inst_6 : Module S E'] [inst_7 : Module S F] [inst_8 : TopologicalSpace F] [T2Space F]
[... | true |
Lean.ExtraModUse.mk._flat_ctor | Lean.ExtraModUses | Lean.Name → Bool → Bool → Lean.ExtraModUse | false |
Lean.Parser.Syntax.atom._regBuiltin.Lean.Parser.Syntax.atom.formatter_7 | Lean.Parser.Syntax | IO Unit | false |
BoundedContinuousFunction.instAddMonoid.eq_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[inst_3 : BoundedAdd R] [inst_4 : ContinuousAdd R],
BoundedContinuousFunction.instAddMonoid =
{ toAdd := BoundedContinuousFunction.instAdd, add_assoc := ⋯, toZero := BoundedContinuousFunction.instZero... | true |
_private.Init.Data.SInt.Bitwise.0.Int64.shiftLeft_or._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int64}, (a = b) = (a.toBitVec = b.toBitVec) | false |
MeasureTheory.measure_ne_zero_iff_nonempty_of_isMulLeftInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G] [μ.IsMulLeftInvariant] [μ.Regular],
μ ≠ 0 → ∀ {s : Set G}, IsOpen s → (μ s ≠ 0 ↔ s.Nonempty) | true |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.separableSpace_iff_countable._simp_1_1 | Mathlib.Topology.Bases | ∀ (α : Type u) [t : TopologicalSpace α], TopologicalSpace.SeparableSpace α = ∃ s, s.Countable ∧ Dense s | false |
GrpCat.abelianizeAdj._proof_2 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ {X : GrpCat} {Y Y' : CommGrpCat} (f : GrpCat.abelianize.obj X ⟶ Y) (g : Y ⟶ Y'),
((CategoryTheory.ConcreteCategory.homEquiv.trans Abelianization.lift.symm).trans
CategoryTheory.ConcreteCategory.homEquiv.symm)
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(((Ca... | false |
PreTilt.instCommRing._proof_22 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p] (a : PreTilt O p),
1 * a = a | false |
List.Perm.product_right | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (t₁ : List β), l₁.Perm l₂ → (l₁.product t₁).Perm (l₂.product t₁) | true |
_private.Mathlib.Order.SupIndep.0.iSupIndep_ne_bot._simp_1_2 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iSup s = ⊥) = ∀ (i : ι), s i = ⊥ | false |
RootPairing.InvariantForm.apply_root_root_zero_iff._simp_1 | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (B : P.InvariantForm)
(i j : ι) [IsDomain R] [NeZero 2], ((B.form (P.root i)) (P.root j) = 0) = (P.pairing i j =... | false |
Std.Iter.repeat | Std.Data.Iterators.Producers.Repeat | {α : Type w} → (f : α → α) → α → Std.Iter α | true |
SelectInsertParamsClass.replaceRange | Mathlib.Tactic.Widget.SelectInsertParamsClass | {α : Type} → [self : SelectInsertParamsClass α] → α → Lean.Lsp.Range | true |
Prod.card_box_succ | Mathlib.Order.Interval.Finset.Box | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : Ring β]
[inst_4 : PartialOrder β] [IsOrderedRing β] [inst_6 : LocallyFiniteOrder α] [inst_7 : LocallyFiniteOrder β]
[inst_8 : DecidableEq α] [inst_9 : DecidableEq β] [inst_10 : DecidableLE (α × β)] (n : ℕ),
(Fins... | true |
CategoryTheory.Limits.WalkingMultispan.instFintype._proof_7 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ (J : CategoryTheory.Limits.MultispanShape),
Function.LeftInverse
(fun x =>
match x with
| CategoryTheory.Limits.WalkingMultispan.left a => Sum.inl a
| CategoryTheory.Limits.WalkingMultispan.right a => Sum.inr a)
fun x =>
match x with
| Sum.inl a => CategoryTheory.Limits.WalkingMult... | false |
Std.LawfulOrderOrd.rec | Init.Data.Order.ClassesExtra | {α : Type u} →
[inst : Ord α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderOrd α → Sort u_1} →
((isLE_compare : ∀ (a b : α), (compare a b).isLE = true ↔ a ≤ b) →
(isGE_compare : ∀ (a b : α), (compare a b).isGE = true ↔ b ≤ a) → motive ⋯) →
(t : Std.LawfulOrderOrd α) → motive t | false |
Lean.CollectMVars.State | Lean.Util.CollectMVars | Type | true |
Lean.instToExprRat.mkInt | Lean.ToExpr | ℤ → Lean.Expr | true |
CategoryTheory.Limits.FormalCoproduct.eval | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
(A : Type u₁) →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
[CategoryTheory.Limits.HasCoproducts A] →
CategoryTheory.Functor (CategoryTheory.Functor C A)
(CategoryTheory.Functor (CategoryTheory.Limits.FormalCoproduc... | true |
Metric.uniformity_basis_dist_inv_nat_pos | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α],
(uniformity α).HasBasis (fun n => 0 < n) fun n => {p | dist p.1 p.2 < 1 / ↑n} | true |
Algebra.FinitePresentation.mk | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type w₁} {A : Type w₂} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
(∃ n f, Function.Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG) → Algebra.FinitePresentation R A | true |
Profinite.isTerminalPUnit | Mathlib.Topology.Category.Profinite.Limits | CategoryTheory.Limits.IsTerminal (Profinite.of PUnit.{u + 1}) | true |
WithVal.instField._proof_16 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Field R] (v : Valuation R Γ₀)
(x y : WithVal v),
(WithVal.equiv v).toEquiv ((WithVal.equiv v).symm ((WithVal.equiv v).toEquiv x * (WithVal.equiv v).toEquiv y)) =
(WithVal.equiv v).toEquiv x * (WithVal.equiv v).toEquiv y | false |
HahnSeries | Mathlib.RingTheory.HahnSeries.Basic | (Γ : Type u_1) → (R : Type u_2) → [PartialOrder Γ] → [Zero R] → Type (max u_1 u_2) | true |
CategoryTheory.Bicategory.pentagon_inv_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (i : d ⟶ e)
{Z : a ⟶ e}
(h_1 :
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h)
i ⟶
Z),
CategoryTheory.CategoryStruct.comp
... | true |
Std.DHashMap.Raw.Const.getD_insert_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {fallback v : β}, Std.DHashMap.Raw.Const.getD (m.insert k v) k fallback = v | true |
CategoryTheory.IsCardinalFiltered.of_le | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ (J : Type u) [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [hκ : Fact κ.IsRegular]
[CategoryTheory.IsCardinalFiltered J κ] {κ' : Cardinal.{w}} [inst_2 : Fact κ'.IsRegular],
κ' ≤ κ → CategoryTheory.IsCardinalFiltered J κ' | true |
Nat.add_descFactorial_eq_ascFactorial' | Mathlib.Data.Nat.Factorial.Basic | ∀ (n k : ℕ), (n + k - 1).descFactorial k = n.ascFactorial k | true |
sbtw_const_vadd_iff._simp_1 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (v : V), Sbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) = Sbtw R x y z | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.uppcRec_true_iff._proof_1_11 | Init.Data.BitVec.Bitblast | ∀ (w : ℕ) (x : BitVec (w + 1)) (s : ℕ),
2 ^ (w - s) ≤ 2 ^ (w - (s - 1)) → 2 ^ (w - (s - 1)) ≤ x.toNat → ¬2 ^ (w - s) ≤ x.toNat → False | false |
UniqueFactorizationMonoid.prod_normalizedFactors_eq | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : UniqueFactorizationMonoid α]
{a : α}, a ≠ 0 → (UniqueFactorizationMonoid.normalizedFactors a).prod = normalize a | true |
norm_mul_le | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : NonUnitalSeminormedRing α] (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | true |
Hyperreal.archimedeanClassMk_coe_nonneg | Mathlib.Analysis.Real.Hyperreal | ∀ (x : ℝ), 0 ≤ ArchimedeanClass.mk ↑x | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.nonempty_closedBall.match_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ} (motive : (Metric.closedBall x ε).Nonempty → Prop)
(x_1 : (Metric.closedBall x ε).Nonempty), (∀ (_x : α) (hx : _x ∈ Metric.closedBall x ε), motive ⋯) → motive x_1 | false |
RingCat.Colimits.descFunLift.match_1 | Mathlib.Algebra.Category.Ring.Colimits | {J : Type u_1} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J RingCat) →
(motive : RingCat.Colimits.Prequotient F → Sort u_2) →
(x : RingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (RingCat.Colimits.Prequotient.of j x)) →
(Unit ... | false |
CochainComplex.HomComplex.Cochain.leftUnshift_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n a n' : ℤ) (hn' : n + a = n'), CochainComplex.HomComplex.Cochain.leftUnshift 0 n hn' = 0 | true |
Lean.Elab.DelabTermInfo.location? | Lean.Elab.InfoTree.Types | Lean.Elab.DelabTermInfo → Option Lean.DeclarationLocation | true |
String.Pos.ofSliceFrom_prev._proof_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {h : p ≠ (s.sliceFrom p₀).startPos},
String.Pos.ofSliceFrom p ≠ s.startPos | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ} (s : ℕ),
i + 1 ≤ (List.findIdxs p [] s).length → i < (List.findIdxs p [] s).length | false |
_private.Mathlib.Topology.Connected.Basic.0.IsPreconnected.subset_or_subset._simp_1_2 | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} {s t : Set α}, (s ∩ t = ∅) = Disjoint s t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.