name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MorphismProperty.Comma.mapRightIso_inverse_map_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | true |
Lean.PersistentArrayNode.brecOn.eq | Lean.Data.PersistentArray | ∀ {α : Type u} {motive_1 : Lean.PersistentArrayNode α → Sort u_1}
{motive_2 : Array (Lean.PersistentArrayNode α) → Sort u_1} {motive_3 : List (Lean.PersistentArrayNode α) → Sort u_1}
(t : Lean.PersistentArrayNode α) (F_1 : (t : Lean.PersistentArrayNode α) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Persistent... | true |
ContinuousLinearMap.bilinearRestrictScalars_eq_restrictScalars_restrictScalarsL_comp | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_6} {G : Type u_8} {𝕜' : Type u_11} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E]
... | true |
Module.Basis.ofIsLocalizedModule_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [inst_3 : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[i... | true |
Nat.dist_tri_right' | Mathlib.Data.Nat.Dist | ∀ (n m : ℕ), n ≤ m + n.dist m | true |
ClusterPt.mono | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {f g : Filter X}, ClusterPt x f → f ≤ g → ClusterPt x g | true |
Lean.PersistentHashMap.mapMAux | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type u} →
{m : Type u → Type w} →
[Monad m] → (β → m σ) → Lean.PersistentHashMap.Node α β → m (Lean.PersistentHashMap.Node α σ) | true |
Std.TreeMap.getKey_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Inhabited α] {k : α}
{f : Option β → Option β} {hc : k ∈ t.alter k f}, (t.alter k f).getKey k hc = k | true |
DFinsupp.erase_single | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (j i : ι) (x : β i),
(DFinsupp.erase j fun₀ | i => x) = if i = j then 0 else fun₀ | i => x | true |
CategoryTheory.Center.ofBraided | Mathlib.CategoryTheory.Monoidal.Center | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.Functor C (CategoryTheory.Center C) | true |
Std.Format.FlattenAllowability.allow.elim | Init.Data.Format.Basic | {motive : Std.Format.FlattenAllowability → Sort u} →
(t : Std.Format.FlattenAllowability) →
t.ctorIdx = 0 → ((fits : Bool) → motive (Std.Format.FlattenAllowability.allow fits)) → motive t | false |
CategoryTheory.MonoidalCategory.rightUnitor_tensor_inv | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLe... | true |
Nat.ceil_int | Mathlib.Algebra.Order.Floor.Defs | Nat.ceil = Int.toNat | true |
AddAction.IsBlock.vadd_eq_or_disjoint | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {B : Set X},
AddAction.IsBlock G B → ∀ (g : G), g +ᵥ B = B ∨ Disjoint (g +ᵥ B) B | true |
Std.TreeMap.getElem!_erase_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited β]
{k : α}, (t.erase k)[k]! = default | true |
Lean.Elab.Term.CoeExpansionTrace.mk._flat_ctor | Lean.Elab.Term.TermElabM | List Lean.Name → Lean.Elab.Term.CoeExpansionTrace | false |
CategoryTheory.Limits.BinaryFan.rightUnitor | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} →
CategoryTheory.Limits.IsLimit s →
{t : CategoryTheory.Limits.BinaryFan X s.pt} → CategoryTheory.Limits.IsLimit t → (t.pt ≅ X) | true |
LinearMap.coe_toContinuousLinearMap_symm | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | true |
Lean.Meta.SplitKind.ctorIdx | Lean.Meta.Tactic.SplitIf | Lean.Meta.SplitKind → ℕ | false |
Lean.Elab.Tactic.saveTacticInfoForToken | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM Unit | true |
HurwitzZeta.hasSum_hurwitzZeta_of_one_lt_re | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ {a : ℝ}, a ∈ Set.Icc 0 1 → ∀ {s : ℂ}, 1 < s.re → HasSum (fun n => 1 / (↑n + ↑a) ^ s) (HurwitzZeta.hurwitzZeta (↑a) s) | true |
CategoryTheory.Localization.homEquiv.congr_simp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
(W W_1 : CategoryTheory.MorphismProperty C) (e_W : W = W_1) (L₁ : CategoryTheory.Functor C D₁)
[inst_3 : L₁.IsLocalizatio... | true |
ContinuousMap.instPow._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Monoid β]
[ContinuousMul β] (f : C(α, β)) (n : ℕ), Continuous fun b => f b ^ n | false |
_private.Init.Data.Range.Polymorphic.UpwardEnumerable.0.Std.PRange.UpwardEnumerable.succMany_succ_eq_succ_succMany._simp_1_1 | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany n (Std.PRange.succ a) = Std.PRange.succMany (n + 1) a | false |
ContinuousLinearMap.toSeminormedRing._proof_2 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (a b : E →L[𝕜] E), a + b = b + a | false |
Lean.Elab.Term.Do.extendUpdatedVars | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.VarSet → Lean.Elab.TermElabM Lean.Elab.Term.Do.CodeBlock | true |
MeasurableSet.map_coe_volume | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} [inst : MeasureTheory.MeasureSpace α] {s : Set α},
MeasurableSet s → MeasureTheory.Measure.map Subtype.val MeasureTheory.volume = MeasureTheory.volume.restrict s | true |
Vector.eq_iff_flatten_eq | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xss xss' : Vector (Vector α n) m}, xss = xss' ↔ xss.flatten = xss'.flatten | true |
Lean.Elab.InfoTree._sizeOf_4 | Lean.Elab.InfoTree.Types | Array Lean.Elab.InfoTree → ℕ | false |
Set.smul_set_mono | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s t : Set β} {a : α}, s ⊆ t → a • s ⊆ a • t | true |
Units.divp_sub_divp | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : CommRing α] (a b : α) (u₁ u₂ : αˣ), a /ₚ u₁ - b /ₚ u₂ = (a * ↑u₂ - ↑u₁ * b) /ₚ (u₁ * u₂) | true |
stableUnderGeneralization_empty | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], StableUnderGeneralization ∅ | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{d : ℤ} →
{p : Int.Linear.Poly} →
{h : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{d' : ℤ} →
{p' : Int.Linear.Poly} →
{h' : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{ d := d, p := p, h := h } = { d := d', p := p', h := h' } → (d = d' → p = p... | false |
LieAlgebra.SemiDirectSum.instLieRing._proof_2 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x, x_1 + x_2⁆ = ⁅x, x_1⁆ + ⁅x, x_2⁆ | false |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.expandLinearCombo.match_12 | Mathlib.Tactic.LinearCombination | (motive : Mathlib.Tactic.LinearCombination.Expanded → Mathlib.Tactic.LinearCombination.Expanded → Sort u_1) →
(__do_lift __do_lift_1 : Mathlib.Tactic.LinearCombination.Expanded) →
((c₁ c₂ : Lean.Term) →
motive (Mathlib.Tactic.LinearCombination.Expanded.const c₁)
(Mathlib.Tactic.LinearCombination... | false |
Stream'.Seq.zip_nil_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α}, s.zip Stream'.Seq.nil = Stream'.Seq.nil | true |
CategoryTheory.OverPresheafAux.YonedaCollection.map₂_id | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
{F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C},
CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F (CategoryTheory.CategoryStruct.id X) = id | true |
Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.BaseTypes.124699504._hygCtx._hyg.2 | Lean.Compiler.LCNF.BaseTypes | IO (Lean.Compiler.LCNF.CacheExtension Lean.Name Lean.Expr) | false |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.map_edgeFinset_induce._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | false |
Module.End.IsSemisimple.mul_of_commute | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f g : Module.End K M}
[FiniteDimensional K M] [PerfectField K], Commute f g → f.IsSemisimple → g.IsSemisimple → (f * g).IsSemisimple | true |
Mathlib.Tactic.Coherence.coherence_loop._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence | optParam ℕ 37 → Lean.Elab.Tactic.TacticM Unit | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.insertListIfNew.eq_def | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l toInsert : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l toInsert =
match toInsert with
| [] => l
| ⟨k, v⟩ :: tl => Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) tl | true |
_private.Init.Data.List.Range.0.List.mem_range'._simp_1_7 | Init.Data.List.Range | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | false |
TypeVec.splitFun_inj | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} {f f' : α.drop.Arrow α'.drop}
{g g' : α.last → α'.last}, TypeVec.splitFun f g = TypeVec.splitFun f' g' → f = f' ∧ g = g' | true |
EmetricSpace.ofRiemannianMetric | Mathlib.Geometry.Manifold.Riemannian.Basic | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type u_2} →
[inst_2 : TopologicalSpace H] →
(I : ModelWithCorners ℝ E H) →
(M : Type u_3) →
[inst_3 : TopologicalSpace M] →
[inst_4 : ChartedSpace H M] →
... | true |
AddSemigrp.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : AddSemigrp}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | true |
OrderMonoidHom.cancel_right | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] {g₁ g₂ : β →*o γ} {f : α →*o β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | true |
WithTop.ofDual_le_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithTop αᵒᵈ}, WithTop.ofDual y ≤ WithTop.ofDual x ↔ x ≤ y | true |
Lean.Omega.Constraint.exact.eq_1 | Init.Omega.Constraint | ∀ (r : ℤ), Lean.Omega.Constraint.exact r = { lowerBound := some r, upperBound := some r } | true |
StarAddMonoid.recOn | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : AddMonoid R] →
{motive : StarAddMonoid R → Sort u_1} →
(t : StarAddMonoid R) →
([toInvolutiveStar : InvolutiveStar R] →
(star_add : ∀ (r s : R), star (r + s) = star r + star s) →
motive { toInvolutiveStar := toInvolutiveStar, star_add := star_add }) →... | false |
CategoryTheory.Limits.isoZeroOfMonoZero._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp 0 0) 0 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | false |
Std.ExtTreeMap.getD_ofList_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false → (Std.ExtTreeMap.ofList l cmp).getD k fallback = fallback | true |
CategoryTheory.Presheaf.isIso_of_isLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
{A : CategoryTheory.Functor C ℰ} [CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.HasPointwiseLeftKanExtension A]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) ℰ)
(... | true |
Lean.Meta.NormCast.Label.toCtorIdx | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.Label → ℕ | false |
AddOpposite.instCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [CommSemigroup α] → CommSemigroup αᵃᵒᵖ | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁.match_1.eq_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (motive : Turing.TM1.Stmt Γ Λ σ → Sort u_4) (Q : Turing.TM1.Stmt Γ Λ σ)
(h_1 :
(Q : Turing.TM1.Stmt Γ Λ σ) →
(a : Turing.Dir) → (q : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.move a q → motive (Turing.TM1.Stmt.move a q))
(h_2 :
(Q : Turing.TM1.Stmt Γ Λ... | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_7 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {n : ℕ} ⦃x : ↥{0}ᶜ⦄, ¬↑x = 0 | false |
ExteriorAlgebra.induction | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{C : ExteriorAlgebra R M → Prop},
(∀ (r : R), C ((algebraMap R (ExteriorAlgebra R M)) r)) →
(∀ (x : M), C ((ExteriorAlgebra.ι R) x)) →
(∀ (a b : ExteriorAlgebra R M), C a → C b → C (a * b)) →
(∀ (a b ... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Operations.0.SimpleGraph.edgeSet_replaceVertex_of_not_adj._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u} (G : SimpleGraph V) {a b c : V}, (s(b, c) ∈ G.incidenceSet a) = (G.Adj b c ∧ (a = b ∨ a = c)) | false |
Pi.isLeftRegular_iff | Mathlib.Algebra.Regular.Pi | ∀ {ι : Type u_1} {R : ι → Type u_3} [inst : (i : ι) → Mul (R i)] {a : (i : ι) → R i},
IsLeftRegular a ↔ ∀ (i : ι), IsLeftRegular (a i) | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [inst_2 : LT β] [Std.IsLinearPreorder β]
[Std.LawfulOrderLT β] {f : α → β} {xs : List α} (h : xs ≠ []) {i : ℕ} (hi : i < xs.length),
(∀ (j : ℕ) (x : j < i), f xs[i] < f xs[j]) → i ≤ List.minIdxOn f xs h | true |
LinearMap.BilinForm.mul_toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (M : Matrix n n R₁),
M * (LinearMap.BilinForm.toMatrix b) B =
(LinearMap.BilinF... | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified.0.AlgebraicGeometry.FormallyUnramified.of_hom_ext._simp_1_3 | Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), (↑φ₁).comp ↑φ₂ = ↑(φ₁.comp φ₂) | false |
continuum_le_cardinal_of_module | Mathlib.Topology.Algebra.Module.Cardinality | ∀ (𝕜 : Type u) (E : Type v) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E] [Module 𝕜 E]
[Nontrivial E], Cardinal.continuum ≤ Cardinal.mk E | true |
HomogeneousIdeal.toIdeal_iInf₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} (s : (i : κ) → κ' i → HomogeneousIdeal 𝒜), (⨅ i, ⨅ j, s i j).toIdeal = ... | true |
Std.PRange.UpwardEnumerable.exists_of_succ_lt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) b →
∃ b', b = Std.PRange.succ b' ∧ Std.PRange.UpwardEnumerable.LT a b' | true |
isRelPrime_one_right | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsRelPrime x 1 | true |
CircularPreorder.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} →
{t : CircularPreorder α} →
{α' : Type u_1} → {t' : CircularPreorder α'} → α = α' → t ≍ t' → CircularPreorder.noConfusionType P t t' | false |
le_of_tendsto' | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIicTopology α] {f : β → α}
{a b : α} {x : Filter β} [x.NeBot], Filter.Tendsto f x (nhds a) → (∀ (c : β), f c ≤ b) → a ≤ b | true |
ContinuousOpenMap.comp._proof_1 | Mathlib.Topology.Hom.Open | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : β →CO γ) (g : α →CO β), IsOpenMap (f.toFun ∘ ⇑g.toContinuousMap) | false |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_3 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_10} {C₃ : Type u_6} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_9, u_10} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | false |
Std.ExtTreeSet.size_diff_le_size_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
(t₁ \ t₂).size ≤ t₁.size | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.downMulHom | Mathlib.Algebra.Group.UniqueProds.Basic | (G : Type u) → [inst : Mul G] → ULift.{u_1, u} G →ₙ* G | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.isNClique_one._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {s : Finset α}, (s.card = 1) = ∃ a, s = {a} | false |
Std.ExtHashMap.getD_modify_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β} {f : β → β},
(m.modify k f).getD k fallback = (Option.map f m[k]?).getD fallback | true |
Frm.hasForgetToLat | Mathlib.Order.Category.Frm | CategoryTheory.HasForget₂ Frm Lat | true |
Polynomial.degreeLT.basis_repr | Mathlib.RingTheory.Polynomial.DegreeLT | ∀ {R : Type u_1} [inst : Semiring R] {n : ℕ} (i : Fin n) (P : ↥(Polynomial.degreeLT R n)),
((Polynomial.degreeLT.basis R n).repr P) i = (↑P).coeff ↑i | true |
norm_indicator_eq_indicator_norm | Mathlib.Analysis.Normed.Group.Indicator | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddGroup E] {s : Set α} (f : α → E) (a : α),
‖s.indicator f a‖ = s.indicator (fun a => ‖f a‖) a | true |
Metric.minimalCover.eq_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal) (A : Set X),
Metric.minimalCover ε A = if h : Metric.coveringNumber ε A ≠ ⊤ then ⋯.choose else ∅ | true |
MeasureTheory.Measure.withDensity._proof_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
(fun s x => ∫⁻ (a : α) in s, f a ∂μ) ∅ ⋯ = 0 | false |
_private.Aesop.Util.Basic.0.Aesop.hasSorry.go._unsafe_rec | Aesop.Util.Basic | Lean.MetavarContext → Lean.Expr → Bool | false |
Int.Linear.Poly.mul_k_eq_mul | Init.Data.Int.Linear | ∀ (k : ℤ) (p : Int.Linear.Poly), p.mul_k k = p.mul k | true |
Lie.Derivation.ofDerivation._proof_3 | Mathlib.Algebra.Lie.Derivation.BaseChange | ∀ {R : Type u_3} [inst : CommRing R] {A : Type u_1} [inst_1 : CommRing A] [inst_2 : Algebra R A] (L : Type u_2)
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (d : Derivation R A A) (x y : TensorProduct R A L),
{ toFun := ⇑(LinearMap.rTensor L ↑d), map_add' := ⋯, map_smul' := ⋯ } ⁅x, y⁆ =
⁅x, { toFun := ⇑(Linea... | false |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatElabInfo | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.ElabInfo → Std.Format | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_4 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x : M}, (x ∈ ↑N) = (x ∈ N) | false |
CategoryTheory.MorphismProperty.HasLocalization.noConfusion | Mathlib.CategoryTheory.Localization.HasLocalization | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{t : W.HasLocalization} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{W' : CategoryTheory.MorphismProperty C'} →
... | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.CoordinateRing.norm_smul_basis._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R},
1 = (WeierstrassCurve.Affine.CoordinateRing.basis W') 0 | false |
Additive.seminormedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (a b : Additive E), a + b = b + a | false |
Real.leftDeriv_mul_log | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {x : ℝ}, x ≠ 0 → derivWithin (fun x => x * Real.log x) (Set.Iio x) x = Real.log x + 1 | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Affine.CoordinateRing.mk_ψ._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R),
(WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C W.Ψ₂Sq) =
(WeierstrassCurve.Affine.CoordinateRing.mk W) W.ψ₂ ^ 2 | false |
VonNeumannAlgebra.mk.inj | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
{toStarSubalgebra : StarSubalgebra ℂ (H →L[ℂ] H)}
{centralizer_centralizer' : toStarSubalgebra.carrier.centralizer.centralizer = toStarSubalgebra.carrier}
{toStarSubalgebra_1 : StarSubalgebra ℂ (H →L[ℂ] H)}
... | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_3 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (pq : ℕ × ℕ), WithBotTop.coe (-↑pq.2) ≤ WithBotTop.coe (-↑pq.2 + 1) | false |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_range_eq_graph._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
Int64.zero_sub | Init.Data.SInt.Lemmas | ∀ (a : Int64), 0 - a = -a | true |
Polynomial.HasSeparableContraction.dvd_degree' | Mathlib.RingTheory.Polynomial.SeparableDegree | ∀ {F : Type u_1} [inst : CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f),
∃ m, hf.degree * q ^ m = f.natDegree | true |
ContDiff.fun_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{𝕜' : Type u_3} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F... | true |
_private.Mathlib.Order.Atoms.0.SetLike.isCoatom_iff._simp_1_6 | Mathlib.Order.Atoms | ∀ {a b c : Prop}, (a → b → c) = (a ∧ b → c) | false |
Module.Flat.baseChange | Mathlib.RingTheory.Flat.Stability | ∀ (R : Type u) (S : Type v) (M : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [Module.Flat R M], Module.Flat S (TensorProduct R S M) | true |
_private.Mathlib.Data.Nat.ModEq.0.Nat.ModEq.mul_right_cancel'._simp_1_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a ≡ b [MOD n]) = (↑n ∣ ↑b - ↑a) | false |
Acc.of_subrel | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {r : α → α → Prop} [IsTrans α r] {b : α} (a : { a // r a b }),
Acc (Subrel r fun x => r x b) a → Acc r ↑a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.