name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
BitVec.smod_eq | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w),
x.smod y =
match x.msb, y.msb with
| false, false => x.umod y
| false, true =>
have u := x.umod (-y);
if u = 0#w then u else u + y
| true, false =>
have u := (-x).umod y;
if u = 0#w then u else y - u
| true, true => -(-x).umod (-y) | true |
spectrum.subset_subalgebra | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubringClass S A] [inst_5 : SMulMemClass S R A] {s : S} (a : ↥s),
spectrum R ↑a ⊆ spectrum R a | true |
IsPrimitiveRoot.isIntegral | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K}, IsPrimitiveRoot μ n → 0 < n → IsIntegral ℤ μ | true |
Equiv.nonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β], e (e.symm 0) = 0 | false |
QPF.fixToW._proof_1 | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u_1 → Type u_1} [q : QPF F] (x y : (QPF.P F).W),
QPF.Wequiv x y → QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) x = QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) y | false |
FiberBundleCore.localTrivAsPartialEquiv_target | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι), (Z.localTrivAsPartialEquiv i).target = (Z.localTriv i).target | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Constructions.0.contMDiffWithinAt_pi_space._simp_1_4 | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.cocone_nonempty._simp_1_4 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_excenter_singleton_eq._proof_1_4 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₃ : Fin 3},
i₁ ≠ i₃ → ∃ x, ¬x = i₃ ∧ t.points x = t.points i₁ | false |
_private.Init.Data.UInt.Bitwise.0.UInt64.zero_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Lean.Omega.IntList.gcd_eq_zero._simp_1 | Init.Omega.IntList | ∀ {xs : Lean.Omega.IntList}, (xs.gcd = 0) = ∀ x ∈ xs, x = 0 | false |
Ring.DirectLimit.lift_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) (i : ι) (x : G i),
(Ring.DirectLimit.lift G f P g... | true |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.casesOn | Lean.Meta.InferType | {motive : Lean.Meta.ArrowPropResult✝ → Sort u} →
(t : Lean.Meta.ArrowPropResult✝¹) →
motive Lean.Meta.ArrowPropResult.false✝ →
motive Lean.Meta.ArrowPropResult.true✝ →
motive Lean.Meta.ArrowPropResult.undef✝ → ((idx : ℕ) → motive (Lean.Meta.ArrowPropResult.bvar✝ idx)) → motive t | false |
CategoryTheory.Monad.monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms._proof_1 | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D}
(adj : F ⊣ G) [CategoryTheory.Limits.HasReflexiveCoequalizers D] [G.ReflectsIsomorphisms]
[CategoryTheory.Monad.PreservesC... | false |
sigmaFinsuppEquivDFinsupp_symm_apply | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {η : ι → Type u_4} {N : Type u_5} [inst : Zero N] (f : Π₀ (i : ι), η i →₀ N) (s : (i : ι) × η i),
(sigmaFinsuppEquivDFinsupp.symm f) s = (f s.fst) s.snd | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_14 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
¬-1 * ↑i + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
((a ++ b).extract i j).size = (a.extract i j).size →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | false |
UInt8.ofBitVec_shiftRight_mod | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8) (b : ℕ), { toBitVec := a >>> (b % 8) } = { toBitVec := a } >>> UInt8.ofNat b | true |
Std.Time.TimeZone.convertTZif | Std.Time.Zoned.Database.Basic | Std.Time.TimeZone.TZif.TZif → String → Except String Std.Time.TimeZone.ZoneRules | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.Structured.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json.Structured → Sort u_1) →
(x : Lean.Json.Structured) →
((a : Array Lean.Json) → motive (Lean.Json.Structured.arr a)) →
((o : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.Structured.obj o)) → motive x | false |
CategoryTheory.SmallObject.SuccStruct.isColimitIterationCocone | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | true |
ULift.group._proof_6 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Group α] (x : ULift.{u_1, u_2} α) (x_1 : ℤ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) | false |
WithBot.unbotD_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] (d : α), WithBot.unbotD d 0 = 0 | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_11 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k < ↑i - 1 → ¬↑k + 1 < ↑j → ↑k < ↑j → ↑k < ↑i → ↑k + 1 + 1 = ↑k | false |
BddAbove.smul_of_nonpos | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : AddCommGroup β]
[inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β] {s : Set β} {a : α},
a ≤ 0 → BddAbove s → BddBelow (a • s) | true |
Orientation.norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖y‖ / (o.oangle (x - y) x).tan = ‖x‖ | true |
ValuationRing.instOfIsLocalRingOfIsBezout | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsLocalRing R] [IsBezout R], ValuationRing R | true |
RingHom.SurjectiveOnStalks.baseChange | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {T : Type u_3} [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra R S],
(algebraMap R T).SurjectiveOnStalks → (algebraMap S (TensorProduct R S T)).SurjectiveOnStalks | true |
Int.bmod_eq_of_le_mul_two | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {y : ℕ}, -↑y ≤ x * 2 → x * 2 < ↑y → x.bmod y = x | true |
Commute.conj | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → ∀ (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) | true |
lp.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_1} {α : Type u_3} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedField 𝕜]
[inst_2 : (i : α) → NormedSpace 𝕜 (E i)] (i : α), IsBoundedSMul 𝕜 (E i) | false |
ContinuousAffineMap.toContinuousMap_coe | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (f : P →ᴬ[R] Q), ... | true |
Int.neg_le_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → -b ≤ -a | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y), (I.precomp g).Y = Z | true |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_6 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
s = {t | t ∈ s ∧ IsOpen t} ∪ {t | t ∈ s ∧ IsClosed t} → {t | t ∈ s ∧ IsOpen t} ⊆ s | false |
Lean.Parser.Tactic.Conv.pattern | Init.Conv | Lean.ParserDescr | true |
Lean.Server.Test.Cancel._aux_Lean_Server_Test_Cancel___elabRules_Lean_Server_Test_Cancel_commandWait_for_cancel_once_command__1 | Lean.Server.Test.Cancel | Lean.Elab.Command.CommandElab | false |
_private.Mathlib.RingTheory.OreLocalization.NonZeroDivisors.0.OreLocalization.inv._simp_2 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {a : Prop}, (a ∨ a) = a | false |
instModuleGradedTensorProduct._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_1) {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSlice | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | {M : Type u_1} → [Add M] → Set M → Prop | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_minKey?._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) | false |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.of_equivalence._simp_1_1 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC.0.Lean.Meta.Grind.Arith.Cutsat.isNonlinearTerm | Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC | Lean.Expr → Lean.Meta.Grind.GoalM Bool | true |
Option.bind.match_1 | Init.Data.Option.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → (α → Option β) → Sort u_3) →
(x : Option α) →
(x_1 : α → Option β) →
((x : α → Option β) → motive none x) → ((a : α) → (f : α → Option β) → motive (some a) f) → motive x x_1 | false |
CategoryTheory.Functor.PreservesEffectiveEpis.recOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpis → Sort u} →
(t : F.PreservesEffectiveEpis) →
((preserves :
... | false |
OrderHom.instBotOfOrderBot | Mathlib.Order.Hom.Order | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [OrderBot β] → Bot (α →o β) | true |
Real.logb_nonpos_iff' | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 0 ≤ x → (Real.logb b x ≤ 0 ↔ x ≤ 1) | true |
List.tailD_nil | Init.Data.List.Basic | ∀ {α : Type u} {l' : List α}, [].tailD l' = l' | true |
EuclideanGeometry.Sphere.mk_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] (c : P) (r : ℝ), { center := c, radius := r }.center = c | true |
SymAlg.instOne.eq_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : One α], SymAlg.instOne = { one := SymAlg.sym 1 } | true |
MvPolynomial.quotientEquivQuotientMvPolynomial._proof_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (I : Ideal R), (Ideal.map MvPolynomial.C I).IsTwoSided | false |
FP.Float.isFinite._sparseCasesOn_1 | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
{motive : FP.Float → Sort u} →
(t : FP.Float) →
((a : Bool) → (e : ℤ) → (m : ℕ) → (a_1 : FP.ValidFinite e m) → motive (FP.Float.finite a e m a_1)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Equivalence.congrLeft._proof_5 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
(e : C ≌ D) (F : CategoryTheory.Functor C E),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.whiskeringLe... | false |
Std.DTreeMap.Const.getD_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{fallback : β} {f : Option β → Option β},
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.alter t k f) k' fallback =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).getD fallback... | true |
BoundedOrderHom.dual._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ), f.toFun ⊥ = ⊥ | false |
Membership.mem.step | Init.Data.Range.Basic | ∀ {i : ℕ} {r : Std.Legacy.Range}, i ∈ r → (i - r.start) % r.step = 0 | true |
Set.preimage_const_mul_Ioi₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {c : G₀} (a : G₀),
0 < c → (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c) | true |
MeasureTheory.Measure.addHaar_smul_of_nonneg | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
0 ≤ r → ∀ (s : Set E), μ (r • s) = ENNReal.ofReal (r ^ Module.finrank ℝ E) * μ s | true |
Lean.Doc.Block._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → [SizeOf i] → [SizeOf b] → SizeOf (Lean.Doc.Block i b) | false |
Int.tdiv_tmod_unique' | Init.Data.Int.DivMod.Lemmas | ∀ {a b r q : ℤ}, a ≤ 0 → b ≠ 0 → (a.tdiv b = q ∧ a.tmod b = r ↔ r + b * q = a ∧ -↑b.natAbs < r ∧ r ≤ 0) | true |
Aesop.GoalUnsafe.brecOn_2.eq | Aesop.Tree.Data | ∀ {motive_1 : Aesop.GoalUnsafe → Sort u} {motive_2 : Aesop.MVarClusterUnsafe → Sort u}
{motive_3 : Aesop.RappUnsafe → Sort u} {motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u}
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u}
{motive_6 : Aesop.RappData Aesop... | true |
PerfectClosure.liftOn.congr_simp | Mathlib.FieldTheory.PerfectClosure | ∀ {K : Type u} [inst : CommRing K] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] {L : Type u_1}
(x x_1 : PerfectClosure K p),
x = x_1 →
∀ (f f_1 : ℕ × K → L) (e_f : f = f_1) (hf : ∀ (x y : ℕ × K), PerfectClosure.R K p x y → f x = f y),
x.liftOn f hf = x_1.liftOn f_1 ⋯ | true |
Lean.Meta.getCtorNumPropFields | Lean.Meta.Tactic.Injection | Lean.ConstructorVal → Lean.MetaM ℕ | true |
_private.Mathlib.Data.Sign.Basic.0.sign_sum._simp_1_3 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableLT α] {a : α}, (SignType.sign a = 1) = (0 < a) | false |
Std.TreeSet.Equiv.get?_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.get? k = t₂.get? k | true |
RingHom.IsStandardSmooth.smooth | Mathlib.RingTheory.RingHom.LocallyStandardSmooth | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.IsStandardSmooth → f.Smooth | true |
LocallyConstant.constMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : MulOneClass Y] (y : Y),
LocallyConstant.constMonoidHom y = LocallyConstant.const X y | true |
Lean.Meta.withIncSynthPending | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α | true |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0._aux_Mathlib_RingTheory_Perfectoid_BDeRham___unexpand_BDeRhamPlus_1 | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.PrettyPrinter.Unexpander | false |
List.maxIdxOn_lt_length._simp_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []),
(List.maxIdxOn f xs h < xs.length) = True | false |
OreLocalization.instCommMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(a : OreLocalization S R), 0 * a = 0 | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT._proof_4 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [Std.TransOrd α] (k : α) (size : ℕ) (ky : α) (y : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(∃ a ∈ Std.DTreeMap.Internal.Impl.inner size ky y l r, compare a k = Ordering.lt) →
¬compare k ky = Ordering.gt → ∃ a ∈ l, compare a k = Ordering.lt | false |
MeasureTheory.ae_eq_of_forall_setIntegral_eq_of_sigmaFinite | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [MeasureTheory.SigmaFinite μ] {f g : α → E},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), Measurabl... | true |
Meromorphic.sub | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f g : 𝕜 → E}, Meromorphic f → Meromorphic g → Meromorphic (f - g) | true |
IsSepClosure.mk._flat_ctor | Mathlib.FieldTheory.IsSepClosed | ∀ {k : Type u} [inst : Field k] {K : Type v} [inst_1 : Field K] [inst_2 : Algebra k K],
IsSepClosed K → Algebra.IsSeparable k K → IsSepClosure k K | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.swapRows | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
[self : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α] → {n m : ℕ} → α n m → ℕ → ℕ → α n m | true |
Submodule.comapSubtypeEquivOfLe_symm_apply | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (hpq : p ≤ q) (x : ↥p), (Submodule.comapSubtypeEquivOfLe hpq).symm x = ⟨⟨↑x, ⋯⟩, ⋯⟩ | true |
Batteries.RBNode.WF.below.casesOn | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {motive : (a : Batteries.RBNode α) → Batteries.RBNode.WF cmp a → Prop}
{motive_1 : {a : Batteries.RBNode α} → (t : Batteries.RBNode.WF cmp a) → Batteries.RBNode.WF.below t → Prop}
{a : Batteries.RBNode α} {t : Batteries.RBNode.WF cmp a} (t_1 : Batteries.RBNode.WF.below t),
... | false |
MvPolynomial.algebraTensorAlgEquiv._proof_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u_3) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
(Algebra.TensorProduct.lift (Algebra.ofId A (MvPolynomial σ A)) (MvPolynomial.mapAlgHom (Algebra.ofId R A)) ⋯).comp
(MvPolynomial.aeval fun s => 1 ⊗ₜ[R] MvPolynomial.X s) =
AlgHom.id A (M... | false |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.restrict_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (a < b) = (↑a < ↑b) | false |
Lean.Syntax.getArg | Init.Prelude | Lean.Syntax → ℕ → Lean.Syntax | true |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instFromJsonDependencyBuildMode.fromJson.match_3 | Lean.Data.Lsp.Extra | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x | false |
Finset.zsmul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Zero α] [inst_2 : Add α] [inst_3 : Neg α],
Finset.zsmul = { smul := fun x x_1 => zsmulRec nsmulRec x x_1 } | true |
MeasurableEquiv.map_measurableEquiv_injective | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSpace β] (e : α ≃ᵐ β),
Function.Injective (MeasureTheory.Measure.map ⇑e) | true |
CategoryTheory.Limits.ReflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) → [CategoryTheory.Category.{w', w} J] → CategoryTheory.Functor C D → Prop | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.0.gosper_catalan_sub_eq_central_binom_div._simp_1_7 | Mathlib.Combinatorics.Enumerative.Catalan | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt},
CategoryTheory.CategoryStruct.comp k t.fst = CategoryTheory.CategoryStruct.comp l t.fst →
CategoryTheory.Cate... | true |
LieAlgebra.lieCharacterEquivLinearDual_symm_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(ψ : Module.Dual R L), LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ } | true |
IsReduced.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R | false |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.FormalCoproduct.evalOp C ... | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {t : Finset (α × β × γ)} {b : β} {c : γ}
(motive : (∃ a, (a, b, c) ∈ t) → Prop) (x : ∃ a, (a, b, c) ∈ t), (∀ (w : α) (h : (w, b, c) ∈ t), motive ⋯) → motive x | false |
Std.Internal.Parsec.instReprParseResult | Std.Internal.Parsec.Basic | {α ι : Type} → [Repr α] → [Repr ι] → Repr (Std.Internal.Parsec.ParseResult α ι) | true |
Function.mtr | Mathlib.Logic.Basic | ∀ {a b : Prop}, (¬a → ¬b) → b → a | true |
DFinsupp.equivFunOnFintype_symm_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (f : Π₀ (i : ι), β i),
DFinsupp.equivFunOnFintype.symm ⇑f = f | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : Semiring R] (a b : R) (m n : ℕ),
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(n + 1))) =
(Polynomial.monomial (m + 1 - 1 + (n + 1))) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1 - 1)))... | false |
_private.Mathlib.Algebra.Order.Ring.Ordering.Basic.0.RingPreordering.supportAddSubgroup_eq_bot._simp_1_1 | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, (x ∈ P.supportAddSubgroup) = (x ∈ P ∧ -x ∈ P) | false |
MeasureTheory.LocallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | {X : Type u_1} →
{ε : Type u_3} →
[inst : MeasurableSpace X] →
[TopologicalSpace X] →
[inst_2 : TopologicalSpace ε] →
[ContinuousENorm ε] →
(X → ε) → autoParam (MeasureTheory.Measure X) MeasureTheory.LocallyIntegrable._auto_1 → Prop | true |
IsAlgebraic.nontrivial | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → Nontrivial R | true |
CategoryTheory.Limits.preservesFiniteLimits_of_op | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F.op],
CategoryTheory.Limits.PreservesFiniteLimits F | true |
IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_8 : CommRing Sₚ] [inst_9 : Algebra S Sₚ]
... | true |
Lean._aux_Lean_Message___macroRules_Lean_termM!__1 | Lean.Message | Lean.Macro | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.