name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Sym2.coe_map | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (z : Sym2 α), ↑(Sym2.map f z) = f '' ↑z | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero.0.CategoryTheory.Functor.map_isZero._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Multiset.sup_eq_union | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ⊔ t = s ∪ t | null | true |
Aesop.ForwardRuleStateStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardRuleStateStats → ℕ | null | false |
MonoidHom.id._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_1) [inst : MulOne M], 1 = 1 | null | false |
HahnModule.instIsTorsionFree | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {R : Type u_3} {Γ : Type u_6} {V : Type u_7} [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup V]
[inst_3 : AddCommMonoid Γ] [inst_4 : LinearOrder Γ] [inst_5 : IsOrderedCancelAddMonoid Γ] [inst_6 : Module R V]
[Module.IsTorsionFree R V], Module.IsTorsionFree (HahnSeries Γ R) (HahnModule Γ R V) | null | true |
Ideal.comap._proof_3 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) {x y : R}, x ∈ ⇑f ⁻¹' ↑I → y ∈ ⇑f ⁻¹' ↑I → x + y ∈ ⇑f ⁻¹' ↑I | null | false |
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_5} {n : WithTop ℕ∞} {E₁ : B → Type u_6}
{E₂ : B → Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
... | null | false |
Std.ExtHashSet.contains_of_contains_insert' | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α}, (m.insert k).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_insert` that is written to exactly match the proof
obligation in the statement of `get_insert`. | true |
NormedCommRing.toNonUnitalNormedCommRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | null | false |
AddCommGrpCat.epi_iff_range_eq_top | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ (AddCommGrpCat.Hom.hom f).range = ⊤ | null | true |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (∃ n, x ≤ ↑n) → Prop) (x_1 : ∃ n, x ≤ ↑n),
(∀ (n : ℕ) (h : x ≤ ↑n), motive ⋯) → motive x_1 | null | false |
Homotopy.symm._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} (h : Homotopy f g) (i j : ι),
¬c.Rel j i → (-h.hom) i j = 0 | null | false |
Lean.Elab.Visibility.private.elim | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → t.ctorIdx = 1 → motive Lean.Elab.Visibility.private → motive t | null | false |
Finset.Icc_ofDual | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : αᵒᵈ),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a) | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
DoubleCoset.eq_of_not_disjoint | Mathlib.GroupTheory.DoubleCoset | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
¬Disjoint (DoubleCoset.doubleCoset a ↑H ↑K) (DoubleCoset.doubleCoset b ↑H ↑K) →
DoubleCoset.doubleCoset a ↑H ↑K = DoubleCoset.doubleCoset b ↑H ↑K | null | true |
Mathlib.Tactic.Bicategory.naturality_inv | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a ⟶ b} {f g : b ⟶ c} {pf : a ⟶ c} {η : f ≅ g}
(η_f : CategoryTheory.CategoryStruct.comp p f ≅ pf) (η_g : CategoryTheory.CategoryStruct.comp p g ≅ pf),
CategoryTheory.Bicategory.whiskerLeftIso p η ≪≫ η_g = η_f →
CategoryTheory.Bicategory.whiske... | null | true |
IsAddQuotientCoveringMap.homeomorph_comp_iff | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] {Y : Type u_4} [inst_4 : TopologicalSpace Y] (φ : X ≃ₜ Y),
IsAddQuotientCoveringMap (⇑φ ∘ f) G ↔ IsAddQuotientCoveringMap f G | null | true |
Valued.integer.norm_unit | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (u : (↥(Valued.integer K))ˣ),
‖↑u‖ = 1 | null | true |
NumberField.instCommRingRingOfIntegers._proof_31 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K], autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
ISize.div_self | Init.Data.SInt.Lemmas | ∀ {a : ISize}, a / a = if a = 0 then 0 else 1 | null | true |
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.altitudeFoot i ∈ affineSpan ℝ (s.points '' {i}ᶜ) | null | true |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars._unsafe_rec | Lean.Meta.Tactic.Cleanup | Lean.Expr → StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit | null | false |
One.toOfNat1.hcongr_2 | Mathlib.GroupTheory.CoprodI | ∀ (α α' : Type u_1), α = α' → ∀ (inst : One α) (inst' : One α'), inst ≍ inst' → One.toOfNat1 ≍ One.toOfNat1 | null | true |
CategoryTheory.RetractArrow.left_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left | null | true |
CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X : CategoryTheory.GradedObject I C} {p : I → J} {j : J} [inst_1 : X.HasMap p] {c : X.CofanMapObjFun p j}
(hc : CategoryTheory.Limits.IsColimit c) (i : I) (hi : p i = j),
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | true |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : ↑I.multicospan.sections),
(fun s =>
⟨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right... | null | false |
IsInvApply.rec | Mathlib.Data.FunLike.IsApply | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Inv β] →
[inst_2 : Inv F] →
{motive : IsInvApply F α β → Sort u} →
((inv_apply : ∀ (f : F) (x : α), f⁻¹ x = (f x)⁻¹) → motive ⋯) → (t : IsInvApply F α β) → motive t | null | false |
Std.Sat.CNF.Clause.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → α → Std.Sat.CNF.Clause α → Prop | Variable `v` occurs in `Clause` `c`.
| true |
Std.ExtTreeSet.self_le_max?_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k kmi : α},
(t.insert k).max?.get ⋯ = kmi → (cmp k kmi).isLE = true | null | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {x : α} {f : Fin n → Option α}, Fin.findSome? f = some x → ∃ i, f i = some x | null | false |
geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_1} [inst : Field K] {x y : K},
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) | null | true |
Lean.Parser.Term.binderTactic.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
DirectSum.Decomposition.casesOn | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
{ℳ : ι → σ} →
{motive : DirectSum.Decomposition ℳ → Sort u} →
(t ... | null | false |
CategoryTheory.Triangulated.TStructure.ge | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | the predicate of objects that are `≥ n` for `n : ℤ`. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSliceFrom_le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | null | false |
Lean.Expr.ensureHasNoMVars | Mathlib.Lean.Expr.Basic | Lean.Expr → Lean.MetaM Unit | Check that an expression contains no metavariables (after instantiation). | true |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.mkIgnoreFnImpl.match_3 | Lean.Linter.UnusedVariables | (motive : Lean.ImportM.Context → Sort u_1) →
(x : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive x | null | false |
Int.inductionOn'.neg._f | Mathlib.Data.Int.Init | {motive : ℤ → Sort u_1} →
(b : ℤ) →
motive b → ((k : ℤ) → k ≤ b → motive k → motive (k - 1)) → (n : ℕ) → Nat.below n → motive (b + Int.negSucc n) | null | false |
Polynomial.resultant_taylor | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R),
((Polynomial.taylor r) f).resultant ((Polynomial.taylor r) g) = f.resultant g | `Res(f(x + r), g(x + r)) = Res(f, g)`. | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsBoundedSMul ℝ F | null | false |
List.mkSlice_rii_eq_mkSlice_rci | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, Std.Rii.Sliceable.mkSlice xs *...* = Std.Rci.Sliceable.mkSlice xs 0...* | null | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.... | null | true |
Int8.toNatClampNeg_eq_zero_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {n : Int8}, (n.toNatClampNeg = 0) = (n ≤ 0) | null | false |
NonUnitalStarAlgHom.ofClass | Mathlib.Algebra.Star.StarAlgHom | {F : Type u_1} →
{R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_... | Turn an element of a type `F` satisfying `NonUnitalAlgHomClass F R A B` and `StarHomClass F A B`
into an actual `NonUnitalStarAlgHom`. | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 3 →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
motive t | null | false |
USize.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toFin = b.toFin → a = b | null | true |
UInt8._sizeOf_inst | Init.SizeOf | SizeOf UInt8 | null | false |
Std.TreeSet.getD_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.maxD fallback) fallback' = t.maxD fallback | null | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Mathlib.Data.Sym.Basic.0.Sym.count_coe_fill_of_ne._simp_1_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Multiset.replicate n a) = (n ≠ 0 ∧ b = a) | null | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {p : Finset α → Prop} (motive : (∃ s, ∃ (hs : s.Finite), p hs.toFinset) → Prop)
(x : ∃ s, ∃ (hs : s.Finite), p hs.toFinset),
(∀ (s : Set α) (hs : s.Finite) (hs' : p hs.toFinset), motive ⋯) → motive x | null | false |
Nat.chineseRemainderOfList.match_1 | Mathlib.Data.Nat.ChineseRemainder | {ι : Type u_1} →
(s : ι → ℕ) →
(motive : (x : List ι) → List.Pairwise (Function.onFun Nat.Coprime s) x → Sort u_2) →
(x : List ι) →
(x_1 : List.Pairwise (Function.onFun Nat.Coprime s) x) →
((x : List.Pairwise (Function.onFun Nat.Coprime s) []) → motive [] x) →
((i : ι) →
... | null | false |
AddConstEquiv.instPowInt._proof_1 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] {a : G} (e : AddConstEquiv G G a a) (n : ℤ) (x : G),
(↑e ^ n).toFun (x + a) = (↑e ^ n).toFun x + a | null | false |
IsCoxeterGroup | Mathlib.GroupTheory.Coxeter.Basic | (W : Type u) → [Group W] → Prop | A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. | true |
UnitAddTorus.mFourierLp._proof_7 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1}, SecondCountableTopologyEither (UnitAddTorus d) ℂ | null | false |
IsAbsoluteValue.abv_nonneg | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_4} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_5} [inst_2 : Semiring R] (abv : R → S)
[IsAbsoluteValue abv] (x : R), 0 ≤ abv x | null | true |
Real.HolderTriple.holderConjugate_div_div | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → (p / r).HolderConjugate (q / r) | null | true |
MonoidAlgebra.mapRingHom_comp_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_7} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Monoid M]
(f : R →+* S),
(MonoidAlgebra.mapRingHom M f).comp (algebraMap R (MonoidAlgebra R M)) = (algebraMap S (MonoidAlgebra S M)).comp f | null | true |
HasStrictFDerivAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasStrictFDerivAt f f' x → f x ≠ 0 → HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x | null | true |
LinearMap.vecEmpty | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{M : Type v} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₃] → [inst_3 : Module R M] → [inst_4 : Module R M₃] → M →ₗ[R] Fin 0 → M₃ | The linear map defeq to `Matrix.vecEmpty` | true |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_7 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | null | false |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_6 | Mathlib.GroupTheory.Descent | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator._proof_13 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ : CategoryTheory.Arrow C)
[inst_3 :
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.span (CategoryTheory.MonoidalCategoryStruct... | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.quasiIsoAt_ι._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n : ℤ), n ≤ n | null | false |
CoxeterMatrix.instGroupGroup._proof_20 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (M : CoxeterMatrix B),
autoParam (∀ (n : ℕ) (a : M.Group), a ^ ↑n.succ = a ^ ↑n * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
_private.Mathlib.Order.Fin.InsertNth.0.Fin.insertNth_monotone._proof_1_1 | Mathlib.Order.Fin.InsertNth | ∀ {n : ℕ} (i j : Fin n), j.castSucc.succ < i.castSucc.succ → j.castSucc.succ ≠ Fin.last (n + 1) | null | false |
_private.Init.Data.Dyadic.Round.0.Dyadic.precision_roundDown.match_1_1 | Init.Data.Dyadic.Round | ∀ (motive : Dyadic → Prop) (x : Dyadic),
(∀ (_ : Unit), motive Dyadic.zero) → (∀ (n k : ℤ) (hn : n % 2 = 1), motive (Dyadic.ofOdd n k hn)) → motive x | null | false |
Std.Http.URI.Path.mk.injEq | Std.Http.Data.URI.Basic | ∀ (segments : Array Std.Http.URI.EncodedSegment) (absolute : Bool) (segments_1 : Array Std.Http.URI.EncodedSegment)
(absolute_1 : Bool),
({ segments := segments, absolute := absolute } = { segments := segments_1, absolute := absolute_1 }) =
(segments = segments_1 ∧ absolute = absolute_1) | null | true |
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1 | Mathlib.Data.EReal.Basic | ∀ {x y : ENNReal}, (↑x ≤ ↑y) = (x ≤ y) | null | false |
Finset.pimage_eq_image_filter | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) {x ∈ s | (f x).Dom}.attach | Rewrite `s.pimage f` in terms of `Finset.filter`, `Finset.attach`, and `Finset.image`. | true |
CategoryTheory.nerveFunctor.full | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.nerveFunctor.Full | null | true |
_private.Init.Data.String.Lemmas.Search.0.String.front_eq._simp_1_1 | Init.Data.String.Lemmas.Search | ∀ {s : String}, s.front = s.toSlice.front | null | false |
AlgebraicGeometry.PrimeSpectrum.Top.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R], AlgebraicGeometry.PrimeSpectrum.Top R = ↧(PrimeSpectrum R) | null | true |
CategoryTheory.Presieve.BindStruct.hg | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h),
R ⋯ self.g | null | true |
AlgebraicGeometry.Scheme.Hom.normalizationCoprodIso._proof_4 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U V : AlgebraicGeometry.Scheme} {iU : U ⟶ X} {iV : V ⟶ X}
(e : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk iU iV))
[inst_2 : AlgebraicGeometry.QuasiComp... | null | false |
Pi.comul_coe_finsupp | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M] (x : n →₀ M),
CoalgebraStruct.comul ⇑x = (TensorProduct.map Finsupp.lcoeFun Finsupp.lcoeFun) (CoalgebraStruct.comul x) | null | true |
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x • x_1) = id (x • x_1) | null | false |
AffineSubspace.finite_of_finDim_ne_zero | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u} {V : Type v} {A : Type a} [inst : AddCommGroup V] [inst_1 : AddTorsor V A] [inst_2 : Ring R]
[inst_3 : Module R V] [StrongRankCondition R] (s : AffineSubspace R A) [Module.Free R ↥s.direction],
s.finDim ≠ 0 → Module.Finite R ↥s.direction | null | true |
ENNReal.mulRightOrderIso._proof_2 | Mathlib.Basic.ENNReal.Inv | ∀ (a : ENNReal) (ha : IsUnit a) {a_1 b : ENNReal}, ha.unit.mulRight a_1 ≤ ha.unit.mulRight b ↔ a_1 ≤ b | null | false |
SimpleGraph.Hom.sum_apply | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_3} {V' : Type u_4} {W : Type u_5} {W' : Type u_6} {G : SimpleGraph V} {H : SimpleGraph W}
{G' : SimpleGraph V'} {H' : SimpleGraph W'} (f : G →g G') (g : H →g H') (a : V ⊕ W), (f.sum g) a = Sum.map (⇑f) (⇑g) a | null | true |
CategoryTheory.MonoidalCategory.DayConvolution.unit_uniqueUpToIso_hom_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{F G : CategoryTheory.Functor C V} (h h' : CategoryTheory.MonoidalCategory.DayConvolution F G)
{Z : Cate... | null | true |
Asymptotics.isLittleOTVS_fun_neg_right | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | null | true |
aemeasurable_inv_iff._simp_2 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G : Type u_4} [inst : InvolutiveInv G]
[inst_1 : MeasurableSpace G] [MeasurableInv G] {f : α → G}, AEMeasurable (fun x => (f x)⁻¹) μ = AEMeasurable f μ | null | false |
CategoryTheory.Subobject.Classifier.instUniqueHomΩ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {c : CategoryTheory.Subobject.Classifier C} → (Y : C) → Unique (Y ⟶ c.Ω₀) | null | true |
CategoryTheory.Limits.prod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ≅ Y) (g : X ≅ Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom | null | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.stabilizer_coe._simp_1_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} [h : Decidable p], (false = decide p) = ¬p | null | false |
Lean.Server.Snapshots.Snapshot.recOn | Lean.Server.Snapshots | {motive : Lean.Server.Snapshots.Snapshot → Sort u} →
(t : Lean.Server.Snapshots.Snapshot) →
((stx : Lean.Syntax) →
(mpState : Lean.Parser.ModuleParserState) →
(cmdState : Lean.Elab.Command.State) → motive { stx := stx, mpState := mpState, cmdState := cmdState }) →
motive t | null | false |
MDifferentiableWithinAt.neg | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
AddLocalization.liftOn₂_mk | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p)
(H :
∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
(AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d')
(a c : M) (b d : ↥S), (AddLocalization.mk... | null | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ : CategoryTheory.Functor J C) {F₂ F₂' : CategoryTheory.Functor J C} (g : F₂ ⟶ F₂') (j : J),
CategoryTheory.CategoryStruct.comp ((C... | null | true |
ContinuousMultilinearMap.instIsAddApplyForall | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [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 : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂... | null | true |
IO.Process.Output.stderr | Init.System.IO | IO.Process.Output → String | Everything that was written to the process's standard error. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.exists_concat_eq_cons.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u w : V} (motive : (v : V) → G.Walk u v → G.Adj v w → Prop) (v : V)
(x : G.Walk u v) (x_1 : G.Adj v w),
(∀ (h : G.Adj u w), motive u SimpleGraph.Walk.nil h) →
(∀ (v v_1 : V) (h' : G.Adj u v_1) (p : G.Walk v_1 v) (h : G.Adj v w), motive v (SimpleGraph.Walk.cons h' p) h) →
... | null | false |
Polynomial.map_evalRingHom_eval | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p | null | true |
MulArchimedeanClass.mk_right_le_mk_mul_iff._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk (a * b)) = (MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk a) | null | false |
Equiv.subRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G),
Equiv.subRight a = { toFun := fun b => b - a, invFun := fun b => b + a, left_inv := ⋯, right_inv := ⋯ } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.