name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
grade_strictMono | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
StrictMono (grade 𝕆) | true |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (h : j < i),
(xs.set i a w).eraseIdx j ⋯ = (xs.eraseIdx j ⋯).set (i - 1) a ⋯ | true |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X ⟶ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom | true |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} → [inst : DivisionRing K] → PartialOrder (Subfield K) | true |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | (L : FirstOrder.Language) → (M : Type w) → [L.Structure M] → Set (CategoryTheory.Bundled L.Structure) | true |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [inst_3 : Zero γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | true |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α : Type u_1} (a : α), Std.Do.PredTrans.Conjunctive fun Q => Q.1 a | false |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : ℕ),
0 < ↑x ^ n | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_430 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5 | Mathlib.Tactic.MkIffOfInductiveProp | (motive : ℕ → ℕ → Sort u_1) →
(m n : ℕ) →
(Unit → motive 0 0) →
((n : ℕ) → motive 0 n.succ) → ((m n : ℕ) → motive m.succ n.succ) → ((x x_1 : ℕ) → motive x x_1) → motive m n | false |
NNRat.nndist_eq._simp_1 | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist ↑p ↑q = nndist p q | false |
List.Sublist.tail | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.tail.Sublist l₂.tail | true |
«term_<|_» | Init.Notation | Lean.TrailingParserDescr | true |
CategoryTheory.Under.map.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y),
CategoryTheory.Under.map f =
CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun x => f) | true |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.format | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfoMap → Lean.Compiler.LCNF.CompilerM Std.Format | true |
smul_nonneg_iff_neg_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[PosSMulStrictMono α β] {a : α} {b : β}, 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) | true |
Projectivization.logHeight_mk | Mathlib.NumberTheory.Height.Projectivization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [inst_2 : Finite ι] {x : ι → K}
(hx : x ≠ 0), (Projectivization.mk K x hx).logHeight = Height.logHeight x | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right' | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
CategoryTheory.Limits.HasLimit
(CategoryTheory.Limits.cospan
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.Sheaf... | true |
if_true_right._simp_1 | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then q else True) = (p → q) | false |
ENat.forall_natCast_le_iff_le | Mathlib.Data.ENat.Basic | ∀ {m n : ℕ∞}, (∀ (a : ℕ), ↑a ≤ m → ↑a ≤ n) ↔ m ≤ n | true |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n : ℕ), ¬Std.Tactic.BVDecide.BVUnOp.clz = Std.Tactic.BVDecide.BVUnOp.rotateRight n | false |
Plausible.Testable.mk | Plausible.Testable | {p : Prop} → (Plausible.Configuration → Bool → Plausible.Gen (Plausible.TestResult p)) → Plausible.Testable p | true |
Complex.arg_of_im_pos | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, 0 < z.im → z.arg = Real.arccos (z.re / ‖z‖) | true |
Nat.dfold_zero._proof_7 | Init.Data.Nat.Fold | 0 ≤ 0 | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_70 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Ideal.comap_map_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided],
I ≤ J → Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J | true |
prodXSubSMul.eval | Mathlib.Algebra.Polynomial.GroupRingAction | ∀ (G : Type u_2) [inst : Group G] [inst_1 : Fintype G] (R : Type u_3) [inst_2 : CommRing R]
[inst_3 : MulSemiringAction G R] (x : R), Polynomial.eval x (prodXSubSMul G R x) = 0 | true |
QuotientGroup.instSeminormedCommGroup._proof_4 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M) (x y z : M ⧸ S), dist x z ≤ dist x y + dist y z | false |
Order.IsIntent.eq | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} {t : Set β}, Order.IsIntent r t → upperPolar r (lowerPolar r t) = t | true |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum'_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_3} {β : Type u_4} {M : Matroid α} (f : α ≃ β) {I X : Set β},
(M.mapEquiv f).IsBasis I X = M.IsBasis (⇑f.symm '' I) (⇑f.symm '' X) | false |
Set.InjOn.eq_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x = f y ↔ x = y) | 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 | true |
DomAddAct.instAddCommMonoidOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [AddCommMonoid Mᵃᵒᵖ] → AddCommMonoid Mᵈᵃᵃ | true |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_le_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander | 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 | 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✝¹ ⋯ | true |
jacobiSym.mul_right' | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b₁ b₂ : ℕ}, b₁ ≠ 0 → b₂ ≠ 0 → jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂ | true |
TopCommRingCat.hasForgetToTopCat | Mathlib.Topology.Category.TopCommRingCat | CategoryTheory.HasForget₂ TopCommRingCat TopCat | true |
Equiv.Perm.coe_pow._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} (f : Equiv.Perm α) (n : ℕ), (⇑f)^[n] = ⇑(f ^ n) | 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... | false |
_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) →
(__discr : α × Lean.Meta.Simp.State) → ((r : α) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive __discr | false |
Batteries.Tactic.PrintPrefixConfig.imported._default | Batteries.Tactic.PrintPrefix | Bool | false |
Qq.unpackParensIdent | Qq.Match | Lean.Syntax → Option Lean.Syntax | 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) | false |
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 | true |
Finmap.lookup_eq_none | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Finmap β}, Finmap.lookup a s = none ↔ a ∉ s | true |
even_neg._simp_1 | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | false |
Lean.Elab.Info.format | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.Info → IO Std.Format | true |
Int64.toISize_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ^^^ b).toISize = a.toISize ^^^ b.toISize | true |
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... | 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) | false |
Bool.not_eq_eq_eq_not | Init.SimpLemmas | ∀ {a b : Bool}, (!a) = b ↔ a = !b | 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) | 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 | true |
MeasureTheory.Measure.restrict_apply_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α), (μ.restrict s) s = μ s | true |
Array.filter_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool}, Array.filter p #[] = #[] | true |
BoundedContinuousFunction.instLattice._proof_4 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β],
Function.Injective fun f => ⇑f | false |
Lean.IR.SimpleGroundExpr.string | Lean.Compiler.IR.SimpleGroundExpr | String → Lean.IR.SimpleGroundExpr | true |
_private.Plausible.Gen.0.Plausible.Gen.permutationOf._proof_7 | Plausible.Gen | ∀ {α : Type u_1} (ys : List α), ¬0 ≤ ys.length → False | false |
_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) | 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) | 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 | 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 : ∀... | 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'... | false |
Lean.Omega.Fin.lt_of_not_le | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, ¬i ≤ j → j < i | true |
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... | false |
_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... | false |
QuotientGroup.fintypeQuotientRightRel | Mathlib.GroupTheory.Coset.Card | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → [Fintype (α ⧸ s)] → Fintype (Quotient (QuotientGroup.rightRel s)) | 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 | true |
Lean.Omega.IntList.mul_get | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList) (i : ℕ), (xs * ys).get i = xs.get i * ys.get i | true |
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 | false |
Batteries.RBNode.foldr_reverse | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Batteries.RBNode α} {f : α → β → β} {init : β},
Batteries.RBNode.foldr f t.reverse init = Batteries.RBNode.foldl (flip f) init t | true |
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) | true |
Option.get!_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α], none.get! = default | true |
_private.Lean.Compiler.LCNF.Simp.SimpM.0.Lean.Compiler.LCNF.Simp.withIncRecDepth.throwMaxRecDepth.match_3 | Lean.Compiler.LCNF.Simp.SimpM | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((declName : Lean.Name) → (stack : List Lean.Name) → motive (declName :: stack)) → motive x | false |
_private.Mathlib.Data.Set.Prod.0.Set.pi_inter_distrib._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)},
(s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ | false |
sub_lt_comm | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, a - b < c ↔ a - c < b | true |
SimpleGraph.Walk.take_add_eq | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (n m : ℕ),
p.take (n + m) = ((p.take n).append ((p.drop n).take m)).copy ⋯ ⋯ | true |
PadicInt.withValIntegersRingEquiv | Mathlib.NumberTheory.Padics.WithVal | {p : ℕ} → [inst : Fact (Nat.Prime p)] → ↥(Valued.integer (Rat.padicValuation p).Completion) ≃+* ℤ_[p] | true |
DiscreteTiling.PlacedTile.coe_nonempty_iff | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} {pt : DiscreteTiling.PlacedTile ps}, (↑pt).Nonempty ↔ (↑(↑ps pt.index)).Nonempty | true |
Std.PRange.Least?.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
(t : Std.PRange.Least? α) → ((least? : Option α) → motive { least? := least? }) → motive t | false |
ContinuousMap.Homotopy.casesOn | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{motive : f₀.Homotopy f₁ → Sort u_1} →
(t : f₀.Homotopy f₁) →
((toContinuousMap : C(↑unitInterval × X, Y)) →
(map_zero_left : ∀ (x : X... | false |
AddHomClass.toAddHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_add' := ⋯ } | true |
TopologicalSpace.NonemptyCompacts.coe_map | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (s : TopologicalSpace.NonemptyCompacts α),
↑(TopologicalSpace.NonemptyCompacts.map f hf s) = f '' ↑s | true |
Std.PreorderPackage.ofLE._proof_3 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (args : Std.Packages.PreorderOfLEArgs α), Std.IsPreorder α | false |
_private.Mathlib.Analysis.Convex.Function.0.strictConvexOn_iff_div._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | false |
Subring.mem_mk'._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R} (ha : ↑sa = s)
{x : R}, (x ∈ Subring.mk' s sm sa hm ha) = (x ∈ s) | false |
instPartialOrderGroupCone | Mathlib.Algebra.Order.Group.Cone | (G : Type u_1) → [inst : CommGroup G] → PartialOrder (GroupCone G) | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCycles_f | 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) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | true |
IsLowerSet.null_frontier | Mathlib.MeasureTheory.Order.UpperLower | ∀ {ι : Type u_1} [inst : Fintype ι] {s : Set (ι → ℝ)}, IsLowerSet s → MeasureTheory.volume (frontier s) = 0 | true |
_private.Aesop.RuleSet.0.Aesop.BaseRuleSet.merge.match_1 | Aesop.RuleSet | (motive : Option (Aesop.UnorderedArraySet Aesop.RuleName) → Sort u_1) →
(x : Option (Aesop.UnorderedArraySet Aesop.RuleName)) →
(Unit → motive none) → ((ns : Aesop.UnorderedArraySet Aesop.RuleName) → motive (some ns)) → motive x | false |
MulEquiv.symmEquiv_apply_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : P ≃* Q) (a : Q),
((MulEquiv.symmEquiv P Q) h) a = h.symm a | true |
CategoryTheory.Oplax.OplaxTrans.naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) {a b c : B} (f : a ⟶ b)
(g : b ⟶ c) {Z : F.obj a ⟶ G.obj c}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryT... | true |
MeasureTheory.measureUnivNNReal | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → NNReal | true |
Lean.Server.Watchdog.handleDidChange | Lean.Server.Watchdog | Lean.Lsp.DidChangeTextDocumentParams → Lean.Server.Watchdog.ServerM Unit | true |
isPRadical_iff | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommSemiring K] [inst_1 : CommSemiring L] (i : K →+* L) (p : ℕ),
IsPRadical i p ↔ (∀ (x : L), ∃ n y, i y = x ^ p ^ n) ∧ RingHom.ker i ≤ pNilradical K p | true |
Filter.Tendsto.nonpos_add_atBot | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedAddMonoid M] {l : Filter α}
{f g : α → M},
(∀ (x : α), f x ≤ 0) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot | true |
MeasureTheory.eLpNorm_conj | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {m : MeasurableSpace α} {𝕜 : Type u_5} [inst : RCLike 𝕜] (f : α → 𝕜) (p : ENNReal)
(μ : MeasureTheory.Measure α), MeasureTheory.eLpNorm ((starRingEnd (α → 𝕜)) f) p μ = MeasureTheory.eLpNorm f p μ | true |
Std.Internal.IO.Process.ResourceUsageStats.casesOn | Std.Internal.Async.Process | {motive : Std.Internal.IO.Process.ResourceUsageStats → Sort u} →
(t : Std.Internal.IO.Process.ResourceUsageStats) →
((cpuUserTime cpuSystemTime : Std.Time.Millisecond.Offset) →
(peakResidentSetSizeKb sharedMemorySizeKb unsharedDataSizeKb unsharedStackSizeKb minorPageFaults majorPageFaults
swap... | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_3 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(s : Set (Submodule R M)) (w : Submodule R M) (compl : IsCompl N w)
(motive : (∃ m ∈ s, N.linearProjOfIsCompl w compl ∘ₗ m.subtype ≠ 0) → Prop)
(x : ∃ m ∈ s, N.linearProjOfIsCompl w compl ∘ₗ m.subty... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.