name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.Cone.functoriality_obj_π_app | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F) (j : J),
((CategoryTheory.Limits.Cone.functoriality F G).obj A).π.app j = G.map (A.π.app j) |
MLList.fix?._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → (α → m (Option α)) → α → MLList m α |
CategoryTheory.Limits.MultispanIndex.SymmStruct._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{ι : Type w} →
(I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C) →
[SizeOf C] → [SizeOf ι] → SizeOf I.SymmStruct |
Differentiable.cosh._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ},
Differentiable ℝ f → (Differentiable ℝ fun x => Real.cosh (f x)) = True |
_private.Mathlib.Data.Holor.0.Holor._aux_Mathlib_Data_Holor___unexpand_Holor_mul_1 | Mathlib.Data.Holor | Lean.PrettyPrinter.Unexpander |
Function.Even.add | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] [inst_1 : Add β] {f g : α → β},
Function.Even f → Function.Even g → Function.Even (f + g) |
CategoryTheory.adjunctionOfStructuredArrowInitials | Mathlib.CategoryTheory.Adjunction.Comma | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor D C) →
[inst_2 : ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] →
CategoryTheory.leftAdjointOfStructuredArrowInitials G ⊣ G |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.glueData._simp_5 | Mathlib.AlgebraicGeometry.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(f = CategoryTheory.CategoryStruct.comp α.hom g) = (CategoryTheory.CategoryStruct.comp α.inv f = g) |
Int.bitwise.eq_2 | Mathlib.Data.Int.Bitwise | ∀ (f : Bool → Bool → Bool) (m n : ℕ),
Int.bitwise f (Int.ofNat m) (Int.negSucc n) = Int.natBitwise (fun x y => f x !y) m n |
Std.IterM.findSome?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β]
[inst_2 : Std.IteratorLoop α m m] [LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m]
{it : Std.IterM m β} {f : β → Option γ},
it.findSome? f = do
let __do_lift ← it.step
match ↑__do_lift.inflate with
| Std.IterStep.yield it' out =>
match f out with
| none => it'.findSome? f
| some fx => pure (some fx)
| Std.IterStep.skip it' => it'.findSome? f
| Std.IterStep.done => pure none |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftActionOfOppositeLeftAction_actionUnitIso | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction Cᵒᵖ Dᵒᵖ] (x : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso x =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso (Opposite.op x)).symm.unop |
Ideal.stabilizerEquiv | Mathlib.RingTheory.Ideal.Pointwise | {M : Type u_1} →
{R : Type u_2} →
[inst : Group M] →
[inst_1 : Semiring R] →
[inst_2 : MulSemiringAction M R] →
{N : Type u_3} →
[inst_3 : Group N] →
[inst_4 : MulSemiringAction N R] →
(I : Ideal R) →
(e : M ≃* N) →
(∀ (m : M) (x : R), e m • x = m • x) → ↥(MulAction.stabilizer M I) ≃* ↥(MulAction.stabilizer N I) |
MeasureTheory.ComplexMeasure.HaveLebesgueDecomposition.recOn | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | {α : Type u_1} →
{m : MeasurableSpace α} →
{c : MeasureTheory.ComplexMeasure α} →
{μ : MeasureTheory.Measure α} →
{motive : c.HaveLebesgueDecomposition μ → Sort u} →
(t : c.HaveLebesgueDecomposition μ) →
((rePart : (MeasureTheory.ComplexMeasure.re c).HaveLebesgueDecomposition μ) →
(imPart : (MeasureTheory.ComplexMeasure.im c).HaveLebesgueDecomposition μ) → motive ⋯) →
motive t |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_insert._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
AlgebraicGeometry.Scheme.Pullback.Triplet.specTensorTo_snd | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
CategoryTheory.CategoryStruct.comp T.SpecTensorTo (CategoryTheory.Limits.pullback.snd f g) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map T.tensorInr) (Y.fromSpecResidueField T.y) |
Std.ExtDTreeMap.Const.get!_inter_of_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited β] {k : α},
k ∈ t₂ → Std.ExtDTreeMap.Const.get! (t₁ ∩ t₂) k = Std.ExtDTreeMap.Const.get! t₁ k |
Polynomial.Bivariate.Transcendental.algEquivAdjoin_apply | Mathlib.RingTheory.Adjoin.Polynomial.Bivariate | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {x : A}
(hx : Transcendental R x) (p : Polynomial (Polynomial R)),
(Polynomial.Bivariate.Transcendental.algEquivAdjoin hx) p = (Polynomial.mapAlgHom (Polynomial.aeval ⟨x, ⋯⟩)) p |
Std.Internal.IO.Async.Signal.toCtorIdx | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal → ℕ |
UniformSpace.completelyNormalSpace_of_isCountablyGenerated_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] [(uniformity α).IsCountablyGenerated], CompletelyNormalSpace α |
CategoryTheory.Limits.cokernel.mapIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {X' Y' : C} (f' : X' ⟶ Y')
[inst_3 : CategoryTheory.Limits.HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y')
(w : CategoryTheory.CategoryStruct.comp f q.hom = CategoryTheory.CategoryStruct.comp p.hom f'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.map f' f p.inv q.inv ⋯)
(CategoryTheory.Limits.cokernel.map f f' p.hom q.hom w) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.cokernel f') |
Module.Presentation.directSum_relation | Mathlib.Algebra.Module.Presentation.DirectSum | ∀ {A : Type u} [inst : Ring A] {ι : Type w} [inst_1 : DecidableEq ι] {M : ι → Type v}
[inst_2 : (i : ι) → AddCommGroup (M i)] [inst_3 : (i : ι) → Module A (M i)]
(pres : (i : ι) → Module.Presentation A (M i)) (x : (i : ι) × ((fun i => (pres i).toRelations) i).R),
(Module.Presentation.directSum pres).relation x =
Finsupp.embDomain (Function.Embedding.sigmaMk x.fst) ((pres x.fst).relation x.snd) |
MeasureTheory.IsSetSemiring.rec | Mathlib.MeasureTheory.SetSemiring | {α : Type u_1} →
{C : Set (Set α)} →
{motive : MeasureTheory.IsSetSemiring C → Sort u} →
((empty_mem : ∅ ∈ C) →
(inter_mem : ∀ s ∈ C, ∀ t ∈ C, s ∩ t ∈ C) →
(diff_eq_sUnion' : ∀ s ∈ C, ∀ t ∈ C, ∃ I, ↑I ⊆ C ∧ (↑I).PairwiseDisjoint id ∧ s \ t = ⋃₀ ↑I) → motive ⋯) →
(t : MeasureTheory.IsSetSemiring C) → motive t |
CStarMatrix.instNonUnitalNonAssocRing | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {n : Type u_2} → {A : Type u_5} → [Fintype n] → [NonUnitalNonAssocRing A] → NonUnitalNonAssocRing (CStarMatrix n n A) |
Ideal.qoutMapEquivTensorQout | Mathlib.LinearAlgebra.TensorProduct.Quotient | {R : Type u_1} →
[inst : CommRing R] →
(S : Type u_4) →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] → {I : Ideal R} → (S ⧸ Ideal.map (algebraMap R S) I) ≃ₗ[S] TensorProduct R S (R ⧸ I) |
_private.Mathlib.Data.FinEnum.0.List.pfunFinEnum._simp_2 | Mathlib.Data.FinEnum | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
LinearEquiv.det_coe_symm | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {𝕜 : Type u_5} [inst_1 : Field 𝕜] [inst_2 : Module 𝕜 M] (f : M ≃ₗ[𝕜] M),
LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹ |
Filter.EventuallyEq.hasFDerivAtFilter_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f₀' f₁' : E →L[𝕜] F} {L : Filter (E × E)},
Prod.map f₀ f₀ =ᶠ[L] Prod.map f₁ f₁ →
(∀ (x : E), f₀' x = f₁' x) → (HasFDerivAtFilter f₀ f₀' L ↔ HasFDerivAtFilter f₁ f₁' L) |
Projectivization.rep | Mathlib.LinearAlgebra.Projectivization.Basic | {K : Type u_1} →
{V : Type u_2} →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → Projectivization K V → V |
GrpCat.FilteredColimits.colimitGroup._proof_2 | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J GrpCat) (a : ↑(GrpCat.FilteredColimits.G F)), zpowRec npowRec 0 a = 1 |
PosNum.isOne._sparseCasesOn_1 | Mathlib.Data.Num.Basic | {motive : PosNum → Sort u} → (t : PosNum) → motive PosNum.one → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Rep.resCoindHomEquiv._proof_6 | Mathlib.RepresentationTheory.Coinduced | ∀ {k : Type u_1} [inst : CommRing k], RingHomCompTriple (RingHom.id k) (RingHom.id k) (RingHom.id k) |
Ordinal.one_add_of_omega0_le | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {o : Ordinal.{u_4}}, Ordinal.omega0 ≤ o → 1 + o = o |
Orientation.oangle_eq_angle_or_eq_neg_angle | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V},
x ≠ 0 → y ≠ 0 → o.oangle x y = ↑(InnerProductGeometry.angle x y) ∨ o.oangle x y = -↑(InnerProductGeometry.angle x y) |
_private.Mathlib.Algebra.Notation.Support.0.Function.range_subset_insert_image_mulSupport._simp_1_2 | Mathlib.Algebra.Notation.Support | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) |
Real.surjOn_log' | Mathlib.Analysis.SpecialFunctions.Log.Basic | Set.SurjOn Real.log (Set.Iio 0) Set.univ |
LinearEquiv.ofLeftInverse | Mathlib.Algebra.Module.Submodule.Equiv | {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₂] →
{module_M : Module R M} →
{module_M₂ : Module R₂ M₂} →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
{f : M →ₛₗ[σ₁₂] M₂} →
[inst_4 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_5 : RingHomInvPair σ₂₁ σ₁₂] →
{g : M₂ → M} → Function.LeftInverse g ⇑f → M ≃ₛₗ[σ₁₂] ↥f.range |
Int.toList_roc_eq_singleton_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, (m<...=n).toList = [k] ↔ n = m + 1 ∧ m + 1 = k |
Array.append_eq_toArray_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {as : List α}, xs ++ ys = as.toArray ↔ xs.toList ++ ys.toList = as |
_private.Mathlib.Tactic.Variable.0.Mathlib.Command.Variable.completeBinders'._proof_9 | Mathlib.Tactic.Variable | ∀ (gas : ℕ) (binders : Lean.TSyntaxArray `Lean.Parser.Term.bracketedBinder) (i : ℕ),
0 < gas ∧ i < Array.size binders → ¬i ≤ Array.size binders → False |
AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U ⟶ X.toTopCat}
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) (V : TopologicalSpace.Opens ↑U) (x : ↑U)
(hx : x ∈ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.germ (h.functor.obj V) ((CategoryTheory.ConcreteCategory.hom f) x) ⋯)
(X.restrictStalkIso h x).inv =
(X.restrict h).presheaf.germ V x hx |
CategoryTheory.Grothendieck.pre._proof_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C CategoryTheory.Cat)
(G : CategoryTheory.Functor D C) (X : CategoryTheory.Grothendieck (G.comp F)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
{ base := G.map (CategoryTheory.CategoryStruct.id X).base,
fiber := (CategoryTheory.CategoryStruct.id X).fiber }.fiber =
(CategoryTheory.CategoryStruct.id { base := G.obj X.base, fiber := X.fiber }).fiber |
Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) →
((p : Lean.Grind.CommRing.Poly) →
(h : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) → motive_2 h → motive_1 { p := p, h := h }) →
((a b : Lean.Expr) →
(ra rb : Lean.Grind.CommRing.Expr) →
motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.core a b ra rb)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) →
motive_1 c → motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm c)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive_1 c → motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.cancelDen c val x n)) →
motive_2 t |
PFunctor.M.corecOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type u_2} → X → (X → ↑F X) → F.M |
Lean.MonadError.toMonadExceptOf | Lean.Exception | {m : Type → Type} → [self : Lean.MonadError m] → MonadExceptOf Lean.Exception m |
NumberField.RingOfIntegers.withValEquiv_symm_apply | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {K : Type u_3} [inst_1 : Field K] (v : Valuation K Γ₀)
(R : Type u_4) [inst_2 : CommRing R] [inst_3 : Algebra R K] [inst_4 : IsIntegralClosure R ℤ K] (a : R),
(NumberField.RingOfIntegers.withValEquiv v R).symm a =
(IsIntegralClosure.equiv ℤ R (WithVal v) (NumberField.RingOfIntegers (WithVal v))) a |
CategoryTheory.RegularMono._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.RegularMono f) |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUSize_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) |
Std.DTreeMap.contains_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ ∩ t₂).contains k = (t₁.contains k && t₂.contains k) |
WeakDual.CharacterSpace.homeoEval._proof_1 | Mathlib.Topology.ContinuousMap.Ideals | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 |
Std.HashMap.Raw.size_add_size_eq_size_union_add_size_inter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.size + m₂.size = (m₁ ∪ m₂).size + (m₁ ∩ m₂).size |
List.finite_toSet | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (l : List α), {x | x ∈ l}.Finite |
CategoryTheory.Retract.refl_r | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.Retract.refl X).r = CategoryTheory.CategoryStruct.id X |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.alts._default | Lean.Elab.Tactic.Induction | Array Lean.Elab.Tactic.ElimApp.Alt |
TensorProduct.map_comp_comm_eq | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_7}
{N : Type u_8} {M₂ : Type u_12} {N₂ : Type u_14} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R M] [inst_7 : Module R N]
[inst_8 : Module R₂ M₂] [inst_9 : Module R₂ N₂] (f : M →ₛₗ[σ₁₂] M₂) (g : N →ₛₗ[σ₁₂] N₂),
TensorProduct.map f g ∘ₛₗ ↑(TensorProduct.comm R N M) = ↑(TensorProduct.comm R₂ N₂ M₂) ∘ₛₗ TensorProduct.map g f |
Lean.Meta.Grind.Arith.Linear.EqCnstr.brecOn.go | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Linear.IneqCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Linear.DiseqCnstr → Sort u} →
{motive_6 : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof → Sort u} →
{motive_7 : Lean.Meta.Grind.Arith.Linear.UnsatProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.EqCnstr) →
((t : Lean.Meta.Grind.Arith.Linear.EqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Arith.Linear.EqCnstrProof) → t.below → motive_2 t) →
((t : Lean.Meta.Grind.Arith.Linear.IneqCnstr) → t.below → motive_3 t) →
((t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) → t.below → motive_4 t) →
((t : Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → t.below → motive_5 t) →
((t : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof) → t.below → motive_6 t) →
((t : Lean.Meta.Grind.Arith.Linear.UnsatProof) → t.below → motive_7 t) →
motive_1 t ×' t.below |
CommAlgCat.instMonoidalCategory | Mathlib.Algebra.Category.CommAlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.MonoidalCategory (CommAlgCat R) |
SimpleGraph.Walk.mem_support_nil_iff | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ∈ SimpleGraph.Walk.nil.support ↔ u = v |
_private.Mathlib.Data.Seq.Computation.0.Computation.liftRel_bind.match_1_9 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_3} {γ : Type u_1} {δ : Type u_2} (S : γ → δ → Prop) {f1 : α → Computation γ} {x : δ} (w : α)
(motive : (∃ a ∈ f1 w, S a x) → Prop) (x_1 : ∃ a ∈ f1 w, S a x),
(∀ (w_1 : γ) (c₂ : w_1 ∈ f1 w) (cd : S w_1 x), motive ⋯) → motive x_1 |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.inj | Lean.Server.ProtocolOverview | ∀ {method : String} {direction : Lean.JsonRpc.MessageDirection}
{kinds : Array Lean.Server.Overview.ProtocolExtensionKind✝} {parameterType : Type} {description method_1 : String}
{direction_1 : Lean.JsonRpc.MessageDirection} {kinds_1 : Array Lean.Server.Overview.ProtocolExtensionKind✝¹}
{parameterType_1 : Type} {description_1 : String},
{ method := method, direction := direction, kinds := kinds, parameterType := parameterType,
description := description } =
{ method := method_1, direction := direction_1, kinds := kinds_1, parameterType := parameterType_1,
description := description_1 } →
method = method_1 ∧
direction = direction_1 ∧ kinds = kinds_1 ∧ parameterType = parameterType_1 ∧ description = description_1 |
Lean.Doc.Inline.linebreak.noConfusion | Lean.DocString.Types | {i : Type u} →
{P : Sort u_1} →
{string string' : String} →
Lean.Doc.Inline.linebreak string = Lean.Doc.Inline.linebreak string' → (string = string' → P) → P |
Ordinal.CNF.coeff_zero_right | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_1}), Ordinal.CNF.coeff b 0 = 0 |
IntervalIntegrable.comp_add_left_iff | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b : ℝ}
[TopologicalSpace.PseudoMetrizableSpace ε] {c : ℝ},
autoParam (‖f (min a b)‖ₑ ≠ ⊤) IntervalIntegrable.comp_add_left_iff._auto_1 →
(IntervalIntegrable (fun x => f (c + x)) MeasureTheory.volume (a - c) (b - c) ↔
IntervalIntegrable f MeasureTheory.volume a b) |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.sSup_eq_eqvGen._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r s : Setoid α}, (r ≤ s) = ∀ {x y : α}, r x y → s x y |
MulOpposite.instNonUnitalSemiring._proof_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (a b c : Rᵐᵒᵖ), a * b * c = a * (b * c) |
Cardinal.ofNat_eq_toENat | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}} {n : ℕ} [inst : n.AtLeastTwo], OfNat.ofNat n = Cardinal.toENat c ↔ OfNat.ofNat n = c |
Real.toNNReal_coe | Mathlib.Data.NNReal.Defs | ∀ {r : NNReal}, (↑r).toNNReal = r |
AddMonoidAlgebra.commRing._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommMonoid M] (a b : AddMonoidAlgebra R M),
a * b = b * a |
Int.gcd_eq_zero_iff._simp_1 | Init.Data.Int.Gcd | ∀ {a b : ℤ}, (a.gcd b = 0) = (a = 0 ∧ b = 0) |
Left.one_lt_mul_of_le_of_lt | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftStrictMono α] {a b : α}, 1 ≤ a → 1 < b → 1 < a * b |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.containsInOrderLower.go._unsafe_rec | Lean.Data.FuzzyMatching | String → String → String.Pos.Raw → String.Pos.Raw → Bool |
MeasureTheory.average_neg | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
(μ : MeasureTheory.Measure α) (f : α → E), ⨍ (x : α), -f x ∂μ = -⨍ (x : α), f x ∂μ |
AlgebraicGeometry.Scheme.Pullback.diagonalCover_map._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).X i).OpenCover)
(I : (AlgebraicGeometry.Scheme.Pullback.diagonalCover f 𝒰 𝒱).I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp ((𝒱 I.fst).f I.snd.2) (AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 f I.fst))
(𝒰.f I.fst) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp ((𝒱 I.fst).f I.snd.2) (CategoryTheory.Limits.pullback.fst f (𝒰.f I.fst))) f |
StrictConvexOn.rightDeriv_lt_slope | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y : ℝ},
StrictConvexOn ℝ S f →
x ∈ S → y ∈ S → x < y → DifferentiableWithinAt ℝ f (Set.Ioi x) x → derivWithin f (Set.Ioi x) x < slope f x y |
Batteries.RBNode.fold | Batteries.Data.RBMap.Basic | {σ : Sort u_1} → {α : Type u_2} → σ → (σ → α → σ → σ) → Batteries.RBNode α → σ |
CategoryTheory.PreOneHypercover.noConfusionType | Mathlib.CategoryTheory.Sites.Hypercover.One | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
CategoryTheory.PreOneHypercover S →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] → {S' : C'} → CategoryTheory.PreOneHypercover S' → Sort u_1 |
BoundedContinuousFunction.charAlgHom_apply | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : Module ℝ V] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup W] [inst_4 : Module ℝ W] [inst_5 : TopologicalSpace W] {e : AddChar ℝ Circle}
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} {he : Continuous ⇑e} {hL : Continuous fun p => (L p.1) p.2} (w : AddMonoidAlgebra ℂ W)
(v : V), ((BoundedContinuousFunction.charAlgHom he hL) w) v = ∑ a ∈ w.support, w a * ↑(e ((L v) a)) |
CategoryTheory.Limits.Fan.isLimitOfIsIsoPiLift._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] (c : CategoryTheory.Limits.Fan f) (x : β),
c.π.app { as := x } =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.lift (CategoryTheory.Discrete.functor f) c)
(CategoryTheory.Limits.limit.π (CategoryTheory.Discrete.functor f) { as := x }) |
_private.Mathlib.Topology.Order.UpperLowerSetTopology.0.Topology.WithUpperSet.toUpperSet_specializes_toUpperSet._simp_1_1 | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y = (closure {y} ⊆ closure {x}) |
IsCoatom.Ici | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : OrderTop α] {a x : α}, IsCoatom a → ∀ (hax : x ≤ a), IsCoatom ⟨a, hax⟩ |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_3 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a = b) = (a.toNat = b.toNat) |
Lean.DeclarationRanges.noConfusionType | Lean.Data.DeclarationRange | Sort u → Lean.DeclarationRanges → Lean.DeclarationRanges → Sort u |
Std.Internal.instIsStrictCutCompare | Std.Data.Internal.Cut | ∀ {α : Type u} [inst : Ord α] [Std.TransOrd α] {k : α}, Std.Internal.IsStrictCut compare (compare k) |
_private.Mathlib.Data.Set.Prod.0.Set.prod_mono.match_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s₁ : Set α} {t₁ : Set β} (x : α × β) (motive : x ∈ s₁ ×ˢ t₁ → Prop)
(x_1 : x ∈ s₁ ×ˢ t₁), (∀ (h₁ : x.1 ∈ s₁) (h₂ : x.2 ∈ t₁), motive ⋯) → motive x_1 |
TwoSidedIdeal.ext_iff | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {I J : TwoSidedIdeal R}, I = J ↔ ∀ (x : R), x ∈ I ↔ x ∈ J |
Int.lcm_eq_natAbs_right | Init.Data.Int.Gcd | ∀ {a b : ℤ}, a ∣ b → a.lcm b = b.natAbs |
Lean.Compiler.LCNF.LambdaLifting.visitCode | Lean.Compiler.LCNF.LambdaLifting | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.LambdaLifting.LiftM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) |
USize.le_size | Init.Data.UInt.Basic | 2 ^ 32 ≤ USize.size |
ContinuousMap.instCommRingOfIsTopologicalRing._proof_10 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : CommRing β]
[inst_3 : IsTopologicalRing β] (f g : C(α, β)), ⇑(f * g) = ⇑f * ⇑g |
MvQPF.Mcongr | Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {n : ℕ} →
{F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → {α : TypeVec.{u} n} → (MvQPF.P F).M α → (MvQPF.P F).M α → Prop |
Lean.Elab.Tactic.Do.ProofMode.elabMIntro._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMIntro_1 | Lean.Elab.Tactic.Do.ProofMode.Intro | IO Unit |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBNode.Path.ins.match_1.splitter | Batteries.Data.RBMap.Alter | {α : Type u_1} →
(motive : Batteries.RBNode.Path α → Batteries.RBNode α → Sort u_2) →
(x : Batteries.RBNode.Path α) →
(x_1 : Batteries.RBNode α) →
((t : Batteries.RBNode α) → motive Batteries.RBNode.Path.root t) →
((parent : Batteries.RBNode.Path α) →
(y : α) →
(b a : Batteries.RBNode α) → motive (Batteries.RBNode.Path.left Batteries.RBColor.red parent y b) a) →
((a : Batteries.RBNode α) →
(y : α) →
(parent : Batteries.RBNode.Path α) →
(b : Batteries.RBNode α) →
motive (Batteries.RBNode.Path.right Batteries.RBColor.red a y parent) b) →
((parent : Batteries.RBNode.Path α) →
(y : α) →
(b a : Batteries.RBNode α) →
motive (Batteries.RBNode.Path.left Batteries.RBColor.black parent y b) a) →
((a : Batteries.RBNode α) →
(y : α) →
(parent : Batteries.RBNode.Path α) →
(b : Batteries.RBNode α) →
motive (Batteries.RBNode.Path.right Batteries.RBColor.black a y parent) b) →
motive x x_1 |
mdifferentiableOn_iff_differentiableOn | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {f : E → E'}
{s : Set E}, MDiff[s] f ↔ DifferentiableOn 𝕜 f s |
LeftPreLieRing.ext | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {L : Type u_1} {x y : LeftPreLieRing L},
Add.add = Add.add →
Zero.zero = Zero.zero →
AddMonoid.nsmul = AddMonoid.nsmul →
Neg.neg = Neg.neg → Sub.sub = Sub.sub → SubNegMonoid.zsmul = SubNegMonoid.zsmul → Mul.mul = Mul.mul → x = y |
AlgEquiv.toRingHom_trans._simp_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₃ : Type uA₃} [inst : CommSemiring R] [inst_1 : Semiring A₁]
[inst_2 : Semiring A₂] [inst_3 : Semiring A₃] [inst_4 : Algebra R A₁] [inst_5 : Algebra R A₂] [inst_6 : Algebra R A₃]
(e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃), (↑e₂).comp ↑e₁ = ↑(e₁.trans e₂) |
Nat.factorizationLCMRight_zero_right | Mathlib.Data.Nat.Factorization.LCM | ∀ (a : ℕ), a.factorizationLCMRight 0 = 1 |
PadicInt.mahlerEquiv._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], RingHomInvPair (RingHom.id ℤ_[p]) (RingHom.id ℤ_[p]) |
Lean.Server.Test.Runner.setDesynced | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerM Unit |
Std.Roo.isSome_succMany?_of_lt_size_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {i : ℕ}, i < r.toArray.size → (Std.PRange.succMany? (i + 1) r.lower).isSome = true |
Finset.sum_bij | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : AddCommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ),
(∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) →
(∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) →
(∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), i a ha = b) →
(∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) → ∑ x ∈ s, f x = ∑ x ∈ t, g x |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Degenerate.0.SSet.unique_nonDegenerate.map_g_op_y₂ | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk n))} {m₁ m₂ : ℕ}
{f₁ : SimplexCategory.mk n ⟶ SimplexCategory.mk m₁} (hf₁ : CategoryTheory.SplitEpi f₁) {y₁ : ↑(X.nonDegenerate m₁)},
x = X.map f₁.op ↑y₁ →
∀ {f₂ : SimplexCategory.mk n ⟶ SimplexCategory.mk m₂} {y₂ : X.obj (Opposite.op (SimplexCategory.mk m₂))},
x = X.map f₂.op y₂ → X.map (SSet.unique_nonDegenerate.g✝ hf₁ f₂).op y₂ = ↑y₁ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.