name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Meta.Grind.Arith.propagateNatXOr | Lean.Meta.Tactic.Grind.Arith.Propagate | Lean.Meta.Grind.Propagator |
Subring.mk.injEq | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : Ring R] (toSubsemiring : Subsemiring R)
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) (toSubsemiring_1 : Subsemiring R)
(neg_mem'_1 : ∀ {x : R}, x ∈ toSubsemiring_1.carrier → -x ∈ toSubsemiring_1.carrier),
({ toSubsemiring := toSubsemiring, neg_mem' := neg_mem' } =
{ toSubsemiring := toSubsemiring_1, neg_mem' := neg_mem'_1 }) =
(toSubsemiring = toSubsemiring_1) |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_3 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (π : Y ⟶ X) ⦃V : C⦄ ⦃f : V ⟶ X⦄
(motive :
(CategoryTheory.Sieve.generate
(CategoryTheory.Presieve.ofArrows (fun x => Y) fun x =>
match x with
| PUnit.unit => π)).arrows
f →
Prop)
(h :
(CategoryTheory.Sieve.generate
(CategoryTheory.Presieve.ofArrows (fun x => Y) fun x =>
match x with
| PUnit.unit => π)).arrows
f),
(∀ (Y₁ : C) (h : V ⟶ Y₁) (g : Y₁ ⟶ X)
(hY :
CategoryTheory.Presieve.ofArrows (fun x => Y)
(fun x =>
match x with
| PUnit.unit => π)
g)
(hf : CategoryTheory.CategoryStruct.comp h g = f), motive ⋯) →
motive h |
Lean.Meta.AuxLemmas.mk.sizeOf_spec | Lean.Meta.Tactic.AuxLemma | ∀ (lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name × List Lean.Name)),
sizeOf { lemmas := lemmas } = 1 + sizeOf lemmas |
Lean.PrettyPrinter.Delaborator.delabSort | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab |
HahnSeries.SummableFamily.instAddCommGroup._proof_7 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_2} {R : Type u_3} {α : Type u_1} [inst : PartialOrder Γ] [inst_1 : AddCommGroup R]
(a : HahnSeries.SummableFamily Γ R α), SubNegMonoid.zsmul 0 a = 0 |
AddLocalization.decidableEq.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : IsCancelAdd α] {s : AddSubmonoid α} [inst_2 : DecidableEq α]
(a b : AddLocalization s),
a.decidableEq b = a.recOnSubsingleton₂ b fun x x_1 x_2 x_3 => decidable_of_iff' (↑x_3 + x = ↑x_2 + x_1) ⋯ |
Filter.eventually_and | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x |
Set.range_inl | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2}, Set.range Sum.inl = {x | x.isLeft = true} |
NonUnitalSubsemiring.comap | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
{F : Type u_1} →
[inst_2 : FunLike F R S] → [NonUnitalRingHomClass F R S] → F → NonUnitalSubsemiring S → NonUnitalSubsemiring R |
FirstOrder.Language.graphRel.noConfusion | Mathlib.ModelTheory.Graph | {P : Sort u} →
{a : ℕ} →
{t : FirstOrder.Language.graphRel a} →
{a' : ℕ} →
{t' : FirstOrder.Language.graphRel a'} → a = a' → t ≍ t' → FirstOrder.Language.graphRel.noConfusionType P t t' |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.ArgInfo.rec | Lean.Meta.Tactic.Grind.MBTC | {motive : Lean.Meta.Grind.ArgInfo✝ → Sort u} →
((arg app : Lean.Expr) → motive { arg := arg, app := app }) → (t : Lean.Meta.Grind.ArgInfo✝¹) → motive t |
PFunctor.M.casesOn_mk' | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {r : F.M → Sort u_2} {a : F.A} (x : F.B a → F.M)
(f : (a : F.A) → (f : F.B a → F.M) → r (PFunctor.M.mk ⟨a, f⟩)), (PFunctor.M.mk ⟨a, x⟩).casesOn' f = f a x |
Std.Do.PostShape.noConfusion | Std.Do.PostCond | {P : Sort u_1} → {t t' : Std.Do.PostShape} → t = t' → Std.Do.PostShape.noConfusionType P t t' |
Subfield._sizeOf_inst | Mathlib.Algebra.Field.Subfield.Defs | (K : Type u) → {inst : DivisionRing K} → [SizeOf K] → SizeOf (Subfield K) |
_private.Mathlib.Topology.Algebra.WithZeroTopology.0.WithZeroTopology.orderClosedTopology._simp_2 | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
ContDiffAt.smulRight | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {n : WithTop ℕ∞} {f : E → StrongDual 𝕜 F}
{g : E → G},
ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n g x → ContDiffAt 𝕜 n (fun x => ContinuousLinearMap.smulRight (f x) (g x)) x |
Equiv.image_swap_of_mem_of_notMem | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} [inst : DecidableEq α] {s : Set α} {i j : α}, i ∈ s → j ∉ s → ⇑(Equiv.swap i j) '' s = insert j s \ {i} |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f),
CategoryTheory.CategoryStruct.comp ((fun s => ht.lift s.flip) s) t.snd = s.fst |
Lean.PrettyPrinter.Parenthesizer.checkColGt.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer |
rootsOfUnityUnitsMulEquiv._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) (ζ ζ' : ↥(rootsOfUnity n Mˣ)), ⟨↑↑(ζ * ζ'), ⋯⟩ = ⟨↑↑ζ, ⋯⟩ * ⟨↑↑ζ', ⋯⟩ |
WithLp.toLp_fst | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} (x : α × β), (WithLp.toLp p x).fst = x.1 |
Fintype.prod_eq_mul | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Fintype α] [inst_1 : CommMonoid M] {f : α → M} (a b : α),
a ≠ b → (∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1) → ∏ x, f x = f a * f b |
_private.Lean.Meta.MethodSpecs.0.Lean.rewriteThm | Lean.Meta.MethodSpecs | Lean.Meta.Simp.Context → Lean.Meta.Simprocs → Lean.Name → Lean.Name → Lean.MetaM Unit |
Nat.reducePow | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc |
geom_sum_Ico_mul_neg | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) {m n : ℕ}, m ≤ n → (∑ i ∈ Finset.Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n |
Multiset.mem_filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β},
b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b |
Algebra.RingHom.adjoinAlgebraMapEquiv._proof_1 | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B)
(p : Polynomial A), (Polynomial.aeval b) p ∈ Algebra.adjoin A {b} |
Polynomial.coeff_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.coeff = ⇑p |
AdjoinRoot.equiv'._proof_2 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (g : Polynomial R)
(pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0)
(h₂ : (Polynomial.aeval pb.gen) g = 0) (x : S),
(AdjoinRoot.liftAlgHom g (Algebra.ofId R S) pb.gen h₂) ((pb.lift (AdjoinRoot.root g) h₁) x) = x |
Localization.subalgebra.isFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) (hS : S ≤ nonZeroDivisors A) [inst_1 : CommRing K]
[inst_2 : Algebra A K] [inst_3 : IsFractionRing A K], IsFractionRing (↥(Localization.subalgebra K S hS)) K |
Int16.toInt64_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 < b.toInt64) = (a < b) |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor | Mathlib.RingTheory.Invariant.Profinite | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
{G : Type u_3} →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
[SMulCommClass G A B] →
[inst_6 : TopologicalSpace G] →
(P : Ideal A) →
(Q : Ideal B) →
[inst_7 : Q.LiesOver P] →
((B ⧸ Q) ≃ₐ[A ⧸ P] B ⧸ Q) → CategoryTheory.Functor (OpenNormalSubgroup G) (Type u_3) |
SetLike.Homogeneous.smul | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {S : Type u_3} {R : Type u_4} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
{A : ι → Submodule S R} {s : S} {r : R}, SetLike.IsHomogeneousElem A r → SetLike.IsHomogeneousElem A (s • r) |
jacobiTheta₂'_term | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ℤ → ℂ → ℂ → ℂ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback_of_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
CategoryTheory.AB5StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5StarOfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 : CategoryTheory.IsCofiltered J],
CategoryTheory.HasExactLimitsOfShape J C) →
motive ⋯) →
(t : CategoryTheory.AB5StarOfSize.{w, w', v, u} C) → motive t |
Lean.Server.Test.Runner.Client.MsgEmbed.trace.injEq | Lean.Server.Test.Runner | ∀ (indent : ℕ) (cls : Lean.Name) (msg : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)
(collapsed : Bool)
(children :
Lean.Server.Test.Runner.Client.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed))
Lean.Lsp.RpcRef)
(indent_1 : ℕ) (cls_1 : Lean.Name) (msg_1 : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)
(collapsed_1 : Bool)
(children_1 :
Lean.Server.Test.Runner.Client.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed))
Lean.Lsp.RpcRef),
(Lean.Server.Test.Runner.Client.MsgEmbed.trace indent cls msg collapsed children =
Lean.Server.Test.Runner.Client.MsgEmbed.trace indent_1 cls_1 msg_1 collapsed_1 children_1) =
(indent = indent_1 ∧ cls = cls_1 ∧ msg = msg_1 ∧ collapsed = collapsed_1 ∧ children = children_1) |
VectorBundleCore.trivializationAt_coordChange_eq | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) {b₀ b₁ b : B},
b ∈ (trivializationAt F Z.Fiber b₀).baseSet ∩ (trivializationAt F Z.Fiber b₁).baseSet →
∀ (v : F),
(Bundle.Trivialization.coordChangeL R (trivializationAt F Z.Fiber b₀) (trivializationAt F Z.Fiber b₁) b) v =
(Z.coordChange (Z.indexAt b₀) (Z.indexAt b₁) b) v |
Aesop.EqualUpToIds.MVarValue._sizeOf_inst | Aesop.Util.EqualUpToIds | SizeOf Aesop.EqualUpToIds.MVarValue |
Std.Net.InterfaceAddress.address | Std.Net.Addr | Std.Net.InterfaceAddress → Std.Net.IPAddr |
Lean.Doc.elabInline._unsafe_rec | Lean.Elab.DocString | Lean.TSyntax `inline → Lean.Doc.DocM (Lean.Doc.Inline Lean.ElabInline) |
AdjoinRoot.algEquivOfAssociated_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : Associated f g), (AdjoinRoot.algEquivOfAssociated R f g hfg).symm = AdjoinRoot.algEquivOfAssociated R g f ⋯ |
Lean.MonadTrace.getTraceState | Lean.Util.Trace | {m : Type → Type} → [self : Lean.MonadTrace m] → m Lean.TraceState |
ConditionallyCompleteLinearOrder.toSuccOrder | Mathlib.Order.SuccPred.CompleteLinearOrder | {α : Type u_2} → [inst : ConditionallyCompleteLinearOrder α] → [WellFoundedLT α] → SuccOrder α |
Std.TreeSet.Raw.min!_eq_default | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = true → t.min! = default |
IO.FS.createDir | Init.System.IO | System.FilePath → IO Unit |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt.match_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α}
(motive : (x : ℕ) → (∀ i < x, m.IsCaratheodory (s i)) → Prop) (x : ℕ) (x_1 : ∀ i < x, m.IsCaratheodory (s i)),
(∀ (x : ∀ i < 0, m.IsCaratheodory (s i)), motive 0 x) →
(∀ (n : ℕ) (h : ∀ i < n + 1, m.IsCaratheodory (s i)), motive n.succ h) → motive x x_1 |
_private.Mathlib.Geometry.Euclidean.Congruence.0.EuclideanGeometry.angle_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Congruence | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {P₁ : Type u_4} {P₂ : Type u_2} [inst : NormedAddCommGroup V₁]
[inst_1 : NormedAddCommGroup V₂] [inst_2 : InnerProductSpace ℝ V₁] [inst_3 : InnerProductSpace ℝ V₂]
[inst_4 : MetricSpace P₁] [inst_5 : MetricSpace P₂] [inst_6 : NormedAddTorsor V₁ P₁] [inst_7 : NormedAddTorsor V₂ P₂]
{a b c : P₁} {a' b' c' : P₂},
¬Collinear ℝ {a, b, c} →
EuclideanGeometry.angle a b c = EuclideanGeometry.angle a' b' c' →
EuclideanGeometry.angle b c a = EuclideanGeometry.angle b' c' a' →
dist c a = dist c' a' →
EuclideanGeometry.angle c a b + EuclideanGeometry.angle a b c + EuclideanGeometry.angle b c a = Real.pi →
¬Collinear ℝ {a', b', c'} |
_private.Lean.Util.LeanOptions.0.Lean.LeanOptions.toOptions.match_1 | Lean.Util.LeanOptions | (motive : Lean.Name × Lean.LeanOptionValue → Sort u_1) →
(x : Lean.Name × Lean.LeanOptionValue) →
((name : Lean.Name) → (optionValue : Lean.LeanOptionValue) → motive (name, optionValue)) → motive x |
Std.ExtDHashMap.Const.getKey!_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.ExtDHashMap.Const.get m x_2 ⋯)).isSome).get! |
BoundedContinuousFunction.coeFn_toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3)
[inst_5 : Fact (1 ≤ p)] [inst_6 : NormedRing 𝕜] [inst_7 : Module 𝕜 E] [inst_8 : IsBoundedSMul 𝕜 E]
(f : BoundedContinuousFunction α E), ↑↑((BoundedContinuousFunction.toLp p μ 𝕜) f) =ᵐ[μ] ⇑f |
Cauchy.eq_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (f : Filter α), Cauchy f = (f.NeBot ∧ f ×ˢ f ≤ uniformity α) |
CategoryTheory.Over.postAdjunctionRight._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {Y : D} {F : CategoryTheory.Functor T D}
{G : CategoryTheory.Functor D T} (a : F ⊣ G) (A : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj Y)),
CategoryTheory.CategoryStruct.comp (a.counit.app A.left)
((CategoryTheory.Functor.id (CategoryTheory.Over ((CategoryTheory.Functor.id D).obj Y))).obj A).hom =
(((CategoryTheory.Over.post G).comp
((CategoryTheory.Over.post F).comp (CategoryTheory.Over.map (a.counit.app Y)))).obj
A).hom |
Vector.mapFinIdx_append._proof_4 | Init.Data.Vector.MapIdx | ∀ {n m : ℕ}, ∀ i < m, i + n < n + m |
Matrix.kroneckerTMulStarAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algebra S A]
[inst_10 : IsScalarTower R S A] [inst_11 : Fintype m] [inst_12 : DecidableEq m] [inst_13 : StarRing R]
[inst_14 : StarAddMonoid A] [inst_15 : StarAddMonoid B] [inst_16 : StarModule R A] [inst_17 : StarModule R B]
(x : Matrix (m × n) (m × n) (TensorProduct R A B)),
(Matrix.kroneckerTMulStarAlgEquiv m n R S A B).symm x = (kroneckerTMulLinearEquiv m m n n R S A B).symm x |
FirstOrder.Language.PartialEquiv.toEmbeddingOfEqTop | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → {f : L.PartialEquiv M N} → f.dom = ⊤ → L.Embedding M N |
_private.Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto.0.Real.tendstoLocallyUniformlyOn_rpow_sub_one_log._proof_1_12 | Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto | ∀ (p : ℝ), 0 < p → 0 ≤ p⁻¹ |
Function.Periodic.eq_1 | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] (f : α → β) (c : α), Function.Periodic f c = ∀ (x : α), f (x + c) = f x |
AddMonoidHom.codRestrict | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
{S : Type u_5} →
[inst_2 : SetLike S N] →
[inst_3 : AddSubmonoidClass S N] → (f : M →+ N) → (s : S) → (∀ (x : M), f x ∈ s) → M →+ ↥s |
_private.Init.Data.Array.Extract.0.Array.extract_size_left._proof_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, ¬min j as.size ≤ as.size → False |
quotAdjoinEquivQuotMap._proof_2 | Mathlib.RingTheory.Conductor | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S], RingHomClass (R →+* S) R S |
CategoryTheory.functorProdFunctorEquivUnitIso | Mathlib.CategoryTheory.Products.Basic | (A : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
(B : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
(C : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
CategoryTheory.Functor.id (CategoryTheory.Functor A B × CategoryTheory.Functor A C) ≅
(CategoryTheory.prodFunctorToFunctorProd A B C).comp (CategoryTheory.functorProdToProdFunctor A B C) |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.equiv_padic_of_bounded._simp_1_6 | Mathlib.NumberTheory.Ostrowski | ∀ {x : ℝ}, 0 ≤ x → ∀ (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) |
CategoryTheory.instDecidableEqPairwise.decEq._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} (a a_1 : ι), CategoryTheory.Pairwise.pair a a_1 = CategoryTheory.Pairwise.pair a a_1 |
Int.getD_toList_roo_eq_fallback | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n fallback : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toList.getD i fallback = fallback |
Nat.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Nat | MonoidWithZero ℕ |
Array.any_flatten' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {stop : ℕ} {f : α → Bool} {xss : Array (Array α)},
stop = xss.flatten.size → xss.flatten.any f 0 stop = xss.any fun x => x.any f |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform.0.CategoryTheory.Limits.CatCospanTransform.instIsIsoWhiskerRight._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
[inst_6 : CategoryTheory.Category.{v₇, u₇} A''] [inst_7 : CategoryTheory.Category.{v₈, u₈} B'']
[inst_8 : CategoryTheory.Category.{v₉, u₉} C''] {F'' : CategoryTheory.Functor A'' B''}
{G'' : CategoryTheory.Functor C'' B''} {ψ ψ' ψ'' : CategoryTheory.Limits.CatCospanTransform F G F' G'} (η : ψ ⟶ ψ')
(η' : ψ' ⟶ ψ'') {φ : CategoryTheory.Limits.CatCospanTransform F' G' F'' G''},
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight η φ)
(CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight η' φ) =
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight (CategoryTheory.CategoryStruct.comp η η') φ |
CategoryTheory.MonoOver.imageMonoOver | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasImage f] → CategoryTheory.MonoOver Y |
fintypeAffineCoords.eq_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ (ι : Type u_1) (k : Type u_2) [inst : Ring k] [inst_1 : Fintype ι],
fintypeAffineCoords ι k = AffineSubspace.comap (Fintype.linearCombination k 1).toAffineMap (affineSpan k {1}) |
Lean.PrettyPrinter.Delaborator.delabNeg | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.zero_mem_asymptoticCone._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) |
Filter.Tendsto.inseparable_iff_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] {β : Type u_1} {l : Filter β} [l.NeBot] {f g : β → α} {a b : α},
Filter.Tendsto f l (nhds a) →
Filter.Tendsto g l (nhds b) → (Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (uniformity α)) |
CategoryTheory.Functor.structuredArrowMapCone._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (G : CategoryTheory.Functor D H) (α : L.comp G ⟶ F)
(Y : D) ⦃X Y_1 : CategoryTheory.StructuredArrow Y L⦄ (f : X ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.StructuredArrow Y L)).obj (G.obj Y)).map f)
(CategoryTheory.CategoryStruct.comp (G.map Y_1.hom) (α.app Y_1.right)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (G.map X.hom) (α.app X.right))
(((CategoryTheory.StructuredArrow.proj Y L).comp F).map f) |
MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_8} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
(∀ (i : ι), MeasurableSet (As i)) → Pairwise (Function.onFun Disjoint As) → ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i) |
SubMulAction.ofStabilizer.conjMap._proof_4 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_2} [inst : Group G] {α : Type u_1} [inst_1 : MulAction G α] {g : G} {a b : α},
b = g • a → ∀ (x : ↥(MulAction.stabilizer G a)) (x_1 : ↥(SubMulAction.ofStabilizer G a)), g • ↑(x • x_1) ∈ {b} → False |
RegularExpression.matches'.eq_def | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (x : RegularExpression α),
x.matches' =
match x with
| RegularExpression.zero => 0
| RegularExpression.epsilon => 1
| RegularExpression.char a => {[a]}
| P.plus Q => P.matches' + Q.matches'
| P.comp Q => P.matches' * Q.matches'
| P.star => KStar.kstar P.matches' |
_private.Init.Data.Array.Lemmas.0.Array.all_toList._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticStop__1 | Init.Tactics | Lean.Macro |
Finset.eventually_cocardinal_notMem | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u} {c : Cardinal.{u}} {hreg : c.IsRegular} (s : Finset α), ∀ᶠ (x : α) in Filter.cocardinal α hreg, x ∉ s |
star_mul_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ star r * r) = True |
Multiset.dedup_cons_of_mem | Mathlib.Data.Multiset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s → (a ::ₘ s).dedup = s.dedup |
String.Pos.find? | Init.Data.String.Search | {ρ : Type} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[(s : String.Slice) → Std.IteratorLoop (σ s) Id Id] →
{s : String} → s.Pos → (pattern : ρ) → [String.Slice.Pattern.ToForwardSearcher pattern σ] → Option s.Pos |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ | Mathlib.Algebra.Homology.ShortComplex.Limits | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} →
(c : CategoryTheory.Limits.Cone F) →
CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₁.mapCone c) →
CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₂.mapCone c) →
CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₃.mapCone c) →
CategoryTheory.Limits.IsLimit c |
Set.biInter_finsetSigma_univ' | Mathlib.Data.Fintype.Sigma | ∀ {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_3} [inst : (i : ι) → Fintype (κ i)] (s : Finset ι)
(f : (i : ι) → κ i → Set α), ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodeExprWithEta.go._unsafe_rec | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array (Array Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry) →
Array (Array Lean.Meta.RefinedDiscrTree.Key) → Lean.MetaM (Array (Array Lean.Meta.RefinedDiscrTree.Key)) |
QuadraticModuleCat.instMonoidalCategoryStruct._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R |
LinearPMap.sSup | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} →
[inst_3 : AddCommGroup F] →
[inst_4 : Module R F] → (c : Set (E →ₗ.[R] F)) → DirectedOn (fun x1 x2 => x1 ≤ x2) c → E →ₗ.[R] F |
Std.Internal.IO.Async.UDP.Membership.rec | Std.Internal.Async.UDP | {motive : Std.Internal.IO.Async.UDP.Membership → Sort u} →
motive Std.Internal.IO.Async.UDP.Membership.leaveGroup →
motive Std.Internal.IO.Async.UDP.Membership.enterGroup → (t : Std.Internal.IO.Async.UDP.Membership) → motive t |
AddOpposite.one_le_op._simp_1 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] {a : α}, (1 ≤ AddOpposite.op a) = (1 ≤ a) |
CategoryTheory.linearYoneda_map_app | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : Cᵒᵖ),
((CategoryTheory.linearYoneda R C).map f).app Y =
ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y) f) |
CommSemiRingCat.instConcreteCategoryRingHomCarrier | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.ConcreteCategory CommSemiRingCat fun R S => ↑R →+* ↑S |
Pi.instPNatPowAssoc | Mathlib.Algebra.Group.PNatPowAssoc | ∀ {ι : Type u_2} {α : ι → Type u_3} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → Pow (α i) ℕ+]
[∀ (i : ι), PNatPowAssoc (α i)], PNatPowAssoc ((i : ι) → α i) |
Lean.KeyedDeclsAttribute.noConfusionType | Lean.KeyedDeclsAttribute | Sort u → {γ : Type} → Lean.KeyedDeclsAttribute γ → {γ' : Type} → Lean.KeyedDeclsAttribute γ' → Sort u |
Lean.Elab.Do.elabNestedAction | Lean.Elab.Do.Basic | Lean.Elab.Term.TermElab |
WType.Listα.cons | Mathlib.Data.W.Constructions | {γ : Type u} → γ → WType.Listα γ |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.SplitIf.3526097586._hygCtx._hyg.2 | Lean.Meta.Tactic.SplitIf | IO Unit |
Turing.ToPartrec.Code.zero_eval | Mathlib.Computability.TMConfig | ∀ (v : List ℕ), Turing.ToPartrec.Code.zero.eval v = pure [0] |
Mathlib.Tactic.BicategoryLike.State.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.PersistentExprMap Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.State |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.