name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.ProgMeasurable.neg | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : MeasurableSpace ι] [inst_3 : AddGroup β]
[ContinuousNeg β], MeasureTheory.IsStronglyProgressive f u → MeasureTheory.IsStronglyProgress... | **Alias** of `MeasureTheory.IsStronglyProgressive.neg`. | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._proof_9 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_2} {L : Type u_4} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing M] [inst_4 : LieAlgebra R M] (E : LieAlgebra.Extension R M L) {s : L →ₗ[R] E.L},
Function.LeftInverse ⇑E.proj ⇑s → ∀ (x y x_1 x_2 : L), ⁅s (x + y), s (x_1 + x_2)⁆ - s ⁅x + y, x_1 + x_2... | null | false |
Std.Sat.CNF.add | Std.Sat.CNF.Basic | {α : Type u_1} → Std.Sat.CNF α → Std.Sat.CNF.Clause α → Std.Sat.CNF α | null | true |
uniformEquicontinuous_iff_uniformContinuous | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {α : Type u_6} {β : Type u_8} [uα : UniformSpace α] [uβ : UniformSpace β] {F : ι → β → α},
UniformEquicontinuous F ↔ UniformContinuous (⇑UniformFun.ofFun ∘ Function.swap F) | A family `𝓕 : ι → β → α` is uniformly equicontinuous iff the function `swap 𝓕 : β → ι → α` is
uniformly continuous *when `ι → α` is equipped with the uniform structure of uniform convergence*.
This is very useful for developing the equicontinuity API, but it should not be used directly
for other purposes. | true |
Std.Net.SocketAddressV6 | Std.Net.Addr | Type | A pair of an `IPv6Addr` and a port.
| true |
Complex.sqrt | Mathlib.Analysis.RCLike.Sqrt | ℂ → ℂ | The square root of a complex number. | true |
Subgroup.leftTransversals.diff.eq_1 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {A : Type u_2} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
(S T : H.LeftTransversal) [inst_2 : H.FiniteIndex],
Subgroup.leftTransversals.diff ϕ S T = ∏ q, ϕ ⟨(↑(⋯.leftQuotientEquiv q))⁻¹ * ↑(⋯.leftQuotientEquiv q), ⋯⟩ | null | true |
List.zipRight'_cons_cons | Mathlib.Data.List.Map2 | ∀ {α : Type u} {β : Type v} (a : α) (as : List α) (b : β) (bs : List β),
(a :: as).zipRight' (b :: bs) =
have r := as.zipRight' bs;
((some a, b) :: r.1, r.2) | null | true |
CategoryTheory.MorphismProperty.Under.Hom.mk_hom | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T} {X : T}
[inst_1 : Q.IsMultiplicative] {A B : P.Under Q X}
(f :
(CategoryTheory.MorphismProperty.Under.forget P Q X).obj A ⟶
(CategoryTheory.MorphismProperty.Under.forget P Q X).obj B)
(hf : Q (Catego... | null | true |
Array.insertIdx_comm._proof_2 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {i j : ℕ} {xs : Array α}, i ≤ j → j ≤ xs.size → i ≤ xs.size | null | false |
Set.decidableInter | Mathlib.Data.Set.Basic | {α : Type u} → (s t : Set α) → (a : α) → [Decidable (a ∈ s)] → [Decidable (a ∈ t)] → Decidable (a ∈ s ∩ t) | null | true |
ModuleCat.carrier | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} → [inst : Ring R] → ModuleCat R → Type v | the underlying type of an object in `ModuleCat R` | true |
MulOpposite.instField._proof_9 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Field α] (q : ℚ≥0) (a : αᵐᵒᵖ), DivisionRing.nnqsmul q a = ↑q * a | null | false |
LE.le.isCofinalFor | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, s ⊆ t → IsCofinalFor s t | **Alias** of `IsCofinalFor.of_subset`. | true |
Std.DHashMap.modify.congr_simp | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (m m_1 : Std.DHashMap α β),
m = m_1 → ∀ (a : α) (f f_1 : β a → β a), f = f_1 → m.modify a f = m_1.modify a f_1 | null | true |
TrivialLieModule.instAddCommGroup._proof_21 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M],
autoParam (∀ (n : ℕ) (a : TrivialLieModule R L M), Int.negSucc n • a = -(↑n.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
derivWithin_neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) (s : Set 𝕜),
UniqueDiffWithinAt 𝕜 s x → derivWithin Neg.neg s x = -1 | null | true |
IsExtreme.left_mem_of_mem_openSegment | Mathlib.Analysis.Convex.Extreme | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {A B : Set E},
IsExtreme 𝕜 A B → ∀ ⦃x : E⦄, x ∈ A → ∀ ⦃y : E⦄, y ∈ A → ∀ ⦃z : E⦄, z ∈ B → z ∈ openSegment 𝕜 x y → x ∈ B | null | true |
List.Vector.getElem_def._proof_1 | Mathlib.Data.Vector.Defs | ∀ {α : Type u_1} {n : ℕ} (v : List.Vector α n) (i : ℕ) {hi : i < n}, i < v.toList.length | null | false |
collinear_iff_exists_forall_eq_smul_vadd | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P), Collinear k s ↔ ∃ p₀ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀ | A set of points is collinear if and only if they can all be
expressed as multiples of the same vector, added to the same base
point. | true |
_private.Lean.Data.Lsp.Diagnostics.0.Lean.Lsp.instBEqPublishDiagnosticsParams.beq.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Lsp.PublishDiagnosticsParams → Lean.Lsp.PublishDiagnosticsParams → Sort u_1) →
(x x_1 : Lean.Lsp.PublishDiagnosticsParams) →
((a : Lean.Lsp.DocumentUri) →
(a_1 : Option ℤ) →
(a_2 : Option Bool) →
(a_3 : Array Lean.Lsp.Diagnostic) →
(b : Lean.Lsp.DocumentU... | null | false |
GradedRingHom.coe_mul._simp_1 | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_6} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} (f g : 𝒜 →+*ᵍ 𝒜),
⇑f ∘ ⇑g = ⇑(f * g) | null | false |
_private.Lean.Elab.Tactic.Doc.0.Lean.Elab.Tactic.Doc.elabPrintTacTags._regBuiltin.Lean.Elab.Tactic.Doc.elabPrintTacTags.declRange_5 | Lean.Elab.Tactic.Doc | IO Unit | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.c._default | Std.Time.Format.Basic | Option Std.Time.Weekday | null | false |
Lean.Lsp.ClientCapabilities.lean? | Lean.Data.Lsp.Capabilities | Lean.Lsp.ClientCapabilities → Option Lean.Lsp.LeanClientCapabilities | Capabilities for Lean language server extensions. | true |
IntermediateField.finrank_fixedField_eq_card | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (H : Subgroup Gal(E/F))
[FiniteDimensional F E], Module.finrank (↥(IntermediateField.fixedField H)) E = Nat.card ↥H | null | true |
CategoryTheory.instMonoidalFunctorFunctorCongrLeft._proof_8 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
[inst_3 : CategoryTheory.MonoidalCategory E] (e : C ≌ D),
autoParam
(∀ (X : CategoryTheory.Functor C E),
(CategoryT... | null | false |
DividedPowers.OfInvertibleFactorial.dpow_comp | Mathlib.RingTheory.DividedPowers.RatAlgebra | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} [inst_1 : DecidablePred fun x => x ∈ I] {n : ℕ},
IsUnit ↑(n - 1).factorial →
I ^ n = 0 →
∀ {m k : ℕ},
k ≠ 0 →
∀ {x : A},
x ∈ I →
DividedPowers.OfInvertibleFactorial.dpow I m (DividedPowers.OfInvertibleFactoria... | null | true |
_private.Mathlib.Order.Filter.Ultrafilter.Defs.0.Ultrafilter.bind._simp_2 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {f : Ultrafilter α} {s : Set α}, (s ∉ f) = (sᶜ ∈ f) | null | false |
Matrix.blockDiag'_blockDiagonal' | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_11} [inst : Zero α] [inst_1 : DecidableEq o]
(M : (i : o) → Matrix (m' i) (n' i) α), (Matrix.blockDiagonal' M).blockDiag' = M | null | true |
PresheafOfModules.forgetToPresheafModuleCatObjMap._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ)
(hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) {Y Z : Cᵒᵖ} (f : Y ⟶ Z)
(x y : ↑(PresheafOfModules.forgetToPresheafModuleCatObjObj X hX M Y)),
(CategoryTheory.ConcreteCategory.hom (... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.dblU_smul._simp_1_6 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar._aux_Mathlib_Tactic_ReduceModChar___elabRules_Tactic_ReduceModChar_reduce_mod_char!_1.unsafe_impl_2 | Mathlib.Tactic.ReduceModChar | Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Lean.Elab.Tactic.TacticM Unit | null | false |
_private.Mathlib.Analysis.InnerProductSpace.TensorProduct.0.TensorProduct.inner_definite | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x : TensorProduct 𝕜 E F), inner 𝕜 x x = 0 → x = 0 | null | true |
Num.pos.inj | Mathlib.Data.Num.Basic | ∀ {a a_1 : PosNum}, Num.pos a = Num.pos a_1 → a = a_1 | null | true |
Complex.norm_cpow_eq_rpow_re_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ}, 0 < x → ∀ (y : ℂ), ‖↑x ^ y‖ = x ^ y.re | null | true |
DiffContOnCl.circleAverage_smul_div | Mathlib.Analysis.Complex.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {R : ℝ}
{c w : ℂ},
DiffContOnCl ℂ f (Metric.ball c |R|) →
w ∈ Metric.ball c |R| → Real.circleAverage (fun z => ((z - c) / (z - w)) • f z) c R = f w | The **Generalized Mean Value Property** of complex differentiable functions: If `f : ℂ → E` is
complex differentiable at all points of a closed disc of radius `R` and center `c`, then for every
point `w` in the disk, the circle average `circleAverage (fun z ↦ ((z - c) * (z - w)⁻¹) • f z) c R`
equals `f w`.
| true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_mul_eq_sum_sum._proof_1_8 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (N n : ℕ), 0 < n ∧ n ≤ N → 0 < n | null | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso_inv_τ₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.constToList_eq._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 |
Lean.InductiveVal.mk._flat_ctor | Lean.Declaration | Lean.Name →
List Lean.Name → Lean.Expr → ℕ → ℕ → List Lean.Name → List Lean.Name → ℕ → Bool → Bool → Bool → Lean.InductiveVal | null | false |
MulAction.fixedPoints_of_subsingleton | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] [Subsingleton α],
MulAction.fixedPoints G α = Set.univ | null | true |
Std.DTreeMap.Internal.Impl.getKey?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[Std.LawfulEqOrd α], t.WF → ∀ {k : α}, k ∈ t → t.getKey? k = some k | null | true |
LieModule.Weight.toLinear_apply | Mathlib.Algebra.Lie.Weights.Linear | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : LieModule.LinearWeights R L M] (χ : LieModule.Weight R ... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'} (k : ℕ),
p₁.support.length + k ≤ p₂.support.length → ∀ i < p₁.darts.length, k + i < p₂.darts.length | null | false |
Std.Time.instHSubOffsetOffset_10 | Std.Time.Date.Basic | HSub Std.Time.Millisecond.Offset Std.Time.Day.Offset Std.Time.Millisecond.Offset | null | true |
Std.ExtDHashMap.Const.mem_unitOfList._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α} {k : α},
(k ∈ Std.ExtDHashMap.Const.unitOfList l) = (l.contains k = true) | null | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.Tableau.casesOn | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {matType : ℕ → ℕ → Type} →
[inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
{motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.Tableau matType → Sort u} →
(t : Mathlib.Tactic.Linarith.SimplexAlgorithm.Tableau matType) →
((basic free : Array ℕ) →
(mat :... | null | false |
MeasureTheory.Measure.InnerRegularCompactLTTop | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} → [inst : MeasurableSpace α] → [TopologicalSpace α] → MeasureTheory.Measure α → Prop | A measure `μ` is inner regular for finite measure sets with respect to compact sets:
for any measurable set `s` with finite measure, then `μ(s) = sup {μ(K) | K ⊆ s compact}`.
The main interest of this class is that it is satisfied for both natural Haar measures (the
regular one and the inner regular one). | true |
AddOreLocalization.oreSub.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {X : Type u_2}
[inst_2 : AddAction R X] (r : X) (s : ↥S), r -ₒ s = Quotient.mk' (r, s) | null | true |
_private.Mathlib.NumberTheory.ModularForms.LFunction.0.ModularForm.tendsto_ofComplex_I_mul_atTop_atImInfty | Mathlib.NumberTheory.ModularForms.LFunction | Filter.Tendsto (fun t => ↑UpperHalfPlane.ofComplex (Complex.I * ↑t)) Filter.atTop UpperHalfPlane.atImInfty | null | true |
CategoryTheory.Limits.Cofan.isColimitEquivOfEquiv.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) {f : γ → C}
(c : CategoryTheory.Limits.Cofan f),
CategoryTheory.Limits.Cofan.isColimitEquivOfEquiv ε c =
CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv (CategoryTheory.Discrete.equivalence ε) | null | true |
CategoryTheory.RelCat.Hom.ofRel.noConfusion | Mathlib.CategoryTheory.Category.RelCat | {X Y : CategoryTheory.RelCat} →
{P : Sort u_1} → {rel rel' : SetRel X Y} → { rel := rel } = { rel := rel' } → (rel ≍ rel' → P) → P | null | false |
instDistribPNat._proof_2 | Mathlib.Data.PNat.Basic | ∀ (a b c : ℕ+), (a + b) * c = a * c + b * c | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.syntheticHole._regBuiltin.Lean.Parser.Term.syntheticHole_1 | Lean.Parser.Term.Basic | IO Unit | null | false |
CategoryTheory.Abelian.SpectralObject.cyclesMap._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {ι : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} ι] {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι}
(f' : i' ⟶ j') (g' : j' ⟶ k')
(α : CategoryTheory.ComposableArrows.mk₂ f g ⟶ CategoryTheory.ComposableArrows.mk₂ f' g'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₂ ... | null | false |
CategoryTheory.Limits.sigmaComparison_map_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : β → C)
[inst_2 : CategoryTheory.Limits.HasCoproduct f] [inst_3 : CategoryTheory.Limits.HasCoproduct fun b => G.obj (f b)]
(P : C) (g : (j : β) → f... | null | true |
_private.Mathlib.Algebra.Polynomial.Homogenize.0.Polynomial.homogenize_finsetProd._simp_1_1 | Mathlib.Algebra.Polynomial.Homogenize | ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s) (p : α → Prop),
(∀ x ∈ Finset.cons a s h, p x) = (p a ∧ ∀ x ∈ s, p x) | null | false |
Lean.Meta.SimpAll.State.ctorIdx | Lean.Meta.Tactic.Simp.SimpAll | Lean.Meta.SimpAll.State → ℕ | null | false |
Vector.contains_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a : α} [inst : BEq α], #v[].contains a = false | null | true |
AlgebraicGeometry.etale_iff | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.Etale f ↔
∀ {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ {V : X.Opens},
AlgebraicGeometry.IsAffineOpen V →
∀ (e : V ≤ (TopologicalSpace.Opens.map f.base).obj U),
(CommRingCat.Hom.hom (Algebra... | null | true |
ContextFreeGrammar.derives_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u v : List (Symbol T g.NT)},
g.reverse.Derives u.reverse v.reverse ↔ g.Derives u v | null | true |
Lean.Meta.Grind.SplitCandidateAnchors.mk.inj | Lean.Meta.Tactic.Grind.Split | ∀ {candidates : Array Lean.Meta.Grind.SplitCandidateWithAnchor} {numDigits : ℕ}
{candidates_1 : Array Lean.Meta.Grind.SplitCandidateWithAnchor} {numDigits_1 : ℕ},
{ candidates := candidates, numDigits := numDigits } = { candidates := candidates_1, numDigits := numDigits_1 } →
candidates = candidates_1 ∧ numDigi... | null | true |
_private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.mulMon.go._sunfold | Init.Data.Nat.Internal.SOM | ℕ → Nat.Internal.SOM.Mon → Nat.Internal.SOM.Poly → Nat.Internal.SOM.Poly → Nat.Internal.SOM.Poly | null | false |
CochainComplex.cm5b.p._proof_1 | Mathlib.Algebra.Homology.Factorizations.CM5b | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (K : CochainComplex C ℤ),
HomologicalComplex.HasHomotopyCofiber (CategoryTheory.CategoryStruct.id (CochainComplex.cm5b.I K)) | null | false |
HahnSeries.cardSuppLTSubring._proof_5 | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ (Γ : Type u_1) (R : Type u_2) (κ : Cardinal.{u_1}) [inst : PartialOrder Γ] [inst_1 : Ring R]
[hκ : Fact (Cardinal.aleph0 ≤ κ)] {x : HahnSeries Γ R},
x ∈ (HahnSeries.cardSuppLTAddSubgroup Γ R κ).carrier → -x ∈ (HahnSeries.cardSuppLTAddSubgroup Γ R κ).carrier | null | false |
Finset.biUnion_filter_eq_of_maps_to | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] {s : Finset α} {t : Finset β}
{f : α → β}, (∀ x ∈ s, f x ∈ t) → (t.biUnion fun a => {c ∈ s | f c = a}) = s | null | true |
AntisymmRel.le_congr | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c d : α} [inst : Preorder α],
AntisymmRel (fun x1 x2 => x1 ≤ x2) a b → AntisymmRel (fun x1 x2 => x1 ≤ x2) c d → (a ≤ c ↔ b ≤ d) | null | true |
Aesop.Goal.instHashable | Aesop.Tree.Data | Hashable Aesop.Goal | null | true |
String.isEmpty_iff._simp_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, (s.isEmpty = true) = (s = "") | null | false |
Aesop.SlotIndex.casesOn | Aesop.Forward.SlotIndex | {motive : Aesop.SlotIndex → Sort u} → (t : Aesop.SlotIndex) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t | null | false |
MvPFunctor.WPath.child.injEq | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} {P : MvPFunctor.{u} (n + 1)} (a : P.A) (f : P.last.B a → P.last.W) (i : Fin2 n) (j : P.last.B a)
(c : P.WPath (f j) i) (j_1 : P.last.B a) (c_1 : P.WPath (f j_1) i),
(MvPFunctor.WPath.child a f i j c = MvPFunctor.WPath.child a f i j_1 c_1) = (j = j_1 ∧ c ≍ c_1) | null | true |
le_smul_of_one_le_left | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Monoid α] [inst_1 : Zero β] [inst_2 : MulAction α β]
[inst_3 : Preorder α] [inst_4 : Preorder β] [SMulPosMono α β], 0 ≤ b → 1 ≤ a → b ≤ a • b | null | true |
MvPolynomial.coeff_rename_embDomain | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (f : σ ↪ τ) (φ : MvPolynomial σ R) (d : σ →₀ ℕ),
((MvPolynomial.rename ⇑f) φ).coeff (Finsupp.embDomain f d) = φ.coeff d | null | true |
le_of_not_gt | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, ¬b < a → a ≤ b | null | true |
Lean.Meta.Sym.Config.enforceUnfoldReducible._default | Lean.Meta.Sym.SymM | Bool | null | false |
tensorKaehlerQuotKerSqEquiv._proof_1 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
Function.LeftInverse
(⇑(TensorProduct.AlgebraTensorModule.lift
((LinearMap.ringLmapEquivSelf... | null | false |
_private.Init.Prelude.0.Bool.ne_true_of_eq_false.match_1_1 | Init.Prelude | ∀ (motive : (x : Bool) → x = false → Prop) (x : Bool) (x_1 : x = false),
(∀ (h : true = false), motive true h) → (∀ (x : false = false), motive false x) → motive x x_1 | null | false |
isPrimePow_nat_iff_bounded_log | Mathlib.Algebra.IsPrimePow | ∀ (n : ℕ), IsPrimePow n ↔ ∃ k ≤ Nat.log 2 n, 0 < k ∧ ∃ p ≤ n, n = p ^ k ∧ Nat.Prime p | null | true |
RelSeries.append_length | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p q : RelSeries r) (connect : (p.last, q.head) ∈ r),
(p.append q connect).length = p.length + q.length + 1 | null | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_inf_le_add._proof_1_6 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ (l₁ l₂ i j : ℕ), (i, j).1 + (i, j).2 = l₁ + l₂ → l₁ ≤ i ∨ l₂ ≤ j | null | false |
Lean.Lsp.LeanModuleHierarchyImportedByParams | Lean.Data.Lsp.Extra | Type | `$/lean/moduleHierarchy/importedBy` client->server request.
Response type: `Array LeanImport`
| true |
_private.Mathlib.CategoryTheory.Discrete.SumsProducts.0.CategoryTheory.Discrete.sumEquiv.match_1.eq_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} (motive : J ⊕ K → Sort u_3) (j : J) (h_1 : (j : J) → motive (Sum.inl j))
(h_2 : (k : K) → motive (Sum.inr k)),
(match Sum.inl j with
| Sum.inl j => h_1 j
| Sum.inr k => h_2 k) =
h_1 j | null | true |
EReal.liminf_mul_le | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_3} {f : Filter α} {u v : α → EReal} [f.NeBot],
0 ≤ᶠ[f] u →
0 ≤ᶠ[f] v →
Filter.limsup u f ≠ 0 ∨ Filter.liminf v f ≠ ⊤ →
Filter.limsup u f ≠ ⊤ ∨ Filter.liminf v f ≠ 0 → Filter.liminf (u * v) f ≤ Filter.limsup u f * Filter.liminf v f | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.isClosedEmbedding_comap_fst._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), IsClosed (PrimeSpectrum.zeroLocus s) = True | null | false |
TopologicalSpace.Clopens.instBooleanAlgebra._proof_9 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x : TopologicalSpace.Clopens α), ⊤ ≤ x ⊔ xᶜ | null | false |
_private.Init.Data.List.Nat.Sum.0.List.sum_eq_foldl_nat._simp_1_1 | Init.Data.List.Nat.Sum | ∀ {α : Type u} [inst : Add α] [inst_1 : Zero α] {l : List α}, List.foldr (fun x1 x2 => x1 + x2) 0 l = l.sum | null | false |
Complex.norm_mul_sin_arg | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (x : ℂ), ‖x‖ * Real.sin x.arg = x.im | null | true |
Lean.Widget.MsgEmbed.goal | Lean.Widget.InteractiveDiagnostic | Lean.Widget.InteractiveGoal → Lean.Widget.MsgEmbed | An interactive goal display. | true |
IsCoveringMap.liftPathQuotient._proof_4 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) {x y : X} (e : ↑(p ⁻¹' {x})) (he : ∀ (γ : Path x y), γ 0 = p ↑e) (γ γ' : Path x y),
γ ≈ γ' →
(fun γ => Path.Homotopic.Quotient.mk { toContinuousMap := cov.liftPath ↑γ ↑e ⋯, source' := ⋯,... | null | false |
CategoryTheory.Sheaf.imageι | Mathlib.CategoryTheory.Sites.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{F F' : CategoryTheory.Sheaf J (Type w)} → (f : F ⟶ F') → CategoryTheory.Sheaf.image f ⟶ F' | The inclusion of the image sheaf to the target. | true |
Lean.Meta.Grind.ENode.hasLambdas | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENode → Bool | `hasLambdas := true` if the equivalence class contains lambda expressions. | true |
_private.Init.Data.Fin.Lemmas.0.Fin.subsingleton_iff_le_one.match_1_5 | Init.Data.Fin.Lemmas | ∀ (motive : Fin 1 → Prop) (x : Fin 1), (∀ (isLt : 0 < 1), motive ⟨0, isLt⟩) → motive x | null | false |
Float.Model.UnpackedFloat.ofScientific._proof_4 | Init.Data.Float.Model.Unpacked.Operations.OfScientific | ∀ (m : ℕ), ¬m = 0 → 0 < m | null | false |
Finset.prod_map_toList | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (s : Finset ι) (f : ι → M), (List.map f s.toList).prod = s.prod f | null | true |
HomotopyGroup.homotopyGroupOfUniqueMulEquivFundamentalGroup | Mathlib.Topology.Homotopy.HomotopyGroup | {X : Type u_2} →
[inst : TopologicalSpace X] →
{x : X} → (N : Type u_3) → [inst_1 : Unique N] → HomotopyGroup N X x ≃* FundamentalGroup X x | The homotopy group at `x` indexed by a singleton is isomorphic to the fundamental group,
i.e. the loops based at `x` up to homotopy. | true |
Std.Iterators.Productive.recOn | Init.Data.Iterators.Basic | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{motive : Std.Iterators.Productive α m → Sort u} →
(t : Std.Iterators.Productive α m) →
((wf : WellFounded Std.IterM.IsPlausibleSkipSuccessorOf) → motive ⋯) → motive t | null | false |
OrderDual.instOrderTopOfOrderBot.eq_1 | Mathlib.Order.BoundedOrder.Basic | ∀ (α : Type u) [inst : LE α] [h : OrderBot α],
OrderDual.instOrderTopOfOrderBot α = { toTop := OrderDual.instTopOfBot α, le_top := ⋯ } | null | true |
Unitization.complex_cfcₙ_eq_cfc_inr | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (a : A) (f : ℂ → ℂ),
autoParam (f 0 = 0) Unitization.complex_cfcₙ_eq_cfc_inr._auto_1 → ↑(cfcₙ f a) = cfc f ↑a | null | true |
Inclusion.Interval.abs | Mathlib.Tactic.Inclusion.Extension.Interval | {α : Type u_1} → [Zero α] → [Neg α] → [LinearOrder α] → Inclusion.Interval α → Inclusion.Interval α | Take the absolute value of an interval. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.