name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
QuaternionAlgebra.Basis.compHom._proof_4 | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
F q.j * F q.i = c₂ • F q.j - F q.k | false |
LipschitzOnWith.dist_le_mul | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {s : Set α}
{f : α → β}, LipschitzOnWith K f s → ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑K * dist x y | true |
Array.scanrM_map | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {α₁ : Type u_3} {α₂ : Type u_4} {β : Type u_1} {init : β} [inst : Monad m] [LawfulMonad m]
{f : α₁ → α₂} {g : α₂ → β → m β} {as : Array α₁},
Array.scanrM g init (Array.map f as) = Array.scanrM (fun a b => g (f a) b) init as | true |
_private.Mathlib.GroupTheory.Submonoid.Inverses.0.Submonoid.leftInvEquiv._simp_4 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M) (a : ↥S.leftInv) (b : M),
(↑(S.fromLeftInv a) = b) = (↑a * b = 1) | false |
Lean.Expr.updateProj! | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | true |
MultilinearMap.compLinearMap_injective | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₁' : ι → Type v₁'} {M₂ : Type v₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (M₁' i)]
... | true |
Lean.Meta.Grind.EMatchTheoremConstraint._sizeOf_inst | Lean.Meta.Tactic.Grind.Extension | SizeOf Lean.Meta.Grind.EMatchTheoremConstraint | false |
Lean.Grind.AC.Seq.contains_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Var → Bool | true |
AddCommGroup.torsion._proof_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : AddCommGroup G] {x : G}, x ∈ (AddCommMonoid.addTorsion G).carrier → IsOfFinAddOrder (-x) | false |
MeasurableSet.sUnion | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : Set (Set α)},
s.Countable → (∀ t ∈ s, MeasurableSet t) → MeasurableSet (⋃₀ s) | true |
Valuation.toAddValuation._proof_4 | Mathlib.RingTheory.Valuation.Basic | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommMonoidWithZero Γ₀] {a b : Γ₀},
Multiplicative.ofAdd (OrderDual.toDual (OrderDual.toDual (Additive.ofMul a))) ≤
Multiplicative.ofAdd (OrderDual.toDual (OrderDual.toDual (Additive.ofMul b))) ↔
Multiplicative.ofAdd (OrderDual.toDual (OrderDual.toDual (Additive.ofMul a... | false |
Lean.Elab.Tactic.BVDecide.Frontend.instToExprBVExpr.go.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) →
(w : ℕ) →
(x : Std.Tactic.BVDecide.BVExpr w) →
((w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx)) →
((w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val)) →
((w : ℕ) →
(lhs : Std... | false |
Hyperreal.Infinite | Mathlib.Analysis.Real.Hyperreal | ℝ* → Prop | true |
GradedModule.isModule._proof_2 | Mathlib.Algebra.Module.GradedModule | ∀ {ιA : Type u_5} {ιM : Type u_1} {A : Type u_4} {M : Type u_2} {σ : Type u_3} {σ' : Type u_6} [inst : AddMonoid ιA]
[inst_1 : AddAction ιA ιM] [inst_2 : Semiring A] (𝓐 : ιA → σ') [inst_3 : SetLike σ' A] (𝓜 : ιM → σ)
[inst_4 : AddCommMonoid M] [inst_5 : Module A M] [inst_6 : SetLike σ M] [inst_7 : AddSubmonoidCla... | false |
Function.Embedding.sigmaSet.congr_simp | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} {ι : Type u_2} {s : ι → Set α} (h : Pairwise (Function.onFun Disjoint s)),
Function.Embedding.sigmaSet h = Function.Embedding.sigmaSet h | true |
HahnSeries.mk_eq_zero._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (f : Γ → R) (h : (Function.support f).IsPWO),
({ coeff := f, isPWO_support' := h } = 0) = (f = 0) | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.mem_keys_iff_contains._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
Nat.exists_mul_emod_eq_one_of_coprime | Mathlib.Data.Int.GCD | ∀ {k n : ℕ}, n.Coprime k → 1 < k → ∃ m < k, n * m % k = 1 | true |
IsClosed.sInf_mem | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] {s : Set α},
s.Nonempty → IsClosed s → sInf s ∈ s | true |
Filter.map_val_atTop_of_Ici_subset | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {a : α} {s : Set α},
Set.Ici a ⊆ s → Filter.map Subtype.val Filter.atTop = Filter.atTop | true |
FirstOrder.Language.Relations.realize_total._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {r : L.Relations 2},
M ⊨ r.total = Std.Total fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] | false |
Lean.SMap.find! | Lean.Data.SMap | {α : Type u} → {β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → [Inhabited β] → Lean.SMap α β → α → β | true |
_private.Mathlib.Data.EReal.Basic.0.EReal.preimage_coe_Ico._simp_1_1 | Mathlib.Data.EReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem._proof_1_6 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (tail : List α),
a ∈ a :: tail → ¬tail.length = 0 → tail.length - 1 < tail.length | false |
_private.Mathlib.Analysis.BoxIntegral.Box.SubboxInduction.0.BoxIntegral.Box.splitCenterBox._simp_1 | Mathlib.Analysis.BoxIntegral.Box.SubboxInduction | ∀ {α : Type u_2} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {a b : α} [IsStrictOrderedRing α],
(a < (a + b) / 2) = (a < b) | false |
Lean.Order.Array.monotone_findRevM? | Init.Internal.Order.Lemmas | ∀ {γ : Type w} [inst : Lean.Order.PartialOrder γ] {m : Type → Type v} [inst_1 : Monad m]
[inst_2 : (α : Type) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m] {α : Type} (f : γ → α → m Bool)
(xs : Array α), Lean.Order.monotone f → Lean.Order.monotone fun x => Array.findRevM? (f x) xs | true |
AddCommGroup.tfae_modEq | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α),
[a ≡ b [PMOD p], ∀ (z : ℤ), b - z • p ∉ Set.Ioo a (a + p), toIcoMod hp a b ≠ toIocMod hp a b,
toIcoMod hp a b + p = toIocMod hp a b].TFAE | true |
Algebra.PreSubmersivePresentation.jacobian | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → Algebra.PreSubmersivePresentation R S ι σ → [Finite σ] → S | true |
Rat.sub.aux | Init.Data.Rat.Basic | ∀ (a b : ℚ) {g ad bd : ℕ},
g = a.den.gcd b.den →
ad = a.den / g →
bd = b.den / g →
have den := ad * b.den;
have num := a.num * ↑bd - b.num * ↑ad;
num.natAbs.gcd g = num.natAbs.gcd den | true |
CategoryTheory.instBraidedCategoryType | Mathlib.CategoryTheory.Monoidal.Types.Basic | CategoryTheory.BraidedCategory (Type u) | true |
isLittleO_pow_const_const_pow_of_one_lt | Mathlib.Analysis.SpecificLimits.Normed | ∀ {R : Type u_2} [inst : NormedRing R] (k : ℕ) {r : ℝ}, 1 < r → (fun n => ↑n ^ k) =o[Filter.atTop] fun n => r ^ n | true |
Complex.norm_dslope_le_div_of_mapsTo_ball | Mathlib.Analysis.Complex.Schwarz | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {R₁ R₂ : ℝ} {f : ℂ → E} {c z : ℂ},
DifferentiableOn ℂ f (Metric.ball c R₁) →
Set.MapsTo f (Metric.ball c R₁) (Metric.closedBall (f c) R₂) → z ∈ Metric.ball c R₁ → ‖dslope f c z‖ ≤ R₂ / R₁ | true |
IsDedekindDomain.HeightOneSpectrum.coe_smul_adicCompletionIntegers | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)), ↑(r • x) = r • ↑x | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.forward.match_1 | Init.Data.String.Iterator | (motive : String.Legacy.Iterator → ℕ → Sort u_1) →
(x : String.Legacy.Iterator) →
(x_1 : ℕ) →
((it : String.Legacy.Iterator) → motive it 0) →
((it : String.Legacy.Iterator) → (n : ℕ) → motive it n.succ) → motive x x_1 | false |
List.eraseRepsBy.loop | Init.Data.List.Basic | {α : Type u_1} → (α → α → Bool) → α → List α → List α → List α | true |
Module.Presentation.tautological.R.smul.inj | Mathlib.Algebra.Module.Presentation.Tautological | ∀ {A : Type u} {M : Type v} {a : A} {m : M} {a_1 : A} {m_1 : M},
Module.Presentation.tautological.R.smul a m = Module.Presentation.tautological.R.smul a_1 m_1 → a = a_1 ∧ m = m_1 | true |
CategoryTheory.CoreSmallCategoryOfSet.smallCategoryOfSet._proof_2 | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) {X Y : ↑h.obj} (f : ↑(h.hom X Y)),
h.homEquiv.symm
(CategoryTheory.CategoryStruct.comp
(h.homEquiv (h.homEquiv.symm (CategoryTheory.CategoryStruct.id (h.objEquiv X)))) (h.homEq... | false |
Submodule.IsCompl.projection_eq_self_sub_projection | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q) (x : E), (Submodule.IsCompl.projection ⋯) x = x - (Submodule.IsCompl.projection hpq) x | true |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Localization.mk_eq_mk_iff._simp_1_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
(Localization.r S) x y = (OreLocalization.oreEqv S M) x y | false |
CovBy._to_dual_cast_4 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_2} [inst : LT α] (a b : α), (b ⋖ a) = (b < a ∧ ∀ ⦃c : α⦄, c < a → ¬b < c) | false |
Lean.Meta.Grind.ActionResult.casesOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.ActionResult → Sort u} →
(t : Lean.Meta.Grind.ActionResult) →
((seq : List Lean.Meta.Grind.TGrind) → motive (Lean.Meta.Grind.ActionResult.closed seq)) →
((gs : List Lean.Meta.Grind.Goal) → motive (Lean.Meta.Grind.ActionResult.stuck gs)) → motive t | false |
AlgebraicGeometry.StructureSheaf.comap_id_eq_map | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u} [inst : CommRing R] (U V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
(iVU : V ⟶ U),
AlgebraicGeometry.StructureSheaf.comap (RingHom.id R) U V ⋯ =
CommRingCat.Hom.hom ((AlgebraicGeometry.Spec.structureSheaf R).obj.map iVU.op) | true |
EReal.coe_ne_bot._simp_1 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (↑x = ⊥) = False | false |
CliffordAlgebra.invOf_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Inversion | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (m : M) [inst_3 : Invertible (Q m)] [inst_4 : Invertible ((CliffordAlgebra.ι Q) m)],
⅟((CliffordAlgebra.ι Q) m) = (CliffordAlgebra.ι Q) (⅟(Q m) • m) | true |
SFinKer.of | Mathlib.Probability.Kernel.Category.SFinKer | (carrier : Type u) → [str : MeasurableSpace carrier] → SFinKer | true |
Fin.zero_mul | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] (k : Fin n), 0 * k = 0 | true |
monotone_add_nat_iff_monotoneOn_nat_Ici | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} [inst : Preorder α] {f : ℕ → α} {k : ℕ}, (Monotone fun n => f (n + k)) ↔ MonotoneOn f {x | k ≤ x} | true |
SchwartzMap.bilinLeftCLM._simp_5 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
Turing.PartrecToTM2.tr.eq_10 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.tr (Turing.PartrecToTM2.Λ'.ret (Turing.PartrecToTM2.Cont'.comp f k)) =
Turing.TM2.Stmt.goto fun x => Turing.PartrecToTM2.trNormal f k | true |
Subgroup.subgroupOfEquivOfLe._proof_7 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (_g _h : ↥(H.subgroupOf K)), ⟨↑↑(_g * _h), ⋯⟩ = ⟨↑↑(_g * _h), ⋯⟩ | false |
spectrum.inv_mem_resolventSet | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : Rˣ} {a : Aˣ},
↑r ∈ resolventSet R ↑a → ↑r⁻¹ ∈ resolventSet R ↑a⁻¹ | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt64.reduceDiv.declare_261._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.97 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
List.modify_eq_take_cons_drop | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {i : ℕ} {l : List α} (h : i < l.length),
l.modify i f = List.take i l ++ f l[i] :: List.drop (i + 1) l | true |
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_getElem_sub_pos._proof_1_6 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} (tail : List α) {s : ℕ}, i - (s + 1) + 1 ≤ tail.length → i - (s + 1) < tail.length | false |
Module.End.iSup_genEigenspace_eq | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Module.End R M)
(μ : R), ⨆ k, (f.genEigenspace μ) ↑k = f.maxGenEigenspace μ | true |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Basic.0.Lean.Meta.Simp.Arith.Int.ToLinear.toLinearExpr.match_1 | Lean.Meta.Tactic.Simp.Arith.Int.Basic | (motive : Option ℤ → Sort u_1) →
(__do_lift : Option ℤ) → ((k : ℤ) → motive (some k)) → (Unit → motive none) → motive __do_lift | false |
CategoryTheory.Functor.Monoidal.inv_μ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C),
CategoryTheory.inv (CategoryTheory.Fun... | true |
CategoryTheory.Bicategory.whiskerLeft_iff | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g : a ⟶ b} (η θ : f ⟶ g),
CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.id a) η =
CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.id a) θ ↔
η = θ | true |
CategoryTheory.ProjectiveResolution.cokernelCofork._proof_1 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | IsRightCancelAdd ℕ | false |
Aesop.Stats.ruleSetConstruction | Aesop.Stats.Basic | Aesop.Stats → Aesop.Nanos | true |
Equiv.Perm.Basis.mem_support_self' | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (self : g.Basis)
(c : ↥g.cycleFactorsFinset), self.toFun c ∈ (↑c).support | true |
_private.Aesop.EMap.0.Aesop.EMap.alterM.match_3 | Aesop.EMap | {α : Type} →
(motive : Option (Lean.Expr × α) → Sort u_1) →
(x : Option (Lean.Expr × α)) →
((e' : Lean.Expr) → (old : α) → motive (some (e', old))) → ((x : Option (Lean.Expr × α)) → motive x) → motive x | false |
AddMonoid.Coprod.toProd_comp_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N],
AddMonoid.Coprod.toProd.comp AddMonoid.Coprod.inl = AddMonoidHom.inl M N | true |
Char.reduceIsAlphaNum._regBuiltin.Char.reduceIsAlphaNum.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.1090167397._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | false |
_private.Init.Data.List.Lemmas.0.List.isEqv.match_1.splitter._sparseCasesOn_5 | Init.Data.List.Lemmas | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Limits.PreservesBinaryBiproduct.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {X Y : C}
{F : CategoryTheory.Functor C D} [inst_4 : F.PreservesZeroMorphisms],
(∀ {b : Ca... | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleDefinition.match_4 | Lean.Server.FileWorker.RequestHandling | (motive : Lean.Elab.HoverableInfoPrio × Lean.Elab.InfoWithCtx → Sort u_1) →
(x : Lean.Elab.HoverableInfoPrio × Lean.Elab.InfoWithCtx) →
((fst : Lean.Elab.HoverableInfoPrio) → (r : Lean.Elab.InfoWithCtx) → motive (fst, r)) → motive x | false |
MvPowerSeries.le_weightedOrder_prod | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {ι : Type u_4} (w : σ → ℕ) (f : ι → MvPowerSeries σ R)
(s : Finset ι), ∑ i ∈ s, MvPowerSeries.weightedOrder w (f i) ≤ MvPowerSeries.weightedOrder w (∏ i ∈ s, f i) | true |
_private.Mathlib.GroupTheory.HNNExtension.0.HNNExtension.NormalWord.unitsSMul_neg._simp_1_5 | Mathlib.GroupTheory.HNNExtension | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | false |
ContDiff.comp₂_contDiffWithinAt | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {E₁ : Type u_6}
{E₂ : Type u_7} [inst_5 : NormedAddCommGroup E₁] [inst_6 : NormedAddCommGroup E... | true |
UInt32.ofNat_sub | Init.Data.UInt.Lemmas | ∀ {a b : ℕ}, b ≤ a → UInt32.ofNat (a - b) = UInt32.ofNat a - UInt32.ofNat b | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toList_roc_add_right_eq_map._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, ¬m + n + 1 = m + 1 + n → False | false |
Ideal.Quotient.factorₐ_comp_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] {I J : Ideal A}
[inst_3 : I.IsTwoSided] [inst_4 : J.IsTwoSided] (hIJ : I ≤ J),
(Ideal.Quotient.factorₐ R₁ hIJ).comp (Ideal.Quotient.mkₐ R₁ I) = Ideal.Quotient.mkₐ R₁ J | true |
Lean.Lsp.instReprPosition.repr | Lean.Data.Lsp.BasicAux | Lean.Lsp.Position → ℕ → Std.Format | true |
IsDiscreteValuationRing.addVal_eq_zero_of_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (u : Rˣ),
(IsDiscreteValuationRing.addVal R) ↑u = 0 | true |
CategoryTheory.Limits.parallelPair.eqOfHomEq._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g f' g' : X ⟶ Y},
f = f' →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair f g).map CategoryTheory.Limits.WalkingParallelPairHom.left)
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.pa... | false |
CategoryTheory.CoreHom.ext_iff | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : CategoryTheory.Core C}
{x y : CategoryTheory.CoreHom X Y}, x = y ↔ x.iso = y.iso | true |
_private.Init.Data.Array.MapIdx.0.Array.mapFinIdx_eq_replicate_iff._simp_1_1 | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : (i : ℕ) → α → i < l.length → β} {b : β},
(l.mapFinIdx f = List.replicate l.length b) = ∀ (i : ℕ) (h : i < l.length), f i l[i] h = b | false |
Finsupp.restrictSupportEquiv | Mathlib.Data.Finsupp.Basic | {α : Type u_1} → (s : Set α) → (M : Type u_12) → [inst : AddCommMonoid M] → { f // ↑f.support ⊆ s } ≃ (↑s →₀ M) | true |
Fin.addNat_last | Init.Data.Fin.Lemmas | ∀ {m : ℕ} (n : ℕ), (Fin.last n).addNat m = Fin.cast ⋯ (Fin.last (n + m)) | true |
derivationToSquareZeroEquivLift_symm_apply_apply_coe | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) [inst_5 : Algebra A B] (hI : I ^ 2 = ⊥)
[inst_6 : IsScalarTower R A B] (f : { f // (Ideal.Quotient.mkₐ R I).comp f = IsScalarTower.toAlgHom R A... | true |
Equiv.prodAssoc | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → (β : Type u_10) → (γ : Type u_11) → (α × β) × γ ≃ α × β × γ | true |
CategoryTheory.Pi.equivalenceOfEquiv_counitIso | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (e : J ≃ I),
(CategoryTheory.Pi.equivalenceOfEquiv C e).counitIso =
CategoryTheory.NatIso.pi' fun i =>
((CategoryTheory.Functor.pi' fun i' => CategoryTheory.Pi.eval C (e i')).associator
(Cat... | true |
Asymptotics.IsBigO.isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =O[l] g → ∃ c, Asymptotics.IsBigOWith c l f g | true |
AddActionHom.prod._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_4} {N : Type u_5} {α : Type u_3} {γ : Type u_1} {δ : Type u_2} [inst : VAdd M α] [inst_1 : VAdd N γ]
[inst_2 : VAdd N δ] {σ : M → N} (f : α →ₑ[σ] γ) (g : α →ₑ[σ] δ) (x : M) (x_1 : α),
(f (x +ᵥ x_1), g (x +ᵥ x_1)) = σ x +ᵥ (f x_1, g x_1) | false |
ENat.eq_top_iff_forall_ne | Mathlib.Data.ENat.Basic | ∀ {n : ℕ∞}, n = ⊤ ↔ ∀ (m : ℕ), ↑m ≠ n | true |
Lean.Parser.unicodeSymbolFnAux | Lean.Parser.Basic | String → String → List String → Lean.Parser.ParserFn | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_11 | Mathlib.Analysis.Complex.JensenFormula | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Mathlib.Tactic.Translate.Reorder.mk.sizeOf_spec | Mathlib.Tactic.Translate.Reorder | ∀ (perm : List { l // 2 ≤ l.length }) (argReorders : Array (ℕ × Mathlib.Tactic.Translate.Reorder)),
sizeOf { perm := perm, argReorders := argReorders } = 1 + sizeOf perm + sizeOf argReorders | true |
_private.Mathlib.Topology.List.0.List.tendsto_insertIdx'._simp_1_4 | Mathlib.Topology.List | ∀ {α β : Type u} (f : Filter (α → β)) (g : Filter α), f.seq g = f <*> g | false |
instAddSemigroupColex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddSemigroup α] → AddSemigroup (Colex α) | true |
FirstOrder.Language.Substructure.mem_withConstants._simp_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : L.Substructure M} {A : Set M} (h : A ⊆ ↑S) {x : M},
(x ∈ S.withConstants h) = (x ∈ S) | false |
_private.Mathlib.Data.Int.GCD.0.Nat.exists_mul_mod_eq_of_coprime._proof_1_2 | Mathlib.Data.Int.GCD | ∀ {k : ℕ}, k ≠ 0 → 0 < k | false |
Filter.PiInfPrincipalPi.neBot | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
[h : ∀ (i : ι), (f i ⊓ Filter.principal (s i)).NeBot] {I : Set ι}, (Filter.pi f ⊓ Filter.principal (I.pi s)).NeBot | true |
Monoid.ExponentExists.orderOf_pos | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Monoid G], Monoid.ExponentExists G → ∀ (g : G), 0 < orderOf g | true |
List.append_eq_flatten_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List (List α)} {ys zs : List α},
ys ++ zs = xs.flatten ↔
(∃ as bs, xs = as ++ bs ∧ ys = as.flatten ∧ zs = bs.flatten) ∨
∃ as bs c cs ds, xs = as ++ (bs ++ c :: cs) :: ds ∧ ys = as.flatten ++ bs ∧ zs = c :: cs ++ ds.flatten | true |
Std.OrientedCmp.not_lt_of_isLE | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, (cmp a b).isLE = true → cmp b a ≠ Ordering.lt | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_305 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | false |
Matrix.IsHermitian.spectrum_eq_image_range | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(hA : A.IsHermitian), spectrum 𝕜 A = RCLike.ofReal '' Set.range hA.eigenvalues | true |
Path.Homotopy.source | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p₀ p₁ : Path x₀ x₁} (F : p₀.Homotopy p₁) (t : ↑unitInterval),
F (t, 0) = x₀ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.