name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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 |
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) |
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 |
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.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).inv)
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv |
PartENat.not_isMax_natCast | Mathlib.Data.Nat.PartENat | ∀ (x : ℕ), ¬IsMax ↑x |
Nat.ceil_int | Mathlib.Algebra.Order.Floor.Defs | Nat.ceil = Int.toNat |
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 |
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 |
Lean.Elab.Term.CoeExpansionTrace.mk._flat_ctor | Lean.Elab.Term.TermElabM | List Lean.Name → Lean.Elab.Term.CoeExpansionTrace |
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) |
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 : IsTopologicalAddGroup F']
[inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E],
⇑LinearMap.toContinuousLinearMap.symm = ContinuousLinearMap.toLinearMap |
Lean.Meta.SplitKind.ctorIdx | Lean.Meta.Tactic.SplitIf | Lean.Meta.SplitKind → ℕ |
Lean.Elab.Tactic.saveTacticInfoForToken | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM Unit |
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) |
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₁.IsLocalization W] (L₂ : CategoryTheory.Functor C D₂) [inst_4 : L₂.IsLocalization W] {X Y : C},
CategoryTheory.Localization.homEquiv W L₁ L₂ = CategoryTheory.Localization.homEquiv W_1 L₁ L₂ |
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 |
_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 |
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 |
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 |
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 |
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 |
Lean.Elab.InfoTree._sizeOf_4 | Lean.Elab.InfoTree.Types | Array Lean.Elab.InfoTree → ℕ |
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 |
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₂) |
stableUnderGeneralization_empty | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], StableUnderGeneralization ∅ |
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' → h = h' → P) → P |
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⁆ |
_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.Expanded.const c₂)) →
((rel₁ : Mathlib.Ineq) →
(p₁ c₂ : Lean.Term) →
motive (Mathlib.Tactic.LinearCombination.Expanded.proof rel₁ p₁)
(Mathlib.Tactic.LinearCombination.Expanded.const c₂)) →
((x : Mathlib.Tactic.LinearCombination.Expanded) →
(rel : Mathlib.Ineq) →
(pf : Lean.Term) → motive x (Mathlib.Tactic.LinearCombination.Expanded.proof rel pf)) →
motive __do_lift __do_lift_1 |
Stream'.Seq.zip_nil_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α}, s.zip Stream'.Seq.nil = Stream'.Seq.nil |
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 |
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) |
_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₂ |
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 |
Mathlib.Tactic.Coherence.coherence_loop._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence | optParam ℕ 37 → Lean.Elab.Tactic.TacticM Unit |
_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 |
_private.Init.Data.List.Range.0.List.mem_range'._simp_1_7 | Init.Data.List.Range | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) |
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' |
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] →
[inst_5 : Bundle.RiemannianBundle fun x => TangentSpace I x] →
[inst_6 : IsManifold I 1 M] →
[IsContinuousRiemannianBundle E fun x => TangentSpace I x] → [T3Space M] → EMetricSpace M |
AddSemigrp.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : AddSemigrp}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id |
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₂) |
WithTop.ofDual_le_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithTop αᵒᵈ}, WithTop.ofDual y ≤ WithTop.ofDual x ↔ x ≤ y |
Lean.Omega.Constraint.exact.eq_1 | Init.Omega.Constraint | ∀ (r : ℤ), Lean.Omega.Constraint.exact r = { lowerBound := some r, upperBound := some r } |
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 }) →
motive t |
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.CategoryStruct.id X) 0 |
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 |
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₂))) ℰ)
(α : A ⟶ CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.comp L) [L.IsLeftKanExtension α], CategoryTheory.IsIso α |
Lean.Meta.NormCast.Label.toCtorIdx | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.Label → ℕ |
AddOpposite.instCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [CommSemigroup α] → CommSemigroup αᵃᵒᵖ |
_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 Γ Λ σ) →
(a : Γ → σ → Γ) →
(q : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.write a q → motive (Turing.TM1.Stmt.write a q))
(h_3 :
(Q : Turing.TM1.Stmt Γ Λ σ) →
(a : Γ → σ → σ) → (q : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.load a q → motive (Turing.TM1.Stmt.load a q))
(h_4 :
(Q : Turing.TM1.Stmt Γ Λ σ) →
(a : Γ → σ → Bool) →
(q₁ q₂ : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.branch a q₁ q₂ → motive (Turing.TM1.Stmt.branch a q₁ q₂))
(h_5 : (Q : Turing.TM1.Stmt Γ Λ σ) → motive Q),
(∀ (a : Turing.Dir) (q : Turing.TM1.Stmt Γ Λ σ), Q = Turing.TM1.Stmt.move a q → False) →
(∀ (a : Γ → σ → Γ) (q : Turing.TM1.Stmt Γ Λ σ), Q = Turing.TM1.Stmt.write a q → False) →
(∀ (a : Γ → σ → σ) (q : Turing.TM1.Stmt Γ Λ σ), Q = Turing.TM1.Stmt.load a q → False) →
(∀ (a : Γ → σ → Bool) (q₁ q₂ : Turing.TM1.Stmt Γ Λ σ), Q = Turing.TM1.Stmt.branch a q₁ q₂ → False) →
(match Q with
| Q@h:(Turing.TM1.Stmt.move a q) => h_1 Q a q h
| Q@h:(Turing.TM1.Stmt.write a q) => h_2 Q a q h
| Q@h:(Turing.TM1.Stmt.load a q) => h_3 Q a q h
| Q@h:(Turing.TM1.Stmt.branch a q₁ q₂) => h_4 Q a q₁ q₂ h
| Q => h_5 Q) =
h_5 Q |
_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 |
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 : ExteriorAlgebra R M), C a → C b → C (a + b)) → ∀ (a : ExteriorAlgebra R M), C a |
_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)) |
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) |
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 |
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.BilinForm.toMatrix b) (B.compLeft ((Matrix.toLin b b) M.transpose)) |
_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 φ₂) |
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 |
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 = ⨅ i, ⨅ j, (s i j).toIdeal |
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' |
isRelPrime_one_right | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsRelPrime x 1 |
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' |
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 |
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) |
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.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_11}
{I₂ : Type u_12} {I₃ : Type u_4} {J : Type u_1} (p : I₁ × I₂ × I₃ → J) (X₁ : CategoryTheory.GradedObject I₁ C₁)
[inst_4 :
∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p]
{X₂ Y₂ : CategoryTheory.GradedObject I₂ C₂} (φ : X₂ ⟶ Y₂) {X₃ Y₃ : CategoryTheory.GradedObject I₃ C₃} (ψ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
({ obj := fun X₃ => CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ X₂ X₃,
map := fun {x x_1} φ =>
CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) φ,
map_id := ⋯, map_comp := ⋯ }.map
ψ)
(CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁) φ
(CategoryTheory.CategoryStruct.id Y₃)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁) φ
(CategoryTheory.CategoryStruct.id X₃))
({ obj := fun X₃ => CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ Y₂ X₃,
map := fun {x x_1} φ =>
CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id Y₂) φ,
map_id := ⋯, map_comp := ⋯ }.map
ψ) |
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 |
_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 |
_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} |
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 |
Frm.hasForgetToLat | Mathlib.Order.Category.Frm | CategoryTheory.HasForget₂ Frm Lat |
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 |
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 |
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 ∅ |
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 |
_private.Aesop.Util.Basic.0.Aesop.hasSorry.go._unsafe_rec | Aesop.Util.Basic | Lean.MetavarContext → Lean.Expr → Bool |
Int.Linear.Poly.mul_k_eq_mul | Init.Data.Int.Linear | ∀ (k : ℤ) (p : Int.Linear.Poly), p.mul_k k = p.mul k |
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 := ⇑(LinearMap.rTensor L ↑d), map_add' := ⋯, map_smul' := ⋯ } y⁆ -
⁅y, { toFun := ⇑(LinearMap.rTensor L ↑d), map_add' := ⋯, map_smul' := ⋯ } x⁆ |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatElabInfo | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.ElabInfo → Std.Format |
_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) |
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'} →
{t' : W'.HasLocalization} →
C = C' →
inst ≍ inst' →
W ≍ W' → t ≍ t' → CategoryTheory.MorphismProperty.HasLocalization.noConfusionType P t t' |
_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 |
Additive.seminormedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (a b : Additive E), a + b = b + a |
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 |
_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 |
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)}
{centralizer_centralizer'_1 : toStarSubalgebra_1.carrier.centralizer.centralizer = toStarSubalgebra_1.carrier},
{ toStarSubalgebra := toStarSubalgebra, centralizer_centralizer' := centralizer_centralizer' } =
{ toStarSubalgebra := toStarSubalgebra_1, centralizer_centralizer' := centralizer_centralizer'_1 } →
toStarSubalgebra = toStarSubalgebra_1 |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_3 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (pq : ℕ × ℕ), WithBotTop.coe (-↑pq.2) ≤ WithBotTop.coe (-↑pq.2 + 1) |
_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 |
Int64.zero_sub | Init.Data.SInt.Lemmas | ∀ (a : Int64), 0 - a = -a |
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 |
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] [IsBoundedSMul 𝕜' F]
[IsScalarTower 𝕜 𝕜' F] {f : E → 𝕜'} {g : E → F}, ContDiff 𝕜 n f → ContDiff 𝕜 n g → ContDiff 𝕜 n fun i => f i • g i |
_private.Mathlib.Order.Atoms.0.SetLike.isCoatom_iff._simp_1_6 | Mathlib.Order.Atoms | ∀ {a b c : Prop}, (a → b → c) = (a ∧ b → c) |
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) |
_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) |
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 |
Finset.ruzsa_triangle_inequality_addNeg_addNeg_addNeg | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + -B).card * (C + -B).card |
UpperSet.upper' | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] (self : UpperSet α), IsUpperSet self.carrier |
Frm.instCategory._proof_2 | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} (f : X.Hom Y), { hom' := { hom' := FrameHom.id ↑Y }.hom'.comp f.hom' } = f |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
((p : Lean.Grind.CommRing.Poly) →
(h : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) →
(sugar id : ℕ) → motive_2 h → motive_1 { p := p, h := h, sugar := sugar, id := id }) →
((a b : Lean.Expr) →
(ra rb : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.core a b ra rb)) →
((a b : Lean.Expr) →
(sa sb : Lean.Meta.Grind.Arith.CommRing.SemiringExpr) →
(ra rb : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.coreS a b sa sb ra rb)) →
((k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(c₁ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(c₂ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ →
motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.superpose k₁ m₁ c₁ k₂ m₂ c₂)) →
((k₁ : ℤ) →
(c₁ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(c₂ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ → motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.simp k₁ c₁ k₂ m₂ c₂)) →
((k : ℤ) →
(e : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 e → motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.mul k e)) →
((k : ℤ) →
(e : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 e → motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.div k e)) →
((a b : ℤ) →
(c₁ c₂ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ → motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.gcd a b c₁ c₂)) →
((k : ℕ) →
(c₁ c₂ : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ → motive_2 (Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.numEq0 k c₁ c₂)) →
motive_1 t |
ContinuousAt.integral_sub_linear_isLittleO_ae | Mathlib.MeasureTheory.Integral.Bochner.FundThmCalculus | ∀ {X : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [CompleteSpace E] [inst_4 : TopologicalSpace X] [OpensMeasurableSpace X]
{μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ] {x : X} {f : X → E},
ContinuousAt f x →
StronglyMeasurableAtFilter f (nhds x) μ →
∀ {s : ι → Set X} {li : Filter ι},
Filter.Tendsto s li (nhds x).smallSets →
∀ (m : optParam (ι → ℝ) fun i => μ.real (s i)),
autoParam ((fun i => μ.real (s i)) =ᶠ[li] m) ContinuousAt.integral_sub_linear_isLittleO_ae._auto_1 →
(fun i => ∫ (x : X) in s i, f x ∂μ - m i • f x) =o[li] m |
AlgebraicGeometry.IsProper.toIsSeparated | Mathlib.AlgebraicGeometry.Morphisms.Proper | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.IsProper f], AlgebraicGeometry.IsSeparated f |
CategoryTheory.IsUniversalColimit.nonempty_isColimit_prod_of_pullbackCone._auto_3 | Mathlib.CategoryTheory.Limits.VanKampen | Lean.Syntax |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.