name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Group.IsFinitelyPresented.casesOn | Mathlib.GroupTheory.FinitelyPresentedGroup | {G : Type u_4} →
[inst : Group G] →
{motive : Group.IsFinitelyPresented G → Sort u} →
(t : Group.IsFinitelyPresented G) →
((out : ∃ n φ, Function.Surjective ⇑φ ∧ φ.ker.IsFinitelyNormallyGenerated) → motive ⋯) → motive t | null | false |
Std.Internal.Parsec.pure | Std.Internal.Parsec.Basic | {α ι : Type} → α → Std.Internal.Parsec ι α | null | true |
HomologicalComplex.ext_of_iso | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(e : C₁ ≅ C₂) (h₁ : ∀ (i : ι), C₁.X i = C₂.X i),
autoParam (∀ (i : ι), e.hom.f i = CategoryTheory.eqToHom ⋯) HomologicalComplex.ext_of_i... | null | true |
Function.Injective.involutiveInv.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₂ : Type u_2} {M₁ : Type u_3} [inst : Inv M₁] [inst_1 : InvolutiveInv M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(inv : ∀ (x : M₁), f x⁻¹ = (f x)⁻¹), Function.Injective.involutiveInv f hf inv = { toInv := inst, inv_inv := ⋯ } | null | true |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_eval_half_eq_zero._simp_1_1 | Mathlib.NumberTheory.ZetaValues | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | null | false |
CategoryTheory.MorphismProperty.instIsStableUnderCoproductsLlp | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C),
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{w, v, u} T.llp | null | true |
ContinuousLinearMap.IsFredholm | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : AddCommGroup F] →
[inst_3 : Module 𝕜 E] →
[inst_4 : Module 𝕜 F] → [inst_5 : TopologicalSpace E] → [inst_6 : TopologicalSpace F] → (E →... | A continuous linear map `u : E →L[𝕜] F` is a **Fredholm operator** if it is strict,
its range is closed and has finite codimension, and its kernel is (topologically) complemented and
has finite dimension.
See also `isFredholm_tfae` for other equivalent characterizations.
We will also prove later (not in Mathlib yet) ... | true |
CategoryTheory.Limits.IsLimit.ofConeOfConeUncurry | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
{D ... | If `coneOfConeUncurry Q c` is a limit cone then `c` is in fact a limit cone.
| true |
CategoryTheory.Limits.Trident.ofι_pt | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [inst_1 : Nonempty J]
{P : C} (ι : P ⟶ X)
(w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)),
(CategoryTheory.Limits.Trident.ofι ι w).pt = P | null | true |
MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.negPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : MeasureTheory.SignedMeasure α} {μ : MeasureTheory.Measure α}
[self : s.HaveLebesgueDecomposition μ], s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ | null | true |
Sum.getLeft.congr_simp | Init.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} (ab ab_1 : α ⊕ β) (e_ab : ab = ab_1) (a : ab.isLeft = true),
ab.getLeft a = ab_1.getLeft ⋯ | null | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_3 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι) (n : ℕ), n + 1 < (a :: l).length → n < l.length | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.IterM.step_intermediateDropWhileWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yi... | null | true |
Lean.Grind.Linarith.eq_coeff_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly) (k : ℕ), Lean.Grind.Linarith.eq_coeff_cert p₁ p₂ k = (k != 0 && p₁ == p₂.mul ↑k) | null | true |
Algebra.Etale.inst | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u} [inst : CommRing R], Algebra.Etale R R | null | true |
CategoryTheory.ObjectProperty.colimitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] (X : C), P X → P.colimitsClosure J X | null | true |
IncidenceAlgebra.instModule._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {𝕝 : Type u_3} {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : Semiring 𝕜]
[inst_3 : Semiring 𝕝] [inst_4 : Module 𝕜 𝕝] (x y : IncidenceAlgebra 𝕜 α) (z : IncidenceAlgebra 𝕝 α),
(x • y) • z = x • y • z | null | false |
Std.Time.Week.Aligned.instOfNatOrdinal | Std.Time.Date.Unit.Week | {n : ℕ} → OfNat Std.Time.Week.Aligned.Ordinal n | null | true |
HomologicalComplex.opInverse._proof_4 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y Z : HomologicalComplex Vᵒᵖ c.symm} (f : X ⟶ Y) (g : Y ⟶ Z),
Quiver.Hom.op { f := fun i => ((CategoryTheory.CategoryStruct.comp f g).f i).unop, comm' := ⋯ } =
... | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.toWord_mul_mk_eq._proof_1_24 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (b : Bool) (x : FreeGroup α) (i : ℕ) (a_1 : α × Bool),
(List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord ++ [(a, b)])[i]? = some a_1 →
i < (List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord ++ [(a, b)]).length | null | false |
IsGroupLikeElem.mul | Mathlib.RingTheory.Bialgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A] {a b : A},
IsGroupLikeElem R a → IsGroupLikeElem R b → IsGroupLikeElem R (a * b) | Group-like elements in a bialgebra are stable under multiplication. | true |
CochainComplex.degreewiseEpiWithInjectiveKernel._proof_1 | Mathlib.Algebra.Homology.Factorizations.Basic | IsRightCancelAdd ℤ | null | false |
Lean.Server.RpcEncodable.mk | Lean.Server.Rpc.Basic | {α : Type} →
(α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) → Lean.Server.RpcEncodable α | null | true |
CategoryTheory.IsGrothendieckAbelian.instMonoIMonomorphismsRlpMonoMapFactorizationDataRlp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f).i | null | true |
OrderIso.divRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a b : α),
(RelIso.symm (OrderIso.divRight a)) b = b * a | null | true |
Language.toDFA | Mathlib.Computability.MyhillNerode | {α : Type u} → (L : Language α) → DFA α ↑(Set.range L.leftQuotient) | The left quotients of a language are the states of an automaton that accepts the language. | true |
Monoid.mk._flat_ctor | Mathlib.Algebra.Group.Monoid | {M : Type u_2} →
(one : M) →
(mul : M → M → M) →
(∀ (a b c : M), a * b * c = a * (b * c)) →
(∀ (a : M), 1 * a = a) →
(∀ (a : M), a * 1 = a) →
(npow : ℕ → M → M) →
autoParam (∀ (x : M), x ^ 0 = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) (... | null | false |
Lean.Parser.instInhabitedParserInfo.default | Lean.Parser.Types | Lean.Parser.ParserInfo | null | true |
Std.List.stream_drop_eq_drop | Batteries.Data.Stream | ∀ {α : Type u_1} {n : ℕ} (l : List α), Std.Stream.drop l n = List.drop n l | null | true |
Polynomial.eq_X_add_C_of_natDegree_le_one | Mathlib.Algebra.Polynomial.Degree.SmallDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
p.natDegree ≤ 1 → p = Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) | null | true |
Array.takeWhile_map | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : β → Bool} {as : Array α},
Array.takeWhile p (Array.map f as) = Array.map f (Array.takeWhile (p ∘ f) as) | null | true |
Std.ExtDTreeMap.self_le_maxKey!_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp k (t.insert k v).maxKey!).isLE = true | null | true |
instStrongNormalizedGCDMonoidNat._proof_3 | Mathlib.Algebra.GCDMonoid.Nat | ∀ (x x_1 : ℕ), normalize (lcm x x_1) = lcm x x_1 | null | false |
GromovHausdorff.instInhabitedGHSpace | Mathlib.Topology.MetricSpace.GromovHausdorff | Inhabited GromovHausdorff.GHSpace | null | true |
List.eraseIdx_eq_self | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : ℕ}, l.eraseIdx k = l ↔ l.length ≤ k | null | true |
neg_add_cancel_left | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), -a + (a + b) = b | null | true |
Std.Sat.CNF.Clause.literals_relabel | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {β : Type u_2} {r : α → β} {c : Std.Sat.CNF.Clause α},
(Std.Sat.CNF.Clause.relabel r c).literals =
List.map
(fun x =>
match x with
| (i, n) => (r i, n))
c.literals | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd c = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd c_1 →
c = c_1 | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn_obj_zero._simp_1_12 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
CategoryTheory.over._auto_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | Lean.Syntax | null | false |
IsClosedMap.codRestrict | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → ∀ {s : Set Y} (hs : ∀ (a : X), f a ∈ s), IsClosedMap (Set.codRestrict f s hs) | null | true |
Option.any_none | Init.Data.Option.Basic | ∀ {α : Type u_1} {p : α → Bool}, Option.any p none = false | null | true |
Lean.Elab.enableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → [Lean.Elab.MonadInfoTree m] → optParam Bool true → m Unit | null | true |
_private.Mathlib.CategoryTheory.FiberedCategory.BasedCategory.0.CategoryTheory.BasedNatTrans.instReflectsIsomorphismsBasedFunctorFunctorObjForgetful._simp_1 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b) [inst_2 : CategoryTheory.IsIso φ]
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ],
p.IsHomLift (CategoryTheory.Categor... | null | false |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux.match_1_3 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
(S : RootPairing (↥LieSubalgebra.root) K (Module.Dual K ↥H) ↥H) (i j : ↥LieSubalgebra.root)
(motive : S.root i - S.root j ∈ Set.r... | null | false |
Associates.isUnit_iff_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : Associates M), IsUnit a ↔ a = 1 | null | true |
mul_lt_mul_of_neg_left | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R], b < a → c < 0 → c * a < c * b | null | true |
MonCat.Colimits.descFunLift.eq_3 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (x_1 y : MonCat.Colimits.Prequotient F),
MonCat.Colimits.descFunLift F s (x_1.mul y) = MonCat.Colimits.descFunLift F s x_1 * MonCat.Colimits.descFunLift F s y | null | true |
_private.Mathlib.Algebra.Group.Finsupp.0.Finsupp.addCommute_of_disjoint._simp_1_2 | Mathlib.Algebra.Group.Finsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s t = (s ∩ t = ∅) | null | false |
CategoryTheory.Sieve.essSurjFullFunctorGaloisInsertion | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.EssSurj] →
[F.Full] →
(X : C) →
GaloisInsertion (CategoryTheory.Sieve.functorPushfor... | When `F` is essentially surjective and full, the Galois connection is a Galois insertion. | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.getParamType | Lean.Elab.App | Lean.Elab.Term.ElabAppArgs.M Lean.Expr | Returns the current parameter's type.
Only valid if `fTypeIsForall` has returned `true`.
| true |
extChartAt_target_eventuallyEq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | **Alias** of `extChartAt_target_eventuallyEqSet_of_mem`.
---
Around a point in the target, `(extChartAt I x).target` and `range I` coincide locally. | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.foldrM.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← Std.DHashMap.Internal.Ass... | null | true |
Mathlib.Notation3.mkFoldlMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name →
Lean.Name →
Lean.Term →
Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) | Create a `Term` that represents a matcher for `foldl` notation.
Reminder: `( lit ","* => foldl (x y => scopedTerm) init)` | true |
_private.Lean.Compiler.CSimpAttr.0.Lean.Compiler.CSimp.isConstantReplacement?._sparseCasesOn_1 | Lean.Compiler.CSimpAttr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
algebraMap_comp_natCast | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⇑(algebraMap R A) ∘ Nat.cast = Nat.cast | null | true |
ArchimedeanClass.stdPart_eq_sSup | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (f : ℝ →+*o K) (x : K),
ArchimedeanClass.stdPart x = sSup {r | f r < x} | null | true |
Fintype.prod_empty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : Fintype ι] [inst_1 : CommMonoid M] [IsEmpty ι] (f : ι → M), ∏ x, f x = 1 | null | true |
instAddCommMonoidFormalMultilinearSeries._proof_6 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | null | false |
CategoryTheory.Limits.WidePushout.head | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{B : C} →
{objs : J → C} →
(arrows : (j : J) → B ⟶ objs j) →
[inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] →
B ⟶ CategoryTheory.Limits.widePushout B objs arrows | The unique map from the head to the pushout. | true |
BooleanSubalgebra.mem_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {f : BoundedLatticeHom α β}
{a : α} {L : BooleanSubalgebra β}, a ∈ BooleanSubalgebra.comap f L ↔ f a ∈ L | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Cartan.Basic.0.CartanMatrix.C_off_diag_nonpos._proof_1_5 | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | 0 ≤ 0 | null | false |
Std.TreeSet.get!_insertMany_list_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α}
{k : α}, k ∈ t → (t.insertMany l).get! k = t.get! k | null | true |
Int.gcd_sub_right_right_of_dvd | Init.Data.Int.Gcd | ∀ {n k : ℤ} (m : ℤ), n ∣ k → n.gcd (m - k) = n.gcd m | null | true |
Representation.coinvariantsToFinsupp._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (α : Type u_2) (x : G),
Finsupp.mapRange.linearMap (Representation.Coinvariants.mk ρ) ∘ₗ (ρ.finsupp α) x =
Finsupp.mapRange.linearMap (Representation.C... | null | false |
_private.Mathlib.MeasureTheory.Function.ConditionalLExpectation.0.MeasureTheory.measurable_condLExp'._simp_1_1 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Zero α],
Measurable 0 = True | null | false |
TypeCat.Hom.hom | Mathlib.CategoryTheory.Types.Basic | {X Y : Type u} → TypeCat.Hom X Y → TypeCat.Fun X Y | Turn a morphism in `Type` back into a function. | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.exists_mem_of_isBasis._simp_1_8 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Subalgebra.algebraicClosure | Mathlib.RingTheory.Algebraic.Integral | (R : Type u_1) →
(S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → [IsDomain R] → Subalgebra R S | If `R` is a domain and `S` is an arbitrary `R`-algebra, then the elements of `S`
that are algebraic over `R` form a subalgebra. | true |
_private.Lean.Linter.Deprecated.0.Lean.Linter.deprecatedAttr.match_8 | Lean.Linter.Deprecated | (motive : Option Lean.Linter.DeprecationEntry → Sort u_1) →
(x : Option Lean.Linter.DeprecationEntry) →
((entry : Lean.Linter.DeprecationEntry) → motive (some entry)) →
((x : Option Lean.Linter.DeprecationEntry) → motive x) → motive x | null | false |
Submodule.orthogonal_disjoint | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E), Disjoint K Kᗮ | `K` and `Kᗮ` have trivial intersection. | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMultispan.functorExt.match_1.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (motive : CategoryTheory.Limits.WalkingMultispan J → Sort u_3) (i : J.L)
(h_1 : (i : J.L) → motive (CategoryTheory.Limits.WalkingMultispan.left i))
(h_2 : (i : J.R) → motive (CategoryTheory.Limits.WalkingMultispan.right i)),
(match CategoryTheory.Limits.WalkingMultispa... | null | true |
CategoryTheory.ComposableArrows.homMk₅_app_three | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_453✝ ⟶ g.obj' 0 _proof_453✝) (app₁ : f.obj' 1 _proof_454✝ ⟶ g.obj' 1 _proof_454✝)
(app₂ : f.obj' 2 _proof_455✝ ⟶ g.obj' 2 _proof_455✝) (app₃ : f.obj' 3 _proof_456✝ ⟶ g.obj' 3 _proof_456... | null | true |
BitVec.reverse.eq_1 | Init.Data.BitVec.Lemmas | ∀ (x_2 : BitVec 0), x_2.reverse = x_2 | null | true |
WithTop.coe_sInf._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α},
s.Nonempty → BddBelow s → ⨅ a ∈ s, ↑a = ↑(sInf s) | null | false |
SemistandardYoungTableau.casesOn | Mathlib.Combinatorics.Young.SemistandardTableau | {μ : YoungDiagram} →
{motive : SemistandardYoungTableau μ → Sort u} →
(t : SemistandardYoungTableau μ) →
((entry : ℕ → ℕ → ℕ) →
(row_weak' : ∀ {i j1 j2 : ℕ}, j1 < j2 → (i, j2) ∈ μ → entry i j1 ≤ entry i j2) →
(col_strict' : ∀ {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → entry i1 j < entry i2... | null | false |
Lean.Compiler.LCNF.SpecEntry.mk.sizeOf_spec | Lean.Compiler.LCNF.SpecInfo | ∀ (declName : Lean.Name) (paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo) (alreadySpecialized : Bool),
sizeOf { declName := declName, paramsInfo := paramsInfo, alreadySpecialized := alreadySpecialized } =
1 + sizeOf declName + sizeOf paramsInfo + sizeOf alreadySpecialized | null | true |
Real.sinh_eq_tsum | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), Real.sinh r = ∑' (n : ℕ), r ^ (2 * n + 1) / ↑(2 * n + 1).factorial | null | true |
CategoryTheory.InducedWideCategory.Hom.mk.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} D] {F : C → D}
{P : CategoryTheory.MorphismProperty D} [inst_1 : P.IsMultiplicative] {X Y : CategoryTheory.InducedWideCategory D F P}
(hom hom_1 : F X ⟶ F Y) (e_hom : hom = hom_1) (property : P hom),
{ hom := hom, property := property } = { ho... | null | true |
CategoryTheory.MonoidalCategory.«term𝟙__» | Mathlib.CategoryTheory.Monoidal.Category | Lean.ParserDescr | Notation for `tensorUnit`, the two-sided identity of `⊗` | true |
Turing.ListBlank.tail_cons | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ), (Turing.ListBlank.cons a l).tail = l | null | true |
CategoryTheory.MorphismProperty.IsLocalAtTarget.mk_of_small | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C} [inst_1 : K.HasPullbacks] [P.RespectsIso] [K.Small],
(∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover Y),
P f → ∀ (i : 𝒰.I₀), P (CategoryTheory.Limits.pullback.snd f (𝒰.f i))) →... | null | true |
ContinuousLinearMap.completion._proof_4 | Mathlib.Topology.Algebra.LinearMapCompletion | ∀ {α : Type u_1} {β : Type u_2} {R : Type u_4} {S : Type u_3} [inst : UniformSpace α] [inst_1 : AddCommGroup α]
[inst_2 : IsUniformAddGroup α] [inst_3 : Semiring S] [inst_4 : Module S α] [inst_5 : Semiring R]
[inst_6 : UniformSpace β] [inst_7 : AddCommGroup β] [inst_8 : IsUniformAddGroup β] [inst_9 : Module R β] {σ... | null | false |
LinearGrowth.le_linearGrowthSup_iff | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {u : ℕ → EReal} {a : EReal}, a ≤ LinearGrowth.linearGrowthSup u ↔ ∀ b < a, ∃ᶠ (n : ℕ) in Filter.atTop, b * ↑n ≤ u n | null | true |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.discharge._default | Lean.Meta.Tactic.Backtrack | Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId)) | null | false |
_private.Std.Data.ExtTreeMap.Lemmas.0.Std.ExtTreeMap.alter_eq_empty_iff._simp_1_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t t' : Std.ExtTreeMap α β cmp}, (t = t') = (t.inner = t'.inner) | null | false |
_private.Mathlib.Control.Basic.0.map_seq._simp_1_1 | Mathlib.Control.Basic | ∀ {f : Type u → Type v} {inst : Applicative f} [self : LawfulApplicative f] {α β : Type u} (g : α → β) (x : f α),
g <$> x = pure g <*> x | null | false |
Numbering.prefixedEquiv._proof_14 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X), ∀ x ∉ s, x ∈ sᶜ | null | false |
Order.IsSuccLimit.sSup_Iio | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLattice α] {x : α}, Order.IsSuccLimit x → sSup (Set.Iio x) = x | null | true |
IsLocalizedModule.commonDenom | Mathlib.Algebra.Module.LocalizedModule.Int | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{M' : Type u_3} →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') → [IsLo... | A choice of a common multiple of the denominators of a `Finset`-indexed family of fractions. | true |
TensorPower.gMul._proof_4 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {i j : ℕ},
IsScalarTower R R (PiTensorProduct R fun i => M) | null | false |
Set.instFintypeIio.eq_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Set.instFintypeIio a = Fintype.ofFinset (Finset.Iio a) ⋯ | null | true |
AntivaryOn.empty | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
AntivaryOn f g ∅ | null | true |
CategoryTheory.Limits.initialMonoClass_of_coproductsDisjoint | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.BinaryCoproductsDisjoint C],
CategoryTheory.Limits.InitialMonoClass C | If `C` has disjoint coproducts, any morphism out of initial is mono. Note it isn't true in
general that `C` has strict initial objects, for instance consider the category of types and
partial functions. | true |
DifferentiableOn.sub_iff_left._simp_2 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (f - g) s = DifferentiableOn 𝕜 f s | null | false |
BitVec.noConfusionType | Init.Prelude | Sort u → {w : ℕ} → BitVec w → {w' : ℕ} → BitVec w' → Sort u | null | false |
SimpleGraph.IsCompleteBetween.disjoint | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {s t : Set V}, G.IsCompleteBetween s t → Disjoint s t | null | true |
BialgCat.category | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} → [inst : CommRing R] → CategoryTheory.Category.{v, max (v + 1) u} (BialgCat R) | null | true |
_private.Mathlib.Algebra.Ring.NonZeroDivisors.0.le_nonZeroDivisorsLeft_iff_isLeftRegular._simp_1_1 | Mathlib.Algebra.Ring.NonZeroDivisors | ∀ {A : Type u_1} {B : outParam (Type u_2)} {inst : Membership B A} {inst_1 : LE A} [self : IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
Fin.castLT_sub_nezero._proof_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i j : Fin n}, i < j → n - ↑i ≠ 0 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.