name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Con.lift_funext | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} (f g : c.Quotient →* P),
(∀ (a : M), f ↑a = g ↑a) → f = g |
StrictConvex.is_linear_preimage | Mathlib.Analysis.Convex.Strict | ∀ {𝕜 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : TopologicalSpace E] [inst_3 : TopologicalSpace F] [inst_4 : AddCommMonoid E] [inst_5 : AddCommMonoid F]
[inst_6 : Module 𝕜 E] [inst_7 : Module 𝕜 F] {s : Set F},
StrictConvex 𝕜 s → ∀ {f : E → F}, IsLinearMap 𝕜 f → Continuous f → Function.Injective f → StrictConvex 𝕜 (f ⁻¹' s) |
mem_skewAdjointMatricesSubmodule._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R)
[inst_2 : DecidableEq n], (A₁ ∈ skewAdjointMatricesSubmodule J) = J.IsSkewAdjoint A₁ |
ProofWidgets.RpcEncodablePacket.goals._@.ProofWidgets.Component.Panel.Basic.2840189264._hygCtx._hyg.1 | ProofWidgets.Component.Panel.Basic | ProofWidgets.RpcEncodablePacket✝ → Lean.Json |
CategoryTheory.LaxMonoidalFunctor.isoOfComponents | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F G : CategoryTheory.LaxMonoidalFunctor C D} →
(e : (X : C) → F.obj X ≅ G.obj X) →
autoParam
(∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (e Y).hom =
CategoryTheory.CategoryStruct.comp (e X).hom (G.map f))
CategoryTheory.LaxMonoidalFunctor.isoOfComponents._auto_1 →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε F.toFunctor)
(e (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom =
CategoryTheory.Functor.LaxMonoidal.ε G.toFunctor)
CategoryTheory.LaxMonoidalFunctor.isoOfComponents._auto_3 →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F.toFunctor X Y)
(e (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (e X).hom (e Y).hom)
(CategoryTheory.Functor.LaxMonoidal.μ G.toFunctor X Y))
CategoryTheory.LaxMonoidalFunctor.isoOfComponents._auto_5 →
(F ≅ G) |
UInt8.ofFin | Init.Data.UInt.Basic | Fin UInt8.size → UInt8 |
Affine.Simplex.points_mem_affineSpan_faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [Nontrivial k] {n : ℕ} [inst_5 : NeZero n] (s : Affine.Simplex k P n) {i j : Fin (n + 1)},
s.points j ∈ affineSpan k (Set.range (s.faceOpposite i).points) ↔ j ≠ i |
cfc_add_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
CategoryTheory.StrongEpi.of_arrow_iso | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) [h : CategoryTheory.StrongEpi f],
CategoryTheory.StrongEpi g |
ContinuousAffineMap.vadd_toAffineMap | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : TopologicalSpace W]
[inst_10 : IsTopologicalAddGroup W] [inst_11 : IsTopologicalAddTorsor Q] (f : P →ᴬ[R] W) (g : P →ᴬ[R] Q),
↑(f +ᵥ g) = ↑f +ᵥ ↑g |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.mkPairs.loop | Lean.Elab.BuiltinNotation | Array Lean.Term → ℕ → Lean.Term → Lean.MacroM Lean.Term |
CategoryTheory.IsHomLift.id_comp_lift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsHomLift f φ],
p.IsHomLift f (CategoryTheory.CategoryStruct.comp φ (CategoryTheory.CategoryStruct.id b)) |
Std.DTreeMap.Internal.Impl.getEntryLE!_eq_get!_getEntryLE? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
[inst_1 : Inhabited ((a : α) × β a)],
Std.DTreeMap.Internal.Impl.getEntryLE! k t = (Std.DTreeMap.Internal.Impl.getEntryLE? k t).get! |
_private.Lean.ReservedNameAction.0.Lean.initFn._@.Lean.ReservedNameAction.2721971034._hygCtx._hyg.2 | Lean.ReservedNameAction | IO (IO.Ref (Array Lean.ReservedNameAction)) |
DomMulAct.isInducing_mk_symm | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], Topology.IsInducing ⇑DomMulAct.mk.symm |
InnerProductSpace.Core.inner_add_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y z : F), inner 𝕜 (x + y) z = inner 𝕜 x z + inner 𝕜 y z |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.loop._unsafe_rec | Lean.Compiler.LCNF.Specialize | optParam ℕ 0 → Lean.Compiler.LCNF.Specialize.SpecializeM✝ Unit |
Homeomorph.mulLeft | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_9 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] {N : Type u_1} [inst_2 : AddCommGroup N]
[inst_3 : Module S N] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
LinearMap.CompatibleSMul N (LocalizedModule y.asIdeal.primeCompl N) R S |
BitVec.sshiftRight_xor_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x ^^^ y).sshiftRight n = x.sshiftRight n ^^^ y.sshiftRight n |
AddOreLocalization.zero_add | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S]
(x : AddOreLocalization S R), 0 + x = x |
AlgebraicTopology.DoldKan.N₁_obj_p | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C), (AlgebraicTopology.DoldKan.N₁.obj X).p = AlgebraicTopology.DoldKan.PInfty |
GenContFract.convs'_succ | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K) (n : ℕ)
[IsStrictOrderedRing K], (GenContFract.of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (GenContFract.of (Int.fract v)⁻¹).convs' n |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.ofList_eq_empty_iff._simp_1_2 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l = []) = (l.isEmpty = true) |
Aesop.FVarIdSubst.casesOn | Aesop.RuleTac.FVarIdSubst | {motive : Aesop.FVarIdSubst → Sort u} →
(t : Aesop.FVarIdSubst) → ((map : Std.HashMap Lean.FVarId Lean.FVarId) → motive { map := map }) → motive t |
Int.Linear.eq_def'_cert | Init.Data.Int.Linear | Int.Linear.Var → Int.Linear.Expr → Int.Linear.Poly → Bool |
Set.powersetCard.mulActionHom_of_embedding.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] (n : ℕ) [inst_2 : DecidableEq α],
Set.powersetCard.mulActionHom_of_embedding G α n = { toFun := Set.powersetCard.ofFinEmb n α, map_smul' := ⋯ } |
Submonoid.adjoin_eq_span_of_eq_span | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (F : Type u_1) (E : Type u_2) {K : Type u_3} [inst : CommSemiring E] [inst_1 : Semiring K] [inst_2 : SMul F E]
[inst_3 : Algebra E K] [inst_4 : Semiring F] [inst_5 : Module F K] [IsScalarTower F E K] (L : Submonoid K)
{S : Set K}, ↑L = ↑(Submodule.span F S) → Subalgebra.toSubmodule (Algebra.adjoin E ↑L) = Submodule.span E S |
Lean.Meta.Grind.CongrKey.ctorIdx | Lean.Meta.Tactic.Grind.Types | {enodes : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodes → ℕ |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) |
Std.Internal.List.getKeyD_eq_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [LawfulBEq α] {l : List ((a : α) × β a)} {k fallback : α},
Std.Internal.List.containsKey k l = true → Std.Internal.List.getKeyD k l fallback = k |
_aux_Init_Notation___unexpand_Dvd_dvd_1 | Init.Notation | Lean.PrettyPrinter.Unexpander |
mdifferentiableWithinAt_inter | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[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 : M → M'} {x : M} {s t : Set M},
t ∈ nhds x → (MDifferentiableWithinAt I I' f (s ∩ t) x ↔ MDifferentiableWithinAt I I' f s x) |
Array.findIdx_extract | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {p : α → Bool}, Array.findIdx p (xs.extract 0 i) = min i (Array.findIdx p xs) |
ContinuousMap.semilatticeInf | Mathlib.Topology.ContinuousMap.Ordered | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemilatticeInf β] → [ContinuousInf β] → SemilatticeInf C(α, β) |
Real.rpow_eq_const_mul_integral | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → x ^ p = (∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t 1)⁻¹ * ∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t x |
ConcaveOn.sub_strictConvexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f g : E → β}, ConcaveOn 𝕜 s f → StrictConvexOn 𝕜 s g → StrictConcaveOn 𝕜 s (f - g) |
Nat.lt_of_lt_of_eq | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, n < m → m = k → n < k |
Mathlib.Tactic.FieldSimp._aux_Mathlib_Tactic_Field___elabRules_Mathlib_Tactic_FieldSimp_field_1 | Mathlib.Tactic.Field | Lean.Elab.Tactic.Tactic |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_ord_eq_lfp._simp_1_3 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ |
iterateInduction._proof_3 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ (k : ℕ) (i : ↥(Finset.Iic k)), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (↑i) k.succ |
IsUnifLocDoublingMeasure.wrapped._@.Mathlib.MeasureTheory.Covering.DensityTheorem.1554790178._hygCtx._hyg.2 | Mathlib.MeasureTheory.Covering.DensityTheorem | Subtype (Eq @IsUnifLocDoublingMeasure.definition✝) |
CategoryTheory.IsKernelPair.lift_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (k.lift p q w) (CategoryTheory.CategoryStruct.comp b h) =
CategoryTheory.CategoryStruct.comp q h |
_private.Mathlib.Analysis.Complex.Trigonometric.0.Mathlib.Meta.Positivity.evalCosh.match_1 | Mathlib.Analysis.Complex.Trigonometric | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e)) →
((α : Q(Type)) →
(x : Q(Zero «$α»)) →
(x_2 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_2 e)) →
motive Lean.Level.zero x x_2 e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(x_2 : Q(Zero «$α»)) →
(x_3 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x_2 x_3 e)) →
motive x x_2 x_3 e __alt __alt_2) →
motive u x x_1 e __alt __alt_1 |
CategoryTheory.IsPreconnected.mk._flat_ctor | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J],
(∀ {α : Type u₁} (F : CategoryTheory.Functor J (CategoryTheory.Discrete α)) (j : J),
Nonempty (F ≅ (CategoryTheory.Functor.const J).obj (F.obj j))) →
CategoryTheory.IsPreconnected J |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_uIcc_castSucc._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.uIcc i.castSucc j.castSucc = Finset.map Fin.castSuccEmb (Finset.uIcc i j) |
_private.Mathlib.Algebra.Regular.Defs.0.isAddRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Add R] {c : R} (motive : IsAddLeftRegular c ∧ IsAddRightRegular c → Prop)
(x : IsAddLeftRegular c ∧ IsAddRightRegular c),
(∀ (h1 : IsAddLeftRegular c) (h2 : IsAddRightRegular c), motive ⋯) → motive x |
algebraMap_cobounded_le_cobounded | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_6) (𝕜' : Type u_7) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
[NormOneClass 𝕜'], Filter.Tendsto (⇑(algebraMap 𝕜 𝕜')) (Bornology.cobounded 𝕜) (Bornology.cobounded 𝕜') |
sup_div_inf_eq_mabs_div | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b : α), (a ⊔ b) / (a ⊓ b) = |b / a|ₘ |
_private.Mathlib.Analysis.SumOverResidueClass.0.not_summable_of_antitone_of_neg._simp_1_1 | Mathlib.Analysis.SumOverResidueClass | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε |
Std.HashSet.Raw.get?_diff_of_not_mem_right | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ \ m₂).get? k = m₁.get? k |
Nat.zeckendorf.match_1 | Mathlib.Data.Nat.Fib.Zeckendorf | (motive : ℕ → Sort u_1) →
(x : ℕ) → (Unit → motive 0) → ((m n : ℕ) → (h : m = n + 1) → motive (namedPattern m n.succ h)) → motive x |
SeminormedCommRing.induced | Mathlib.Analysis.Normed.Ring.Basic | {F : Type u_5} →
(R : Type u_6) →
(S : Type u_7) →
[inst : FunLike F R S] →
[inst_1 : CommRing R] → [inst_2 : SeminormedRing S] → [NonUnitalRingHomClass F R S] → F → SeminormedCommRing R |
AddMonoidHom.liftOfRightInverse_comp | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G₁ : Type u_5} {G₂ : Type u_6} {G₃ : Type u_7} [inst : AddGroup G₁] [inst_1 : AddGroup G₂] [inst_2 : AddGroup G₃]
(f : G₁ →+ G₂) (f_neg : G₂ → G₁) (hf : Function.RightInverse f_neg ⇑f) (g : { g // f.ker ≤ g.ker }),
((f.liftOfRightInverse f_neg hf) g).comp f = ↑g |
CategoryTheory.Limits.CatCospanTransform.mk | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {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} →
{A' : Type u₄} →
{B' : Type u₅} →
{C' : Type u₆} →
[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'} →
(left : CategoryTheory.Functor A A') →
(base : CategoryTheory.Functor B B') →
(right : CategoryTheory.Functor C C') →
autoParam (CategoryTheory.CatCommSq F left base F')
CategoryTheory.Limits.CatCospanTransform.squareLeft._autoParam →
autoParam (CategoryTheory.CatCommSq G right base G')
CategoryTheory.Limits.CatCospanTransform.squareRight._autoParam →
CategoryTheory.Limits.CatCospanTransform F G F' G' |
Setoid.sInf_iff | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {S : Set (Setoid α)} {x y : α}, (sInf S) x y ↔ ∀ s ∈ S, s x y |
Lean.Meta.mkAuxTheorem | Lean.Meta.Closure | Lean.Expr →
Lean.Expr → optParam Bool false → optParam (Option Lean.Name) none → optParam Bool true → Lean.MetaM Lean.Expr |
_private.Init.Data.Order.Ord.0.Std.instLawfulBEqOrd._simp_1 | Init.Data.Order.Ord | ∀ {o : Ordering}, (o.isEq = true) = (o = Ordering.eq) |
IsApproximateSubgroup.mk | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {K : ℝ} {A : Set G},
1 ∈ A → A⁻¹ = A → CovBySMul G K (A ^ 2) A → IsApproximateSubgroup K A |
UniformContinuous.add_const | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α]
[inst_3 : UniformSpace β] {f : β → α}, UniformContinuous f → ∀ (a : α), UniformContinuous fun x => f x + a |
mul_left_cancel | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Mul G] [IsLeftCancelMul G] {a b c : G}, a * b = a * c → b = c |
Polynomial.eval.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (x : R) (p : Polynomial R), Polynomial.eval x p = Polynomial.eval₂ (RingHom.id R) x p |
_private.Mathlib.Algebra.Order.BigOperators.Ring.List.0.CanonicallyOrderedAdd.list_prod_pos.match_1_1 | Mathlib.Algebra.Order.BigOperators.Ring.List | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabFunTarget.match_3 | Lean.Elab.Tactic.Induction | (motive : Lean.Meta.FunIndParamKind → Sort u_1) →
(kind : Lean.Meta.FunIndParamKind) →
(Unit → motive Lean.Meta.FunIndParamKind.dropped) →
(Unit → motive Lean.Meta.FunIndParamKind.param) → (Unit → motive Lean.Meta.FunIndParamKind.target) → motive kind |
ZeroAtInftyContinuousMap.instNonUnitalCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : NonUnitalCStarAlgebra A],
SMulCommClass ℂ (ZeroAtInftyContinuousMap α A) (ZeroAtInftyContinuousMap α A) |
Lean.Elab.Tactic.Do.SplitInfo | Lean.Elab.Tactic.Do.VCGen.Split | Type |
MultilinearMap.mkPiAlgebraFin_apply_const | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {n : ℕ} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
((MultilinearMap.mkPiAlgebraFin R n A) fun x => a) = a ^ n |
MulLECancellable.mul_le_mul_iff_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Mul α] [i : Std.Commutative fun x1 x2 => x1 * x2] [MulLeftMono α] {a b c : α},
MulLECancellable a → (b * a ≤ c * a ↔ b ≤ c) |
preNormEDS_one | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), preNormEDS b c d 1 = 1 |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.summable_pow_mul_cexp._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {α : Type u_1} {E : Type u_2} [inst : Norm E] {l : Filter α} {f : α → E} {g : α → ℝ},
f =O[l] g = f =O[l] fun x => ↑(g x) |
FirstOrder.Language.Substructure.comap._proof_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Hom M N) (S : L.Substructure N) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
(∀ (i : Fin n), x i ∈ ⇑φ ⁻¹' ↑S) → FirstOrder.Language.Structure.funMap f x ∈ ⇑φ ⁻¹' ↑S |
Lean.Elab.Term.Quotation.HeadInfo.casesOn | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadInfo → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadInfo) →
((check : Lean.Elab.Term.Quotation.HeadCheck) →
(onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult) →
(doMatch :
(List Lean.Term → Lean.Elab.TermElabM Lean.Term) →
Lean.Elab.TermElabM Lean.Term → Lean.Elab.TermElabM Lean.Term) →
motive { check := check, onMatch := onMatch, doMatch := doMatch }) →
motive t |
PrimrecPred.of_eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p q : α → Prop}, PrimrecPred p → (∀ (a : α), p a ↔ q a) → PrimrecPred q |
ContMDiffAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.SmoothSection | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommGroup F]
[inst_7 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {V : M → Type u_6} [inst_8 : TopologicalSpace (Bundle.TotalSpace F V)]
[inst_9 : (x : M) → TopologicalSpace (V x)] [inst_10 : FiberBundle F V] [inst_11 : (x : M) → AddCommGroup (V x)]
[inst_12 : (x : M) → Module 𝕜 (V x)] [VectorBundle 𝕜 F V] {ι : Type u_7} {t : ι → (x : M) → V x} {s : Finset ι}
{x₀ : M},
(∀ i ∈ s, ContMDiffAt I (I.prod (modelWithCornersSelf 𝕜 F)) n (fun x => Bundle.TotalSpace.mk' F x (t i x)) x₀) →
ContMDiffAt I (I.prod (modelWithCornersSelf 𝕜 F)) n (fun x => Bundle.TotalSpace.mk' F x (∑ i ∈ s, t i x)) x₀ |
Std.DTreeMap.Internal.Impl.size_containsThenInsert_eq_size | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsert.size t = t.size |
Int.tmod_eq_emod_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → a.tmod b = a % b |
WithCStarModule.norm_single | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A]
[inst_8 : DecidableEq ι] (i : ι) (y : E i), ‖(WithCStarModule.equiv A ((j : ι) → E j)).symm (Pi.single i y)‖ = ‖y‖ |
SetRel.instIsIrreflSetOfProdMatch_1PropOfIrrefl | Mathlib.Data.Rel | ∀ {α : Type u_1} {R : α → α → Prop} [Std.Irrefl R], SetRel.IsIrrefl {(a, b) | R a b} |
IccLeftChart._proof_3 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) (z : ↑(Set.Icc x y)), 0 ≤ ↑z - x |
Lean.Server.RequestHandler.mk.injEq | Lean.Server.Requests | ∀ (fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse))
(fileSource_1 : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle_1 : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)),
({ fileSource := fileSource, handle := handle } = { fileSource := fileSource_1, handle := handle_1 }) =
(fileSource = fileSource_1 ∧ handle = handle_1) |
CategoryTheory.Monad.monToMonad_map_toNatTrans | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Mon (CategoryTheory.Functor C C)}
(f : X ⟶ Y), ((CategoryTheory.Monad.monToMonad C).map f).toNatTrans = f.hom |
CategoryTheory.Limits.instLaxMonoidalFunctorLim._proof_13 | Mathlib.CategoryTheory.Monoidal.Limits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] [inst_3 : CategoryTheory.MonoidalCategory C]
(F G H : CategoryTheory.Functor J C) (j j' : J) (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const J).obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj
(CategoryTheory.Limits.limit (CategoryTheory.MonoidalCategoryStruct.tensorObj F G))
(CategoryTheory.Limits.limit H))).map
f)
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.Limits.limit.π (CategoryTheory.MonoidalCategoryStruct.tensorObj F G) j')
(CategoryTheory.Limits.limit.π H j')) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.Limits.limit.π (CategoryTheory.MonoidalCategoryStruct.tensorObj F G) j)
(CategoryTheory.Limits.limit.π H j))
((CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj F G) H).map f) |
Submodule.fst_orthogonalDecomposition_apply | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E),
(K.orthogonalDecomposition x).fst = K.orthogonalProjection x |
FirstOrder.Language.Term.varsToConstants.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} {γ : Type u_1} (c : γ),
(FirstOrder.Language.var (Sum.inl c)).varsToConstants = FirstOrder.Language.Constants.term (Sum.inr c) |
Nat.floor_add_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R}
[IsStrictOrderedRing R], 0 ≤ a → ∀ (n : ℕ) [inst_4 : n.AtLeastTwo], ⌊a + OfNat.ofNat n⌋₊ = ⌊a⌋₊ + OfNat.ofNat n |
Std.DTreeMap.Internal.Impl.filter_eq_filter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced}
{f : (a : α) → β a → Bool}, (Std.DTreeMap.Internal.Impl.filter f t h).impl = Std.DTreeMap.Internal.Impl.filter! f t |
Quiver.Path.instSubsingletonBddPaths | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (v w : V), Subsingleton (Quiver.Path.BoundedPaths v w 0) |
SemiNormedGrp.id_apply | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (M : SemiNormedGrp) (r : M.carrier), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id M)) r = r |
List.sym2_eq_sym_two | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, List.map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs |
_private.Lean.Compiler.LCNF.PullFunDecls.0.Lean.Compiler.LCNF.PullFunDecls.attach.visit.match_1 | Lean.Compiler.LCNF.PullFunDecls | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool → Sort u_1) →
(x : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool) →
((k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → (visited : Array Bool) → motive (k, visited)) →
motive x |
Std.Internal.Parsec.pure | Std.Internal.Parsec.Basic | {α ι : Type} → α → Std.Internal.Parsec ι α |
Function.Injective.involutiveInv.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₂ : Type u_2} {M₁ : Type u_3} [inst : Inv M₁] [inst_1 : InvolutiveInv M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(inv : ∀ (x : M₁), f x⁻¹ = (f x)⁻¹), Function.Injective.involutiveInv f hf inv = { toInv := inst, inv_inv := ⋯ } |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_eval_half_eq_zero._simp_1_1 | Mathlib.NumberTheory.ZetaValues | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True |
CategoryTheory.Limits.IsLimit.ofConeOfConeUncurry | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
{D : CategoryTheory.Limits.DiagramOfCones F} →
(Q : (j : J) → CategoryTheory.Limits.IsLimit (D.obj j)) →
{c : CategoryTheory.Limits.Cone (CategoryTheory.Functor.uncurry.obj F)} →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfConeUncurry Q c) →
CategoryTheory.Limits.IsLimit c |
CategoryTheory.Limits.Trident.ofι_pt | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [inst_1 : Nonempty J]
{P : C} (ι : P ⟶ X)
(w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)),
(CategoryTheory.Limits.Trident.ofι ι w).pt = P |
MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.negPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : MeasureTheory.SignedMeasure α} {μ : MeasureTheory.Measure α}
[self : s.HaveLebesgueDecomposition μ], s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ |
Sum.getLeft.congr_simp | Init.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} (ab ab_1 : α ⊕ β) (e_ab : ab = ab_1) (a : ab.isLeft = true),
ab.getLeft a = ab_1.getLeft ⋯ |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_3 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι), 0 < (a :: l).length → 0 < (a :: l).length |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.IterM.step_intermediateDropWhileWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩)
(h_2 : (it' : Std.IterM m β) → (h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩)
(h_3 : (h : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩),
(match ⟨Std.IterStep.yield it' out, h⟩ with
| ⟨Std.IterStep.yield it' out, h⟩ => h_1 it' out h
| ⟨Std.IterStep.skip it', h⟩ => h_2 it' h
| ⟨Std.IterStep.done, h⟩ => h_3 h) =
h_1 it' out h |
Lean.Grind.Linarith.eq_coeff_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly) (k : ℕ), Lean.Grind.Linarith.eq_coeff_cert p₁ p₂ k = (k != 0 && p₁ == p₂.mul ↑k) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.