name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Topology.WithScott.instPreorder | Mathlib.Topology.Order.ScottTopology | {α : Type u_1} → [Preorder α] → Preorder (Topology.WithScott α) |
Lean.IR.EmitC.emitFullApp | Lean.Compiler.IR.EmitC | Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FunId → Array Lean.IR.Arg → Lean.IR.EmitC.M Unit |
Array.all_eq_false' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.all p = false ↔ ∃ x ∈ as, ¬p x = true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Poly.mulMon.eq_1 | Init.Data.Nat.SOM | ∀ (p : Nat.SOM.Poly) (k : ℕ) (m : Nat.SOM.Mon), p.mulMon k m = Nat.SOM.Poly.mulMon.go✝ k m p [] |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.coconeBack._proof_7 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Under X)}
(X_1 : CategoryTheory.Limits.Cocone (CategoryTheory.WithInitial.liftFromUnder.obj K)),
{ hom := CategoryTheory.Under.homMk (CategoryTheory.CategoryStruct.id X_1).hom ⋯, w := ⋯ } =
CategoryTheory.CategoryStruct.id
{ pt := CategoryTheory.Under.mk (X_1.ι.app CategoryTheory.WithInitial.star),
ι :=
{
app := fun a =>
{ left := CategoryTheory.CategoryStruct.id (K.obj a).left,
right := X_1.ι.app (CategoryTheory.WithInitial.of a), w := ⋯ },
naturality := ⋯ } } |
CategoryTheory.Limits.CompleteLattice.hasColimits_of_completeLattice | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} [inst : CompleteLattice α], CategoryTheory.Limits.HasColimitsOfSize.{w, w', u, u} α |
nhds_bot_basis | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderBot α] [OrderTopology α]
[Nontrivial α], (nhds ⊥).HasBasis (fun a => ⊥ < a) fun a => Set.Iio a |
Set.sInter_subset_of_mem | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ∈ S → ⋂₀ S ⊆ t |
CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_inv_assoc | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasColimit G] (w : F ≅ G) (j : J) {Z : C} (h : CategoryTheory.Limits.colimit F ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι G j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv h) =
CategoryTheory.CategoryStruct.comp (w.inv.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j) h) |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldrM.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (x_1 : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x x_1 =
match x, x_1 with
| d, Std.DHashMap.Internal.AssocList.nil => pure d
| d, Std.DHashMap.Internal.AssocList.cons a b es => do
let d ← Std.DHashMap.Internal.AssocList.foldrM f d es
f a b d |
Lean.Json.brecOn_2.eq | Lean.Data.Json.Basic | ∀ {motive_1 : Lean.Json → Sort u} {motive_2 : Array Lean.Json → Sort u}
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} {motive_4 : List Lean.Json → Sort u}
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u}
{motive_6 : (Std.DTreeMap.Internal.Impl String fun x => Lean.Json) → Sort u}
(t : Std.TreeMap.Raw String Lean.Json compare) (F_1 : (t : Lean.Json) → t.below → motive_1 t)
(F_2 : (t : Array Lean.Json) → Lean.Json.below_1 t → motive_2 t)
(F_3 : (t : Std.TreeMap.Raw String Lean.Json compare) → Lean.Json.below_2 t → motive_3 t)
(F_4 : (t : List Lean.Json) → Lean.Json.below_3 t → motive_4 t)
(F_5 : (t : Std.DTreeMap.Raw String (fun x => Lean.Json) compare) → Lean.Json.below_4 t → motive_5 t)
(F_6 : (t : Std.DTreeMap.Internal.Impl String fun x => Lean.Json) → Lean.Json.below_5 t → motive_6 t),
Lean.Json.brecOn_2 t F_1 F_2 F_3 F_4 F_5 F_6 = F_3 t (Lean.Json.brecOn_2.go t F_1 F_2 F_3 F_4 F_5 F_6).2 |
Real.holderTriple_iff | Mathlib.Data.Real.ConjExponents | ∀ (p q r : ℝ), p.HolderTriple q r ↔ p⁻¹ + q⁻¹ = r⁻¹ ∧ 0 < p ∧ 0 < q |
Lean.Elab.Tactic.Conv.getRhs | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.TacticM Lean.Expr |
MeasureTheory.Measure.innerRegularWRT_preimage_one_hasCompactSupport_measure_ne_top_of_group | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {G : Type u_2} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [LocallyCompactSpace G]
[inst_4 : MeasurableSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.InnerRegularCompactLTTop],
μ.InnerRegularWRT (fun s => ∃ f, Continuous f ∧ HasCompactSupport f ∧ s = f ⁻¹' {1}) fun s =>
MeasurableSet s ∧ μ s ≠ ⊤ |
FreeAlgebra.instFree | Mathlib.LinearAlgebra.FreeAlgebra | ∀ (R : Type u) (X : Type v) [inst : CommSemiring R], Module.Free R (FreeAlgebra R X) |
Polynomial.mapAlgHom_coe_ringHom | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ↑(Polynomial.mapAlgHom f) = Polynomial.mapRingHom ↑f |
Int.Linear.cooper_right_split.eq_1 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ p₂ : Int.Linear.Poly) (k : ℕ),
Int.Linear.cooper_right_split ctx p₁ p₂ k =
(Int.Linear.Poly.denote' ctx
(((p₁.tail.mul_k p₂.leadCoeff).combine (p₂.tail.mul_k (-p₁.leadCoeff))).addConst (-p₁.leadCoeff * ↑k)) ≤
0 ∧
p₂.leadCoeff ∣ Int.Linear.Poly.denote' ctx (p₂.tail.addConst ↑k)) |
List.zip_eq_zip_take_min | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β},
l₁.zip l₂ = (List.take (min l₁.length l₂.length) l₁).zip (List.take (min l₁.length l₂.length) l₂) |
CategoryTheory.instIsRegularEpiCategorySheafTypeOfHasSheafify | Mathlib.CategoryTheory.Sites.RegularEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
[CategoryTheory.HasSheafify J (Type u)], CategoryTheory.IsRegularEpiCategory (CategoryTheory.Sheaf J (Type u)) |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_singleton._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), {a}.erase a = ∅ |
MonomialOrder.lex._proof_1 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ], IsOrderedCancelAddMonoid (Lex (σ →₀ ℕ)) |
Lean.Order.Array.monotone_mapM | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] (xs : Array α) (f : γ → α → m β),
Lean.Order.monotone f → Lean.Order.monotone fun x => Array.mapM (f x) xs |
Std.Internal.List.DistinctKeys.casesOn | Std.Data.Internal.List.Defs | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
{l : List ((a : α) × β a)} →
{motive : Std.Internal.List.DistinctKeys l → Sort u_1} →
(t : Std.Internal.List.DistinctKeys l) →
((distinct : List.Pairwise (fun a b => (a == b) = false) (Std.Internal.List.keys l)) → motive ⋯) → motive t |
Lean.PPFns | Lean.Util.PPExt | Type |
Lean.KVMap.instValueBool.match_1 | Lean.Data.KVMap | (motive : Lean.DataValue → Sort u_1) →
(x : Lean.DataValue) → ((b : Bool) → motive (Lean.DataValue.ofBool b)) → ((x : Lean.DataValue) → motive x) → motive x |
MvPowerSeries.weightedOrder_le | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {d : σ →₀ ℕ},
(MvPowerSeries.coeff d) f ≠ 0 → MvPowerSeries.weightedOrder w f ≤ ↑((Finsupp.weight w) d) |
Continuous.edist | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : TopologicalSpace β] {f g : β → α},
Continuous f → Continuous g → Continuous fun b => edist (f b) (g b) |
BoxIntegral.TaggedPrepartition.IsSubordinate | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → [Fintype ι] → BoxIntegral.TaggedPrepartition I → ((ι → ℝ) → ↑(Set.Ioi 0)) → Prop |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_9 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α} (h : xs.Perm ys) (w : Fin ys.length)
(h_1 : List.countBefore ys[w] ys ↑w + 1 ≤ (List.filter (fun x => x == xs[⋯.idxBij w]) ys).length),
(List.findIdxs (fun x => x == xs[⋯.idxBij w]) ys)[List.countBefore ys[w] ys ↑w] < ys.length |
_private.Init.Data.List.Range.0.List.getElem?_zipIdx.match_1_1 | Init.Data.List.Range | ∀ {α : Type u_1} (motive : List α → ℕ → ℕ → Prop) (x : List α) (x_1 x_2 : ℕ),
(∀ (x x_3 : ℕ), motive [] x x_3) →
(∀ (head : α) (tail : List α) (x : ℕ), motive (head :: tail) x 0) →
(∀ (head : α) (l : List α) (n m : ℕ), motive (head :: l) n m.succ) → motive x x_1 x_2 |
VitaliFamily.filterAt_enlarge | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
(v : VitaliFamily μ) {δ : ℝ} (δpos : 0 < δ), (v.enlarge δ δpos).filterAt = v.filterAt |
DoubleCentralizer.coe._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A], SMulCommClass 𝕜 𝕜 A |
_private.Mathlib.NumberTheory.Padics.HeightOneSpectrum.0.Rat.int_algebraMap_surjective._simp_1_1 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x |
CategoryTheory.Pseudofunctor.mapComp'_comp_id_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
(F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {b₀ b₁ : B} (f : b₀ ⟶ b₁) (X : ↑(F.obj b₀)) {Z : ↑(F.obj b₁)}
(h : (F.map (CategoryTheory.CategoryStruct.id b₁)).toFunctor.obj ((F.map f).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.mapComp' f (CategoryTheory.CategoryStruct.id b₁) f ⋯).hom.toNatTrans.app X) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp ((F.mapId b₁).inv.toNatTrans.app ((F.map f).toFunctor.obj X)) h) |
hasBasis_nhdsSet_Ici_Ici | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] (a : α)
[(nhdsWithin a (Set.Iio a)).NeBot], (nhdsSet (Set.Ici a)).HasBasis (fun x => x < a) Set.Ici |
CategoryTheory.Cat.HasLimits.limitConeIsLimit | Mathlib.CategoryTheory.Category.Cat.Limit | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CategoryTheory.Cat) →
CategoryTheory.Limits.IsLimit (CategoryTheory.Cat.HasLimits.limitCone F) |
_private.Mathlib.MeasureTheory.Measure.AEMeasurable.0.cond.match_1.eq_1 | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () |
Std.TreeMap.get!_union_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∉ t₂ → (t₁ ∪ t₂).get! k = t₁.get! k |
IsAbsoluteValue.mk | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] {f : R → S},
(∀ (x : R), 0 ≤ f x) →
(∀ {x : R}, f x = 0 ↔ x = 0) →
(∀ (x y : R), f (x + y) ≤ f x + f y) → (∀ (x y : R), f (x * y) = f x * f y) → IsAbsoluteValue f |
Filter.frequently_imp_distrib_right | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} {q : Prop},
(∃ᶠ (x : α) in f, p x → q) ↔ (∀ᶠ (x : α) in f, p x) → q |
matPolyEquiv_symm_apply_coeff | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(p : Polynomial (Matrix n n R)) (i j : n) (k : ℕ), (matPolyEquiv.symm p i j).coeff k = p.coeff k i j |
Lean.Parser.Tactic.Conv.rewrite | Init.Conv | Lean.ParserDescr |
Std.TreeMap.Raw.toList_rco | Std.Data.TreeMap.Raw.Slice | ∀ {α : Type u} {β : Type v} (cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw.toList_rco._auto_1) [Std.TransCmp cmp]
{t : Std.TreeMap.Raw α β cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Rco.Sliceable.mkSlice t lowerBound...upperBound) =
List.filter (fun e => decide ((cmp e.1 lowerBound).isGE = true ∧ (cmp e.1 upperBound).isLT = true)) t.toList |
Finset.inf'_congr | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) {t : Finset β} {f g : β → α}
(h₁ : s = t), (∀ x ∈ s, f x = g x) → s.inf' H f = t.inf' ⋯ g |
CategoryTheory.yoneda'_comp | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.yoneda'.comp (CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendieckTopology (Type u)) =
CategoryTheory.yoneda |
ContinuousMap.HomotopyWith.ext_iff | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop} {F G : f₀.HomotopyWith f₁ P}, F = G ↔ ∀ (x : ↑unitInterval × X), F x = G x |
Vector.mapFinIdxM | Init.Data.Vector.Basic | {n : ℕ} →
{α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → Vector α n → ((i : ℕ) → α → i < n → m β) → m (Vector β n) |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage.match_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
MonoidHom.coe_of_map_mul_inv | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G → H)
(map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹), ⇑(MonoidHom.ofMapMulInv f map_div) = f |
FirstOrder.Language.ElementarilyEquivalent.toModel | Mathlib.ModelTheory.Bundled | {L : FirstOrder.Language} →
(T : L.Theory) →
{M : T.ModelType} → {N : Type u_1} → [LN : L.Structure N] → L.ElementarilyEquivalent (↑M) N → T.ModelType |
SimpleGraph.finsubgraphOfAdj.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (e : G.Adj u v), SimpleGraph.finsubgraphOfAdj e = ⟨G.subgraphOfAdj e, ⋯⟩ |
Filter.pi_mono | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)},
(∀ (i : ι), f₁ i ≤ f₂ i) → Filter.pi f₁ ≤ Filter.pi f₂ |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.instLawfulUpwardEnumerable._simp_4 | Init.Data.Range.Polymorphic.BitVec | ∀ {m n : ℕ}, m ≤ n → ∀ {x : BitVec m}, (x.toNat < 2 ^ n) = True |
Aesop.FVarIdSubst.ofFVarSubstIgnoringNonFVarIds | Aesop.RuleTac.FVarIdSubst | Lean.Meta.FVarSubst → Aesop.FVarIdSubst |
CategoryTheory.isIso_iff_nonzero | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasKernels C] {X Y : C} [CategoryTheory.Simple X] [CategoryTheory.Simple Y] (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ f ≠ 0 |
FinBddDistLat.ofHom | Mathlib.Order.Category.FinBddDistLat | {X Y : Type u} →
[inst : DistribLattice X] →
[inst_1 : BoundedOrder X] →
[inst_2 : Fintype X] →
[inst_3 : DistribLattice Y] →
[inst_4 : BoundedOrder Y] →
[inst_5 : Fintype Y] → BoundedLatticeHom X Y → (FinBddDistLat.of X ⟶ FinBddDistLat.of Y) |
Order.Preimage.instIsStrictOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} {β : Type v} {r : α → α → Prop} [IsStrictOrder α r] {f : β → α}, IsStrictOrder β (f ⁻¹'o r) |
AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : AddMonoid M] →
[inst_1 : AddAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ AddAction.stabilizerAddSubmonoid M a |
Polynomial.instNormalizationMonoid._proof_10 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizationMonoid R] {a b : Polynomial R},
Polynomial.C ↑(normUnit (a * b).leadingCoeff)⁻¹ * Polynomial.C ↑(normUnit (a * b).leadingCoeff) = 1 |
Profinite.NobelingProof.isClosed_C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}},
IsClosed C → ∀ (ho : o < Ordinal.type fun x1 x2 => x1 < x2), IsClosed (Profinite.NobelingProof.C0 C ho) |
Std.DHashMap.Internal.Raw₀.map | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α γ |
Fin.succAbove_of_lt_succ | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), p < i.succ → p.succAbove i = i.succ |
QuadraticAlgebra.instCommSemiring._proof_4 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (x x_1 : QuadraticAlgebra R a b), x * x_1 = x_1 * x |
Part.mem_ofOption._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} {a : α} {o : Option α}, (a ∈ ↑o) = (a ∈ o) |
Lean.Macro.Context.ctorIdx | Init.Prelude | Lean.Macro.Context → ℕ |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_le_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I : Ideal R}, (x ∈ Ideal.span {y} * I) = ∃ z ∈ I, y * z = x |
CategoryTheory.Limits.WidePushoutShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J} (j : J), Z = some j → some j = Z |
Lean.InductiveVal.mk.inj | Lean.Declaration | ∀ {toConstantVal : Lean.ConstantVal} {numParams numIndices : ℕ} {all ctors : List Lean.Name} {numNested : ℕ}
{isRec isUnsafe isReflexive : Bool} {toConstantVal_1 : Lean.ConstantVal} {numParams_1 numIndices_1 : ℕ}
{all_1 ctors_1 : List Lean.Name} {numNested_1 : ℕ} {isRec_1 isUnsafe_1 isReflexive_1 : Bool},
{ toConstantVal := toConstantVal, numParams := numParams, numIndices := numIndices, all := all, ctors := ctors,
numNested := numNested, isRec := isRec, isUnsafe := isUnsafe, isReflexive := isReflexive } =
{ toConstantVal := toConstantVal_1, numParams := numParams_1, numIndices := numIndices_1, all := all_1,
ctors := ctors_1, numNested := numNested_1, isRec := isRec_1, isUnsafe := isUnsafe_1,
isReflexive := isReflexive_1 } →
toConstantVal = toConstantVal_1 ∧
numParams = numParams_1 ∧
numIndices = numIndices_1 ∧
all = all_1 ∧
ctors = ctors_1 ∧
numNested = numNested_1 ∧ isRec = isRec_1 ∧ isUnsafe = isUnsafe_1 ∧ isReflexive = isReflexive_1 |
_private.Init.Data.String.Basic.0.String.copy_toSlice._simp_1_2 | Init.Data.String.Basic | ∀ {s : String}, s.utf8ByteSize = s.toByteArray.size |
CategoryTheory.ObjectProperty.small_unop_iff | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop ↔ CategoryTheory.ObjectProperty.Small.{w, v, u} P |
Finset.ruzsa_triangle_inequality_addNeg_add_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + B).card * (C + B).card |
NonUnitalCommCStarAlgebra.toNonUnitalNormedCommRing | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} → [self : NonUnitalCommCStarAlgebra A] → NonUnitalNormedCommRing A |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.foldlMAux.traverse | Lean.Data.PersistentHashMap | {m : Type w → Type w'} →
[Monad m] →
{σ : Type w} →
{α : Type u_1} →
{β : Type u_2} → (σ → α → β → m σ) → (keys : Array α) → (vals : Array β) → keys.size = vals.size → ℕ → σ → m σ |
Nat.add_mod_eq_add_mod_left | Init.Data.Nat.Lemmas | ∀ {a d b : ℕ} (c : ℕ), a % d = b % d → (c + a) % d = (c + b) % d |
WithConv.casesOn | Mathlib.Algebra.WithConv | {A : Sort u_1} →
{motive : WithConv A → Sort u} → (t : WithConv A) → ((ofConv : A) → motive (WithConv.toConv ofConv)) → motive t |
PresheafOfModules.Sheafify.smul_zero | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Sheaf J AddCommGrpCat} (φ : M₀.presheaf ⟶ A.obj)
[inst_3 : CategoryTheory.Presheaf.IsLocallyInjective J φ] [inst_4 : CategoryTheory.Presheaf.IsLocallySurjective J φ]
{X : Cᵒᵖ} (r : ↑(R.obj.obj X)), PresheafOfModules.Sheafify.smul α φ r 0 = 0 |
eval_det | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {n : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_3} [inst_2 : CommRing R]
(M : Matrix n n (Polynomial R)) (r : R),
Polynomial.eval r M.det = (Polynomial.eval ((Matrix.scalar n) r) (matPolyEquiv M)).det |
CategoryTheory.epi_comp_iff_of_isIso | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[CategoryTheory.IsIso g], CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) ↔ CategoryTheory.Epi f |
IsOpen.tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
IsOpen s →
(TendstoLocallyUniformlyOn F f p s ↔
∀ x ∈ s, Filter.Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ nhds x) (uniformity β)) |
RelIso.prodLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {r₁ : α₁ → α₁ → Prop} {r₂ : α₂ → α₂ → Prop}
{s₁ : β₁ → β₁ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r s₁) (e₂ : r₂ ≃r s₂) {a b : α₁ × α₂},
Prod.Lex s₁ s₂ ((e₁.prodCongr e₂.toEquiv) a) ((e₁.prodCongr e₂.toEquiv) b) ↔ Prod.Lex r₁ r₂ a b |
Lean.NamePart.num.sizeOf_spec | Lean.Data.NameTrie | ∀ (n : ℕ), sizeOf (Lean.NamePart.num n) = 1 + sizeOf n |
CategoryTheory.Limits.Types.isPullback_of_isPushout | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {X₁ X₂ X₃ X₄ : Type u} {t : X₁ ⟶ X₂} {r : X₂ ⟶ X₄} {l : X₁ ⟶ X₃} {b : X₃ ⟶ X₄},
CategoryTheory.IsPushout t l r b → Function.Injective t → CategoryTheory.IsPullback t l r b |
isRelLowerSet_empty._simp_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P = True |
sectionOfRetractionKerToTensorAux.congr_simp | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l l_1 : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(e_l : l = l_1) (hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ σ_1 : S → P) (e_σ : σ = σ_1)
(hσ : ∀ (x : S), (algebraMap P S) (σ x) = x) [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S]
(hf' : RingHom.ker (algebraMap P S) ^ 2 = ⊥),
sectionOfRetractionKerToTensorAux l hl σ hσ hf' = sectionOfRetractionKerToTensorAux l_1 ⋯ σ_1 ⋯ hf' |
nnnorm_cfcₙHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : outParam (A → Prop)} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] (a : A)
(f : ContinuousMapZero (↑(quasispectrum 𝕜 a)) 𝕜) (ha : autoParam (p a) nnnorm_cfcₙHom._auto_1),
‖(cfcₙHom ⋯) f‖₊ = ‖f‖₊ |
Set.instFintypeIcc | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrder α] → (a b : α) → Fintype ↑(Set.Icc a b) |
OptionT.instMonadLift | Init.Control.Option | {m : Type u → Type v} → [Monad m] → MonadLift m (OptionT m) |
Batteries.Tactic.PrintPrefixConfig.ctorIdx | Batteries.Tactic.PrintPrefix | Batteries.Tactic.PrintPrefixConfig → ℕ |
CategoryTheory.Functor.preimageIso_mapIso | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} [inst_2 : F.Full] [inst_3 : F.Faithful] (f : X ≅ Y),
F.preimageIso (F.mapIso f) = f |
CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_ExactFunctor_1 | Mathlib.CategoryTheory.Limits.ExactFunctor | Lean.PrettyPrinter.Unexpander |
Nat.ofNat_lt_cast | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ} [inst_5 : m.AtLeastTwo], OfNat.ofNat m < ↑n ↔ OfNat.ofNat m < n |
IsDedekindDomain.selmerGroup.fromUnit | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → {n : ℕ} → Rˣ →* ↥IsDedekindDomain.selmerGroup |
Lean.Compiler.LCNF.ToMonoM.State.rec | Lean.Compiler.LCNF.ToMono | {motive : Lean.Compiler.LCNF.ToMonoM.State → Sort u} →
((typeParams : Lean.FVarIdHashSet) → motive { typeParams := typeParams }) →
(t : Lean.Compiler.LCNF.ToMonoM.State) → motive t |
_private.Init.Data.Nat.Fold.0.Nat.fold_congr._proof_1 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, n = m → ∀ i < m, ¬i < n → False |
Fintype.sum_subtype_add_sum_subtype | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {ι : Type u_7} [inst : Fintype ι] [inst_1 : AddCommMonoid M] (p : ι → Prop) (f : ι → M)
[inst_2 : DecidablePred p], ∑ i, f ↑i + ∑ i, f ↑i = ∑ i, f i |
Finsupp.embDomain_comapDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] {f : α ↪ β} {g : β →₀ M},
↑g.support ⊆ Set.range ⇑f → Finsupp.embDomain f (Finsupp.comapDomain (⇑f) g ⋯) = g |
Set.MapsTo.subset_preimage | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.MapsTo f s t → s ⊆ f ⁻¹' t |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.Strictness.toPositive.match_1 | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
{e : Q(«$α»)} →
(motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u_1) →
(x : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pf)) →
((x : Mathlib.Meta.Positivity.Strictness zα pα e) → motive x) → motive x |
Setoid.mkClasses_classes | Mathlib.Data.Setoid.Partition | ∀ {α : Type u_1} (r : Setoid α), Setoid.mkClasses r.classes ⋯ = r |
Lean.Elab.Tactic.Omega.Problem.addInequality | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem →
ℤ → Lean.Omega.Coeffs → Option Lean.Elab.Tactic.Omega.Proof → Lean.Elab.Tactic.Omega.Problem |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.