name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BoundedVariationOn.stieltjesFunctionRightLim.congr_simp | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α] {E : Type u_2}
[inst_3 : NormedAddCommGroup E] [inst_4 : CompleteSpace E] {f f_1 : α → E} (e_f : f = f_1)
(hf : BoundedVariationOn f Set.univ) (x₀ x₀_1 : α),
x₀ = x₀_1 → hf.stieltjesFunctionRightLim x₀ = ⋯.stieltjesFu... | null | true |
FreeMagma.traverse_pure' | Mathlib.Algebra.Free | ∀ {α β : Type u} {m : Type u → Type u} [inst : Applicative m] (F : α → m β), traverse F ∘ pure = fun x => pure <$> F x | null | true |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat.match_91 | Mathlib.Tactic.NormNum.IsSquare | (mulQ : Q(Mul ℚ)) →
(a : Q(ℚ)) →
(motive : (b : Bool) × Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b → Sort u_1) →
(__discr : (b : Bool) × Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b) →
((b : Bool) → (pb : Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b) → motive ⟨b, pb⟩) → motive __... | null | false |
PartialEquiv.IsImage.preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.IsImage s t → e.source ∩ ↑e ⁻¹' t = e.source ∩ s | **Alias** of the forward direction of `PartialEquiv.IsImage.iff_preimage_eq`. | true |
PresheafOfModules.limitPresheafOfModules_obj | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
↑((F.comp (PresheafOfModules.evaluation R... | null | true |
Batteries.AssocList.all._f | Batteries.Data.AssocList | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → (x : Batteries.AssocList α β) → Batteries.AssocList.below x → Bool | null | false |
CategoryTheory.MonoidalCategory.Arrow.PullbackHom.isTerminalIso_hom_right | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C] (X : CategoryTheory.Arrow C)
{T : C} (t : CategoryTheory.Limits.IsTerminal T) {W : C},
(CategoryTheory.MonoidalCategory.A... | null | true |
SSet.Truncated.StrictSegal.spine_δ_arrow_lt | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n) (f : X.Path (m + 1)) {i : Fin m}
{j : Fin (m + 2)},
i.succ.castSucc < j →
(X.spine m ⋯
((CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ j) ⋯ ⋯).op))
... | If we take the path along the spine of the `j`th face of a `spineToSimplex`,
the common arrows will agree with those of the original path `f`. In particular,
an arrow `i` with `i + 1 < j` can be identified with the same arrow in `f`. | true |
Subalgebra.instCommRingSubtypeMemCenter._proof_10 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam
(∀ (n : ℕ) (a : ↥(Subalgebra.center R A)),
Subalgebra.instCommRingSubtypeMemCenter._aux_6 (Int.negSucc n) a =
-Subalgebra.instCommRingSubtypeMemCenter._aux_6 (↑n.succ) a)
SubNegMonoid.zsmu... | null | false |
ExceptCpsT.runK_bind_lift | Init.Control.ExceptCps | ∀ {m : Type u_1 → Type u_2} {α ε β : Type u_1} {s : ε} {a : Type u_1} {ok : β → m a} {error : ε → m a} [inst : Monad m]
(x : m α) (f : α → ExceptCpsT ε m β),
(ExceptCpsT.lift x >>= f).runK s ok error = do
let a_1 ← x
(f a_1).runK s ok error | null | true |
Aesop.UnfoldRule.mk | Aesop.Rule | Lean.Name → Option Lean.Name → Aesop.UnfoldRule | null | true |
Std.Time.Year.instOfNatOffset | Std.Time.Date.Unit.Year | {n : ℕ} → OfNat Std.Time.Year.Offset n | null | true |
Lean.Grind.CommRing.Poly.add.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} →
{k : ℤ} →
{v : Lean.Grind.CommRing.Mon} →
{p : Lean.Grind.CommRing.Poly} →
{k' : ℤ} →
{v' : Lean.Grind.CommRing.Mon} →
{p' : Lean.Grind.CommRing.Poly} →
Lean.Grind.CommRing.Poly.add k v p = Lean.Grind.CommRing.Poly.add k' v' p' →
(k ... | null | false |
Module.ofMinimalAxioms._proof_2 | Mathlib.Algebra.Module.MinimalAxioms | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : SMul R M]
(add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x) (x : M), (AddMonoidHom.mk' (fun x_1 => x_1 • x) ⋯) 0 = 0 | null | false |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.modify._proof_1 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (a : α) (f : β a → β a)
(m m' : Std.DHashMap α β), m.Equiv m' → Std.ExtDHashMap.mk (m.modify a f) = Std.ExtDHashMap.mk (m'.modify a f) | null | false |
Primrec.nat_rec' | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → ℕ} {g : α → β}
{h : α → ℕ × β → β},
Primrec f → Primrec g → Primrec₂ h → Primrec fun a => Nat.rec (g a) (fun n IH => h a (n, IH)) (f a) | null | true |
intervalIntegral.FTCFilter.nhdsUniv | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ (a : ℝ), intervalIntegral.FTCFilter a (nhdsWithin a Set.univ) (nhds a) | null | true |
Complex.«term_×ℂ_» | Mathlib.Data.Complex.Basic | Lean.TrailingParserDescr | The product of a set on the real axis and a set on the imaginary axis of the complex plane,
denoted by `s ×ℂ t`. | true |
AddCircle.haarAddCircle._proof_2 | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, IsTopologicalAddGroup (ℝ ⧸ AddSubgroup.zmultiples T) | null | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.mkToSMatch.mkAlts.match_1 | Mathlib.Tactic.DeriveEncodable | (motive : Option Lean.Name → Sort u_1) →
(recName? : Option Lean.Name) →
((recName : Lean.Name) → motive (some recName)) → ((x : Option Lean.Name) → motive x) → motive recName? | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.288960067._hygCtx._hyg.2 | Lean.Elab.DocString | IO (IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocCodeBlockExpander)))) | null | false |
Lean.Meta.arrowDomainsN | Lean.Meta.InferType | ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr) | Given `n` and a non-dependent function type `α₁ → α₂ → ... → αₙ → Sort u`, returns the
types `α₁, α₂, ..., αₙ`. Throws an error if there are not at least `n` argument types or if a
later argument type depends on a prior one (i.e., it's a dependent function type).
This can be used to infer the expected type of the alte... | true |
_private.Batteries.Data.List.Count.0.List.idxToSigmaCount_sigmaCountToIdx._proof_1_65 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs : List α} {xc : (x : α) × Fin (List.count x xs)},
↑(cast ⋯ xc.snd) < (List.filter (fun x => x == xc.fst) xs).length | null | false |
Lean.Elab.Tactic.MkSimpContextResult.ctorIdx | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.MkSimpContextResult → ℕ | null | false |
CategoryTheory.Adjunction.rightAdjointLaxMonoidal | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
{G : Cate... | The right adjoint of an oplax monoidal functor is lax monoidal. | true |
Valuation.IsRankOneDiscrete.generator_ne_zero | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete], ↑(Valuation.IsRankOneDiscrete.generator v) ≠ 0 | null | true |
CategoryTheory.MorphismProperty.RightFraction₂.mk.sizeOf_spec | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
[inst_1 : SizeOf C] [inst_2 : ⦃X Y : C⦄ → (x : X ⟶ Y) → SizeOf (W x)] {X' : C} (s : X' ⟶ X) (hs : W s)
(f f' : X' ⟶ Y),
sizeOf { X' := X', s := s, hs := hs, f := f, f' := f' } = 1 + sizeOf X' + sizeOf ... | null | true |
Std.HashSet.Equiv.mk._flat_ctor | Std.Data.HashSet.Basic | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α}, m₁.inner.Equiv m₂.inner → m₁.Equiv m₂ | null | false |
Lean.Compiler.CSimp.Entry.noConfusion | Lean.Compiler.CSimpAttr | {P : Sort u} → {t t' : Lean.Compiler.CSimp.Entry} → t = t' → Lean.Compiler.CSimp.Entry.noConfusionType P t t' | null | false |
Array.find?_filterMap | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β} {p : β → Bool},
Array.find? p (Array.filterMap f xs) = (Array.find? (fun a => Option.any p (f a)) xs).bind f | null | true |
Equiv.sigmaEquivOptionOfInhabited.match_1 | Mathlib.Logic.Equiv.Sum | ∀ (α : Type u_1) [inst : Inhabited α] (motive : Option { a // a ≠ default } → Prop) (x : Option { a // a ≠ default }),
(∀ (a : Unit), motive none) → (∀ (val : α) (ha : val ≠ default), motive (some ⟨val, ha⟩)) → motive x | null | false |
Int32.toInt_le | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt ≤ Int32.maxValue.toInt | null | true |
AlgebraicTopology.DoldKan.Compatibility.equivalence₁CounitIso_hom_app | Mathlib.AlgebraicTopology.DoldKan.Compatibility | ∀ {A : Type u_1} {A' : Type u_2} {B' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] [inst_2 : CategoryTheory.Category.{v_4, u_4} B'] {eA : A ≌ A'}
{e' : A' ≌ B'} {F : CategoryTheory.Functor A B'} (hF : eA.functor.comp e'.functor ≅ F) (X : B'),
(Algebraic... | null | true |
Ordinal.blsub_congr | Mathlib.SetTheory.Ordinal.Family | ∀ {o₁ o₂ : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o₁ → Ordinal.{max u v}) (ho : o₁ = o₂),
o₁.blsub f = o₂.blsub fun a h => f a ⋯ | null | true |
IntermediateField.inf_relfinrank_right | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A B : IntermediateField F E),
(A ⊓ B).relfinrank B = A.relfinrank B | null | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isCompact_iff_totallyBounded_isComplete.match_1_3 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [uniformSpace : UniformSpace α] {s : Set α} (f : Filter α) (motive : (∃ x ∈ s, ClusterPt x f) → Prop)
(x : ∃ x ∈ s, ClusterPt x f), (∀ (a : α) (as : a ∈ s) (fa : ClusterPt a f), motive ⋯) → motive x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_intMin_of_msb_eq_false.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : (w : ℕ) → {x : BitVec w} → x.msb = false → Prop) (w : ℕ) {x : BitVec w} (hx : x.msb = false),
(∀ (x : BitVec 0) (hx : x.msb = false), motive 0 hx) →
(∀ (w' : ℕ) (x : BitVec (w' + 1)) (hx : x.msb = false), motive w'.succ hx) → motive w hx | null | false |
MvFunctor._aux_Mathlib_Data_TypeVec___unexpand_TypeVec_Arrow_1 | Mathlib.Data.TypeVec | Lean.PrettyPrinter.Unexpander | null | false |
Topology.IsInducing.regularSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [RegularSpace X] [inst_2 : TopologicalSpace Y] {f : Y → X},
Topology.IsInducing f → RegularSpace Y | null | true |
SimplexCategory.Truncated.δ₂_zero_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3 =
SimplexCategory.Truncated.Hom.tr ({ len := 0 }.const { len := 0 + 1 } 1)
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4 SimplexCategory.Truncated.δ₂_zero_comp_... | null | true |
Finset.map_add_right_Ico | Mathlib.Algebra.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α]
[ExistsAddOfLE α] [inst_4 : LocallyFiniteOrder α] (a b c : α),
Finset.map (addRightEmbedding c) (Finset.Ico a b) = Finset.Ico (a + c) (b + c) | null | true |
AlgebraicGeometry.SpecMap_preimage_basicOpen | Mathlib.AlgebraicGeometry.Scheme | ∀ {R S : CommRingCat} (f : R ⟶ S) (r : ↑R),
(TopologicalSpace.Opens.map (AlgebraicGeometry.Spec.map f).base).obj (PrimeSpectrum.basicOpen r) =
PrimeSpectrum.basicOpen ((CategoryTheory.ConcreteCategory.hom f) r) | null | true |
CategoryTheory.Subfunctor.ofSection_le_iff | Mathlib.CategoryTheory.Subfunctor.OfSection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : Cᵒᵖ}
(x : F.obj X) (G : CategoryTheory.Subfunctor F), CategoryTheory.Subfunctor.ofSection x ≤ G ↔ x ∈ G.obj X | null | true |
_private.Mathlib.Order.Filter.Ultrafilter.Defs.0.Ultrafilter.exists_le.match_1_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} (f : Filter α) (motive : (∃ a, IsAtom a ∧ a ≤ f) → Prop) (x : ∃ a, IsAtom a ∧ a ≤ f),
(∀ (u : Filter α) (hu : IsAtom u) (huf : u ≤ f), motive ⋯) → motive x | null | false |
TopModuleCat.ofCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J] {F : CategoryTheory.Functor J (TopModuleCat R)}
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)))) {X Y : J}
(f : X ⟶ Y),
CategoryTheory.Ca... | null | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast | Mathlib.Tactic.Translate.UnfoldBoundary | Lean.Name → Lean.Name → Lean.Name → Lean.Name → Lean.Name → Mathlib.Tactic.UnfoldBoundary.UnfoldEntry | null | true |
IsAdjoinRootMonic.powerBasis_basis | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRootMonic S f), h.powerBasis.basis = h.basis | null | true |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.map_mem_algebraicClosure_iff._simp_1_2 | Mathlib.FieldTheory.AlgebraicClosure | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} [Nontrivial A],
IsIntegral A x = (minpoly A x ≠ 0) | null | false |
Rack.toEnvelGroup.mapAux._sunfold | Mathlib.Algebra.Quandle | {R : Type u_1} →
[inst : Rack R] → {G : Type u_2} → [inst_1 : Group G] → ShelfHom R (Quandle.Conj G) → Rack.PreEnvelGroup R → G | null | false |
emultiplicity_le_emultiplicity_of_dvd_right | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b c : α}, b ∣ c → emultiplicity a b ≤ emultiplicity a c | null | true |
Std.DHashMap.Const.getD_insertIfNew | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k a : α} {fallback v : β},
Std.DHashMap.Const.getD (m.insertIfNew k v) a fallback =
if (k == a) = true ∧ k ∉ m then v else Std.DHashMap.Const.getD m a fallback | null | true |
_private.Init.Data.List.Sublist.0.List.filterMap_subset._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} {b : β},
(b ∈ List.filterMap f l) = ∃ a ∈ l, f a = some b | null | false |
SymplecticGroup.instGroupSubtypeMatrixSumMemSubmonoidSymplecticGroup | Mathlib.LinearAlgebra.SymplecticGroup | {l : Type u_1} →
{R : Type u_2} →
[inst : DecidableEq l] → [inst_1 : Fintype l] → [inst_2 : CommRing R] → Group ↥(Matrix.symplecticGroup l R) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.aux_summable_add | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {k : ℕ}, 1 ≤ k → ∀ (x : ℂ), Summable fun n => (x + (↑n + 1)) ^ (-1 - ↑k) | null | true |
Lean.Elab.ContextInfo.runMetaM | Lean.Elab.InfoTree.Main | {α : Type} → Lean.Elab.ContextInfo → Lean.LocalContext → Lean.MetaM α → IO α | null | true |
Finset.Int.finsetGcd_nonneg | Mathlib.Algebra.GCDMonoid.Finset | ∀ {ι : Type u_1} {s : Finset ι} {f : ι → ℤ}, 0 ≤ s.gcd f | The gcd of a finset of integers is nonnegative. | true |
CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits._proof_6 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasLimitsOfShape K C]
{j₁ j₂ j₃ :... | null | false |
Primcodable.sum._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Primcodable α] [inst_1 : Primcodable β] (n : ℕ),
Encodable.encode
(bif n.bodd then Option.map (fun b => 2 * Encodable.encode (n, b).2 + 1) (Encodable.decode n.div2)
else Option.map (fun b => 2 * Encodable.encode (n, b).2) (Encodable.decode n.div2)) =
Encodable.e... | null | false |
Submodule.quotEquivOfEqBot_apply_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
(hp : p = ⊥) (x : M), (p.quotEquivOfEqBot hp) (Submodule.Quotient.mk x) = x | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.toUSize_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ (a : UInt32) (b : USize), (a.toUSize = b % 4294967296) = (a = b.toUInt32) | null | false |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_hom_right_assoc._simp_1_2 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] {g h : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) | null | false |
Submonoid.mrange_snd | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
MonoidHom.mrange (MonoidHom.snd M N) = ⊤ | null | true |
Submonoid.LocalizationMap.eq_iff_eq | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x y : M}, f x = f y ↔ g x = g y | null | true |
Std.DHashMap.Internal.Raw₀.insertMany_list_singleton | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] {k : α}
{v : β k}, ↑(m.insertMany [⟨k, v⟩]) = m.insert k v | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.map_add_toList_roc'._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ (n m k : ℕ), n + (m + k) = n + m + k | null | false |
Finset.map_ssubset_map._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s t : Finset α}, (Finset.map f s ⊂ Finset.map f t) = (s ⊂ t) | null | false |
Matroid.IsBasis.isBase_of_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → M.Spanning X → M.IsBase I | null | true |
Prod.instCoalgebra._proof_7 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : Coalgebra R A]
[inst_6 : Coalgebra R B],
LinearMap.rTensor (A × B) CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul = (TensorProduct.mk ... | null | false |
_private.Mathlib.Algebra.Group.Int.Even.0.Int.instDecidablePredIsSquare._simp_1 | Mathlib.Algebra.Group.Int.Even | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Padic.adicCompletionEquiv._proof_4 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Algebra R ℚ] [inst_3 : IsFractionRing R ℚ]
[inst_4 : IsIntegralClosure R ℤ ℚ] (p : Nat.Primes),
IsUniformAddGroup
(WithVal (IsDedekindDomain.HeightOneSpectrum.valuation ℚ (Rat.HeightOneSpectrum.primesEquiv.symm p))) | null | false |
List.take_eq_self_iff._simp_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (x : List α) {n : ℕ}, (List.take n x = x) = (x.length ≤ n) | null | false |
_private.Aesop.Forward.Substitution.0.Aesop.Substitution.mergeCompatible._proof_1 | Aesop.Forward.Substitution | ∀ (s₂ : Aesop.Substitution), ∀ i ∈ [:s₂.premises.size], i < s₂.premises.size | null | false |
LocallyConstant.coe_inj._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f g : LocallyConstant X Y}, (⇑f = ⇑g) = (f = g) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_mul_of_nonneg._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x y z : ℤ}, x / y / z = x / (y * z) → ¬x / (y * z) = x / y / z → False | null | false |
AlgebraicGeometry.IsAffineOpen.arrowStalkMapIso._proof_8 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {x : ↥X} (U : Y.Opens) (hU : AlgebraicGeometry.IsAffineOpen U)
(V : X.Opens) (hV : AlgebraicGeometry.IsAffineOpen V) (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U)
(hx : x ∈ V) (this : IsLocalization.AtPrime (↑(Y.presheaf.stalk ↑⟨f x, ⋯⟩)) (hU.primeIdealOf ⟨f x,... | null | false |
Lean.Meta.Grind.AC.DiseqCnstr.brecOn.eq | Lean.Meta.Tactic.Grind.AC.Types | ∀ {motive_1 : Lean.Meta.Grind.AC.DiseqCnstr → Sort u} {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u}
(t : Lean.Meta.Grind.AC.DiseqCnstr) (F_1 : (t : Lean.Meta.Grind.AC.DiseqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.AC.DiseqCnstrProof) → t.below → motive_2 t),
t.brecOn F_1 F_2 = F_1 t (L... | null | true |
Lean.Lsp.CodeActionClientCapabilities.dataSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | null | false |
Lean.Meta.Simp.Arith.Int.ToLinear.State._sizeOf_inst | Lean.Meta.Tactic.Simp.Arith.Int.Basic | SizeOf Lean.Meta.Simp.Arith.Int.ToLinear.State | null | false |
_private.Mathlib.Algebra.Homology.BifunctorAssociator.0.HomologicalComplex.instHasMapProdObjGradedObjectFunctorMapBifunctorMapBifunctorMapObjπX._proof_1 | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_11} {C₂ : Type u_13} {C₁₂ : Type u_9} {C₃ : Type u_7} {C₄ : Type u_5}
[inst : CategoryTheory.Category.{u_10, u_11} C₁] [inst_1 : CategoryTheory.Category.{u_12, u_13} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_7} C₃] [inst_3 : CategoryTheory.Category.{u_4, u_5} C₄]
[inst_4 : CategoryTheory.Catego... | null | false |
SimpleGraph.Subgraph.sup_adj | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {G₁ G₂ : G.Subgraph} {a b : V}, (G₁ ⊔ G₂).Adj a b ↔ G₁.Adj a b ∨ G₂.Adj a b | null | true |
_private.Lean.Elab.Tactic.Conv.Cbv.0.Lean.Elab.Tactic.Conv.evalCbv._regBuiltin.Lean.Elab.Tactic.Conv.evalCbv_1 | Lean.Elab.Tactic.Conv.Cbv | IO Unit | null | false |
_private.Mathlib.Analysis.LocallyConvex.WeakDual.0.LinearMap.mem_span_iff_continuous._simp_1_1 | Mathlib.Analysis.LocallyConvex.WeakDual | ∀ {ι : Type u_4} {𝕜 : Type u_5} {E : Type u_6} [Finite ι] [inst : Field 𝕜] [t𝕜 : TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜 E] [T0Space 𝕜] {f : ι → E →ₗ[𝕜] 𝕜} (φ : E →ₗ[𝕜] 𝕜),
Continuous ⇑φ = (φ ∈ Submodule.span 𝕜 (Set.range f)) | null | false |
CategoryTheory.ObjectProperty.LimitOfShape.ofIso | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} J] →
{X : C} → P.LimitOfShape J X → {Y : C} → (X ≅ Y) → P.LimitOfShape J Y | If `X` is a limit indexed by `J` of objects satisfying a property `P`, then
any object that is isomorphic to `X` also is. | true |
InfHom.instSemilatticeInf._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : SemilatticeInf β] {x y : InfHom α β}, ⇑y < ⇑x ↔ ⇑y < ⇑x | null | false |
Std.TreeMap.Equiv.getEntryGED_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : α × β}, t₁.Equiv t₂ → t₁.getEntryGED k fallback = t₂.getEntryGED k fallback | null | true |
CategoryTheory.Comma.mapLeftComp | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ L₃ : CategoryTheory.Functor A T}... | The functor `Comma L₁ R ⥤ Comma L₃ R` induced by the composition of two natural transformations
`l : L₁ ⟶ L₂` and `l' : L₂ ⟶ L₃` is naturally isomorphic to the composition of the two functors
induced by these natural transformations. | true |
CategoryTheory.GrothendieckTopology.pullbackComp | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{X Y Z : C} →
(f : X ⟶ Y) →
(g : Y ⟶ Z) → J.pullback (CategoryTheory.CategoryStruct.comp f g) ≅ (J.pullback g).comp (J.pullback f) | Pulling back along a composition is naturally isomorphic to
the composition of the pullbacks. | true |
Multiset.Rel.trans | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop) [IsTrans α r] {s t u : Multiset α},
Multiset.Rel r s t → Multiset.Rel r t u → Multiset.Rel r s u | null | true |
Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α},
(f.cycleFactorsFinset = {f}) = f.IsCycle | null | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_9 | Lean.Meta.Tactic.FunInd | (motive : Option (Lean.Elab.Structural.RecArgInfo × Subarray Lean.Elab.Structural.RecArgInfo) → Sort u_1) →
(x : Option (Lean.Elab.Structural.RecArgInfo × Subarray Lean.Elab.Structural.RecArgInfo)) →
(Unit → motive none) →
((recArgInfo : Lean.Elab.Structural.RecArgInfo) →
(s' : Subarray Lean.Elab.... | null | false |
List.replicate_sublist_replicate._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {m n : ℕ} (a : α), (List.replicate m a).Sublist (List.replicate n a) = (m ≤ n) | null | false |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.map_fst_le_of_subset_toEnumFinset._simp_1_4 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Set.Ici_sdiff_Ioi_same | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Ici a \ Set.Ioi a = {a} | null | true |
CategoryTheory.Limits.WalkingParallelFamily.Hom.ctorElimType | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive :
(a a_1 : CategoryTheory.Limits.WalkingParallelFamily J) →
CategoryTheory.Limits.WalkingParallelFamily.Hom J a a_1 → Sort u} →
ℕ → Sort (max 1 (imax (w + 1) u)) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
(n : ℕ) → aig.RefVec w → aig.RefVec n → ℕ → Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget aig w | null | true |
MeasureTheory.FiniteMeasure.eq_of_forall_apply_eq | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.FiniteMeasure Ω),
(∀ (s : Set Ω), MeasurableSet s → μ s = ν s) → μ = ν | null | true |
NumberField.InfinitePlace.orbitRelEquiv._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K] [inst_3 : IsGalois k K],
Function.Injective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) ∧
Function.Surjective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) | null | false |
Fin.castLE.eq_1 | Mathlib.Data.Fin.Tuple.Take | ∀ {n m : ℕ} (h : n ≤ m) (i : Fin n), Fin.castLE h i = ⟨↑i, ⋯⟩ | null | true |
Dilation.edist_eq' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (self : α →ᵈ β),
∃ r, r ≠ 0 ∧ ∀ (x y : α), edist (self.toFun x) (self.toFun y) = ↑r * edist x y | null | true |
Module.Presentation.tautological.R | Mathlib.Algebra.Module.Presentation.Tautological | Type u → Type v → Type (max u v) | The type which parametrizes the tautological relations in an `A`-module `M`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.