name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HomologicalComplex.xNextIso.eq_1 | 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 : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xNextIso r = CategoryTheory.eqToIso ⋯ | null | true |
_private.Init.Data.List.Sort.Basic.0.List.mergeSort.match_1.congr_eq_2 | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (x : List α) (x_1 : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le) (a : α) (x_2 : α → α → Bool),
x = [a] →
... | null | true |
NonUnitalSeminormedRing.noConfusion | Mathlib.Analysis.Normed.Ring.Basic | {P : Sort u} →
{α : Type u_5} →
{t : NonUnitalSeminormedRing α} →
{α' : Type u_5} →
{t' : NonUnitalSeminormedRing α'} → α = α' → t ≍ t' → NonUnitalSeminormedRing.noConfusionType P t t' | null | false |
Finset.sdiff_union_erase_cancel | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, t ⊆ s → a ∈ t → s \ t ∪ t.erase a = s.erase a | null | true |
Nat.getD_toList_roc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, n ≤ i + m → (m<...=n).toList.getD i fallback = fallback | null | true |
GrpCat.SurjectiveOfEpiAuxs.h_apply_fromCoset_nin_range | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
∀ x ∈ (GrpCat.Hom.hom f).range,
∀ b ∉ (GrpCat.Hom.hom f).range,
((GrpCat.SurjectiveOfEpiAuxs.h f) x)
(GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨b • ↑(GrpCat.Hom.hom f).range, ⋯⟩) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨(x * b) • ↑(GrpCa... | null | true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) | null | false |
WittVector.toZModPow_compat | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (m n : ℕ) (h : m ≤ n),
(ZMod.castHom ⋯ (ZMod (p ^ m))).comp (WittVector.toZModPow p n) = WittVector.toZModPow p m | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.map.match_1.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (X Y : CategoryTheory.WithTerminal C) → (X ⟶ Y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(a a_1 : C) →
(f : CategoryTheory.WithTerminal.of a ⟶ CategoryTheory.WithTerminal.of a_1) ... | null | true |
Set.Intersecting.exists_mem_set | Mathlib.Combinatorics.SetFamily.Intersecting | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, 𝒜.Intersecting → ∀ {s t : Set α}, s ∈ 𝒜 → t ∈ 𝒜 → ∃ a ∈ s, a ∈ t | null | true |
_private.Mathlib.CategoryTheory.EssentiallySmall.0.CategoryTheory.essentiallySmall_iff_of_thin._simp_1_2 | Mathlib.CategoryTheory.EssentiallySmall | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [Quiver.IsThin C],
CategoryTheory.LocallySmall.{w, v, u} C = True | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.sqFunctor._proof_4 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X Y : C} (p : X ⟶ Y)
(f : F.obj ⊥ ⟶ X) (g : c.pt ⟶ Y) {X_1 Y_1 Z : Jᵒᵖ} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z),
(TypeCat.of... | null | false |
Lean.Parser.Term.optSemicolon.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | null | true |
Setoid.mk_eq_bot | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r : α → α → Prop} (iseqv : Equivalence r), { r := r, iseqv := iseqv } = ⊥ ↔ r = fun x1 x2 => x1 = x2 | null | true |
Real.sinhOrderIso_symm_apply | Mathlib.Analysis.SpecialFunctions.Arsinh | ⇑(RelIso.symm Real.sinhOrderIso) = Real.arsinh | null | true |
_private.Mathlib.Algebra.Homology.Monoidal.0.HomologicalComplex.instHasTensorTensorUnit_1._proof_1 | Mathlib.Algebra.Homology.Monoidal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Limits.HasZeroObject C]
[inst_4 : (CategoryTheory.MonoidalCategory.curriedTensor C).Additive]
[inst_5 : ∀ (X₁ : C), ((CategoryTheory.Monoidal... | null | false |
CategoryTheory.PreOneHypercover.Hom.mk | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(toHom : E.Hom F.toPreZeroHypercover) →
(s₁ : {i j : E.I₀} → E.I₁ i j → F.I₁ (toHom.s₀ i) (toHom.s₀ j)) →
(h₁ :... | null | true |
_private.Init.Data.List.Sublist.0.List.infix_filterMap_iff._simp_1_3 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {L₁ L₂ : List β} {f : α → Option β},
(List.filterMap f l = L₁ ++ L₂) = ∃ l₁ l₂, l = l₁ ++ l₂ ∧ List.filterMap f l₁ = L₁ ∧ List.filterMap f l₂ = L₂ | null | false |
CategoryTheory.Limits.Multicoequalizer.instHasCoequalizerFstSigmaMapSndSigmaMap | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.left] [inst_3 : CategoryTheory.Limits.HasCoproduct I.right],
CategoryTheor... | null | true |
Finset.biUnion_congr | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : α → Finset β} [inst : DecidableEq β],
s₁ = s₂ → (∀ a ∈ s₁, t₁ a = t₂ a) → s₁.biUnion t₁ = s₂.biUnion t₂ | null | true |
_private.Mathlib.Algebra.Ring.Idempotent.0.IsIdempotentElem.sub_iff._simp_1_5 | Mathlib.Algebra.Ring.Idempotent | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
FreeMonoid.prodAux.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {M : Type u_6} [inst : Monoid M], FreeMonoid.prodAux [] = 1 | null | true |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Simp.Types | ∀ (config : Lean.Meta.Simp.Config) (userConfig : Lean.Options) (zetaDeltaSet initUsedZetaDelta : Lean.FVarIdSet)
(metaConfig indexConfig : Lean.Meta.ConfigWithKey) (maxDischargeDepth : UInt32)
(simpTheorems : Lean.Meta.SimpTheoremsArray) (congrTheorems : Lean.Meta.SimpCongrTheorems)
(parent? : Option Lean.Expr) (... | null | true |
borel_eq_generateFrom_Ioi | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ (α : Type u_1) [inst : TopologicalSpace α] [SecondCountableTopology α] [inst_2 : LinearOrder α] [OrderTopology α],
borel α = MeasurableSpace.generateFrom (Set.range Set.Ioi) | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | null | false |
Std.TreeSet.forIn_eq_forIn | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ}, Std.TreeSet.forIn f init t = forIn t init f | null | true |
Matrix.submatrix_gram | Mathlib.Analysis.InnerProductSpace.GramMatrix | ∀ {E : Type u_1} {n : Type u_2} {𝕜 : Type u_4} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (v : n → E) {m : Set n} (f : ↑m → n),
(Matrix.gram 𝕜 v).submatrix f f = Matrix.gram 𝕜 (v ∘ f) | null | true |
CommAlgCat.binaryCofanIsColimit._proof_1 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (A B : CommAlgCat R) {T : CommAlgCat R} (f : A ⟶ T) (g : B ⟶ T),
CategoryTheory.CategoryStruct.comp (A.binaryCofan B).inl
(CommAlgCat.ofHom (Algebra.TensorProduct.lift (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) ⋯)) =
f | null | false |
iteratedFDeriv_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ},
iteratedFDeriv 𝕜 n 0 = 0 | null | true |
Matrix.cramer | Mathlib.LinearAlgebra.Matrix.Adjugate | {n : Type v} → {α : Type w} → [DecidableEq n] → [Fintype n] → [inst : CommRing α] → Matrix n n α → (n → α) →ₗ[α] n → α | `cramer A b i` is the determinant of the matrix `A` with column `i` replaced with `b`,
and thus `cramer A b` is the vector output by Cramer's rule on `A` and `b`.
If `A * x = b` has a unique solution in `x`, `cramer A` sends the vector `b` to `A.det • x`.
Otherwise, the outcome of `cramer` is well-defined but not nece... | true |
Subalgebra.frontier_spectrum | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_3} {A : Type u_4} {SA : Type u_5} [inst : NormedRing A] [CompleteSpace A] [inst_2 : SetLike SA A]
[inst_3 : SubringClass SA A] [inst_4 : NormedField 𝕜] [inst_5 : NormedAlgebra 𝕜 A] [instSMulMem : SMulMemClass SA 𝕜 A]
(S : SA) [hS : IsClosed ↑S] (x : ↥S), frontier (spectrum 𝕜 x) ⊆ spectrum 𝕜 ↑x | If `S : Subalgebra 𝕜 A` is a closed subalgebra of a Banach algebra `A`, then for any
`x : S`, the boundary of the spectrum of `x` relative to `S` is a subset of the spectrum of
`↑x : A` relative to `A`. | true |
WeierstrassCurve.Jacobian.add_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P Q : Fin 3 → F},
W.Nonsingular P → W.Nonsingular Q → P 2 = 0 → Q 2 = 0 → W.add P Q = P 0 ^ 2 • ![1, 1, 0] | null | true |
_private.Mathlib.Order.SupIndep.0.Finset.SupIndep.biUnion._proof_1_1 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq ι]
{s : Finset ι'} {g : ι' → Finset ι} {f : ι → α} ⦃a : Finset ι⦄,
a ⊆ s.biUnion g →
∀ ⦃b : ι⦄, b ∈ s.biUnion g → b ∉ a → ∀ (i' : ι'), a.sup f ≤ ((s.erase i').biUnion g ∪ (g i').erase b).sup f | null | false |
_private.Lean.Data.Json.FromToJson.Basic.0.Float.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : String ⊕ Lean.JsonNumber → Sort u_1) →
(x : String ⊕ Lean.JsonNumber) →
((e : String) → motive (Sum.inl e)) → ((n : Lean.JsonNumber) → motive (Sum.inr n)) → motive x | null | false |
HahnSeries.SummableFamily.hasFiniteSupport_smul | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} {β : Type u_6} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
(s : HahnSeries.SummableFamily Γ R α) (t : HahnSeries.SummableFamily Γ' V β) (gh : Γ × Γ')... | null | true |
ProbabilityTheory.IsFiniteKernel.exists_univ_le | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[self : ProbabilityTheory.IsFiniteKernel κ], ∃ C < ⊤, ∀ (a : α), (κ a) Set.univ ≤ C | null | true |
IsAddUnit.eq_add_neg_iff_add_eq | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : SubtractionMonoid α] {a b c : α}, IsAddUnit c → (a = b + -c ↔ a + c = b) | null | true |
CompleteSemilatticeSup.toPartialOrder | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} → [self : CompleteSemilatticeSup α] → PartialOrder α | null | true |
HasSum.congr_fun | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α} {a : α}
{L : SummationFilter β}, HasSum f a L → (∀ (x : β), g x = f x) → HasSum g a L | null | true |
Continuous.matrix_diagonal | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
[inst_2 : Zero R] [inst_3 : DecidableEq n] {A : X → n → R}, Continuous A → Continuous fun x => Matrix.diagonal (A x) | null | true |
Option.some_eq_dite_none_left._simp_1 | Init.Data.Option.Lemmas | ∀ {β : Type u_1} {a : β} {p : Prop} {x : Decidable p} {b : ¬p → Option β},
(some a = if h : p then none else b h) = ∃ (h : ¬p), some a = b h | null | false |
CompletelyPositiveMap.map_cstarMatrix_nonneg' | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | ∀ {A₁ : Type u_1} {A₂ : Type u_2} [inst : NonUnitalCStarAlgebra A₁] [inst_1 : NonUnitalCStarAlgebra A₂]
[inst_2 : PartialOrder A₁] [inst_3 : PartialOrder A₂] [inst_4 : StarOrderedRing A₁] [inst_5 : StarOrderedRing A₂]
(self : CompletelyPositiveMap A₁ A₂) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.m... | null | true |
Bundle.Pretrivialization.symm_trans_symm | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e e' : Bundle.Pretrivialization F proj), (e.symm.trans e'.toPartialEquiv).symm = e'.symm.trans e.toPartialEquiv | null | true |
CategoryTheory.Functor.IsLocallyDirected.casesOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.caching.unsafe_impl_2 | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | {α : Type u_1} → α → UInt64 | null | true |
Aesop.GoalUnsafe.brecOn_5 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
contDiffOn_clm_apply | Mathlib.Analysis.Calculus.ContDiff.FiniteDimension | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {D : Type uD} [inst_1 : NormedAddCommGroup D]
[inst_2 : NormedSpace 𝕜 D] {E : Type uE} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {F : Type uF}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} [CompleteSpace 𝕜] {f :... | A family of continuous linear maps is `C^n` on `s` if all its applications are. | true |
CategoryTheory.Functor.obj.ζ_def | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj X],
... | null | true |
Lean.Elab.Tactic.Do.Internal.VCGen.State.preTacFailed._default | Lean.Elab.Tactic.Do.Internal.VCGen.Context | Bool | null | false |
IsIntCastApply.rec | Mathlib.Data.FunLike.IsApply | {F : Type u_1} →
{α : Type u_2} →
[inst : FunLike F α α] →
[inst_1 : IntCast F] →
[inst_2 : SMul ℤ α] →
{motive : IsIntCastApply F α → Sort u} →
((intCast_apply : ∀ (n : ℤ) (x : α), ↑n x = n • x) → motive ⋯) → (t : IsIntCastApply F α) → motive t | null | false |
CategoryTheory.IsPullback.hasLiftingProperty | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y Z W : C} {f : X ⟶ Y} {s : X ⟶ Z} {g : Z ⟶ W}
{t : Y ⟶ W},
CategoryTheory.IsPullback s f g t →
∀ {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.HasLiftingProperty f' g], CategoryTheory.HasLiftingProperty f' f | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.mem_rootsOfUnity._simp_1_3 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Lean.Meta.hasAssignableMVar | Lean.Meta.HasAssignableMVar | Lean.Expr → Lean.MetaM Bool | Return `true` iff expression contains a metavariable that can be assigned. | true |
Fin.image_addNat_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), (fun x => x.addNat m) '' Set.Ioc i j = Set.Ioc (i.addNat m) (j.addNat m) | null | true |
AddSubgroup.isAddCommutative_iSup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Sort u_2} [Nonempty ι] {S : ι → AddSubgroup G}
[hS : ∀ (i : ι), IsAddCommutative ↥(S i)], Directed (fun x1 x2 => x1 ≤ x2) S → IsAddCommutative ↥(⨆ i, S i) | null | true |
List.findM?_pure | Init.Data.List.Control | ∀ {α : Type} {m : Type → Type u_1} [inst : Monad m] [LawfulMonad m] (p : α → Bool) (as : List α),
List.findM? (fun x => pure (p x)) as = pure (List.find? p as) | null | true |
ZMod.intCast_eq_zero_iff_even | Mathlib.Data.ZMod.Basic | ∀ {n : ℤ}, ↑n = 0 ↔ Even n | null | true |
CommRingCat.hom_inv_apply | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommRingCat} (e : R ≅ S) (s : ↑S),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | null | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun'.eq_def | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_2) {α : Type u_5} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (b x : α),
IncidenceAlgebra.muFun'✝ 𝕜 b x =
let a := x;
if a = b then 1
else
-∑ x_1 ∈ (Finset.Ioc a b).attach,
have h := ⋯;
... | null | true |
NumberField.instCommRingAdeleRing._proof_19 | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a : NumberField.AdeleRing R K), a * 1 = a | null | false |
Vector.scanrM.loop.congr_simp | Batteries.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {n : ℕ} [inst : Monad m] (f f_1 : α → β → m β),
f = f_1 →
∀ (as as_1 : Vector α n),
as = as_1 →
∀ (cur cur_1 : β),
cur = cur_1 →
∀ (i : ℕ) (hi : i ≤ n) (acc acc_1 : Vector β (n - i)),
acc = acc_1 → Vector.s... | null | true |
CategoryTheory.Bicategory.leftUnitorNatIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
(a b : B) →
(CategoryTheory.Bicategory.precomposing a a b).obj (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.Functor.id (a ⟶ b) | Left unitor as a natural isomorphism. | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi._simp_1_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True | null | false |
generatePiSystem.inter | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)} {s t : Set α},
generatePiSystem S s → generatePiSystem S t → (s ∩ t).Nonempty → generatePiSystem S (s ∩ t) | null | true |
UniformSpace.mem_ball_comp | Mathlib.Topology.UniformSpace.Defs | ∀ {β : Type ub} {V W : Set (β × β)} {x y z : β},
y ∈ UniformSpace.ball x V → z ∈ UniformSpace.ball y W → z ∈ UniformSpace.ball x (SetRel.comp V W) | The triangle inequality for `UniformSpace.ball` | true |
Qq.Impl.PatternVar.ctorIdx | Qq.Match | Qq.Impl.PatternVar → ℕ | null | false |
_private.Mathlib.Computability.StateTransition.0.StateTransition.tr_eval'.match_1_1 | Mathlib.Computability.StateTransition | ∀ {σ₁ σ₂ : Type u_1} (f₁ : σ₁ → Option σ₁) (tr : σ₁ → σ₂) (a₁ : σ₁) (b₂ : σ₂)
(motive : (∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁) → Prop)
(x : ∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁),
(∀ (b₁ : σ₁) (bb : tr b₁ = b₂) (hb : b₁ ∈ StateTransition.eval f₁ a₁), motive ⋯) → motive x | null | false |
ContinuousLinearMap.mulLeftRight._proof_3 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], SMulCommClass 𝕜 𝕜 (R →L[𝕜] R) | null | false |
Std.ExtHashMap.getD_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → γ} {k : α} {fallback : γ},
(Std.ExtHashMap.map f m).getD k fallback = (Option.map (f k) m[k]?).getD fallback | null | true |
Lean.Diff.instToStringAction.match_1 | Lean.Util.Diff | (motive : Lean.Diff.Action → Sort u_1) →
(x : Lean.Diff.Action) →
(Unit → motive Lean.Diff.Action.insert) →
(Unit → motive Lean.Diff.Action.delete) → (Unit → motive Lean.Diff.Action.skip) → motive x | null | false |
EReal.toReal | Mathlib.Data.EReal.Basic | EReal → ℝ | The map from extended reals to reals sending infinities to zero. | true |
Std.HashMap.getKey!_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m).getKey! k = ((m.getKey? k).pfilter fun x_2 h' => (f x_2 m[x_2]).isSome).get! | null | true |
Bifunctor.mapEquiv_refl_refl | Mathlib.Logic.Equiv.Functor | ∀ {α : Type u} {α' : Type v} (F : Type u → Type v → Type w) [inst : Bifunctor F] [inst_1 : LawfulBifunctor F],
Bifunctor.mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α') | null | true |
Lean.Sym.Char.eq_eq_false | Init.Sym.Lemmas | ∀ (a b : Char), decide (a = b) = false → (a = b) = False | null | true |
CategoryTheory.CategoryOfElements.instHasInitialElementsOfIsCorepresentable | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type u_1)}
[F.IsCorepresentable], CategoryTheory.Limits.HasInitial F.Elements | null | true |
Std.TreeMap.Raw.getKey?_insert_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).getKey? k = some k | null | true |
DistLat.mk.injEq | Mathlib.Order.Category.DistLat | ∀ (carrier : Type u_1) [str : DistribLattice carrier] (carrier_1 : Type u_1) (str_1 : DistribLattice carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
DiffContOnCl.ball_subset_image_closedBall | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {z₀ : ℂ} {ε r : ℝ},
DiffContOnCl ℂ f (Metric.ball z₀ r) →
0 < r →
(∀ z ∈ Metric.sphere z₀ r, ε ≤ ‖f z - f z₀‖) →
(∃ᶠ (z : ℂ) in nhds z₀, f z ≠ f z₀) → Metric.ball (f z₀) (ε / 2) ⊆ f '' Metric.closedBall z₀ r | If the modulus of a holomorphic function `f` is bounded below by `ε` on a circle, then its range
contains a disk of radius `ε / 2`. | true |
PartialEquiv.disjointUnion._proof_5 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_2} {β : Type u_1} (e e' : PartialEquiv α β), e.target.ite e.target e'.target = e.target ∪ e'.target | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabMutualDef.finishElab._sparseCasesOn_2 | Lean.Elab.MutualDef | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
NoetherNormalization.T1._proof_1 | Mathlib.RingTheory.NoetherNormalization | ∀ {n : ℕ}, NeZero (n + 1) | null | false |
_private.Mathlib.Probability.ProbabilityMassFunction.Monad.0.PMF.bindOnSupport_eq_zero_iff._simp_1_1 | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 | null | false |
Homotopy.mkCoinductiveAux₂._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0),
e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero →
e.f 0 =
CategoryTheory.CategoryStruct.comp 0 (HomologicalComplex.dTo Q 0) +
... | null | false |
BitVec.toNat_intMin | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, (BitVec.intMin w).toNat = 2 ^ (w - 1) % 2 ^ w | The RHS is zero in case `w = 0` which is modeled by wrapping the expression in `... % 2 ^ w`.
| true |
ZNum.mod_to_int | Mathlib.Data.Num.ZNum | ∀ (n d : ZNum), ↑(n % d) = ↑n % ↑d | null | true |
Std.Internal.UV.Loop.Options.mk.noConfusion | Std.Internal.UV.Loop | {P : Sort u} →
{accumulateIdleTime blockSigProfSignal accumulateIdleTime' blockSigProfSignal' : Bool} →
{ accumulateIdleTime := accumulateIdleTime, blockSigProfSignal := blockSigProfSignal } =
{ accumulateIdleTime := accumulateIdleTime', blockSigProfSignal := blockSigProfSignal' } →
(accumulateIdleT... | null | false |
HMul.hMul | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HMul α β γ] → α → β → γ | `a * b` computes the product of `a` and `b`.
The meaning of this notation is type-dependent.
Conventions for notations in identifiers:
* The recommended spelling of `*` in identifiers is `mul`. | true |
ContinuousLinearMap.smulRight.congr_simp | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {M₁ : Type u_4} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {M₂ : Type u_6}
[inst_2 : TopologicalSpace M₂] [inst_3 : AddCommMonoid M₂] {R : Type u_9} {S : Type u_10} [inst_4 : Semiring R]
[inst_5 : Semiring S] [inst_6 : Module R M₁] [inst_7 : Module R M₂] [inst_8 : Module R S] [inst_9 : Module S M₂]
... | null | true |
Set.finset_prod_mem_finset_prod | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] (t : Finset ι) (f : ι → Set α) (g : ι → α),
(∀ i ∈ t, g i ∈ f i) → ∏ i ∈ t, g i ∈ ∏ i ∈ t, f i | **Alias** of `Set.finsetProd_mem_finsetProd`.
---
An n-ary version of `Set.mul_mem_mul`. | true |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_length_eq | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a} [inst_1 : Fintype α],
p.IsHamiltonianCycle ↔ p.IsCycle ∧ p.length = Fintype.card α | null | true |
Matrix.vecMulLinear_transpose | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] (M : Matrix m n R),
M.transpose.vecMulLinear = M.mulVecLin | null | true |
Std.Tactic.BVDecide.Reflect.BitVec.add_congr | Std.Tactic.BVDecide.Reflect | ∀ (w : ℕ) (lhs rhs lhs' rhs' : BitVec w), lhs' = lhs → rhs' = rhs → lhs' + rhs' = lhs + rhs | null | true |
SheafOfModules.pushforwardSections_coe | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackFree | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
... | null | true |
EMetricSpace.rec | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{motive : EMetricSpace α → Sort u_1} →
([toPseudoEMetricSpace : PseudoEMetricSpace α] →
(eq_of_edist_eq_zero : ∀ {x y : α}, edist x y = 0 → x = y) →
motive { toPseudoEMetricSpace := toPseudoEMetricSpace, eq_of_edist_eq_zero := eq_of_edist_eq_zero }) →
(t : EMetricSpace α) → ... | null | false |
Lean.Meta.ApplyConfig.mk.sizeOf_spec | Init.Meta.Defs | ∀ (newGoals : Lean.Meta.ApplyNewGoals) (synthAssignedInstances allowSynthFailures approx : Bool),
sizeOf
{ newGoals := newGoals, synthAssignedInstances := synthAssignedInstances,
allowSynthFailures := allowSynthFailures, approx := approx } =
1 + sizeOf newGoals + sizeOf synthAssignedInstances + size... | null | true |
FiniteArchimedeanClass.mk.congr_simp | Mathlib.RingTheory.HahnSeries.Lex | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a a_1 : M)
(e_a : a = a_1) (h : a ≠ 0), FiniteArchimedeanClass.mk a h = FiniteArchimedeanClass.mk a_1 ⋯ | null | true |
Lean.Meta.Grind.Arith.isArithTerm | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | null | true |
SignType.instBoundedOrder | Mathlib.Data.Sign.Defs | BoundedOrder SignType | null | true |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.glueDist_swap.match_1_1 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} (motive : X ⊕ Y → X ⊕ Y → Prop) (x x_1 : X ⊕ Y),
(∀ (val val_1 : X), motive (Sum.inl val) (Sum.inl val_1)) →
(∀ (val val_1 : Y), motive (Sum.inr val) (Sum.inr val_1)) →
(∀ (val : X) (val_1 : Y), motive (Sum.inl val) (Sum.inr val_1)) →
(∀ (val : Y) (val_1 : X), motive ... | null | false |
_private.Mathlib.Data.Nat.Factors.0.Nat.mem_primeFactorsList_mul._simp_1_1 | Mathlib.Data.Nat.Factors | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.