name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Determinant.Cert.casesOn | Mathlib.Tactic.Determinant.Bird.Cert | {u : Lean.Level} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{motive : Mathlib.Tactic.Determinant.Cert rα → Sort u} →
(t : Mathlib.Tactic.Determinant.Cert rα) →
({subject : Q(«$α»)} →
(result : Mathlib.Tactic.Determinant.CertResult rα subject) →
(isZero : Bo... | null | false |
CompositionAsSet.mk.noConfusion | Mathlib.Combinatorics.Enumerative.Composition | {n : ℕ} →
{P : Sort u} →
{boundaries : Finset (Fin n.succ)} →
{zero_mem : 0 ∈ boundaries} →
{getLast_mem : Fin.last n ∈ boundaries} →
{boundaries' : Finset (Fin n.succ)} →
{zero_mem' : 0 ∈ boundaries'} →
{getLast_mem' : Fin.last n ∈ boundaries'} →
... | null | false |
LinearMap.lsum._proof_1 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u_4) {M : Type u_2} {ι : Type u_3} [inst : Semiring R] (φ : ι → Type u_1)
[inst_1 : (i : ι) → AddCommMonoid (φ i)] [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : AddCommMonoid M]
[inst_4 : Module R M] [inst_5 : Fintype ι] (f g : (i : ι) → φ i →ₗ[R] M),
∑ i, (f + g) i ∘ₗ LinearMap.proj i = ∑ i, f i ∘ₗ L... | null | false |
Bundle.contMDiffAt_section | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_7} [inst_5 : NormedAddCommG... | Characterization of `C^n` sections of a vector bundle. | true |
SimpleGraph.insert_neighborFinset_eq_univ | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableEq V] [inst_2 : DecidableRel G.Adj] (v : V),
insert v (G.neighborFinset v) = Finset.univ ↔ G.IsUniversal v | null | true |
LinearMap.intrinsicStar_eq_comp | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u_5} {E : Type u_6} {F : Type u_7} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid E]
[inst_3 : StarAddMonoid E] [inst_4 : Module R E] [inst_5 : StarModule R E] [inst_6 : AddCommMonoid F]
[inst_7 : StarAddMonoid F] [inst_8 : Module R F] [inst_9 : StarModule R F] (f : WithConv (E →ₗ... | null | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension._aux_Mathlib_RingTheory_Valuation_Extension___macroRules__private_Mathlib_RingTheory_Valuation_Extension_0_Valuation_HasExtension_termL₀_1 | Mathlib.RingTheory.Valuation.Extension | Lean.Macro | null | false |
ProfiniteGrp.ProfiniteCompletion.quotientMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | {G : GrpCat} →
{P : ProfiniteGrp.{u}} →
(f : G ⟶ GrpCat.of ↑P.toProfinite.toTop) →
(H : OpenNormalSubgroup ↑P.toProfinite.toTop) →
FiniteGrp.of (↑G ⧸ (ProfiniteGrp.ProfiniteCompletion.preimage f H).toSubgroup) ⟶
FiniteGrp.of (↑P.toProfinite.toTop ⧸ ↑H.toOpenSubgroup) | The induced map on finite quotients coming from a morphism to `P`. | true |
String.Slice.Pos.ne_endPos_of_lt | Init.Data.String.Basic | ∀ {s : String.Slice} {p q : s.Pos}, p < q → p ≠ s.endPos | null | true |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement | Mathlib.Geometry.Manifold.Submersion | {𝕜 : Type u_1} →
{E'' : Type u_3} →
{F : Type u_5} →
{H : Type u_7} →
{G : Type u_9} →
{E : Type u} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGr... | null | true |
LieSubmodule.lieSpan_eq_bot_iff | Mathlib.Algebra.Lie.Submodule | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {s : Set M}, LieSubmodule.lieSpan R L s = ⊥ ↔ ∀ m ∈ s, m = 0 | null | true |
CategoryTheory.ShortComplex.SnakeInput.Hom.mk.inj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Abelian C}
{S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} {f₀ : S₁.L₀ ⟶ S₂.L₀} {f₁ : S₁.L₁ ⟶ S₂.L₁} {f₂ : S₁.L₂ ⟶ S₂.L₂}
{f₃ : S₁.L₃ ⟶ S₂.L₃}
{comm₀₁ :
autoParam (CategoryTheory.CategoryStruct.comp f₀ S₂.v₀₁ = Category... | null | true |
Std.ExtHashMap.getD_insert_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback v : β}, (m.insert k v).getD k fallback = v | null | true |
Lean.Meta.Config.transparency._default | Lean.Meta.Basic | Lean.Meta.TransparencyMode | null | false |
Finset.subtype._proof_2 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α) (x x_1 : ↥(Finset.filter p s)),
⟨↑x, ⋯⟩ = ⟨↑x_1, ⋯⟩ → x = x_1 | null | false |
OrderType.inductionOn | Mathlib.Order.Types.Defs | ∀ {C : OrderType.{u_1} → Prop} (o : OrderType.{u_1}),
(∀ (α : Type u_1) [inst : LinearOrder α], C (OrderType.type α)) → C o | `Quotient.inductionOn` specialized to `OrderType`. | true |
Int64.ofIntClamp_int16ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int16), Int64.ofIntClamp x.toInt = x.toInt64 | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_Ico_le_integral_of_le._proof_1_5 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), ↑a ≤ ↑i ∧ ↑i + 1 ≤ ↑b → Set.Ico ↑i ↑(i + 1) ⊆ Set.Ico ↑a ↑b | null | false |
smoothSheafGroup._proof_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
MvPolynomial.homogeneousComponent_eq_self | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {n : ℕ} {p : MvPolynomial σ R},
p.IsHomogeneous n → (MvPolynomial.homogeneousComponent n) p = p | null | true |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Eval.0.Polynomial.sub_one_pow_totient_lt_cyclotomic_eval._simp_1_5 | Mathlib.RingTheory.Polynomial.Cyclotomic.Eval | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
Std.DHashMap.contains_of_contains_erase | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α}, (m.erase k).contains a = true → m.contains a = true | null | true |
SchwartzMap.noConfusionType | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | Sort u →
{E : Type u_5} →
{F : Type u_6} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
SchwartzMap E F →
{E' : Type u_5} →
{F' : Type u_6} →
... | null | false |
Finset.insert_sdiff_insert | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α) (x : α), insert x s \ insert x t = s \ insert x t | null | true |
MeromorphicAt.eventually_eq_zero_or_eventually_ne_zero | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {z₀ : 𝕜},
MeromorphicAt f z₀ → (∀ᶠ (z : 𝕜) in nhdsWithin z₀ {z₀}ᶜ, f z = 0) ∨ ∀ᶠ (z : 𝕜) in nhdsWithin z₀ {z₀}ᶜ, f z ≠ 0 | Analogue of the principle of isolated zeros for an analytic function: if a function is
meromorphic at `z₀`, then either it is identically zero in a punctured neighborhood of `z₀`, or it
does not vanish there at all. | true |
Finset.sum_range_add_sub_sum_range | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {G : Type u_3} [inst : AddCommGroup G] (f : ℕ → G) (n m : ℕ),
∑ k ∈ Finset.range (n + m), f k - ∑ k ∈ Finset.range n, f k = ∑ k ∈ Finset.range m, f (n + k) | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodySum_volume._simp_1_8 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {ι : Type u_1} {G : Type u_5} {s : Finset ι} [inst : SubtractionCommMonoid G] (f : ι → G),
-∑ x ∈ s, f x = ∑ x ∈ s, -f x | null | false |
List.mem_dedup._simp_1 | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {l : List α}, (a ∈ l.dedup) = (a ∈ l) | null | false |
Turing.ToPartrec.instDecidableEqCode.decEq._unsafe_rec | Mathlib.Computability.TuringMachine.Config | (x x_1 : Turing.ToPartrec.Code) → Decidable (x = x_1) | null | false |
CategoryTheory.PreGaloisCategory.mulAction_naturality | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat) {X Y : C}
(σ : CategoryTheory.Aut F) (f : X ⟶ Y) (x : (F.obj X).obj),
σ • (CategoryTheory.ConcreteCategory.hom (F.map f)) x = (CategoryTheory.ConcreteCategory.hom (F.map f)) (σ • x) | null | true |
Lean.mkLambda | Lean.Expr | Lean.Name → Lean.BinderInfo → Lean.Expr → Lean.Expr → Lean.Expr | `.lam x t b bi` is now the preferred form.
| true |
Lean.Parser.FirstTokens.merge | Lean.Parser.Types | Lean.Parser.FirstTokens → Lean.Parser.FirstTokens → Lean.Parser.FirstTokens | null | true |
Lean.mkLabelExt | Lean.LabelAttribute | autoParam Lean.Name Lean.mkLabelExt._auto_1 → IO Lean.LabelExtension | Helper function for `registerLabelAttr`. | true |
DoubleQuot.quotQuotEquivQuotOfLEₐ_comp_mkₐ | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u) {A : Type u_1} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {I J : Ideal A}
(h : I ≤ J),
(↑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h)).comp (Ideal.Quotient.mkₐ R (Ideal.map (Ideal.Quotient.mkₐ R I) J)) =
Ideal.Quotient.factorₐ R h | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Prod.0.QuadraticMap.posDef_prod_iff._simp_1_1 | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {M : Type u_4} {N : Type u_5} {R₂ : Type u} [inst : CommSemiring R₂] [inst_1 : AddCommMonoid M] [inst_2 : Module R₂ M]
[inst_3 : PartialOrder N] [inst_4 : AddCommMonoid N] [inst_5 : Module R₂ N] {Q : QuadraticMap R₂ M N},
Q.PosDef = ((∀ (x : M), 0 ≤ Q x) ∧ Q.Anisotropic) | null | false |
HomologicalComplex.XIsoOfEq_inv_naturality | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {K L : HomologicalComplex V c} (φ : K ⟶ L)
{n n' : ι} (h : n = n'),
CategoryTheory.CategoryStruct.comp (φ.f n') (L.XIsoOfEq h).inv =
CategoryTheory.CategoryStruct.co... | null | true |
addSubgroupOfIdempotent._proof_2 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Finite G] (S : Set G) (hS1 : S.Nonempty) (hS2 : S + S = S) {a b : G},
a ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier →
b ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier → a + b ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier | null | false |
HolderOnWith.ediam_image_le_of_le | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal} {f : X → Y}
{s : Set X}, HolderOnWith C r f s → ∀ {d : ENNReal}, Metric.ediam s ≤ d → Metric.ediam (f '' s) ≤ ↑C * d ^ ↑r | null | true |
NonarchAddGroupNorm.ctorIdx | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} → {inst : AddGroup G} → NonarchAddGroupNorm G → ℕ | null | false |
IsMulApplyEqComp.mul_apply_eq_comp | Mathlib.Data.FunLike.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {inst : FunLike F α α} {inst_1 : Mul F} [self : IsMulApplyEqComp F α]
(f g : F) (x : α), (f * g) x = f (g x) | null | true |
Condensed.ofSheafForgetCompHaus._proof_1 | Mathlib.Condensed.Explicit | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} A] {FA : A → A → Type u_5} {CA : A → Type u_4}
[inst_1 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_2 : CategoryTheory.ConcreteCategory A FA]
[CategoryTheory.Limits.ReflectsFiniteLimits (CategoryTheory.forget A)] (F : CategoryTheory.Functor CompHaus... | null | false |
Lean.NameSet.instInhabited | Lean.Data.NameMap.Basic | Inhabited Lean.NameSet | null | true |
Std.Tactic.BVDecide.instHashableBVBit.hash | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBit → UInt64 | null | true |
rTensor.inverse_of_rightInverse._proof_4 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N], SMulCommClass R R N | null | false |
Prod.instIsIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} {Y : Type u_1} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y]
[inst_2 : SMul M X] [IsIsometricSMul M X] [inst_4 : SMul M Y] [IsIsometricSMul M Y], IsIsometricSMul M (X × Y) | null | true |
Cubic.coeff_eq_zero | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R] {n : ℕ}, 3 < n → P.toPoly.coeff n = 0 | null | true |
Polynomial.monicEquivDegreeLT._proof_2 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] [Nontrivial R] (n : ℕ) (p : { p // p.Monic ∧ p.natDegree = n }),
(↑p).eraseLead ∈ Polynomial.degreeLT R n | null | false |
Compactum.str | Mathlib.Topology.Category.Compactum | (X : Compactum) → Ultrafilter X.A → X.A | The structure map for a compactum, essentially sending an ultrafilter to its limit. | true |
_private.Std.Async.System.0.Std.Async.System.instDecidableEqSystemUser.decEq.match_1 | Std.Async.System | (motive : Std.Async.System.SystemUser → Std.Async.System.SystemUser → Sort u_1) →
(x x_1 : Std.Async.System.SystemUser) →
((a : String) →
(a_1 : Option Std.Async.System.UserId) →
(a_2 : Option Std.Async.System.GroupId) →
(a_3 : Option String) →
(a_4 : Option System.File... | null | false |
Mathlib.Tactic.BicategoryLike.HorizontalComp.tgtM | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.HorizontalComp → m Mathlib.Tactic.BicategoryLike.Mor₁ | The codomain of a 2-morphism. | true |
Sigma.instAddAction._proof_1 | Mathlib.Algebra.Group.Action.Sigma | ∀ {ι : Type u_1} {M : Type u_3} {α : ι → Type u_2} {m : AddMonoid M} [inst : (i : ι) → AddAction M (α i)] (a b : M)
(x : (i : ι) × α i), (a + b) +ᵥ x = a +ᵥ b +ᵥ x | null | false |
ProbabilityTheory.setLIntegral_stieltjesOfMeasurableRat | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β} {f : α × β → ℚ → ℝ}
[ProbabilityTheory.IsFiniteKernel κ] (hf : ProbabilityTheory.IsRatCondKernelCDF f κ ν) (a : α) (x : ℝ) {s : Set β},
MeasurableSet s →
... | null | true |
Std.Http.Headers.mk.noConfusion | Std.Http.Data.Headers | {P : Sort u} →
{map map' : Std.Internal.IndexMultiMap Std.Http.Header.Name Std.Http.Header.Value} →
{ map := map } = { map := map' } → (map = map' → P) → P | null | false |
Lean.registerEnvExtension | Lean.Environment | {σ : Type} →
IO σ →
optParam (Option (Lean.ReplayFn σ)) none →
optParam Lean.EnvExtension.AsyncMode Lean.EnvExtension.AsyncMode.mainOnly → IO (Lean.EnvExtension σ) | Environment extensions can only be registered during initialization.
Reasons:
1- Our implementation assumes the number of extensions does not change after an environment object is created.
2- We do not use any synchronization primitive to access `envExtensionsRef`.
Note that by default, extension state is *not* stored... | true |
Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] (a : R) (b : ℕ), Mathlib.Meta.NormNum.IsNat b 1 → a ^ b = a | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.IsAffine.finrank_of_isPullback | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {X S Y T : AlgebraicGeometry.Scheme} (f : X ⟶ S) [inst : AlgebraicGeometry.IsAffine S]
[inst_1 : AlgebraicGeometry.IsAffine T] (f' : Y ⟶ T) (g' : Y ⟶ X) (g : T ⟶ S),
CategoryTheory.IsPullback g' f' f g →
∀ [AlgebraicGeometry.Flat f] [AlgebraicGeometry.IsFinite f] (s : ↥S) (t : ↥T),
g t = s → AlgebraicGe... | null | true |
instPartialOrderHomogeneousSubmodule_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule | {ιA : Type u_1} →
{ιM : Type u_2} →
{σA : Type u_3} →
{σM : Type u_4} →
{A : Type u_5} →
{M : Type u_6} →
[inst : Semiring A] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module A M] →
(𝒜 : ιA → σA) →
(ℳ : ιM → σM... | null | true |
ProofWidgets.RefreshToken.state | ProofWidgets.Component.RefreshComponent | ProofWidgets.RefreshToken → IO.Ref ProofWidgets.RefreshComponent.RefreshState | null | true |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.ofPrime_le_of_le.match_1_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (Q : Ideal ↥A) [inst_1 : Q.IsPrime] (_x : K)
(motive : _x ∈ A.ofPrime Q → Prop) (x : _x ∈ A.ofPrime Q),
(∀ (a s : ↥A) (hs : s ∈ Q.primeCompl) (he : _x = (algebraMap (↥A) K) a * ((algebraMap (↥A) K) s)⁻¹), motive ⋯) →
motive x | null | false |
FormalMultilinearSeries.instAddCommGroup._proof_3 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : Ring 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F], SMulCommClass 𝕜 ℤ F | null | false |
LieAlgebra.HasCentralRadical.casesOn | Mathlib.Algebra.Lie.Semisimple.Defs | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{motive : LieAlgebra.HasCentralRadical R L → Sort u} →
(t : LieAlgebra.HasCentralRadical R L) →
((radical_eq_center : LieAlgebra.radical R L = LieAlgebra.cen... | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.noConfusionType | Lean.Elab.MutualInductive | Sort u → Lean.Elab.Command.FinalizeContext✝ → Lean.Elab.Command.FinalizeContext✝ → Sort u | null | false |
FreeAbelianGroup.one | Mathlib.GroupTheory.FreeAbelianGroup | (α : Type u) → [One α] → One (FreeAbelianGroup α) | null | true |
Std.Http.Version.recOn | Std.Http.Data.Version | {motive : Std.Http.Version → Sort u} →
(t : Std.Http.Version) →
motive Std.Http.Version.v10 →
motive Std.Http.Version.v11 → motive Std.Http.Version.v20 → motive Std.Http.Version.v30 → motive t | null | false |
ProbabilityTheory.Kernel.snd_compProd_prodMkLeft | Mathlib.Probability.Kernel.Composition.KernelLemmas | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {mX : MeasurableSpace X} {mY : MeasurableSpace Y}
{mZ : MeasurableSpace Z} (κ : ProbabilityTheory.Kernel X Y) (η : ProbabilityTheory.Kernel Y Z)
[ProbabilityTheory.IsSFiniteKernel κ] [ProbabilityTheory.IsSFiniteKernel η],
(κ.compProd (ProbabilityTheory.Kernel.prodMkL... | null | true |
_private.Mathlib.MeasureTheory.Measure.Support.0.MeasureTheory.Measure.isClosed_support._proof_1_2 | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ : MeasureTheory.Measure X} (x : X),
(∀ (i : Set X), x ∈ i ∧ IsOpen i → ∃ x ∈ i, ∀ (i : Set X), x ∈ i ∧ IsOpen i → 0 < μ i) →
∀ (i : Set X), x ∈ i ∧ IsOpen i → 0 < μ i | null | false |
_private.Mathlib.Analysis.Normed.Field.Ultra.0.IsUltrametricDist.isUltrametricDist_of_forall_pow_norm_le_nsmul_pow_max_one_norm._simp_1_2 | Mathlib.Analysis.Normed.Field.Ultra | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | null | false |
Lean.KVMap.instValueInt.match_1 | Lean.Data.KVMap | (motive : Lean.DataValue → Sort u_1) →
(x : Lean.DataValue) → ((i : ℤ) → motive (Lean.DataValue.ofInt i)) → ((x : Lean.DataValue) → motive x) → motive x | null | false |
LinearMap.IsAdjointPair.sub | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} {M₂ : Type u_7} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup M₁] [inst_4 : Module R M₁] [inst_5 : AddCommGroup M₂]
[inst_6 : Module R M₂] {B : M →ₗ[R] M →ₗ[R] M₂} {B' : M₁ →ₗ[R] M₁ →ₗ[R] M₂} {f f' : M → M₁} {g g' : M₁ → M}... | null | true |
Lean.Grind.IntInterval.ii | Init.Grind.ToInt | Lean.Grind.IntInterval | The infinite interval `(-∞, ∞)`. | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.getElemAsFin._proof_2 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {L : List ℕ}, ∀ k < L.length, k < L.length | null | false |
OnePoint.continuousMapDiscreteEquiv._proof_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ (X : Type u_2) [inst : TopologicalSpace X] (Y : Type u_1) [DiscreteTopology X] [inst_2 : TopologicalSpace Y]
(f : C(OnePoint X, Y)), ∃ L, Filter.Tendsto (fun x => f ↑x) Filter.cofinite (nhds L) | null | false |
CategoryTheory.Limits.CategoricalPullback.toCatCommSqOver | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor A B) →
(G : CategoryTheory.Functor C B) →
... | Interpret a functor to the categorical pullback as a `CatCommSqOver`. | true |
MeasureTheory.L2.innerProductSpace._private_3 | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] (f f' g : ↥(MeasureTheory.Lp E 2 μ)),
inner 𝕜 (f + f') g = inner 𝕜 f g + inner 𝕜 f' g | null | false |
BoundedOrderHom.rec | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : BoundedOrder α] →
[inst_3 : BoundedOrder β] →
{motive : BoundedOrderHom α β → Sort u} →
((toOrderHom : α →o β) →
(map_top' : toOrderHom.toFun ⊤ = ⊤) →
... | null | false |
String.instLTRaw | Init.Data.String.PosRaw | LT String.Pos.Raw | null | true |
_private.Mathlib.Data.Nat.ModEq.0.Nat.ModEq.add_left_cancel._simp_1_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a ≡ b [MOD n]) = (↑n ∣ ↑b - ↑a) | null | false |
addSemiconjBy_iff_eq | Mathlib.Algebra.Group.Semiconj.Defs | ∀ {M : Type u_2} [inst : AddCancelCommMonoid M] {a x y : M}, AddSemiconjBy a x y ↔ x = y | null | true |
Std.DHashMap.Internal.AssocList.instIteratorAssocListIteratorIdSigma.match_1 | Std.Data.DHashMap.Internal.AssocList.Iterator | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Std.IterStep (Std.IterM Id ((a : α) × β a)) ((a : α) × β a) → Sort u_3) →
(x : Std.IterStep (Std.IterM Id ((a : α) × β a)) ((a : α) × β a)) →
((it' : Std.IterM Id ((a : α) × β a)) → (out : (a : α) × β a) → motive (Std.IterStep.yield it' out)) →
... | null | false |
ProofWidgets.LayoutKind.noConfusionType | ProofWidgets.Data.Html | Sort v✝ → ProofWidgets.LayoutKind → ProofWidgets.LayoutKind → Sort v✝ | null | true |
CochainComplex.mappingCocone.liftCochain_v_snd_v | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{n m : ℤ} (α : CochainComplex.HomComplex.Cochain M K n) (β : CochainComplex.HomComplex.Cochain M L... | null | true |
_private.Mathlib.RingTheory.Smooth.Pi.0.Algebra.FormallySmooth.of_pi._simp_1_2 | Mathlib.RingTheory.Smooth.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i : ι) (x y : α i),
Pi.single i x * Pi.single i y = Pi.single i (x * y) | null | false |
_private.Mathlib.Tactic.Linter.AuxLemma.0.Mathlib.Linter.AuxLemma.nameRefersToAuxLemma | Mathlib.Tactic.Linter.AuxLemma | Lean.Name → Bool | Returns `true` if any component of the name is an auto-generated auxiliary name. | true |
Multiplicative.leftCancelSemigroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [AddLeftCancelSemigroup α] → LeftCancelSemigroup (Multiplicative α) | null | true |
Module.Basis.toDualFlip_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) (m₁ m₂ : M), (b.toDualFlip m₁) m₂ = (b.toDual m₂) m₁ | null | true |
Mathlib.Tactic.DuplicateDecls.Target.ctorIdx | Mathlib.Tactic.DuplicateDecls | Mathlib.Tactic.DuplicateDecls.Target → ℕ | null | false |
intermediate_value_Ici' | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a : α} {f : α → δ},
ContinuousOn f (Set.Ici a) → Filter.Tendsto f Filter.atTop Filter.atBot →... | null | true |
Prod.swap_swap | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} (x : α × β), x.swap.swap = x | null | true |
HomologicalComplex.cyclesMap_i | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} (φ : K ⟶ L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.cy... | null | true |
Std.Internal.List.maxKey!_le_maxKey!_insertEntryIfNew | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k},
(compare (Std.Internal.List.maxKey! l)
(Std.Internal.Li... | null | true |
MeasureTheory.AEStronglyMeasurable.measurable_mk | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [TopologicalSpace.PseudoMetrizableSpace β] [inst_2 : MeasurableSpace β] [BorelSpace β]
(hf : MeasureTheory.AEStronglyMeasurable f μ), Measurable (MeasureTheory.AEStronglyMeasurable.mk f h... | null | true |
Std.ExtHashMap.contains_of_contains_insertIfNew' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_of_contains_insertIfNew` that is written to exactly match the proof
obligation in the statement of `getElem_insertIfNew`. | true |
Option.isSome.match_1.congr_eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : Option α) (h_1 : (val : α) → motive (some val))
(h_2 : Unit → motive none) (val : α),
x = some val →
(match x with
| some val => h_1 val
| none => h_2 ()) ≍
h_1 val | null | true |
FiniteIndexNormalSubgroup.instMax._proof_2 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] (U V : FiniteIndexNormalSubgroup G), (U.toSubgroup ⊔ V.toSubgroup).FiniteIndex | null | false |
String.instLinearOrder._proof_10 | Mathlib.Data.String.Basic | ∀ (a b : String), (if a ≤ b then b else a) = if a ≤ b then b else a | null | false |
CommGrpCat.instConcreteCategoryMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : CommGrpCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
Lean.Parser.Tactic.mvcgenMacro | Init.Tactics | Lean.ParserDescr | `mvcgen` will break down a Hoare triple proof goal like `⦃P⦄ prog ⦃Q⦄` into verification conditions,
provided that all functions used in `prog` have specifications registered with `@[spec]`.
### Verification Conditions and specifications
A verification condition is an entailment in the stateful logic of `Std.Do.SPred... | true |
CategoryTheory.Idempotents.instAddCommGroupHom._proof_5 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{P Q : CategoryTheory.Idempotents.Karoubi C} (n : ℕ) (x : P ⟶ Q), (n + 1) • x = n • x + x | null | false |
Iic_mem_nhdsSet_Iic_iff._simp_1 | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] {a b : α}
[(nhdsWithin b (Set.Ioi b)).NeBot], (Set.Iic a ∈ nhdsSet (Set.Iic b)) = (b < a) | null | false |
Lean.collectFVars | Lean.Util.CollectFVars | Lean.CollectFVars.State → Lean.Expr → Lean.CollectFVars.State | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.