name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Aesop.Match.forwardDeps | Aesop.Forward.Match.Types | Aesop.Match → Array Aesop.PremiseIndex | Premises that appear in slots which are as yet unassigned in this match
(i.e., in slots with index greater than `level`). This is a property of the
rule, but we include it here because it's used to check whether two matches
are equivalent. | true |
Module.subsingletonEquiv.congr_simp | Mathlib.LinearAlgebra.Basis.Defs | ∀ (R : Type u_4) (M : Type u_5) (ι : Type u_6) [inst : Semiring R] [inst_1 : Subsingleton R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], Module.subsingletonEquiv R M ι = Module.subsingletonEquiv R M ι | null | true |
CategoryTheory.Comon.MonOpOpToComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : (CategoryTheory.Mon Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(C... | null | false |
_private.Lean.Elab.Tactic.Config.0.Lean.Elab.Tactic.elabConfig.match_3 | Lean.Elab.Tactic.Config | (motive : Option Lean.Term → Sort u_1) →
(source? : Option Lean.Term) →
((source : Lean.Term) → motive (some source)) → ((x : Option Lean.Term) → motive x) → motive source? | null | false |
Lean.PersistentHashMap.instIteratorLoop | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} → {n : Type u_3 → Type u_4} → [Monad n] → Std.IteratorLoop (Lean.PersistentHashMap.Zipper α β) Id n | null | true |
EmbeddingLike.comp_injective._simp_1 | Mathlib.Data.FunLike.Embedding | ∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_4} {F : Sort u_5} [inst : FunLike F β γ] [EmbeddingLike F β γ] (f : α → β)
(e : F), Function.Injective (⇑e ∘ f) = Function.Injective f | null | false |
_private.Mathlib.Algebra.Homology.ShortComplex.Preadditive.0.CategoryTheory.ShortComplex.Homotopy.eq_add_nullHomotopic._abel_1_2 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
CategoryTheory.CategoryStruct.comp S₁.g h.h₂ + CategoryTheory.CategoryStruct.comp h.h₁ S₂.f + φ₂.τ₂ =
... | null | false |
_private.Mathlib.Order.OrderIsoNat.0.exists_covBy_seq_of_wellFoundedLT_wellFoundedGT_of_le._simp_1_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
CategoryTheory.WithTerminal.lift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z),
(∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) →
∀ {X Y Z_1 : CategoryTheory.Wi... | null | false |
AddSubmonoid.matrix._proof_1 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddMonoid A] (S : AddSubmonoid A) {a b : Matrix m n A},
a ∈ (↑S).matrix → b ∈ (↑S).matrix → ∀ (i : m) (j : n), a i j + b i j ∈ S | null | false |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero C).hom.app X).hom₃ =
(CategoryTheory.shiftFunctorZero C ℤ).hom.app X... | null | true |
CochainComplex.HomComplex.Cochain.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cochain K K 1 | The differential on a cochain complex, as a cochain of degree `1`. | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₄Toδ₃'._proof_6 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (n₀ n₁ : ℤ),
autoParam (n₀ + 1 = n₁)
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₄Toδ₃'._auto_1 →
n₀ + 1 = n₁ | null | false |
LinearMap.toContinuousLinearMap._proof_7 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst... | null | false |
IsCyclotomicExtension.Rat.ramificationIdxIn_eq | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (n : ℕ) {m p k : ℕ} [hp : Fact (Nat.Prime p)] (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
[IsCyclotomicExtension {n} ℚ K],
n = p ^ (k + 1) * m → ¬p ∣ m → (Ideal.span {↑p}).ramificationIdxIn (NumberField.RingOfIntegers K) = p ^ k * (p - 1) | Write `n = p ^ (k + 1) * m` where the prime `p` does not divide `m`, then the ramification index
of `p` in `ℚ(ζₙ)` is `p ^ k * (p - 1)`.
| true |
_private.Mathlib.LinearAlgebra.FiniteDimensional.Basic.0.LinearMap.ker_noncommProd_eq_of_supIndep_ker._simp_1_2 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Option.map_dmap | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (x : Option α) (f : (a : α) → x = some a → β) (g : β → γ),
Option.map g (Std.Internal.List.Option.dmap✝ x f) = Std.Internal.List.Option.dmap✝ x fun a h => g (f a h) | null | true |
Lean.Meta.Simp.Methods.toMethodsRef | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Methods → Lean.Meta.Simp.MethodsRef | null | true |
Polynomial.degree_mul_C_of_isUnit | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {a : R} [inst : Semiring R], IsUnit a → ∀ (p : Polynomial R), (p * Polynomial.C a).degree = p.degree | null | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_separation_compact_nhds._simp_1_5 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | null | false |
Lean.Grind.CommRing.Mon.beq' | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Bool | null | true |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkLeLtPrefix | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Name → Lean.Meta.Grind.Order.OrderM Lean.Expr | Returns `declName α leInst ltInst lawfulOrderLtInst`
| true |
GenContFract.terminatedAt_iff_s_none | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {α : Type u_1} {g : GenContFract α} {n : ℕ}, g.TerminatedAt n ↔ g.s.get? n = none | null | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Decl.isExtern._sparseCasesOn_1 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(t : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(type : Lean.IR.IRType) → (ext : Lean.ExternAttrData) → motive (Lean.IR.Decl.extern f xs type ext)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Polynomial.natDegree_multiset_prod_of_monic | Mathlib.Algebra.Polynomial.BigOperators | ∀ {R : Type u} [inst : CommSemiring R] (t : Multiset (Polynomial R)),
(∀ f ∈ t, f.Monic) → t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum | null | true |
Polynomial.splits_mul_iff_right | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f g : Polynomial R} [IsDomain R], f ≠ 0 → f.Splits → ((f * g).Splits ↔ g.Splits) | null | true |
Group.rank | Mathlib.GroupTheory.Rank | (G : Type u_1) → [inst : Group G] → [h : Group.FG G] → ℕ | The minimum number of generators of a group. | true |
Complex.UnitI | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ℂˣ | The imaginary unit as an invertible element. | true |
Finset.mem_neg_vadd_finset_iff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β] {s : Finset β}
{a : α} {b : β}, b ∈ -a +ᵥ s ↔ a +ᵥ b ∈ s | null | true |
List.modifyHead_eq_nil_iff._simp_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α}, (List.modifyHead f l = []) = (l = []) | null | false |
CategoryTheory.Bicategory.rightUnitor_comp_inv | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.Bicategory.rightUnitor (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).inv)
(Ca... | null | true |
Lean.Parser.registerBuiltinParserAttribute._auto_1 | Lean.Parser.Extension | Lean.Syntax | null | false |
Complex.VerticalIntegrable._auto_1 | Mathlib.Analysis.MellinTransform | Lean.Syntax | null | false |
ISize.toBitVec_or | Init.Data.SInt.Bitwise | ∀ (a b : ISize), (a ||| b).toBitVec = a.toBitVec ||| b.toBitVec | null | true |
Mathlib.Tactic.BicategoryLike.HorizontalComp.cons.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ (e : Mathlib.Tactic.BicategoryLike.Mor₂) (η : Mathlib.Tactic.BicategoryLike.WhiskerRight)
(ηs : Mathlib.Tactic.BicategoryLike.HorizontalComp),
sizeOf (Mathlib.Tactic.BicategoryLike.HorizontalComp.cons e η ηs) = 1 + sizeOf e + sizeOf η + sizeOf ηs | null | true |
Int.sign_one | Init.Data.Int.Order | Int.sign 1 = 1 | null | true |
CategoryTheory.Equivalence.instMonoidalInverseRefl._aux_1 | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶
CategoryTheory.Equivalence.refl.inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | false |
Std.DTreeMap.Raw.instInhabited | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Inhabited (Std.DTreeMap.Raw α β cmp) | null | true |
AlgCat.instCategory._proof_1 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_2) [inst : CommRing R] {X Y : AlgCat R} (f : X.Hom Y),
{ hom' := f.hom'.comp { hom' := AlgHom.id R ↑X }.hom' } = f | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor._proof_14 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] (c : C) {c' c'' : C} (f : c' ⟶ c'')
(d : D),
(F.map (Catego... | null | false |
ContinuousMonoidHom.compLeft._proof_1 | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_1} {B : Type u_3} (E : Type u_2) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : CommGroup E]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace E]
[inst_6 : IsTopologicalGroup E] (f : A →ₜ* B), ContinuousMonoidHom.comp 1 f = ContinuousMonoidHom.comp 1 f | null | false |
Finsupp.Lex.wellFounded | Mathlib.Data.Finsupp.WellFounded | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] {r : α → α → Prop} {s : N → N → Prop},
(∀ ⦃n : N⦄, ¬s n 0) → WellFounded s → WellFounded (rᶜ ⊓ fun x1 x2 => x1 ≠ x2) → WellFounded (Finsupp.Lex r s) | null | true |
DerivingHelpers._aux_Init_LawfulBEqTactics___macroRules_DerivingHelpers_tacticDeriving_ReflEq_tactic_1 | Init.LawfulBEqTactics | Lean.Macro | null | false |
Lean.Elab.Tactic.Conv.evalUnfold | Lean.Elab.Tactic.Conv.Unfold | Lean.Elab.Tactic.Tactic | null | true |
ENNReal.add_lt_add_iff_right | Mathlib.Data.ENNReal.Operations | ∀ {a b c : ENNReal}, a ≠ ⊤ → (b + a < c + a ↔ b < c) | null | true |
PSigma.Lex.orderTop._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : PartialOrder ι] [inst_1 : OrderTop ι] [inst_2 : (i : ι) → Preorder (α i)]
[inst_3 : OrderTop (α ⊤)] (a : ι) (b : α a), ⟨a, b⟩ ≤ ⟨⊤, ⊤⟩ | null | false |
Std.DTreeMap.Internal.Unit.RioSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → {inst : Ord α} → [SizeOf α] → SizeOf (Std.DTreeMap.Internal.Unit.RioSliceData α) | null | false |
Bundle.Trivialization.coordChangeL | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_4 : AddCommMonoid F] →
... | A coordinate change function between two trivializations, as a continuous linear equivalence.
Defined to be the identity when `b` does not lie in the base set of both trivializations. | true |
Std.ExtDTreeMap.maxKeyD_le | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {k fallback : α}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | null | true |
Set.subset_symmDiff_union_symmDiff_left | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u} {s t u : Set α}, Disjoint s t → u ⊆ symmDiff s u ∪ symmDiff t u | null | true |
HomologicalComplex.extend.d_eq | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c) {i j : Option ι} {a b : ι} (hi : i = some a) (hj : j = some b),
HomologicalComplex.ex... | null | true |
CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (j : ℕ), 0 ≤ j + 1 | null | false |
String.Slice.takeEndWhile_takeEndWhile | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.BackwardPattern pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s : String.Slice}, (s.takeEndWhile pat).takeEndWhile pat = s.takeEndWhile pat | null | true |
Lean.Parser.LeadingIdentBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.LeadingIdentBehavior → Lean.Parser.LeadingIdentBehavior → Sort v✝ | null | true |
ContinuousMap.tendsto_iff_tendstoLocallyUniformly | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {α : Type u₁} {β : Type u₂} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {f : C(α, β)} {ι : Type u₃}
{p : Filter ι} {F : ι → C(α, β)} [WeaklyLocallyCompactSpace α],
Filter.Tendsto F p (nhds f) ↔ TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p | In a weakly locally compact space,
convergence in the compact-open topology is the same as locally uniform convergence.
The right-to-left implication holds in any topological space,
see `ContinuousMap.tendsto_of_tendstoLocallyUniformly`. | true |
Prefunctor.IsCovering.symmetrify | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V),
φ.IsCovering → φ.symmetrify.IsCovering | null | true |
IsCompactOperator.hasEigenvalue_iff_mem_spectrum | Mathlib.Analysis.Normed.Operator.Compact.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜} [CompleteSpace X],
IsCompactOperator ⇑T → μ ≠ 0 → (Module.End.HasEigenvalue (↑T) μ ↔ μ ∈ spectrum 𝕜 T) | If `T` is a compact operator on a Banach space, then the nonzero eigenvalues of `T` are exactly
the nonzero points in the spectrum of `T`. This is a consequence of the Fredholm alternative for
compact operators. | true |
CompletelyRegularSpace.mk | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X],
(∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K) → CompletelyRegularSpace X | null | true |
BitVec.carry_extractLsb'_eq_carry | Init.Data.BitVec.Bitblast | ∀ {w i len : ℕ},
i < len →
∀ {x y : BitVec w} {b : Bool},
BitVec.carry i (BitVec.extractLsb' 0 len x) (BitVec.extractLsb' 0 len y) b = BitVec.carry i x y b | The value of `(carry i x y false)` can be computed by truncating `x` and `y`
to `len` bits where `len ≥ i`. | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_2 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft f.hom (CategoryTheory.CategoryStruct.id g).hom) =
Ca... | null | false |
PowerSeries.«term_%ʷ_» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.TrailingParserDescr | The remainder `r` in Weierstrass division, denoted by `f %ʷ g`. Note that when the image of
`g` in the residue field is zero, this is defined to be zero. | true |
Flag.ofIsMaxChain._proof_2 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (c : Set α),
IsMaxChain (fun x1 x2 => x1 ≤ x2) c → ∀ ⦃t : Set α⦄, IsChain (fun x1 x2 => x1 ≤ x2) t → c ⊆ t → c = t | null | false |
Mathlib.Tactic.IntervalCases.Bound._sizeOf_1 | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Bound → ℕ | null | false |
TopCommRingCat.isCommRing | Mathlib.Topology.Category.TopCommRingCat | (self : TopCommRingCat) → CommRing self.α | null | true |
Dilation.ratioHom | Mathlib.Topology.MetricSpace.Dilation | {α : Type u_1} → [inst : PseudoEMetricSpace α] → (α →ᵈ α) →* NNReal | `Dilation.ratio` as a monoid homomorphism from `α →ᵈ α` to `ℝ≥0`. | true |
irrational_ratCast_add_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (↑q + x) ↔ Irrational x | null | true |
mulActionSphereClosedBall._proof_2 | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ} (x : ↑(Metric.closedBall 0 r)), 1 • x = x | null | false |
MeasurableEquiv.shearAddRight | Mathlib.MeasureTheory.Group.Prod | (G : Type u_1) →
[inst : MeasurableSpace G] → [inst_1 : AddGroup G] → [MeasurableAdd₂ G] → [MeasurableNeg G] → G × G ≃ᵐ G × G | The map `(x, y) ↦ (x, x + y)` as a `MeasurableEquiv`. | true |
lie_abelian_iff_equiv_lie_abelian | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), IsLieAbelian L₁ ↔ IsLieAbelian L₂ | null | true |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscrete_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S : Set X},
(S ∈ Filter.codiscrete X) = ∀ (x : X), Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal Sᶜ) | null | false |
Lean.Grind.CommRing.Poly.NonnegCoeffs.below.casesOn | Init.Grind.Ring.CommSemiringAdapter | ∀ {motive : (a : Lean.Grind.CommRing.Poly) → a.NonnegCoeffs → Prop}
{motive_1 :
{a : Lean.Grind.CommRing.Poly} → (t : a.NonnegCoeffs) → Lean.Grind.CommRing.Poly.NonnegCoeffs.below t → Prop}
{a : Lean.Grind.CommRing.Poly} {t : a.NonnegCoeffs} (t_1 : Lean.Grind.CommRing.Poly.NonnegCoeffs.below t),
(∀ (c : ℤ) (a... | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (π : Y ⟶ X) ⦃V : C⦄ ⦃f : V ⟶ X⦄
(motive : (CategoryTheory.Sieve.generate (CategoryTheory.Presieve.ofArrows (fun x => Y) fun x => π)).arrows f → Prop)
(h : (CategoryTheory.Sieve.generate (CategoryTheory.Presieve.ofArrows (fun x => Y) fun x => π... | null | false |
Submonoid.map.congr_simp | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f f_1 : F),
f = f_1 → ∀ (S S_1 : Submonoid M), S = S_1 → Submonoid.map f S = Submonoid.map f_1 S_1 | null | true |
CategoryTheory.Limits.idZeroEquivIsoZero_apply_hom | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) (h : CategoryTheory.CategoryStruct.id X = 0),
((CategoryTheory.Limits.idZeroEquivIsoZero X) h).hom = 0 | null | true |
UniqueDiffWithinAt.inter' | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → t ∈ nhdsWithin x s → UniqueDiffWithinAt 𝕜 (s ∩ t) x | null | true |
Polynomial.Monic.pow | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (n : ℕ), (p ^ n).Monic | null | true |
CentroidHom.instFunLike._proof_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f g : CentroidHom α),
(fun f => (↑f.toAddMonoidHom).toFun) f = (fun f => (↑f.toAddMonoidHom).toFun) g → f = g | null | false |
CommGroupWithZero.ctorIdx | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → CommGroupWithZero G₀ → ℕ | null | false |
HomologicalComplex.units_smul_f_apply | Mathlib.Algebra.Homology.Linear | ∀ {R : Type u_1} [inst : Semiring R] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ι : Type u_4} {c : ComplexShape ι}
{X Y : HomologicalComplex C c} (r : Rˣ) (f : X ⟶ Y) (n : ι), (r • f).f n = r • f.f n | null | true |
WithLp.noConfusion | Mathlib.Analysis.Normed.Lp.WithLp | {P : Sort u} →
{p : ENNReal} →
{V : Type u_1} →
{t : WithLp p V} →
{p' : ENNReal} →
{V' : Type u_1} → {t' : WithLp p' V'} → p = p' → V = V' → t ≍ t' → WithLp.noConfusionType P t t' | null | false |
CategoryTheory.Limits.IsImage.lift | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{F : CategoryTheory.Limits.MonoFactorisation f} →
CategoryTheory.Limits.IsImage F → (F' : CategoryTheory.Limits.MonoFactorisation f) → F.I ⟶ F'.I | Data exhibiting that a given factorisation through a mono is initial. | true |
instPreorderShrink | Mathlib.Order.Shrink | {α : Type u_1} → [inst : Small.{u, u_1} α] → [Preorder α] → Preorder (Shrink.{u, u_1} α) | null | true |
UpperHalfPlane.cuspFunction.eq_1 | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ (h : ℝ) (f : UpperHalfPlane → ℂ),
UpperHalfPlane.cuspFunction h f = Function.Periodic.cuspFunction h (f ∘ ↑UpperHalfPlane.ofComplex) | null | true |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.match_1 | Std.Data.DHashMap.Internal.Defs | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Option ((a : α) × β a) → Sort u_3) →
(x : Option ((a : α) × β a)) → ((kv' : (a : α) × β a) → motive (some kv')) → (Unit → motive none) → motive x | null | false |
Std.Sat.AIG.Entrypoint.ctorIdx | Std.Sat.AIG.Basic | {α : Type} → {inst : DecidableEq α} → {inst_1 : Hashable α} → Std.Sat.AIG.Entrypoint α → ℕ | null | false |
Multiset.exists_multiset_eq_map_quot_mk | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {r : α → α → Prop} (s : Multiset (Quot r)), ∃ t, s = Multiset.map (Quot.mk r) t | null | true |
CliffordAlgebra.reverse_mem_evenOdd_iff._simp_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
(CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n) = (x ∈ CliffordAlgebra.evenOdd Q n) | null | false |
CommGroup.monoidHomMonoidHomEquiv._proof_5 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_2) (M : Type u_1) [inst : CommGroup G] [inst_1 : CommMonoid M] (g : G), 1 g = 1 | null | false |
CategoryTheory.Adjunction.mapAddGrp | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
... | An adjunction of monoidal functors lifts to an adjunction of their lifts
to additive group objects. | true |
FractionalIdeal.coeIdeal_inj | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{I J : Ideal R}, ↑I = ↑J ↔ I = J | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.supp_injective._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
CategoryTheory.Limits.Cone.equivalenceOfReindexing | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{G : CategoryTheory.Functor K C} →
... | The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
| true |
Std.Time.OffsetO | Std.Time.Format.Basic | Type | `OffsetO` represents localized offset text formats based on the number of pattern letters.
| true |
Lean.Unhygienic.Context.mk.inj | Lean.Hygiene | ∀ {ref : Lean.Syntax} {scope : Lean.MacroScope} {ref_1 : Lean.Syntax} {scope_1 : Lean.MacroScope},
{ ref := ref, scope := scope } = { ref := ref_1, scope := scope_1 } → ref = ref_1 ∧ scope = scope_1 | null | true |
Std.DHashMap.insert_eq_insert | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {p : (a : α) × β a},
insert p m = m.insert p.fst p.snd | null | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_self'._auto_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | Lean.Syntax | null | false |
_private.Mathlib.Analysis.Meromorphic.IsolatedZeros.0.MeromorphicAt.eventually_nhdsSet_eventuallyEq_codiscreteWithin._simp_1_1 | Mathlib.Analysis.Meromorphic.IsolatedZeros | ∀ {a : Prop}, (a → a) = True | null | false |
Std.DHashMap.Equiv.symm | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β}, m₁.Equiv m₂ → m₂.Equiv m₁ | null | true |
QuotientGroup.Quotient.group._proof_13 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal],
autoParam
(∀ (n : ℕ) (a : G ⧸ N),
QuotientGroup.Quotient.group._aux_9 N (Int.negSucc n) a = (QuotientGroup.Quotient.group._aux_9 N (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam | null | false |
UInt8.toFin_inj | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a.toFin = b.toFin ↔ a = b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.