name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Analysis.Seminorm.0.Seminorm.closedBall_smul_closedBall._simp_1_3 | Mathlib.Analysis.Seminorm | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.closedBall 0 r) = (‖a‖ ≤ r) |
unitSphereToUnits._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ (𝕜 : Type u_1) [inst : NormedDivisionRing 𝕜] (x : ↑(Metric.sphere 0 1)), ↑x ≠ 0 |
RegularExpression.zero.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 0 → motive RegularExpression.zero → motive t |
LinearMap.isPositive_toContinuousLinearMap_iff | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E), (LinearMap.toContinuousLinearMap T).IsPositive ↔ T.IsPositive |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast._proof_2 | Mathlib.Data.Rat.Cast.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (_pα : Q(PartialOrder «$α»)) (_oα : Q(LinearOrder «$α»)),
«$_pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder |
Lean.Elab.Tactic.Omega.MetaProblem.processFacts | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → Lean.Elab.Tactic.Omega.OmegaM (Lean.Elab.Tactic.Omega.MetaProblem × ℕ) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
AlgEquiv.uniqueProd._proof_5 | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (x : R), ((algebraMap R (B × A)) x).2 = ((algebraMap R (B × A)) x).2 |
MeasurableEmbedding.equivImage._proof_2 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β} (s : Set α),
MeasurableEmbedding f → Measurable fun x => ⟨(f ∘ fun a => ↑(id a)) x, ⋯⟩ |
BoxIntegral.unitPartition.box | Mathlib.Analysis.BoxIntegral.UnitPartition | {ι : Type u_1} → (n : ℕ) → [NeZero n] → (ι → ℤ) → BoxIntegral.Box ι |
Irrational.intCast_div | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ {m : ℤ}, m ≠ 0 → Irrational (↑m / x) |
FirstOrder.Language.LHom.sumInr | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → L' →ᴸ L.sum L' |
AddMonoidHom.toMultiplicativeRight_symm_apply_apply | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_3} {β : Type u_4} [inst : MulOneClass α] [inst_1 : AddZeroClass β] (f : α →* Multiplicative β)
(a : Additive α), (AddMonoidHom.toMultiplicativeRight.symm f) a = Multiplicative.toAdd (f (Additive.toMul a)) |
List.SortedLT.getElem_lt_getElem_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : LinearOrder α],
l.SortedLT → ∀ {i j : ℕ} {hi : i < l.length} {hj : j < l.length}, l[i] < l[j] ↔ i < j |
HurwitzZeta.completedCosZeta_eq | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle) (s : ℂ),
HurwitzZeta.completedCosZeta a s = HurwitzZeta.completedCosZeta₀ a s - 1 / s - (if a = 0 then 1 else 0) / (1 - s) |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors.0.«_aux_Mathlib_RingTheory_UniqueFactorizationDomain_NormalizedFactors___macroRules__private_Mathlib_RingTheory_UniqueFactorizationDomain_NormalizedFactors_0_term_~ᵤ__1» | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | Lean.Macro |
ContinuousLinearMap.homeomorphOfUnit._proof_4 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_2} [inst : Semiring R₁] {M₁ : Type u_1} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (T : (M₁ →L[R₁] M₁)ˣ), Continuous ⇑↑T⁻¹ |
CStarAlgebra.sub._inherited_default | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
(add : A → A → A) →
(∀ (a b c : A), a + b + c = a + (b + c)) →
(zero : A) →
(∀ (a : A), 0 + a = a) →
(∀ (a : A), a + 0 = a) →
(nsmul : ℕ → A → A) →
(∀ (x : A), nsmul 0 x = 0) → (∀ (n : ℕ) (x : A), nsmul (n + 1) x = nsmul n x + x) → (A → A) → A → A → A |
Lean.Elab.Tactic.State._sizeOf_1 | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.State → ℕ |
LieSubalgebra.lieRing._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u_2) (L : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(L' : LieSubalgebra R L) (x y z : ↥L'), ⟨⁅↑(x + y), ↑z⁆, ⋯⟩ = ⟨⁅↑x, ↑z⁆, ⋯⟩ + ⟨⁅↑y, ↑z⁆, ⋯⟩ |
UInt8.ofBitVec_shiftRight | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8), ∀ b < 8, { toBitVec := a >>> b } = { toBitVec := a } >>> UInt8.ofNat b |
CategoryTheory.Mod_.casesOn | Mathlib.CategoryTheory.Monoidal.Mod_ | {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.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : CategoryTheory.MonObj A] →
{motive : CategoryTheory.Mod_ D A → Sort u} →
(t : CategoryTheory.Mod_ D A) →
((X : D) → [mod : CategoryTheory.ModObj A X] → motive { X := X, mod := mod }) → motive t |
MeasureTheory.AECover.integrable_of_integral_tendsto_of_nonneg_ae | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι} [l.NeBot]
[l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → ℝ} (I : ℝ),
(∀ (i : ι), MeasureTheory.IntegrableOn f (φ i) μ) →
(∀ᵐ (x : α) ∂μ, 0 ≤ f x) →
Filter.Tendsto (fun i => ∫ (x : α) in φ i, f x ∂μ) l (nhds I) → MeasureTheory.Integrable f μ |
Lean.Meta.Grind.AC.State.steps._default | Lean.Meta.Tactic.Grind.AC.Types | ℕ |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_25 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length},
List.findIdxNth (fun x_1 => x_1 == x) (head :: tail) n < (head :: tail).length |
Multiset.instHasSubset | Mathlib.Data.Multiset.Defs | {α : Type u_1} → HasSubset (Multiset α) |
MvPFunctor._sizeOf_1 | Mathlib.Data.PFunctor.Multivariate.Basic | {n : ℕ} → MvPFunctor.{u} n → ℕ |
Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec.filterFn | Lean.Elab.GuardMsgs | Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec → Lean.Message → Lean.Elab.Tactic.GuardMsgs.FilterSpec |
ENNReal.top_mul' | Mathlib.Data.ENNReal.Operations | ∀ {a : ENNReal}, ⊤ * a = if a = 0 then 0 else ⊤ |
NonUnitalAlgHom.mem_equalizer._simp_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : FunLike F A B]
[inst_6 : NonUnitalAlgHomClass F R A B] (φ ψ : F) (x : A), (x ∈ NonUnitalAlgHom.equalizer φ ψ) = (φ x = ψ x) |
Lean.MetavarContext.LevelMVarToParam.State._sizeOf_1 | Lean.MetavarContext | Lean.MetavarContext.LevelMVarToParam.State → ℕ |
_private.Mathlib.Data.Int.Basic.0.Int.dvd_natCast._simp_1_2 | Mathlib.Data.Int.Basic | ∀ {a b : ℤ}, (-a ∣ b) = (a ∣ b) |
Lists'.mem_of_subset'._unary | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} (_x : (l₁ : Lists' α true) ×' (l₂ : Lists' α true) ×' (_ : l₁ ⊆ l₂) ×' a ∈ l₁.toList),
a ∈ _x.2.1 |
WithTop.LinearOrderedAddCommGroup.sub_eq_top_iff | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G] {x y : WithTop G}, x - y = ⊤ ↔ x = ⊤ ∨ y = ⊤ |
Lean.Lsp.DocumentChange.create | Lean.Data.Lsp.Basic | Lean.Lsp.CreateFile → Lean.Lsp.DocumentChange |
String.Slice.toInt! | Init.Data.String.Slice | String.Slice → ℤ |
RatFunc.toFractionRing_smul | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] {R : Type u_1} [inst_1 : SMul R (FractionRing (Polynomial K))] (c : R)
(p : RatFunc K), (c • p).toFractionRing = c • p.toFractionRing |
Aesop.Frontend.Parser.builder_nameConstructors | Aesop.Frontend.RuleExpr | Lean.ParserDescr |
Nat.prod_primeFactors_invOn_squarefree | Mathlib.Data.Nat.Squarefree | Set.InvOn (fun n => n.factorization.support) (fun s => ∏ p ∈ s, p) {s | ∀ p ∈ s, Nat.Prime p} {n | Squarefree n} |
ONote.fastGrowing_succ | Mathlib.SetTheory.Ordinal.Notation | ∀ (o : ONote) {a : ONote}, o.fundamentalSequence = Sum.inl (some a) → o.fastGrowing = fun i => a.fastGrowing^[i] i |
AddSubsemigroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {s t : Set M} (h_add : ∀ {a b : M}, a ∈ s → b ∈ s → a + b ∈ s)
(h_add' : ∀ {a b : M}, a ∈ t → b ∈ t → a + b ∈ t),
({ carrier := s, add_mem' := h_add } ≤ { carrier := t, add_mem' := h_add' }) = (s ⊆ t) |
NumberField.mixedEmbedding.fundamentalCone.prod_deriv_expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K),
∏ w,
NumberField.mixedEmbedding.fundamentalCone.deriv_expMap_single w
((NumberField.mixedEmbedding.fundamentalCone.completeBasis K).equivFun.symm x w) =
Real.exp (x NumberField.Units.dirichletUnitTheorem.w₀) ^ Module.finrank ℚ K *
(∏ w, ↑NumberField.mixedEmbedding.fundamentalCone.expMapBasis x ↑w)⁻¹ *
2⁻¹ ^ NumberField.InfinitePlace.nrComplexPlaces K |
_private.Std.Data.Iterators.Lemmas.Equivalence.Basic.0.Std.quotMk_eq_quotOfQuot_comp | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α : Sort u_1} {R S : α → α → Prop} (h : ∀ (a b : α), R a b → S a b), Quot.mk S = Std.quotOfQuot✝ h ∘ Quot.mk R |
Sigma.instIsCentralVAdd | Mathlib.Algebra.Group.Action.Sigma | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [inst : (i : ι) → VAdd M (α i)] [inst_1 : (i : ι) → VAdd Mᵃᵒᵖ (α i)]
[∀ (i : ι), IsCentralVAdd M (α i)], IsCentralVAdd M ((i : ι) × α i) |
_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b |
le_mul_right | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : Preorder α] [CanonicallyOrderedMul α] {a b c : α}, a ≤ b → a ≤ b * c |
Mathlib.Tactic.Ring.Result.proof | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} → {E : Q(«$α») → Type} → {e : Q(«$α»)} → (self : Mathlib.Tactic.Ring.Result E e) → Q(«$e» = unknown_1) |
AddAction.IsBlock.vadd_eq_vadd_or_disjoint | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} {X : Type u_2} [inst : VAdd G X] {B : Set X},
AddAction.IsBlock G B → ∀ (g₁ g₂ : G), g₁ +ᵥ B = g₂ +ᵥ B ∨ Disjoint (g₁ +ᵥ B) (g₂ +ᵥ B) |
Ring.DimensionLEOne.casesOn | Mathlib.RingTheory.DedekindDomain.Basic | {R : Type u_1} →
[inst : CommRing R] →
{motive : Ring.DimensionLEOne R → Sort u} →
(t : Ring.DimensionLEOne R) →
((maximalOfPrime : ∀ {p : Ideal R}, p ≠ ⊥ → p.IsPrime → p.IsMaximal) → motive ⋯) → motive t |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofNat_eq_iff_mod_eq_toNat._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a = b) = (a.toNat = b.toNat) |
IntermediateField.coe_div._simp_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
(x y : ↥S), ↑x / ↑y = ↑(x / y) |
CategoryTheory.ShortComplex.HomologyMapData.add_right | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData}
(γ : CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂) (γ' : CategoryTheory.ShortComplex.HomologyMapData φ' h₁ h₂),
(γ.add γ').right = γ.right.add γ'.right |
Multiset.nodup_iff_count_le_one | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α}, s.Nodup ↔ ∀ (a : α), Multiset.count a s ≤ 1 |
AddMonoidAlgebra.basis.eq_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_6) (k : Type u_7) [inst : Semiring k],
AddMonoidAlgebra.basis R k = { repr := LinearEquiv.refl k (R →₀ k) } |
starL'_apply | Mathlib.Topology.Algebra.Module.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TrivialStar R]
[inst_3 : AddCommMonoid A] [inst_4 : StarAddMonoid A] [inst_5 : Module R A] [inst_6 : StarModule R A]
[inst_7 : TopologicalSpace A] [inst_8 : ContinuousStar A] (a : A), (starL' R) a = star a |
_private.Mathlib.Algebra.Module.NatInt.0.Module.addCommMonoidToAddCommGroup._simp_4 | Mathlib.Algebra.Module.NatInt | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z |
Finset.card_univ_diff | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Finset α),
(Finset.univ \ s).card = Fintype.card α - s.card |
MulOpposite.instNormedAddCommGroup | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_2} → [NormedAddCommGroup E] → NormedAddCommGroup Eᵐᵒᵖ |
Aesop.PersistentHashSet.filter | Aesop.Util.Basic | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → (α → Bool) → Lean.PHashSet α → Lean.PHashSet α |
_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.List.prod_set'._proof_1_1 | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_1} (L : List G) (n : ℕ), ¬n < L.length → L.length ≤ n |
AddCon | Mathlib.GroupTheory.Congruence.Defs | (M : Type u_1) → [Add M] → Type u_1 |
Lean.Meta.Try.Collector.OrdSet.mk | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Array α → Std.HashSet α → Lean.Meta.Try.Collector.OrdSet α |
Std.ExtDTreeMap.isSome_maxKey?_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insertIfNew k v).maxKey?.isSome = true |
Batteries.Tactic.Alias.setDeprecatedTarget | Batteries.Tactic.Alias | Lean.Name → Array Lean.Elab.Attribute → Array Lean.Elab.Attribute × Bool |
_private.Init.Data.Option.Lemmas.0.Option.ext.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : (x x_1 : Option α) → (∀ (a : α), x = some a ↔ x_1 = some a) → Prop) (x x_1 : Option α)
(x_2 : ∀ (a : α), x = some a ↔ x_1 = some a),
(∀ (x : ∀ (a : α), none = some a ↔ none = some a), motive none none x) →
(∀ (val : α) (x : Option α) (H : ∀ (a : α), some val = some a ↔ x = some a), motive (some val) x H) →
(∀ (x : Option α) (val : α) (H : ∀ (a : α), x = some a ↔ some val = some a), motive x (some val) H) →
motive x x_1 x_2 |
Std.DTreeMap.Internal.Impl.Const.maxKey?_modify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey? =
Option.map (fun km => if compare km k = Ordering.eq then k else km) t.maxKey? |
Profinite.NobelingProof.spanCone._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, IsCompact C → CompactSpace ↑C |
_private.Mathlib.Topology.UniformSpace.Basic.0.nhdset_of_mem_uniformity.match_1_7 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (s : SetRel α α) (motive : (x : α × α) → x ∈ s → Prop) (x : α × α) (hp : x ∈ s),
(∀ (a b : α) (hp : (a, b) ∈ s), motive (a, b) hp) → motive x hp |
Fin.le_castPred_iff | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n), j ≤ i.castPred hi ↔ j.castSucc ≤ i |
addRothNumber_empty | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α], addRothNumber ∅ = 0 |
ComplexShape.Associative.ε₂_ε₁ | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {I₁₂ : Type u_4} {I₂₃ : Type u_5} {J : Type u_6}
{c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {c₃ : ComplexShape I₃} {c₁₂ : ComplexShape I₁₂} {c₂₃ : ComplexShape I₂₃}
{c : ComplexShape J} {inst : TotalComplexShape c₁ c₂ c₁₂} {inst_1 : TotalComplexShape c₁₂ c₃ c}
{inst_2 : TotalComplexShape c₂ c₃ c₂₃} {inst_3 : TotalComplexShape c₁ c₂₃ c} [self : c₁.Associative c₂ c₃ c₁₂ c₂₃ c]
(i₁ : I₁) (i₂ : I₂) (i₃ : I₃),
c₁.ε₂ c₂₃ c (i₁, c₂.π c₃ c₂₃ (i₂, i₃)) * c₂.ε₁ c₃ c₂₃ (i₂, i₃) =
c₁₂.ε₁ c₃ c (c₁.π c₂ c₁₂ (i₁, i₂), i₃) * c₁.ε₂ c₂ c₁₂ (i₁, i₂) |
BitVec.toInt_add | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), (x + y).toInt = (x.toInt + y.toInt).bmod (2 ^ w) |
CategoryTheory.Oplax.StrongTrans.mkOfOplax'._proof_6 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
[inst_2 : ∀ (a b : B) (f : a ⟶ b), CategoryTheory.IsIso (η.naturality f)] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.asIso (η.naturality (CategoryTheory.CategoryStruct.comp f g))).hom
(CategoryTheory.Bicategory.whiskerLeft (η.app a) (G.mapComp f g)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (η.app c))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (η.app c)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f) (CategoryTheory.asIso (η.naturality g)).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (η.app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.asIso (η.naturality f)).hom (G.map g))
(CategoryTheory.Bicategory.associator (η.app a) (G.map f) (G.map g)).hom)))) |
OneHomClass.bound_of_antilipschitz | Mathlib.Analysis.Normed.Group.Uniform | ∀ {𝓕 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
[inst_2 : FunLike 𝓕 E F] [OneHomClass 𝓕 E F] (f : 𝓕) {K : NNReal},
AntilipschitzWith K ⇑f → ∀ (x : E), ‖x‖ ≤ ↑K * ‖f x‖ |
Lean.Grind.CommRing.Mon.degree | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ |
IsUnit.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction_actionObj_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (d : D) (c : C),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj (Opposite.op d) (Opposite.op c) =
Opposite.op (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c) |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.c_eq_zero._simp_1_2 | Mathlib.NumberTheory.Modular | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n |
_private.Mathlib.Order.Ideal.0.Order.isIdeal_sUnion_of_directedOn.match_1_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} {C : Set (Set P)} (motive : C.Nonempty → Prop) (hNe : C.Nonempty),
(∀ (I : Set P) (hI : I ∈ C), motive ⋯) → motive hNe |
Int32.xor_left_inj._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32} (c : Int32), (a ^^^ c = b ^^^ c) = (a = b) |
OrderHom.instSemilatticeInf._proof_1 | Mathlib.Order.Hom.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : SemilatticeInf β] (a b : α →o β),
SemilatticeInf.inf a b ≤ a |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint.match_1.congr_eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(motive : Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → Sort u_1)
(x : Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(h_1 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth)
(h_2 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty)
(h_3 :
(l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
(b : Bool) → motive (Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b)))
(h_4 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit),
x = Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth →
(match x with
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth => h_1 ()
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty => h_2 ()
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b) => h_3 l b
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit => h_4 ()) ≍
h_1 () |
AlgebraicGeometry.Scheme.fromSpecResidueField.eq_1 | Mathlib.AlgebraicGeometry.ResidueField | ∀ (X : AlgebraicGeometry.Scheme) (x : ↥X),
X.fromSpecResidueField x =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.residue x)) (X.fromSpecStalk x) |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_iff_utf8EncodeChar_eq._proof_1_10 | Init.Data.String.Decode | ∀ {c : Char}, 65535 < c.val.toNat → ¬65536 ≤ c.val.toNat → False |
MvPowerSeries.exists_coeff_ne_zero_and_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R},
↑(MvPowerSeries.weightedOrder w f).toNat = MvPowerSeries.weightedOrder w f →
∃ d, (MvPowerSeries.coeff d) f ≠ 0 ∧ ↑((Finsupp.weight w) d) = MvPowerSeries.weightedOrder w f |
Lean.Parser.Command.include.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
alternatingGroup.kleinFour_card_of_card_eq_four | Mathlib.GroupTheory.SpecificGroups.Alternating.KleinFour | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
Nat.card α = 4 → Nat.card ↥(alternatingGroup.kleinFour α) = 4 |
Filter.tendsto_mul_const_atBot_of_neg | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α}, r < 0 → (Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop) |
SSet.prodStdSimplex.isoNerve._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ (p q d : ℕ)
(s : (CategoryTheory.nerve (ULift.{u_1, 0} (Fin (p + 1) × Fin (q + 1)))).obj (Opposite.op (SimplexCategory.mk d))),
Monotone s.obj |
PresentedAddMonoid.instAddMonoid | Mathlib.Algebra.PresentedMonoid.Basic | {α : Type u_1} → {rels : FreeAddMonoid α → FreeAddMonoid α → Prop} → AddMonoid (PresentedAddMonoid rels) |
realPart_comp_subtype_selfAdjoint | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A],
realPart ∘ₗ (selfAdjoint.submodule ℝ A).subtype = LinearMap.id |
Equiv.Set.univPi._proof_3 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_2} {β : α → Type u_1} (s : (a : α) → Set (β a)) (f : ↑(Set.univ.pi s)) (a : α), ↑f a ∈ s a |
_private.Lean.Parser.Types.0.Lean.Parser.SyntaxStack.mk.noConfusion | Lean.Parser.Types | {P : Sort u} →
{raw : Array Lean.Syntax} →
{drop : ℕ} →
{raw' : Array Lean.Syntax} →
{drop' : ℕ} →
{ raw := raw, drop := drop } = { raw := raw', drop := drop' } → (raw = raw' → drop = drop' → P) → P |
_private.Mathlib.Algebra.Order.Ring.GeomSum.0.geom_sum_alternating_of_lt_neg_one._simp_1_3 | Mathlib.Algebra.Order.Ring.GeomSum | ∀ {n : ℕ}, Even (n + 1) = ¬Even n |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.isUnit_iff_singleton._simp_1_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u} [inst : Group α] (a : α), IsUnit a = True |
_private.Mathlib.Order.Atoms.0.IsCoatomic.Set.Ici.isCoatomic.match_3 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] {x : α} (motive : ↑(Set.Ici x) → Prop) (x_1 : ↑(Set.Ici x)),
(∀ (y : α) (hy : y ∈ Set.Ici x), motive ⟨y, hy⟩) → motive x_1 |
Lean.Parser.orelseInfo | Lean.Parser.Basic | Lean.Parser.ParserInfo → Lean.Parser.ParserInfo → Lean.Parser.ParserInfo |
List.findFinIdx?._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (a : α) (l_1 : List α) (i : ℕ), (a :: l_1).length + i = l.length → i < l.length |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.throwCannotInferResultingUniverse | Lean.Elab.MutualInductive | {α : Type} → Lean.Level → Lean.MessageData → Lean.Elab.TermElabM α |
_private.Mathlib.Algebra.Lie.Weights.Chain.0.LieModule.lie_mem_genWeightSpaceChain_of_genWeightSpace_eq_bot_right._simp_1_2 | Mathlib.Algebra.Lie.Weights.Chain | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.