name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Nat.not_dvd_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → ¬p ∣ n / p ^ n.factorization p | true |
MulLEAddHomClass.rec | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : Mul α] →
[inst_1 : Add β] →
[inst_2 : LE β] →
[inst_3 : FunLike F α β] →
{motive : MulLEAddHomClass F α β → Sort u} →
((map_mul_le_add : ∀ (f : F) (a b : α), f (a * b) ≤ f a + f b) → motive... | false |
Std.LawfulRightIdentity.mk | Init.Core | ∀ {α : Sort u} {β : Sort u_1} {op : α → β → α} {o : outParam β} [toRightIdentity : Std.RightIdentity op o],
(∀ (a : α), op a o = a) → Std.LawfulRightIdentity op o | true |
ChainComplex.of._proof_3 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{α : Type u_3} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
(d : (n : α) → X (n + 1) ⟶ X n),
(∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (... | false |
CategoryTheory.Functor.mapAction_obj_V | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
(M : Action V G), ((F.mapAction G).obj M).V = F.obj M.V | true |
Lean.Meta.Grind.setENode | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Meta.Grind.ENode → Lean.Meta.Grind.GoalM Unit | true |
Turing.ToPartrec.Code.rec._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.3 | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.ToPartrec.Code → Sort u} →
motive Turing.ToPartrec.Code.zero' →
motive Turing.ToPartrec.Code.succ →
motive Turing.ToPartrec.Code.tail →
((a a_1 : Turing.ToPartrec.Code) → motive a → motive a_1 → motive (a.cons a_1)) →
((a a_1 : Turing.ToPartrec.Code) → motive a → motive a_... | false |
List.foldr_range_eq_of_range_eq | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → α → α} {g : γ → α → α},
Set.range f = Set.range g → ∀ (a : α), Set.range (List.foldr f a) = Set.range (List.foldr g a) | true |
ENat.mul_iInf' | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_2} {f : ι → ℕ∞} {a : ℕ∞}, (a = 0 → Nonempty ι) → a * ⨅ i, f i = ⨅ i, a * f i | true |
NonUnitalSubalgebra.topologicalClosure._proof_1 | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalSemiring A] [IsSemitopologicalSemiring A],
ContinuousAdd A | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.evalNSMul._proof_1 | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)}, «$α» =Q ℕ | false |
UniqueFactorizationMonoid | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | (α : Type u_2) → [CommMonoidWithZero α] → Prop | true |
Rep.instConcreteCategoryIntertwiningMapVρ._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {X Y Z : Rep.{u_1, u_2, u_3} k G} (f : X ⟶ Y)
(g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | false |
TrivSqZeroExt.inr_injective | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Zero R], Function.Injective TrivSqZeroExt.inr | true |
ClosedSubmodule.orthogonal_orthogonal_eq | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : ClosedSubmodule 𝕜 E) [(↑K).HasOrthogonalProjection], Kᗮᗮ = K | true |
HomologicalComplex.mapBifunctor₁₂.d₁ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₁₂ : Type u_3} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_... | true |
SSet.skeletonOfMono_obj_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) [inst : CategoryTheory.Mono i] {d n : ℕ},
d < n → ((SSet.skeletonOfMono i) n).obj (Opposite.op (SimplexCategory.mk d)) = ⊤ | true |
CategoryTheory.GrothendieckTopology.mk.noConfusion | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{sieves : (X : C) → Set (CategoryTheory.Sieve X)} →
{top_mem' : ∀ (X : C), ⊤ ∈ sieves X} →
{pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves X → Cate... | false |
IsUniformAddGroup.to_topologicalAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsTopologicalAddGroup α | true |
Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| ⊔ |a ⊓ c - b ⊓ c| ≤ |a - b| | true |
AbsoluteValue.instSetoid | Mathlib.Analysis.AbsoluteValue.Equivalence | {R : Type u_1} →
[inst : Semiring R] → {S : Type u_2} → [inst_1 : Semiring S] → [inst_2 : PartialOrder S] → Setoid (AbsoluteValue R S) | true |
BddLat.Hom.casesOn | Mathlib.Order.Category.BddLat | {X Y : BddLat} →
{motive : X.Hom Y → Sort u_1} →
(t : X.Hom Y) → ((hom' : BoundedLatticeHom ↑X.toLat ↑Y.toLat) → motive { hom' := hom' }) → motive t | false |
FormalMultilinearSeries.le_radius_of_summable_norm | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {r : NNReal}
(p : FormalMultilinearSeries 𝕜 E F), (Summable fun n => ‖p n‖ * ↑r ^ n) → ↑r ≤ p.radius | true |
Std.Sat.AIG.BinaryRefVec.rhs_get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α}
(s : aig1.BinaryRefVec len) (idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).rhs.get idx hidx = (s.rhs.get idx hidx).cast hcast | true |
Ordinal.veblenWith.match_1 | Mathlib.SetTheory.Ordinal.Veblen | (o : Ordinal.{u_1}) →
(motive : { x // x ∈ Set.Iio o } → Sort u_2) →
(x : { x // x ∈ Set.Iio o }) → ((x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩) → motive x | false |
gal_zero_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F], IsSolvable (Polynomial.Gal 0) | true |
Lean.Server.Test.Runner.logRpcResponse | Lean.Server.Test.Runner | {α : Type u_1} →
Lean.Name →
[Lean.ToJson α] →
α →
(β : optParam Type Lean.Json) →
[Lean.FromJson β] →
[Lean.ToJson β] →
optParam Bool true →
optParam (β → Lean.Server.Test.Runner.Client.NormalizeM β) pure → Lean.Server.Test.Runner.RunnerM Unit | true |
hnot_le_iff_codisjoint_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢a ≤ b ↔ Codisjoint a b | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.Decl.extractClosed.match_1 | Lean.Compiler.LCNF.ExtractClosed | (motive : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State → Sort u_1) →
(__discr : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(s : Lean... | false |
LinearMap.instModuleDomMulActOfSMulCommClass._proof_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_2} {R' : Type u_3} {S : Type u_1} {M : Type u_4} {M' : Type u_5} [inst : Semiring R]
[inst_1 : Semiring R'] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M]
[inst_5 : Module R' M'] {σ₁₂ : R →+* R'} [inst_6 : Semiring S] [inst_7 : Module S M] [inst_8 : SMulCommClass R S M]
... | false |
Finite.Set.finite_replacement | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {β : Type v} [Finite α] (f : α → β), Finite ↑{x | ∃ x_1, f x_1 = x} | true |
SSet.Subcomplex.Pairing.pairingCore._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [inst : P.IsProper] {s t : ↑P.II},
{ dim := (↑s).dim + 1, simplex := ((↑(P.p s)).cast ⋯).simplex } =
{ dim := (↑t).dim + 1, simplex := ((↑(P.p t)).cast ⋯).simplex } →
s = t | false |
convexOn_norm | Mathlib.Analysis.Normed.Module.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → ConvexOn ℝ s norm | true |
_private.Mathlib.Probability.Kernel.RadonNikodym.0.ProbabilityTheory.Kernel.singularPart_compl_mutuallySingularSetSlice._simp_1_8 | Mathlib.Probability.Kernel.RadonNikodym | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
TopologicalSpace.OpenNhdsOf.instMax | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → Max (TopologicalSpace.OpenNhdsOf x) | true |
AddGroupExtension.Equiv.Simps.symm_apply.eq_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
{S : AddGroupExtension N E G} {E' : Type u_4} [inst_3 : AddGroup E'] {S' : AddGroupExtension N E' G}
(equiv : S.Equiv S'), AddGroupExtension.Equiv.Simps.symm_apply equiv = ⇑equiv.symm | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (p : Int.Linear.Poly) (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof),
sizeOf { p := p, h := h } = 1 + sizeOf p + sizeOf h | true |
ZeroHom.ctorIdx | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} → {N : Type u_11} → {inst : Zero M} → {inst_1 : Zero N} → ZeroHom M N → ℕ | false |
Std.HashSet.Raw.any_eq_not_all_not | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] {p : α → Bool},
m.WF → m.any p = !m.all fun a => !p a | true |
Std.DTreeMap.Internal.Cell.of | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → β k → Std.DTreeMap.Internal.Cell α β (compare k) | true |
Lean.Elab.Tactic.Do.Uses.casesOn | Lean.Elab.Tactic.Do.LetElim | {motive : Lean.Elab.Tactic.Do.Uses → Sort u} →
(t : Lean.Elab.Tactic.Do.Uses) →
motive Lean.Elab.Tactic.Do.Uses.zero →
motive Lean.Elab.Tactic.Do.Uses.one → motive Lean.Elab.Tactic.Do.Uses.many → motive t | false |
MeasureTheory.AddContent.mk.injEq | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommMonoid G] {C : Set (Set α)} (toFun : Set α → G) (empty' : toFun ∅ = 0)
(sUnion' : ∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun (⋃₀ ↑I) = ∑ u ∈ I, toFun u)
(toFun_1 : Set α → G) (empty'_1 : toFun_1 ∅ = 0)
(sUnion'_1 :
∀ (I : Finset... | true |
Filter.mem_comap._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g : Filter β} {m : α → β} {s : Set α}, (s ∈ Filter.comap m g) = ∃ t ∈ g, m ⁻¹' t ⊆ s | false |
Mathlib.Tactic.Push.initFn._@.Mathlib.Tactic.Push.609137422._hygCtx._hyg.4 | Mathlib.Tactic.Push | IO (Lean.Option Bool) | false |
_private.Lean.Meta.Tactic.Constructor.0.Lean.MVarId.existsIntro._sparseCasesOn_2 | Lean.Meta.Tactic.Constructor | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Graded.equiv_symm_apply_coe | Mathlib.Data.FunLike.Graded | ∀ {E : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_4} {τ : Type u_5} {ι : Type u_6} [inst : SetLike σ A]
[inst_1 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} [inst_2 : EquivLike E A B] [inst_3 : GradedEquivLike E 𝒜 ℬ] (e : E)
(i : ι) (y : ↥(ℬ i)), ↑((Graded.equiv e i).symm y) = EquivLike.inv e ↑y | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {γ : Type u_1} →
(motive : Option γ → Sort u_2) →
(__do_lift : Option γ) → (Unit → motive none) → ((fb : γ) → motive (some fb)) → motive __do_lift | true |
CategoryTheory.inhabitedLiftableCocone | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone (K.comp (CategoryTheory.Functor.id C))) →
Inhabited (CategoryTheory.LiftableCocone K ... | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_6 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | 0 ≤ 1 | false |
R1Space.specializes_or_disjoint_nhds | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_3} {inst : TopologicalSpace X} [self : R1Space X] (x y : X), x ⤳ y ∨ Disjoint (nhds x) (nhds y) | true |
Aesop.Frontend.Feature.elab._unsafe_rec | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.Feature | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT.0.CategoryTheory.Triangulated.TStructure.isLE_truncLE_obj._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ (a b : ℤ), a ≤ b → a + 1 ≤ b + 1 | false |
Set.self_mem_Iic | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ Set.Iic a | true |
Submonoid.center.commMonoid'.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : MulOneClass M],
Submonoid.center.commMonoid' =
{ toMul := (Submonoid.center M).toMulOneClass.toMul, mul_assoc := ⋯,
toOne := (Submonoid.center M).toMulOneClass.toOne, one_mul := ⋯, mul_one := ⋯, npow := npowRecAuto,
npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } | true |
SimpleGraph.IsFiveWheelLike.card_right | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {s : Finset α} {G : SimpleGraph α} {r k : ℕ} [inst : DecidableEq α] {v w₁ w₂ : α} {t : Finset α},
G.IsFiveWheelLike r k v w₁ w₂ s t → t.card = r | true |
Lean.Elab.Term.instToStringArg.match_1 | Lean.Elab.App | (motive : Lean.Elab.Term.Arg → Sort u_1) →
(x : Lean.Elab.Term.Arg) →
((val : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx val)) →
((val : Lean.Expr) → motive (Lean.Elab.Term.Arg.expr val)) → motive x | false |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith_mk_mul._proof_1_10 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u_1} [inst : DecidableEq α] (g : FreeGroup α), 2 ≤ g.toWord.length → 1 < g.toWord.length | false |
_private.Mathlib.Tactic.Explode.Pretty.0.Mathlib.Explode.rowToMessageData.match_1 | Mathlib.Tactic.Explode.Pretty | (motive : Mathlib.Explode.Status → Sort u_1) →
(x : Mathlib.Explode.Status) →
(Unit → motive Mathlib.Explode.Status.sintro) →
(Unit → motive Mathlib.Explode.Status.intro) →
(Unit → motive Mathlib.Explode.Status.cintro) →
(Unit → motive Mathlib.Explode.Status.lam) → (Unit → motive Mathlib.E... | false |
AlgebraicGeometry.Scheme.Cover.fromGlued_isOpenEmbedding | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover),
Topology.IsOpenEmbedding ⇑(AlgebraicGeometry.Scheme.Cover.fromGlued 𝒰) | true |
WithBot.ofDual_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x : WithBot αᵒᵈ} {y : WithTop α}, WithBot.ofDual x ≤ y ↔ WithTop.toDual y ≤ x | true |
AlgebraicGeometry.Scheme.instIsOpenImmersionMapOfHomAwayAlgebraMap | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {R : Type u_1} [inst : CommRing R] (f : R),
AlgebraicGeometry.IsOpenImmersion
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away f)))) | true |
Matrix.adjugate_conjTranspose | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : Matrix n n α), A.adjugate.conjTranspose = A.conjTranspose.adjugate | true |
CategoryTheory.GradedNatTrans.naturality_assoc | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{A : CategoryTheory.Center V} {F G : CategoryTheory.EnrichedFunctor V C D}
(self : Categor... | true |
Submodule.smithNormalFormOfLE._proof_7 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n : ℕ)
(x : ∃ o, ∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))),
∃ (hno : n ≤ Classical.choose x), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.ca... | false |
DyckWord.le_add_self | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p q : DyckWord), q ≤ p + q | true |
CategoryTheory.Bicategory.Adj.Bicategory.associator_hom_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : CategoryTheory.Bicategory.Adj B} (α : a ⟶ b) (β : b ⟶ c)
(γ : c ⟶ d),
(CategoryTheory.Bicategory.Adj.Bicategory.associator α β γ).hom.τl =
(CategoryTheory.Bicategory.associator α.l β.l γ.l).hom | true |
NonAssocRing.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀... | false |
upperSemicontinuousOn_iff_restrict._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
UpperSemicontinuous (s.restrict f) = UpperSemicontinuousOn f s | false |
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.guard.parenthesizer_105 | Lean.Meta.Tactic.Grind.Parser | IO Unit | false |
_private.Init.Core.0.if_neg.match_1_1 | Init.Core | ∀ {c : Prop} (motive : Decidable c → Prop) (h : Decidable c),
(∀ (hc : c), motive (isTrue hc)) → (∀ (h : ¬c), motive (isFalse h)) → motive h | false |
NonUnitalStarSubalgebra.ofClass._proof_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : SetLike S A]
[NonUnitalSubsemiringClass S A] (s : S), 0 ∈ s | false |
_private.Mathlib.Order.KrullDimension.0.Order.height_eq_krullDim_Iic._simp_1_3 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
Subgroup.commutator_le_focalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), commutator ↥H ≤ H.focalSubgroupOf | true |
instDecidableEqNzsNum | Mathlib.Data.Num.Bitwise | DecidableEq NzsNum | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Mathlib.Meta.NormNum.evalRPow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | (motive :
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Sort u_1) →
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.NormNum.... | false |
tendsto_mul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {a b : M},
Filter.Tendsto (fun p => p.1 * p.2) (nhds (a, b)) (nhds (a * b)) | true |
Lean.Compiler.LCNF.LambdaLifting.State.recOn | Lean.Compiler.LCNF.LambdaLifting | {motive : Lean.Compiler.LCNF.LambdaLifting.State → Sort u} →
(t : Lean.Compiler.LCNF.LambdaLifting.State) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(nextIdx : ℕ) → motive { decls := decls, nextIdx := nextIdx }) →
motive t | false |
CategoryTheory.Abelian.mono_inr_of_isColimit | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
[CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono f]
{s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s), CategoryTheory.Mono s.inr | true |
HomotopicalAlgebra.FibrantObject.HoCat.localizerMorphismResolution | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences C)
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject.HoCat C)) | true |
Aesop.popGoal? | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Aesop.GoalRef) | true |
Algebra.SubmersivePresentation.ofHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : Finite σ] →
(P : Algebra.SubmersivePresentation R S ι σ) →
(R₀ : Type u_5) →
... | true |
Valuation.ltSubmodule_monotone | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
Monotone v.ltSubmodule | true |
OrthonormalBasis.coe_equiv_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E),
⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x => ∑ i, x.ofLp i • b i | true |
SModEq.symm | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x y : M}, x ≡ y [SMOD U] → y ≡ x [SMOD U] | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Basic.0.MeasureTheory.Measure.zero_le_toSignedMeasure._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, (0 ≤ μ.real s) = True | false |
Units.add._proof_1 | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (x : Rˣ) (t : R) (h : ‖t‖ < ‖↑x⁻¹‖⁻¹),
↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ = ↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.mk.injEq | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(inverts : W.IsInvertedBy L) (lift : (F : CategoryTh... | true |
Bifunctor.snd | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} → [Bifunctor F] → {α : Type u₀} → {β β' : Type u₁} → (β → β') → F α β → F α β' | true |
Lean.mkAppRange | Lean.Expr | Lean.Expr → ℕ → ℕ → Array Lean.Expr → Lean.Expr | true |
Lean.Parser.Term.fun._regBuiltin.Lean.Parser.Term.fun_1 | Lean.Parser.Term | IO Unit | false |
MeasureTheory.UniformIntegrable.memLp_of_ae_tendsto | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{p : ENNReal} {κ : Type u_4} {u : Filter κ} [u.NeBot] [u.IsCountablyGenerated] {f : κ → α → β} {g : α → β},
MeasureTheory.UniformIntegrable f p μ →
(∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) ... | true |
_private.Aesop.Builder.Forward.0.Aesop.RuleBuilder.getImmediatePremises._sparseCasesOn_1 | Aesop.Builder.Forward | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
Set.infinite_of_injective_forall_mem | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} [Infinite α] {s : Set β} {f : α → β},
Function.Injective f → (∀ (x : α), f x ∈ s) → s.Infinite | true |
IntCast.rec | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → ((intCast : ℤ → R) → motive { intCast := intCast }) → (t : IntCast R) → motive t | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_isClosed_diagonal._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | false |
QuadraticForm.radical_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : Field 𝕜] [NeZero 2] [inst_2 : Fintype ι] {w : ι → 𝕜},
(QuadraticMap.weightedSumSquares 𝕜 w).radical = Pi.spanSubset 𝕜 {i | w i = 0} | true |
Std.Rxi.HasSize.rec | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
((size : α → ℕ) → motive { size := size }) → (t : Std.Rxi.HasSize α) → motive t | false |
CategoryTheory.ShortComplex.RightHomologyMapData.mk | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
(φQ : h₁.Q ⟶ h₂.Q) →
... | true |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop._proof_3 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {R : CommRingCat} {ι : Type u_1} (s : ι → ↑R),
Ideal.span (Set.range s) = ⊤ → ∀ (x : ↥(AlgebraicGeometry.Spec R)), ∃ i, s i ∉ x.asIdeal | false |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.Tree.term | Lean.Elab.Extra | Lean.Syntax → Lean.PersistentArray Lean.Elab.InfoTree → Lean.Expr → Lean.Elab.Term.Op.Tree✝ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.