name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.biprod.lift_desc_assoc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {T U : C} {f : T ⟶ X} {g : T ⟶ Y} {h : X ⟶ U} {i : Y ⟶ U}
{Z : C} (h_1 : U ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift ... | null | true |
Representation.IsIrreducible.finrank_intertwiningMap_self | Mathlib.RepresentationTheory.Irreducible | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) [ρ.IsIrreducible] [FiniteDimensional k V] [IsAlgClosed k],
Module.finrank k (ρ.IntertwiningMap ρ) = 1 | null | true |
Set.encard_exchange' | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} {a b : α}, a ∉ s → b ∈ s → (insert a s \ {b}).encard = s.encard | null | true |
Std.IterM.dropWhileWithPostcondition | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → (P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)) → Std.IterM m β → Std.IterM m β | *Note: This is a very general combinator that requires an advanced understanding of monads,
dependent types and termination proofs. The variants `dropWhile` and `dropWhileM` are easier to use
and sufficient for most use cases.*
Given an iterator `it` and a monadic predicate `P`, `it.dropWhileWithPostcondition P` is an... | true |
inl_coprodIsoPushout_hom_assoc | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y]
{Z : C}
(h : CategoryTheory.Limits.pushout (CategoryTheory.Limits.initial.to X) (CategoryTheory.Li... | null | true |
CategoryTheory.Bicategory.whiskerLeftIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
(f : a ⟶ b) →
{g h : b ⟶ c} → (g ≅ h) → (CategoryTheory.CategoryStruct.comp f g ≅ CategoryTheory.CategoryStruct.comp f h) | The left whiskering of a 2-isomorphism is a 2-isomorphism. | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.instEvalExprConfig.evalExpr | Lean.Elab.Tactic.Simp | Lean.Expr → Lean.MetaM Lean.Meta.Simp.Config | null | true |
_private.Init.Data.FloatArray.Basic.0.FloatArray.forIn.loop._proof_3 | Init.Data.FloatArray.Basic | ∀ (as : FloatArray) (i : ℕ), as.size - 1 < as.size → as.size - 1 - i < as.size | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.isPointwiseLeftKanExtensionUnit | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
(F G : CategoryTheory.Functor C V) →
[self :... | The transformation `unit` exhibits `F ⊛ G` as a pointwise left Kan extension
of `F ⊠ G` along `tensor C`. | true |
CategoryTheory.ShortComplex.Homotopy.ofEq._proof_10 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂},
φ₁ = φ₂ → φ₁.τ₃ = 0 + CategoryTheory.CategoryStruct.comp 0 S₂.g + φ₂.τ₃ | null | false |
Matrix.self_mul_conjTranspose_mulVec_eq_zero | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : PartialOrder R]
[inst_3 : NonUnitalRing R] [inst_4 : StarRing R] [StarOrderedRing R] [NoZeroDivisors R] (A : Matrix m n R)
(v : m → R), (A * A.conjTranspose).mulVec v = 0 ↔ A.conjTranspose.mulVec v = 0 | null | true |
Rat.le_coe_toNNRat | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ), q ≤ ↑q.toNNRat | null | true |
_private.Init.Grind.Ordered.Rat.0.Lean.Grind.instOrderedAddRat._simp_1 | Init.Grind.Ordered.Rat | ∀ {a b c : ℚ}, (c + a ≤ c + b) = (a ≤ b) | null | false |
IsPrimitiveRoot.integralPowerBasis_dim | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.integralPowerBasis.dim = n.totient | null | true |
curveIntegral | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | {𝕜 : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → {a b : E} → (E → E →L[𝕜] F) → Path a b → F | Integral of a 1-form `ω : E → E →L[𝕜] F` along a path `γ`,
defined as $\int_0^1 \omega(\gamma(t))(\gamma'(t))$.
The actual definition uses `curveIntegralFun` which uses `Path.extend γ`
and `derivWithin (Path.extend γ) (Set.Icc 0 1) t`,
because calculus-related definitions in Mathlib expect globally defined functions ... | true |
CategoryTheory.ObjectProperty.IsVerdierLeftLocalizing.recOn | Mathlib.CategoryTheory.Triangulated.LocalizingSubcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A B : CategoryTheory.ObjectProperty C} →
{motive : A.IsVerdierLeftLocalizing B → Sort u} →
(t : A.IsVerdierLeftLocalizing B) →
((fac :
∀ {X Y : C} (f : X ⟶ Y), A X → B Y → ∃ Z a b, A Z ∧ B Z ∧ CategoryTheory.... | null | false |
Aesop.RulePattern.mk | Aesop.RulePattern | Lean.Meta.AbstractMVarsResult → Array (Option ℕ) → Array (Option ℕ) → Array Lean.Meta.DiscrTree.Key → Aesop.RulePattern | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.formatMarkerShort.match_1 | Std.Time.Format.Basic | (motive : Std.Time.HourMarker → Sort u_1) →
(marker : Std.Time.HourMarker) →
(Unit → motive Std.Time.HourMarker.am) → (Unit → motive Std.Time.HourMarker.pm) → motive marker | null | false |
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.Solution.tensor.match_1.splitter | Mathlib.Algebra.Module.Presentation.Tensor | {A : Type u_5} →
[inst : CommRing A] →
{relations₁ : Module.Relations A} →
{relations₂ : Module.Relations A} →
(motive : (relations₁.tensor relations₂).G → Sort u_6) →
(x : (relations₁.tensor relations₂).G) →
((g₁ : relations₁.G) → (g₂ : relations₂.G) → motive (g₁, g₂)) → motiv... | null | true |
termSudoSet_option___In_ | Mathlib.Tactic.SudoSetOption | Lean.ParserDescr | The command `sudo set_option name val in term` is similar to `set_option name val in term`,
but it also allows to set undeclared options.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_one_add_div_one_sub._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.surjective_π_app_zero_of_surjective_map_aux.match_1_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕᵒᵖ → Sort u_1) → (x : ℕᵒᵖ) → ((n : ℕ) → motive (Opposite.op n)) → motive x | null | false |
String.front_eq | Init.Data.String.Lemmas.Search | ∀ {s : String}, s.front = s.front?.getD default | null | true |
WeierstrassCurve.toCharTwoJNeZeroNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | {F : Type u_2} → [inst : Field F] → (W : WeierstrassCurve F) → W.a₁ ≠ 0 → WeierstrassCurve.VariableChange F | For a `WeierstrassCurve` defined over a field of characteristic = 2,
there is an explicit change of variables of it to `Y² + XY = X³ + a₂X² + a₆`
(`WeierstrassCurve.IsCharTwoJNeZeroNF`) if its j ≠ 0. | true |
Metric.ediam_pi_le_of_le | Mathlib.Topology.EMetricSpace.Diam | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → PseudoEMetricSpace (X i)]
{s : (i : ι) → Set (X i)} {c : ENNReal}, (∀ (b : ι), Metric.ediam (s b) ≤ c) → Metric.ediam (Set.univ.pi s) ≤ c | null | true |
DenseRange.zpow_of_ergodic_mul_left | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[OpensMeasurableSpace G] {μ : MeasureTheory.Measure G} [μ.IsOpenPosMeasure] {g : G},
Ergodic (fun x => g * x) μ → DenseRange fun x => g ^ x | If the left multiplication by `g` is ergodic
with respect to a measure which is positive on nonempty open sets,
then the integer powers of `g` are dense in `G`. | true |
UpperHalfPlane.cuspFunction_smul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ},
ContinuousAt (UpperHalfPlane.cuspFunction h f) 0 →
∀ (a : ℂ), UpperHalfPlane.cuspFunction h (a • f) = a • UpperHalfPlane.cuspFunction h f | null | true |
CategoryTheory.Sigma.descUniq_inv_app | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D)
(q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I)
(... | null | true |
Nat.psub | Mathlib.Data.Nat.PSub | ℕ → ℕ → Option ℕ | Partial subtraction operation. Returns `psub m n = some k`
if `m = n + k`, otherwise `none`. | true |
groupCohomology.isMulCoboundary₁_of_isMulCocycle₁_of_aut_to_units | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
(f : Gal(L/K) → Lˣ), groupCohomology.IsMulCocycle₁ f → groupCohomology.IsMulCoboundary₁ f | Noether's generalization of Hilbert's Theorem 90: given a finite extension of fields and a
function `f : Aut_K(L) → Lˣ` satisfying `f(gh) = g(f(h)) * f(g)` for all `g, h : Aut_K(L)`, there
exists `β : Lˣ` such that `g(β)/β = f(g)` for all `g : Aut_K(L).` | true |
continuousOn_union_iff_of_isOpen | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s t : Set α} {f : α → β},
IsOpen s → IsOpen t → (ContinuousOn f (s ∪ t) ↔ ContinuousOn f s ∧ ContinuousOn f t) | A function is continuous on two open sets iff it is also continuous on their union. | true |
Finmap.lookup_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
Finmap.lookup a s.toFinmap = AList.lookup a s | null | true |
Unitary.mulRight_apply | Mathlib.Analysis.CStarAlgebra.Unitary.Maps | ∀ (R : Type u_1) {A : Type u_2} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : CStarRing A] [inst_3 : Ring R]
[inst_4 : Module R A] [inst_5 : IsScalarTower R A A] (u : ↥(unitary A)) (x : A), (Unitary.mulRight R u) x = x * ↑u | null | true |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.restrict_isLoopAt._simp_1_2 | Mathlib.Combinatorics.Graph.Delete | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Quiver.Path.addWeightOfEPs_cons | Mathlib.Combinatorics.Quiver.Path.Weight | ∀ {V : Type u_1} [inst : Quiver V] {R : Type u_2} [inst_1 : AddMonoid R] (w : V → V → R) {a b c : V}
(p : Quiver.Path a b) (e : b ⟶ c), Quiver.Path.addWeightOfEPs w (p.cons e) = Quiver.Path.addWeightOfEPs w p + w b c | null | true |
PreAbstractSimplicialComplex.instMin | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → Min (PreAbstractSimplicialComplex ι) | The complex consisting of only the faces present in both of its arguments. | true |
AffineSubspace.instNontrivial | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], Nontrivial (AffineSubspace k P) | null | true |
IsStarNormal.recOn | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
[inst : Mul R] →
[inst_1 : Star R] →
{x : R} →
{motive : IsStarNormal x → Sort u} →
(t : IsStarNormal x) → ((star_comm_self : Commute (star x) x) → motive ⋯) → motive t | null | false |
AugmentedSimplexCategory.inl'_eval | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y : SimplexCategory) (i : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom (AugmentedSimplexCategory.inl' x y)) i = Fin.cast ⋯ (Fin.castAdd (y.len + 1) i) | null | true |
Quiver.reverse | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_4} → [inst : Quiver V] → [Quiver.HasReverse V] → {a b : V} → (a ⟶ b) → (b ⟶ a) | Reverse the direction of an arrow. | true |
AffineEquiv.equivLike | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | null | true |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheck.match_12 | Lean.Elab.Quotation.Precheck | (motive : Option String → Sort u_1) →
(x : Option String) → ((text : String) → motive (some text)) → (Unit → motive none) → motive x | null | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.findGoalsAt?.getPositions | Lean.Server.FileWorker.RequestHandling | Lean.Syntax → Option (String.Pos.Raw × String.Pos.Raw × String.Pos.Raw) | null | true |
UpperSet.mem_iInf_iff | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] {a : α} {f : ι → UpperSet α}, a ∈ ⨅ i, f i ↔ ∃ i, a ∈ f i | null | true |
ModularGroup.denom_apply | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g)) ↑z =
↑(↑g 1 0) * ↑z + ↑(↑g 1 1) | null | true |
Nat.lt.base | Init.Data.Nat.Basic | ∀ (n : ℕ), n < n.succ | null | true |
finprod_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {N : Type u_6} [inst : CommMonoid N] {α : Type u_7} {ι : Type u_8} {f : ι → α → N},
Function.HasFiniteMulSupport f → ∀ (a : α), (∏ᶠ (i : ι), f i) a = ∏ᶠ (i : ι), f i a | null | true |
Std.Time.PlainDateTime.toPlainTime | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.PlainTime | Extracts the `PlainTime` component from a `PlainDateTime`.
| true |
Parser.Attr.mfld_simps_proc | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | Simplification procedure | true |
CategoryTheory.RetractArrow.right_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.right.i = h.i.right | null | true |
ENat.floor_le._simp_1 | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal} {n : ℕ∞}, n ≠ ⊤ → (⌊r⌋ₑ ≤ n) = (r < ↑n + 1) | null | false |
Nat.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Nat | IsCompl {n | Even n} {n | Odd n} | null | true |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.Precoverage.RespectsIso.of_forall_exists_iso.match_1_7 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {S : C} {R T : CategoryTheory.Presieve S}
(YR : ⦃Z : C⦄ → (g : Z ⟶ S) → R g → C) (eR : ⦃Z : C⦄ → (g : Z ⟶ S) → (a : R g) → YR g a ≅ Z),
let F :=
{ I₀ := ↑R.uncurry ⊕ ↑T.uncurry, X := fun i => Sum.elim (fun j => YR (↑j).snd ⋯) (fun j => (↑j).fst) i,
... | null | false |
Subspace.orderIsoFiniteCodimDim._proof_5 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ),
Module.Finite K ↥(Submodule.dualAnnihilator ↑⟨Submodule.dualCoannihilator ↑(OrderDual.ofDual W), ⋯⟩) | null | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.evalSimp._regBuiltin.Lean.Elab.Tactic.evalSimp.declRange_3 | Lean.Elab.Tactic.Simp | IO Unit | null | false |
SSet.chainComplexFunctorAdjunction._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.Limits.HasCoproducts C] (n : ℕ) (R : C),
CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun x => R) | null | false |
Metric.eventually_notMem_thickening_of_infEDist_pos | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {E : Set α} {x : α},
x ∉ closure E → ∀ᶠ (δ : ℝ) in nhds 0, x ∉ Metric.thickening δ E | An exterior point of a subset `E` (i.e., a point outside the closure of `E`) is not in the
(open) `δ`-thickening of `E` for small enough positive `δ`. | true |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_term__¹_1» | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro | null | false |
SSet.horn.isCompatible_zero_iff_true._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | ∀ {X : SSet} {i : Fin 2} (f : (j : Fin 2) → j ≠ i → (SSet.stdSimplex.obj { len := 0 } ⟶ X)),
SSet.horn.IsCompatible f = True | null | false |
PosNum.shiftl | Mathlib.Data.Num.Bitwise | PosNum → ℕ → PosNum | Left-shift the binary representation of a `PosNum`. | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.hasBasis_nhds_zero.match_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_2} {R : Type u_1} [inst : Ring R] (motive : TwoSidedIdeal R × (σ →₀ ℕ) → Prop)
(h : TwoSidedIdeal R × (σ →₀ ℕ)), (∀ (I : TwoSidedIdeal R) (d : σ →₀ ℕ), motive (I, d)) → motive h | null | false |
CategoryTheory.Limits.Cone.functoriality.eq_1 | 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),
CategoryTheory.Limits.Cone.functoriality F G =
{ obj := fun A =... | null | true |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.one_sub_eta_logDeriv_eq | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ (z : ℂ) (n : ℕ),
logDeriv (fun x => 1 - ModularForm.eta_q n x) z =
2 * ↑Real.pi * Complex.I * (↑n + 1) * -ModularForm.eta_q n z / (1 - ModularForm.eta_q n z) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_endpoint._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {α : Type u_1} {a b c d : α}, (s(a, b) = s(c, d)) = Sym2.Rel α (a, b) (c, d) | null | false |
CategoryTheory.Over.map_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Over X}
{g : U ⟶ V}, CategoryTheory.Over.Hom.left ((CategoryTheory.Over.map f).map g) = CategoryTheory.Over.Hom.left g | null | true |
MeasureTheory.VectorMeasure.integral_zero_cbm | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (f : X → E) (μ : MeasureTheory.VectorMeasure X F), ∫ᵛ ... | null | true |
_private.Mathlib.Algebra.Group.Prod.0.Prod.instCancelMonoid._simp_3 | Mathlib.Algebra.Group.Prod | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | false |
Std.DTreeMap.Const.getD_ofList_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.ofList l cmp) k fallback = fallback | null | true |
MeasureTheory.weightedSMul_union' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureTheory.weightedSMul μ s + Measu... | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.mkGetLsbD.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | (motive : Option Lean.Expr → Sort u_1) →
(__x : Option Lean.Expr) →
((subProof : Lean.Expr) → motive (some subProof)) → ((x : Option Lean.Expr) → motive x) → motive __x | null | false |
AlgebraicGeometry.IsAffine.casesOn | Mathlib.AlgebraicGeometry.AffineScheme | {X : AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.IsAffine X → Sort u} →
(t : AlgebraicGeometry.IsAffine X) → ((affine : CategoryTheory.IsIso X.toSpecΓ) → motive ⋯) → motive t | null | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVLogicalCache.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → Sort u_1) →
(x : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical)) →
((hit : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → motive (some hit)) →
(Unit → motive none) → motive x | null | false |
Std.ExtDHashMap.Const.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
Std.ExtDHashMap.Const.getD (m₁.union m₂) k fallback =
Std.ExtDHashMap.Const.getD m₂ k (Std.ExtDHashMap.Const.getD m₁ k fallback) | null | true |
Filter.prod_mono_right | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : Filter α) {g₁ g₂ : Filter β}, g₁ ≤ g₂ → f ×ˢ g₁ ≤ f ×ˢ g₂ | null | true |
Lean.Meta.Grind.Order.Weight.casesOn | Lean.Meta.Tactic.Grind.Order.Types | {motive : Lean.Meta.Grind.Order.Weight → Sort u} →
(t : Lean.Meta.Grind.Order.Weight) → ((k : ℤ) → (strict : Bool) → motive { k := k, strict := strict }) → motive t | null | false |
Mathlib.Tactic.AtomM.Recurse.Config.zetaDelta | Mathlib.Util.AtomM.Recurse | Mathlib.Tactic.AtomM.Recurse.Config → Bool | if true, local let variables can be unfolded | true |
Std.DTreeMap.Internal.Impl.insertMin!._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → (k : α) → β k → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey_beq._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α} {a : α}, (o = some a) = ∃ (h : o.isSome = true), o.get h = a | null | false |
Std.Net.SocketAddressV6.mk.noConfusion | Std.Net.Addr | {P : Sort u} →
{addr : Std.Net.IPv6Addr} →
{port : UInt16} →
{addr' : Std.Net.IPv6Addr} →
{port' : UInt16} →
{ addr := addr, port := port } = { addr := addr', port := port' } → (addr = addr' → port = port' → P) → P | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_sum._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Type u_1} (s : Finset α) (f : α → ℝ), ∏ x ∈ s, Real.exp (f x) = Real.exp (∑ x ∈ s, f x) | null | false |
CategoryTheory.Abelian.SpectralObject.zero₂ | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ :... | null | true |
ONote.split._sunfold | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote × ℕ | null | false |
_private.Mathlib.NumberTheory.ModularForms.NormTrace.0.ModularForm.eq_const_of_weight_zero₀._simp_1_6 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
IO.Process.SpawnArgs.inheritEnv._default | Init.System.IO | Bool | null | false |
PartialEquiv.trans' | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → (e : PartialEquiv α β) → (e' : PartialEquiv β γ) → e.target = e'.source → PartialEquiv α γ | Composing two partial equivs if the target of the first coincides with the source of the
second. | true |
IsLocalHomeomorph.localInverseAt_apply_self | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y}
(hf : IsLocalHomeomorph f) {x : X}, ↑(hf.localInverseAt x) (f x) = x | The function `localInverseAt x` sends `f x` back to `x`. | true |
Perfection.instCommSemiring._proof_21 | Mathlib.RingTheory.Perfection | ∀ (R : Type u_1) [inst : CommSemiring R] (p : ℕ) [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (a b : Perfection R p),
a * b = b * a | null | false |
Std.Time.PlainDateTime.instHSubDuration | Std.Time.DateTime | HSub Std.Time.PlainDateTime Std.Time.PlainDateTime Std.Time.Duration | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} → F.PreOneHypercoverDenseData X → CategoryTheory.Limits.MulticospanShape | The shape of the multiforks attached to `data : F.PreOneHypercoverDenseData X`. | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.entryAtIdx?_eq_getElem?._simp_1_3 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b : ℕ}, (compare a b = Ordering.eq) = (a = b) | null | false |
FiberBundleCore.rec | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_5} →
{B : Type u_6} →
[inst : TopologicalSpace B] →
{F : Type u_7} →
[inst_1 : TopologicalSpace F] →
{motive : FiberBundleCore ι B F → Sort u} →
((baseSet : ι → Set B) →
(isOpen_baseSet : ∀ (i : ι), IsOpen (baseSet i)) →
(indexAt : ... | null | false |
Asymptotics.IsEquivalent.mono | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {l : Filter α} {f g : α → β} {l' : Filter α},
Asymptotics.IsEquivalent l' f g → l ≤ l' → Asymptotics.IsEquivalent l f g | null | true |
ArchimedeanOrder.of | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → M ≃ ArchimedeanOrder M | Create a `ArchimedeanOrder` element from the underlying type. | true |
WriterT.uliftable' | Mathlib.Control.ULiftable | {w : Type u_3} →
{w' : Type u_4} →
{m : Type u_3 → Type u_5} →
{m' : Type u_4 → Type u_6} → [ULiftable m m'] → w ≃ w' → ULiftable (WriterT w m) (WriterT w' m') | for specific writer monads, this function helps to create a uliftable instance | true |
ModularFormClass.qExpansion_coeff_unique | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ} {c : ℕ → ℂ},
0 < h →
h ∈ Γ.strictPeriods →
∀ {f : F} [ModularFormClass F Γ k],
(∀ (τ : UpperHalfPlane), HasSum (fun m => c m • Function.Periodic.qParam h ↑τ ^ m) (f τ)) →
∀ (m : ℕ), c m = (Po... | null | true |
USize.ofBitVec.sizeOf_spec | Init.SizeOf | ∀ (toBitVec : BitVec System.Platform.numBits), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec | null | true |
Sylow.noConfusionType | Mathlib.GroupTheory.Sylow | Sort u →
{p : ℕ} →
{G : Type u_1} →
[inst : Group G] → Sylow p G → {p' : ℕ} → {G' : Type u_1} → [inst' : Group G'] → Sylow p' G' → Sort u | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.mkClosureForAux._unsafe_rec | Lean.Elab.MutualDef | Array Lean.FVarId → StateRefT' IO.RealWorld Lean.Elab.Term.MutualClosure.ClosureState Lean.Elab.TermElabM Unit | null | false |
HasCompactMulSupport.list_prod | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_9} {β : Type u_10} [inst : TopologicalSpace α] [inst_1 : Monoid β] {l : List (α → β)},
(∀ f ∈ l, HasCompactMulSupport f) → HasCompactMulSupport l.prod | null | true |
Distribution.IsVanishingOn.disjoint_dsupport | Mathlib.Analysis.Distribution.Support | ∀ {α : Type u_2} {β : Type u_3} {F : Type u_6} {V : Type u_10} [inst : FunLike F α β] [inst_1 : TopologicalSpace α]
[inst_2 : Zero β] [inst_3 : Zero V] {f : F → V} {s : Set α},
Distribution.IsVanishingOn f s → IsOpen s → Disjoint s (Distribution.dsupport f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.