name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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.... | null | true |
MLList.fix?._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → (α → m (Option α)) → α → MLList m α | null | false |
_private.ImportGraph.Shake.Core.0.ImportGraph.Shake.NeedsKind.priv._proof_1 | ImportGraph.Shake.Core | ¬(false = true ∧ false = true) | null | false |
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 | null | false |
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 | null | false |
_private.Mathlib.Data.Holor.0.Holor._aux_Mathlib_Data_Holor___unexpand_Holor_mul_1 | Mathlib.Data.Holor | Lean.PrettyPrinter.Unexpander | null | false |
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) | null | true |
CategoryTheory.Pretriangulated.productTriangle.π._proof_6 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_3}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : Categor... | null | false |
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.leftAdjo... | If each structured arrow category on `G` has an initial object, we have a constructed left adjoint
to `G`.
| true |
_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) | null | false |
Std.Http.Protocol.H1.Reader.mk | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} →
Std.Http.Protocol.H1.Reader.State dir →
ByteArray.Iterator → Std.Http.Protocol.H1.Message.Head dir → ℕ → ℕ → ℕ → Bool → Std.Http.Protocol.H1.Reader dir | null | true |
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 | null | true |
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... | null | true |
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.actionU... | null | true |
Ideal.stabilizerEquiv | Mathlib.RingTheory.Ideal.Pointwise | {M : Type u_1} →
{R : Type u_3} →
[inst : Group M] →
[inst_1 : Semiring R] →
[inst_2 : MulSemiringAction M R] →
{N : Type u_4} →
[inst_3 : Group N] →
[inst_4 : MulSemiringAction N R] →
(I : Ideal R) →
(e : M ≃* N) →
... | Assume that `M` and `N` are isomorphic and act in a compatible way on `R`, then for any
ideal `I` of `R`, the stabilizer of `I` in `M` is isomorphic to the stabilizer of `I` in `N`.
| true |
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 μ... | null | false |
_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) | null | false |
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) | null | true |
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 | null | true |
CategoryTheory.Functor.mapAddGrp | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
... | A finite-product-preserving functor takes additive group objects to additive group objects. | true |
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 | null | true |
UniformSpace.completelyNormalSpace_of_isCountablyGenerated_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] [(uniformity α).IsCountablyGenerated], CompletelyNormalSpace α | null | true |
CategoryTheory.Triangulated.SpectralObject.triangleMap._proof_2 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | null | false |
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.CategoryS... | null | false |
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 =
... | null | true |
CategoryTheory.SubmonoidFunctor.map | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : CategoryTheory.Functor C MonCat}
(self : CategoryTheory.SubmonoidFunctor M) {U V : C} (i : U ⟶ V),
self.obj U ≤ Submonoid.comap (MonCat.Hom.hom (M.map i)) (self.obj V) | For any `i : U ⟶ V`, `M.map i` maps the submonoid `obj U` into the submonoid `obj V`. | true |
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) →
(sdiff_eq_sUnion' : ∀ s ∈ C, ∀ t ∈ C, ∃ I, ↑I ⊆ C ∧ (↑I).PairwiseDisjoint id ∧ s \ t = ⋃₀ ↑I) → motive ⋯) →
(t : MeasureTh... | null | false |
CStarMatrix.instNonUnitalNonAssocRing | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {n : Type u_2} → {A : Type u_5} → [Fintype n] → [NonUnitalNonAssocRing A] → NonUnitalNonAssocRing (CStarMatrix n n A) | null | true |
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) | **Alias** of `Ideal.quotMapEquivTensorQuot`.
---
Let `R` be a commutative ring, `S` be an `R`-algebra, `I` is be ideal of `R`, then `S ⧸ IS` is
isomorphic to `S ⊗[R] (R ⧸ I)` as `S` modules. | true |
_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 | null | false |
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)⁻¹ | The determinant of `f.symm` is the inverse of that of `f` when `f` is a linear equiv. | true |
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₀... | null | true |
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 | Choose a representative of `v : Projectivization K V` in `V`. | true |
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)), a ^ 0 = 1 | null | false |
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 | null | false |
Erased.mk_inj | Init.Data.Erased | ∀ {α : Sort u} {a b : α}, Erased.mk a = Erased.mk b ↔ a = b | null | true |
Lean.Grind.CommRing.instReprPoly.repr._f | Init.Grind.Ring.CommSolver | (x : Lean.Grind.CommRing.Poly) → Lean.Grind.CommRing.Poly.below (motive := fun x => ℕ → Std.Format) x → ℕ → Std.Format | null | false |
Ordinal.one_add_of_omega0_le | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {o : Ordinal.{u_4}}, Ordinal.omega0 ≤ o → 1 + o = o | null | true |
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) | The oriented angle between two nonzero vectors is plus or minus the unoriented angle. | true |
_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) | null | false |
Real.surjOn_log' | Mathlib.Analysis.SpecialFunctions.Log.Basic | Set.SurjOn Real.log (Set.Iio 0) Set.univ | null | true |
LinearEquiv.ofLeftInverse | Mathlib.Algebra.Module.Submodule.Equiv | {R : Type u_1} →
{R₂ : Type u_2} →
{M : Type u_4} →
{M₂ : Type u_6} →
[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₂} →... | A linear map `f : M →ₗ[R] M₂` with a left-inverse `g : M₂ →ₗ[R] M` defines a linear
equivalence between `M` and `f.range`.
This is a computable alternative to `LinearEquiv.ofInjective`, and a bidirectional version of
`LinearMap.rangeRestrict`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array.0._regBuiltin.Array.reduceGetElem.declare_6._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array.697310858._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array | IO Unit | null | false |
Int.toList_roc_eq_singleton_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, (m<...=n).toList = [k] ↔ n = m + 1 ∧ m + 1 = k | null | true |
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 | null | true |
_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 | null | 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 ... | null | true |
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 ... | null | false |
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... | null | false |
PFunctor.M.corecOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type u_2} → X → (X → ↑F X) → F.M | corecursor for `M F` with swapped arguments | true |
Lean.MonadError.toMonadExceptOf | Lean.Exception | {m : Type → Type} → [self : Lean.MonadError m] → MonadExceptOf Lean.Exception m | null | true |
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... | null | true |
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) | null | false |
_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) | null | false |
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) | null | true |
WeakDual.CharacterSpace.homeoEval._proof_1 | Mathlib.Topology.ContinuousMap.Ideals | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 | null | false |
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 | null | true |
_private.Mathlib.Tactic.Simproc.ExistsAndEq.0.ExistsAndEq.proveFromHoisted.match_3 | Mathlib.Tactic.Simproc.ExistsAndEq | (motive : ExistsAndEq.Path → Sort u_1) →
(path : ExistsAndEq.Path) →
(Unit → motive []) →
((tl : List ExistsAndEq.GoTo) → motive (ExistsAndEq.GoTo.andLeft :: tl)) →
((tl : List ExistsAndEq.GoTo) → motive (ExistsAndEq.GoTo.andRight :: tl)) →
((tl : List ExistsAndEq.GoTo) → motive (ExistsAnd... | null | false |
List.finite_toSet | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (l : List α), {x | x ∈ l}.Finite | null | true |
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 | null | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.alts._default | Lean.Elab.Tactic.Induction | Array Lean.Elab.Tactic.ElimApp.Alt | null | false |
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_4}
{N : Type u_5} {M₂ : Type u_9} {N₂ : Type u_11} [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... | Given semilinear maps `f : M → P`, `g : N → Q`, if we identify `M ⊗ N` with `N ⊗ M` and `P ⊗ Q`
with `Q ⊗ P`, then this lemma states that `f ⊗ g = g ⊗ f`. | true |
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.D... | null | true |
String.Slice.skipSuffix?_slice_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat s : String.Slice} {pos : s.Pos}, s.skipSuffix? pat = some pos ↔ ∃ t, pos.Splits t pat.copy | null | true |
CommAlgCat.instMonoidalCategory | Mathlib.Algebra.Category.CommAlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.MonoidalCategory (CommAlgCat R) | null | true |
SimpleGraph.Walk.mem_support_nil_iff | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ∈ SimpleGraph.Walk.nil.support ↔ u = v | null | true |
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 | null | false |
Ordinal.CNF.coeff_zero_right | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_1}), Ordinal.CNF.coeff b 0 = 0 | null | true |
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) ↔
... | null | true |
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) | null | false |
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 | null | true |
Real.toNNReal_coe | Mathlib.Basic.NNReal.Defs | ∀ {r : NNReal}, (↑r).toNNReal = r | null | true |
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 | null | false |
Int.gcd_eq_zero_iff._simp_1 | Init.Data.Int.Gcd | ∀ {a b : ℤ}, (a.gcd b = 0) = (a = 0 ∧ b = 0) | null | false |
Left.one_lt_mul_of_le_of_lt | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftStrictMono α],
b ≤ c → 1 < a → b < c * a | Assumes left covariance.
The lemma assuming right covariance is `Right.one_lt_mul_of_le_of_lt`. | true |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.containsInOrderLower.go._unsafe_rec | Lean.Data.FuzzyMatching | String → String → String.Pos.Raw → String.Pos.Raw → Bool | null | false |
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 ∂μ | null | true |
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.Cat... | null | false |
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 | null | true |
CategoryTheory.Subobject.Classifier.casesOn | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Subobject.Classifier C → Sort u_1} →
(t : CategoryTheory.Subobject.Classifier C) →
((Ω₀ Ω : C) →
(truth : Ω₀ ⟶ Ω) →
(mono_truth : CategoryTheory.Mono truth) →
(χ₀ : (U : C) →... | null | false |
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 | null | false |
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 ℂ... | null | true |
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)
... | null | false |
_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}) | null | false |
IsCoatom.Ici | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : OrderTop α] {a x : α}, IsCoatom a → ∀ (hax : x ≤ a), IsCoatom ⟨a, hax⟩ | null | true |
_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) | null | false |
Lean.DeclarationRanges.noConfusionType | Lean.Data.DeclarationRange | Sort u → Lean.DeclarationRanges → Lean.DeclarationRanges → Sort u | null | false |
Std.Internal.instIsStrictCutCompare | Std.Data.Internal.Cut | ∀ {α : Type u} [inst : Ord α] [Std.TransOrd α] {k : α}, Std.Internal.IsStrictCut compare (compare k) | null | true |
_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 | null | false |
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 | null | true |
Int.lcm_eq_natAbs_right | Init.Data.Int.Gcd | ∀ {a b : ℤ}, a ∣ b → a.lcm b = b.natAbs | null | true |
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) | null | true |
USize.le_size | Init.Data.UInt.Basic | 2 ^ 32 ≤ USize.size | null | true |
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 | Equivalence relation on M-types representing a value of type `Cofix F` | true |
_private.Mathlib.GroupTheory.Congruence.BigOperators.0.AddCon.coe_dfinsuppSumAddHom._simp_1_1 | Mathlib.GroupTheory.Congruence.BigOperators | ∀ {M : Type u_1} [inst : AddZeroClass M] {c : AddCon M}, AddCon.toQuotient = ⇑c.mk' | null | false |
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 | For maps between vector spaces, `MDifferentiableOn` and `DifferentiableOn` coincide | true |
Std.Http.Response.Builder.mk.sizeOf_spec | Std.Http.Data.Response | ∀ (line : Std.Http.Response.Head) (extensions : Std.Http.Extensions),
sizeOf { line := line, extensions := extensions } = 1 + sizeOf line + sizeOf extensions | null | true |
LeftPreLieRing.ext | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {L : Type u_1} {x y : LeftPreLieRing L},
Zero.zero = Zero.zero →
Add.add = Add.add →
NSMul.nsmul = NSMul.nsmul →
Neg.neg = Neg.neg → Sub.sub = Sub.sub → ZSMul.zsmul = ZSMul.zsmul → Mul.mul = Mul.mul → x = y | null | true |
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₂) | null | false |
Nat.factorizationLCMRight_zero_right | Mathlib.Data.Nat.Factorization.LCM | ∀ (a : ℕ), a.factorizationLCMRight 0 = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.