name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.LinearAlgebra.Dimension.DivisionRing.0.rank_add_rank_split._simp_1_2 | Mathlib.LinearAlgebra.Dimension.DivisionRing | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) |
Hyperreal.Infinitesimal | Mathlib.Analysis.Real.Hyperreal | ℝ* → Prop |
WeierstrassCurve.Jacobian.fin3_def_ext | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a ∧ ![a, b, c] 1 = b ∧ ![a, b, c] 2 = c |
LinearPMap._sizeOf_inst | Mathlib.LinearAlgebra.LinearPMap | (R : Type u) →
{inst : Ring R} →
(E : Type v) →
{inst_1 : AddCommGroup E} →
{inst_2 : Module R E} →
(F : Type w) →
{inst_3 : AddCommGroup F} →
{inst_4 : Module R F} → [SizeOf R] → [SizeOf E] → [SizeOf F] → SizeOf (E →ₗ.[R] F) |
hfdifferential._proof_2 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_2}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : ContMDiffMap I I' M M' ↑⊤} {x : M}
{y : M'} (v : PointDerivation I x) (k : 𝕜) (g : PointedContMDiffMap 𝕜 I' M' (↑⊤) y),
v (ContMDiffMap.comp (k • g) f) = (RingHom.id 𝕜) k • v (ContMDiffMap.comp g f) |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq._sparseCasesOn_2 | Aesop.Forward.State | {motive : Aesop.RawHyp → Sort u} →
(t : Aesop.RawHyp) →
((subst : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst subst)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Finpartition.casesOn | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
(t : Finpartition a) →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot_notMem : ⊥ ∉ parts) →
motive
{ parts := parts, supIndep := supIndep, sup_parts := sup_parts, bot_notMem := bot_notMem }) →
motive t |
CategoryTheory.Bicategory.Adj.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{t : CategoryTheory.Bicategory.Adj.Hom a b} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{t' : CategoryTheory.Bicategory.Adj.Hom a' b'} →
B = B' →
inst ≍ inst' → a ≍ a' → b ≍ b' → t ≍ t' → CategoryTheory.Bicategory.Adj.Hom.noConfusionType P t t' |
Lean.Grind.CommRing.instBEqPoly.beq._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool |
CategoryTheory.Adjunction.conesIsoComponentHom._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J D}
(X : Cᵒᵖ) (t : (F.op.comp ((CategoryTheory.cones J D).obj K)).obj X) (j j' : J) (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp ((Opposite.unop ((CategoryTheory.Functor.const J).op.obj X)).map f)
((adj.homEquiv (Opposite.unop X) (K.obj j')) (t.app j')) =
CategoryTheory.CategoryStruct.comp ((adj.homEquiv (Opposite.unop X) (K.obj j)) (t.app j)) ((K.comp G).map f) |
ENormedAddMonoid.enorm_eq_zero | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} {inst : TopologicalSpace E} [self : ENormedAddMonoid E] (x : E), ‖x‖ₑ = 0 ↔ x = 0 |
Lean.Meta.Omega.OmegaConfig.mk | Init.Meta.Defs | Bool → Bool → Bool → Bool → Lean.Meta.Omega.OmegaConfig |
Std.ExtTreeMap.isSome_maxKey?_modify_eq_isSome | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{f : β → β}, (t.modify k f).maxKey?.isSome = t.maxKey?.isSome |
CategoryTheory.ULift.equivalence_functor | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.ULift.equivalence.functor = CategoryTheory.ULift.upFunctor |
Lean.ImportArtifacts.ofArray | Lean.Setup | Array System.FilePath → Lean.ImportArtifacts |
ContinuousLinearMap.flipMultilinear._proof_6 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_3} {ι : Type u_4} {E : ι → Type u_5} {G : Type u_1} {G' : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[inst_6 : NormedSpace 𝕜 G'] [inst_7 : Fintype ι] (f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G')
[inst_8 : DecidableEq ι] (m : (i : ι) → E i) (i : ι) (c : 𝕜) (x : E i),
{ toFun := fun x_1 => (f x_1) (Function.update m i (c • x)), map_add' := ⋯, map_smul' := ⋯ }.mkContinuous
(‖f‖ * ∏ i_1, ‖Function.update m i (c • x) i_1‖) ⋯ =
c •
{ toFun := fun x_1 => (f x_1) (Function.update m i x), map_add' := ⋯, map_smul' := ⋯ }.mkContinuous
(‖f‖ * ∏ i_1, ‖Function.update m i x i_1‖) ⋯ |
MonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [Monoid M] → MonCat |
Std.DTreeMap.Raw.getKey!_diff_of_not_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [inst : Inhabited α]
[Std.TransCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₂ → (t₁ \ t₂).getKey! k = t₁.getKey! k |
Int16.toBitVec_div | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a / b).toBitVec = a.toBitVec.sdiv b.toBitVec |
Filter.not_bddBelow_of_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {l : Filter α} [l.NeBot] {f : α → β} [NoMinOrder β],
Filter.Tendsto f l Filter.atBot → ¬BddBelow (Set.range f) |
entourageProd.match_1 | Mathlib.Topology.UniformSpace.Basic | {α : Type u_2} →
{β : Type u_1} →
(motive : (α × β) × α × β → Sort u_3) →
(x : (α × β) × α × β) → ((a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → motive ((a₁, b₁), a₂, b₂)) → motive x |
MeasureTheory.Measure.NullMeasurableSet.const_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {s : Set E},
MeasureTheory.NullMeasurableSet s μ → ∀ (r : ℝ), MeasureTheory.NullMeasurableSet (r • s) μ |
CategoryTheory.Enriched.FunctorCategory.functorEnrichedCategory._proof_2 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
(C : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} C] (J : Type u_3)
[inst_3 : CategoryTheory.Category.{u_1, u_3} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
[inst_5 :
∀ (F₁ F₂ : CategoryTheory.Functor J C), CategoryTheory.Enriched.FunctorCategory.HasFunctorEnrichedHom V F₁ F₂]
(X Y : CategoryTheory.Functor J C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V X Y)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedId V X)
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V X Y))
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedComp V X X Y)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V X Y) |
Lean.Lsp.RpcCallParams.mk._flat_ctor | Lean.Data.Lsp.Extra | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.Position → UInt64 → Lean.Name → Lean.Json → Lean.Lsp.RpcCallParams |
Int.tdiv_dvd_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b → b ∣ c → b.tdiv a ∣ c.tdiv a |
Std.Tactic.BVDecide.BVBinPred.ult | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinPred |
_private.Lean.Meta.Basic.0.Lean.Meta.exposeRelevantUniverses._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 24 t.ctorIdx → motive t) → motive t |
GroupCone.mk.injEq | Mathlib.Algebra.Order.Group.Cone | ∀ {G : Type u_1} [inst : CommGroup G] (toSubmonoid : Submonoid G)
(eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1)
(toSubmonoid_1 : Submonoid G)
(eq_one_of_mem_of_inv_mem'_1 : ∀ {a : G}, a ∈ toSubmonoid_1.carrier → a⁻¹ ∈ toSubmonoid_1.carrier → a = 1),
({ toSubmonoid := toSubmonoid, eq_one_of_mem_of_inv_mem' := eq_one_of_mem_of_inv_mem' } =
{ toSubmonoid := toSubmonoid_1, eq_one_of_mem_of_inv_mem' := eq_one_of_mem_of_inv_mem'_1 }) =
(toSubmonoid = toSubmonoid_1) |
YoungDiagram.transpose_eq_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.transpose = ν.transpose ↔ μ = ν |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux.handleEnumWithDefault.intersperseDefault | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.InductiveVal →
Lean.Expr → List Lean.Level → List (ℕ × Lean.Expr) → ℕ → List (ℕ × Lean.Expr) → Lean.MetaM (List (ℕ × Lean.Expr)) |
Nat.floor_sub_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
[inst_4 : Sub R] [OrderedSub R] [ExistsAddOfLE R] (a : R) (n : ℕ) [inst_7 : n.AtLeastTwo],
⌊a - OfNat.ofNat n⌋₊ = ⌊a⌋₊ - OfNat.ofNat n |
WeierstrassCurve.Ψ₂Sq._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (3 + 1).AtLeastTwo |
Aesop.SafeRulesResult.ctorElimType | Aesop.Search.Expansion | {motive : Aesop.SafeRulesResult → Sort u} → ℕ → Sort (max 1 u) |
Std.Rcc.pairwise_toList_le | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [LT α] [inst_3 : Std.PRange.UpwardEnumerable α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.Rxc.IsAlwaysFinite α], List.Pairwise (fun a b => a ≤ b) r.toList |
Mathlib.Ineq.WithStrictness.casesOn | Mathlib.Tactic.LinearCombination.Lemmas | {motive : Mathlib.Ineq.WithStrictness → Sort u} →
(t : Mathlib.Ineq.WithStrictness) →
motive Mathlib.Ineq.WithStrictness.eq →
motive Mathlib.Ineq.WithStrictness.le →
((strict : Bool) → motive (Mathlib.Ineq.WithStrictness.lt strict)) → motive t |
CategoryTheory.CommGrp._sizeOf_inst | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} → [SizeOf C] → SizeOf (CategoryTheory.CommGrp C) |
CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso_inv | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : a ⟶ c)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanExtension f g] {x : B} (h : c ⟶ x)
[inst_2 : CategoryTheory.Bicategory.Lan.CommuteWith f g h],
(CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso f g h).inv =
(CategoryTheory.Bicategory.Lan.CommuteWith.isKan f g h).desc
(CategoryTheory.Bicategory.lanLeftExtension f (CategoryTheory.CategoryStruct.comp g h)) |
Nat.ceil_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R] (n : ℕ)
[inst_4 : n.AtLeastTwo], ⌈OfNat.ofNat n⌉₊ = OfNat.ofNat n |
SimplexCategory.orderIsoOfIso._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (e : x ≅ y) (i : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom e.inv) ((SimplexCategory.Hom.toOrderHom e.hom) i) = i |
MulRingNormClass.mk | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonAssocRing α] [inst_1 : Semiring β]
[inst_2 : PartialOrder β] [inst_3 : FunLike F α β] [toMulRingSeminormClass : MulRingSeminormClass F α β],
(∀ (f : F) {a : α}, f a = 0 → a = 0) → MulRingNormClass F α β |
Encodable.encode_prod_val | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Encodable β] (a : α) (b : β),
Encodable.encode (a, b) = Nat.pair (Encodable.encode a) (Encodable.encode b) |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0.String.reduceListChar._unsafe_rec | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | Lean.Expr → String → Lean.Meta.SimpM Lean.Meta.Simp.DStep |
USize.reduceToNat._regBuiltin.USize.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1306150149._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
Relator.RightTotal.rel_forall | Mathlib.Logic.Relator | ∀ {α : Sort u₁} {β : Sort u₂} {R : α → β → Prop},
Relator.RightTotal R →
Relator.LiftFun (Relator.LiftFun R fun x1 x2 => ∀ (a : x1), x2) (fun x1 x2 => ∀ (a : x1), x2)
(fun p => (i : α) → p i) fun q => ∀ (i : β), q i |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFinish._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFinish_1 | Lean.Elab.Tactic.Grind.BuiltinTactic | IO Unit |
posMulMono_iff | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ (α : Type u_1) [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
PosMulMono α ↔ ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b c : α⦄, b ≤ c → a * b ≤ a * c |
Relation.ReflGen.rec | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a : α} {motive : (a_1 : α) → Relation.ReflGen r a a_1 → Prop},
motive a ⋯ → (∀ {b : α} (a_1 : r a b), motive b ⋯) → ∀ {a_1 : α} (t : Relation.ReflGen r a a_1), motive a_1 t |
Filter.HasBasis.prod | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} {ι' : Type u_7} {pa : ι → Prop}
{sa : ι → Set α} {pb : ι' → Prop} {sb : ι' → Set β},
la.HasBasis pa sa → lb.HasBasis pb sb → (la ×ˢ lb).HasBasis (fun i => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2 |
_private.Mathlib.Algebra.Polynomial.CoeffMem.0.Polynomial.coeff_divModByMonicAux_mem_span_pow_mul_span._simp_1_4 | Mathlib.Algebra.Polynomial.CoeffMem | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.degree = ⊥) = (p = 0) |
Function.Injective.sumElim | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Sort u_3} {f : α → γ} {g : β → γ},
Function.Injective f → Function.Injective g → (∀ (a : α) (b : β), f a ≠ g b) → Function.Injective (Sum.elim f g) |
_private.Mathlib.Data.Nat.Bitwise.0.Nat.binaryRec_of_ne_zero._simp_1_1 | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ} {b : Bool}, (Nat.bit b n = 0) = (n = 0 ∧ b = false) |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_bot_of_neg.match_1_1 | Mathlib.Data.EReal.Operations | ∀ (motive : (x : EReal) → x < 0 → Prop) (x : EReal) (x_1 : x < 0),
(∀ (x : ⊥ < 0), motive none x) →
(∀ (x : ℝ) (h : ↑x < 0), motive (some (some x)) h) → (∀ (h : ⊤ < 0), motive (some none) h) → motive x x_1 |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_iff_exists_append._simp_1_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) |
_private.Mathlib.Analysis.Calculus.Deriv.Slope.0.hasDerivAtFilter_iff_tendsto_slope._simp_1_2 | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y |
AddGroupSeminorm.toFun_eq_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p : AddGroupSeminorm E}, p.toFun = ⇑p |
instModuleWeakSpace | Mathlib.Topology.Algebra.Module.WeakDual | (𝕜 : Type u_1) →
(E : Type u_2) →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] → [inst_6 : TopologicalSpace E] → Module 𝕜 (WeakSpace 𝕜 E) |
Matrix.l2OpNormedAddCommGroupAux._proof_5 | Mathlib.Analysis.CStarAlgebra.Matrix | ∀ {𝕜 : Type u_1} {m : Type u_2} [inst : RCLike 𝕜], SMulCommClass 𝕜 𝕜 (WithLp 2 (m → 𝕜)) |
Mathlib.Tactic.Rify.ratCast_lt._simp_1 | Mathlib.Tactic.Rify | ∀ (a b : ℚ), (a < b) = (↑a < ↑b) |
Lean.Language.Lean.waitForFinalCmdState? | Lean.Language.Lean | Lean.Language.Lean.InitialSnapshot → Option Lean.Elab.Command.State |
DivInvOneMonoid.inv_one | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_2} [self : DivInvOneMonoid G], 1⁻¹ = 1 |
_private.Mathlib.LinearAlgebra.QuadraticForm.Radical.0.QuadraticForm.radical_weightedSumSquares._simp_1_3 | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {M : Type u_4} [inst : AddMonoid M] [IsRightCancelAdd M] {a b : M}, (a + b = b) = (a = 0) |
Ideal.quotTorsionOfEquivSpanSingleton | Mathlib.Algebra.Module.Torsion.Basic | (R : Type u_1) →
(M : Type u_2) →
[inst : Ring R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (x : M) → (R ⧸ Ideal.torsionOf R M x) ≃ₗ[R] ↥(R ∙ x) |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.toArray_eq_fold._simp_1_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray |
Aesop.LIFOQueue | Aesop.Search.Queue | Type |
_private.Lean.CoreM.0.Lean.mkAuxDeclName.match_1 | Lean.CoreM | (motive : Lean.Name × Lean.DeclNameGenerator → Sort u_1) →
(x : Lean.Name × Lean.DeclNameGenerator) →
((n : Lean.Name) → (ngen : Lean.DeclNameGenerator) → motive (n, ngen)) → motive x |
LocallyConstant.constₗ._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_3) [inst_1 : Semiring R]
[inst_2 : AddCommMonoid Y] [inst_3 : Module R Y] (x : R) (x_1 : Y),
LocallyConstant.const X (x • x_1) = LocallyConstant.const X (x • x_1) |
CategoryTheory.ObjectProperty.isLocal_of_isIso | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) {X Y : C}
(f : X ⟶ Y) [CategoryTheory.IsIso f], P.isLocal f |
algEquivEquivAlgHom._proof_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ (K : Type u_1) [inst : Field K], IsDomain K |
SimpleGraph.Iso.mapEdgeSet | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → {W : Type u_2} → {G : SimpleGraph V} → {G' : SimpleGraph W} → G ≃g G' → ↑G.edgeSet ≃ ↑G'.edgeSet |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli._proof_1 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C)
(x : CategoryTheory.Cokleisli U),
CategoryTheory.CategoryStruct.comp (U.δ.app x.of) (U.map (U.ε.app x.of)) =
CategoryTheory.CategoryStruct.id (U.obj x.of) |
Sym.erase_mk._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] (m : Multiset α), m.card = n + 1 → ∀ a ∈ m, (m.erase a).card = n |
Fin.dfoldlM_succ | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Fin (n + 1 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin (n + 1)) → α i.castSucc → m (α i.succ)) (x : α 0),
Fin.dfoldlM (n + 1) α f x = do
let x ← f 0 x
Fin.dfoldlM n (α ∘ Fin.succ) (fun x1 x2 => f x1.succ x2) x |
Set.range_list_getI | Mathlib.Data.Set.List | ∀ {α : Type u_1} [inst : Inhabited α] (l : List α), Set.range l.getI = insert default {x | x ∈ l} |
AddCommGroup.DirectLimit.map._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (G i)]
{f : (i j : ι) → i ≤ j → G i →+ G j} [inst_2 : DecidableEq ι] {G' : ι → Type u_2}
[inst_3 : (i : ι) → AddCommMonoid (G' i)] {f' : (i j : ι) → i ≤ j → G' i →+ G' j} (g : (i : ι) → G i →+ G' i),
(∀ (i j : ι) (h : i ≤ j), (g j).comp (f i j h) = (f' i j h).comp (g i)) →
∀ (i j : ι) (h : i ≤ j) (g_1 : G i),
((fun i => (AddCommGroup.DirectLimit.of G' f' i).comp (g i)) j) ((f i j h) g_1) =
((fun i => (AddCommGroup.DirectLimit.of G' f' i).comp (g i)) i) g_1 |
CategoryTheory.evaluationAdjunctionLeft._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) {X : CategoryTheory.Functor C D}
{Y Y' : D} (f : ((CategoryTheory.evaluation C D).obj c).obj X ⟶ Y) (g : Y ⟶ Y'),
{
toFun := fun f =>
{ app := fun x => CategoryTheory.Limits.Pi.lift fun g => CategoryTheory.CategoryStruct.comp (X.map g) f,
naturality := ⋯ },
invFun := fun f =>
CategoryTheory.CategoryStruct.comp (f.app c)
(CategoryTheory.Limits.Pi.π (fun x => Y') (CategoryTheory.CategoryStruct.id c)),
left_inv := ⋯, right_inv := ⋯ }
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
({
toFun := fun f =>
{ app := fun x => CategoryTheory.Limits.Pi.lift fun g => CategoryTheory.CategoryStruct.comp (X.map g) f,
naturality := ⋯ },
invFun := fun f =>
CategoryTheory.CategoryStruct.comp (f.app c)
(CategoryTheory.Limits.Pi.π (fun x => Y) (CategoryTheory.CategoryStruct.id c)),
left_inv := ⋯, right_inv := ⋯ }
f)
((CategoryTheory.evaluationRightAdjoint D c).map g) |
_private.Mathlib.Analysis.Analytic.Within.0.analyticOn_of_locally_analyticOn._simp_1_4 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) |
Lean.LeanOptions.mk.noConfusion | Lean.Util.LeanOptions | {P : Sort u} →
{values values' : Lean.NameMap Lean.LeanOptionValue} →
{ values := values } = { values := values' } → (values = values' → P) → P |
Subgroup.instNormalSubtypeMemFocalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroupOf.Normal |
FintypeCat.toLightProfinite | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.Functor FintypeCat LightProfinite |
Matrix.liftLinear_comp_singleLinearMap | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} (S : Type u_6) {α : Type u_7} {β : Type u_8} [inst : DecidableEq m]
[inst_1 : DecidableEq n] [inst_2 : Fintype m] [inst_3 : Fintype n] [inst_4 : Semiring R] [inst_5 : Semiring S]
[inst_6 : AddCommMonoid α] [inst_7 : AddCommMonoid β] [inst_8 : Module R α] [inst_9 : Module R β]
[inst_10 : Module S β] [inst_11 : SMulCommClass R S β] (f : m → n → α →ₗ[R] β) (i : m) (j : n),
(Matrix.liftLinear S) f ∘ₗ Matrix.singleLinearMap R i j = f i j |
ULift.recOn | Init.Prelude | {α : Type s} →
{motive : ULift.{r, s} α → Sort u} → (t : ULift.{r, s} α) → ((down : α) → motive { down := down }) → motive t |
ISize.toInt16_not | Init.Data.SInt.Bitwise | ∀ (a : ISize), (~~~a).toInt16 = ~~~a.toInt16 |
LinOrd.ext | Mathlib.Order.Category.LinOrd | ∀ {X Y : LinOrd} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g |
AffineEquiv.instCoeOutEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
[inst_5 : AddTorsor V₁ P₁] → [inst_6 : AddTorsor V₂ P₂] → CoeOut (P₁ ≃ᵃ[k] P₂) (P₁ ≃ P₂) |
_private.Mathlib.CategoryTheory.SmallObject.Iteration.Basic.0.CategoryTheory.SmallObject.SuccStruct.Iteration.subsingleton._simp_5 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
List.Cursor.current.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (c : l.Cursor) (h : 0 < c.suffix.length), c.current h = c.suffix[0] |
CategoryTheory.Limits.Cofork.IsColimit.desc'.congr_simp | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g}
(hs hs_1 : CategoryTheory.Limits.IsColimit s),
hs = hs_1 →
∀ {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limits.Cofork.IsColimit.desc' hs k h = CategoryTheory.Limits.Cofork.IsColimit.desc' hs_1 k h |
SeparationQuotient.instCommRing._proof_14 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : CommRing R] [inst_2 : IsTopologicalRing R] (c : ℤ) (x : R),
SeparationQuotient.mk (c • x) = c • SeparationQuotient.mk x |
Lean.Widget.MsgEmbed.brecOn_3.go | Lean.Widget.InteractiveDiagnostic | {motive_1 : Lean.Widget.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u} →
{motive_4 : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u} →
{motive_5 : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u} →
(t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
((t : Lean.Widget.MsgEmbed) → t.below → motive_1 t) →
((t : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Lean.Widget.MsgEmbed.below_1 t → motive_2 t) →
((t :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) →
Lean.Widget.MsgEmbed.below_2 t → motive_3 t) →
((t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
Lean.Widget.MsgEmbed.below_3 t → motive_4 t) →
((t : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
Lean.Widget.MsgEmbed.below_4 t → motive_5 t) →
motive_4 t ×' Lean.Widget.MsgEmbed.below_3 t |
SubAddAction.fixingAddSubgroupInsertEquiv._proof_6 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : AddGroup M] [inst_1 : AddAction M α] (a : α)
(s : Set ↥(SubAddAction.ofStabilizer M a)) (x : ↥(fixingAddSubgroup M (insert a (Subtype.val '' s)))),
(fun m => ⟨↑↑m, ⋯⟩) ((fun m => ⟨⟨↑m, ⋯⟩, ⋯⟩) x) = x |
Mathlib.instReprIneq | Mathlib.Data.Ineq | Repr Mathlib.Ineq |
Shrink.instAdd | Mathlib.Algebra.Group.Shrink | {α : Type u_2} → [inst : Small.{v, u_2} α] → [Add α] → Add (Shrink.{v, u_2} α) |
Pi.commMonoidWithZero._proof_3 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → CommMonoidWithZero (α i)] (a : (i : ι) → α i), a * 0 = 0 |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Iio_True._simp_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) |
ZeroHom.coe_copy | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {x : Zero M} {x_1 : Zero N} (f : ZeroHom M N) (f' : M → N) (h : f' = ⇑f),
⇑(f.copy f' h) = f' |
Real.fourier_continuousMultilinearMap_apply | Mathlib.Analysis.Fourier.FourierTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] [inst_6 : FiniteDimensional ℝ V]
{ι : Type u_4} [inst_7 : Fintype ι] {M : ι → Type u_5} [inst_8 : (i : ι) → NormedAddCommGroup (M i)]
[inst_9 : (i : ι) → NormedSpace ℝ (M i)] {f : V → ContinuousMultilinearMap ℝ M E} {m : (i : ι) → M i} {v : V},
MeasureTheory.Integrable f MeasureTheory.volume →
(FourierTransform.fourier f v) m = FourierTransform.fourier (fun x => (f x) m) v |
Set.iUnion_setOf | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} (P : ι → α → Prop), ⋃ i, {x | P i x} = {x | ∃ i, P i x} |
String.Slice.Pattern.ForwardSliceSearcher.startsWith | Init.Data.String.Pattern.String | String.Slice → String.Slice → Bool |
_private.Mathlib.LinearAlgebra.Span.Basic.0.LinearMap.submoduleOf_span_singleton_of_mem._simp_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) |
Affine.Simplex.Equilateral.angle_eq_pi_div_three | Mathlib.Geometry.Euclidean.Simplex | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} {s : Affine.Simplex ℝ P n},
s.Equilateral →
∀ {i₁ i₂ i₃ : Fin (n + 1)},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → EuclideanGeometry.angle (s.points i₁) (s.points i₂) (s.points i₃) = Real.pi / 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.