name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ArithmeticFunction.carmichael_finset_prod | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {α : Type u_1} {s : Finset α} {f : α → ℕ},
(↑s).Pairwise (Function.onFun Nat.Coprime f) →
ArithmeticFunction.carmichael (s.prod f) = s.lcm (⇑ArithmeticFunction.carmichael ∘ f) | **Alias** of `ArithmeticFunction.carmichael_finsetProd`. | true |
_private.Lean.Compiler.Specialize.0.Lean.Compiler.specializeAttr._regBuiltin.Lean.Compiler.specializeAttr.docString_1 | Lean.Compiler.Specialize | IO Unit | null | false |
Array.foldl_cons_eq_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {stop : ℕ} {as : Array α} {bs : List β} {f : α → β},
stop = as.size → Array.foldl (fun acc a => f a :: acc) bs as 0 stop = (Array.map f as).reverse.toList ++ bs | null | true |
ContinuousMultilinearMap.isUniformEmbedding_toUniformOnFun | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
Ctop.Realizer.is_basis | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [T : TopologicalSpace α] (F : Ctop.Realizer α), TopologicalSpace.IsTopologicalBasis (Set.range F.F.f) | null | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.link2.match_1.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (l l'' : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl.Tree α β (l.size + l''.size) → Sort u_3) (ℓ : Std.DTreeMap.Internal.Impl α β)
(hℓ₁ : ℓ.Balanced) (hℓ₂ : ℓ.size = l.size + l''.size)
(h_1 :
(ℓ : Std.DTreeMap.Internal.Impl α β) →
(hℓ₁ : ℓ.Bal... | null | true |
Lean.Meta.Grind.instInhabitedEMatchTheorem | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheorem | null | true |
Valuation.map_add_eq_of_lt_right | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v x < v y → v (x + y) = v y | null | true |
ChainComplex.fromSingle₀Equiv._proof_4 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V),
Function.LeftInverse (fun f => HomologicalComplex.mkHomFromSingle f ⋯) fun f => f.f 0 | null | false |
AlgEquiv.casesOn | Mathlib.Algebra.Algebra.Equiv | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
{motive : (A ≃ₐ[R] B) → Sort u_1} →
(t : A ≃ₐ[R] B) →
... | null | false |
CategoryTheory.Limits.zeroProdIso | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] → (X : C) → 0 ⨯ X ≅ X | A zero object is a left unit for categorical product. | true |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_10 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist c a = dist a b / dist a' b' * dist c' a' → dist c a = dist a b / dist a' b' * dist c' a' | null | false |
Quotient.liftOn₂.congr_simp | Mathlib.Data.Fintype.Quotient | ∀ {α : Sort uA} {β : Sort uB} {φ : Sort uC} {s₁ : Setoid α} {s₂ : Setoid β} (q₁ q₁_1 : Quotient s₁),
q₁ = q₁_1 →
∀ (q₂ q₂_1 : Quotient s₂),
q₂ = q₂_1 →
∀ (f f_1 : α → β → φ) (e_f : f = f_1)
(c : ∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂),
q₁.lif... | null | true |
MulMemClass.subtype | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : Mul M] → [inst_1 : SetLike A M] → [hA : MulMemClass A M] → (S' : A) → ↥S' →ₙ* M | The natural semigroup hom from a subsemigroup of semigroup `M` to `M`. | true |
MeasureTheory.condExpL1CLM_indicatorConst | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {hm : m ≤ m0} [inst_2 : MeasureTheory.SigmaFinite (μ.trim hm)] {s : Set α}
[inst_3 : CompleteSpace F'] (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (x : F'),
(MeasureTheor... | null | true |
UniformOnFun.gen_mono | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} {S S' : Set α} {V V' : Set (β × β)},
S' ⊆ S → V ⊆ V' → UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V' | `UniformOnFun.gen` is antitone in the first argument and monotone in the second. | true |
_private.Lean.Meta.Basic.0.Lean.Meta.ExprConfigCacheKey.mk.inj | Lean.Meta.Basic | ∀ {expr : Lean.Expr} {configKey : UInt64} {expr_1 : Lean.Expr} {configKey_1 : UInt64},
{ expr := expr, configKey := configKey } = { expr := expr_1, configKey := configKey_1 } →
expr = expr_1 ∧ configKey = configKey_1 | null | true |
AddSemigrp.Hom.casesOn | Mathlib.Algebra.Category.Semigrp.Basic | {A B : AddSemigrp} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₙ+ ↑B) → motive { hom' := hom' }) → motive t | null | false |
invertibleTwo._proof_2 | Mathlib.Algebra.CharP.Invertible | (1 + 1).AtLeastTwo | null | false |
ergodic_smul_of_denseRange_pow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : Monoid M] [inst_5 : TopologicalSpace M] [inst_6 : MulAction M X] [ContinuousSMul M X] {g : M},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMeasur... | If a monoid `M` continuously acts on an R₁ topological space `X`,
`g` is an element of `M` such that its natural powers are dense in `M`,
and `μ` is a finite inner regular measure on `X` which is ergodic with respect to the action of `M`,
then the scalar multiplication by `g` is an ergodic map. | true |
Derivation.leibniz | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] (D : Derivation R A M)
(a b : A), D (a * b) = a • D b + b • D a | null | true |
Lean.ErrorExplanation.instToJsonMetadata.toJson | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Lean.Json | null | true |
_private.Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain.0.HasStrictFDerivAt.implicitFunctionDataOfProdDomain._proof_3 | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomSurjective (RingHom.id 𝕜) | null | false |
Metric.cthickening_empty | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ), Metric.cthickening δ ∅ = ∅ | The closed thickening of the empty set is empty. | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.tendsto_pow_logb_div_mul_add_atTop._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
Std.IterM.all_eq_allM | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} {p : β → Bool},
Std.IterM.all p it = Std.IterM.allM (fun x => pure { down := p x }) it | null | true |
ModuleCat.projective_of_module_projective | Mathlib.Algebra.Category.ModuleCat.Projective | ∀ {R : Type u} [inst : Ring R] (P : ModuleCat R) [Small.{v, u} R] [CategoryTheory.Projective P], Module.Projective R ↑P | null | true |
CategoryTheory.CommGrp.instCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {X Y : CategoryTheory.CommGrp C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f)
Ca... | null | false |
Nonneg.instContinuousFunctionalCalculus | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : PartialOrder A] [inst_2 : StarRing A] [StarOrderedRing A]
[inst_4 : TopologicalSpace A] [inst_5 : Algebra ℝ A] [ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[NonnegSpectrumClass ℝ A], ContinuousFunctionalCalculus NNReal A fun x => 0 ≤ x | null | true |
Set.Finset.coe_einfsep | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Finset α}, (↑s).einfsep = s.offDiag.inf (Function.uncurry edist) | null | true |
_private.Mathlib.MeasureTheory.Measure.Doubling.0.IsUnifLocDoublingMeasure.eventually_measure_mul_le_scalingConstantOf_mul._simp_1_1 | Mathlib.MeasureTheory.Measure.Doubling | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
instAntisymmLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], Std.Antisymm fun x1 x2 => x1 ≤ x2 | null | true |
Std.DTreeMap.Raw.mem_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
k' ∈ t.alter k f ↔ if cmp k k' = Ordering.eq then (f (t.get? k)).isSome = true else k' ∈ t | null | true |
TopologicalSpace.Opens.coe_compl | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Opens α), ↑s.compl = (↑s)ᶜ | null | true |
Lean.trace.profiler.threshold | Lean.Util.Trace | Lean.Option ℕ | null | true |
RelHom.coe_mul | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (f g : r →r r), ⇑(f * g) = ⇑f ∘ ⇑g | null | true |
Topology.IsOpenEmbedding.locallyPathConnectedSpace | Mathlib.Topology.Connected.LocallyPathConnected | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [LocallyPathConnectedSpace X]
{e : Y → X}, Topology.IsOpenEmbedding e → LocallyPathConnectedSpace Y | null | true |
StateTransition.evalInduction._proof_1 | Mathlib.Computability.StateTransition | ∀ {σ : Type u_1} {f : σ → Option σ} (a' b' : σ), f a' = some b' → Sum.inr b' = (f a').elim (Sum.inl a') Sum.inr | null | false |
_private.Mathlib.RingTheory.WittVector.FrobeniusFractionField.0.WittVector.frobeniusRotationCoeff.match_1.splitter | Mathlib.RingTheory.WittVector.FrobeniusFractionField | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | true |
ContinuousLinearMap.opNorm_le_bound₂ | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_8} {G : Type u_12}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField �... | null | true |
ContinuousLinearMap.seminorm._proof_3 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {F : Type u_1} [inst : SeminormedAddCommGroup F], ContinuousAdd F | null | false |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Down.erase_mem_compression_of_mem_compression._simp_1_1 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
(s ∈ Down.compression a 𝒜) = (s ∈ 𝒜 ∧ s.erase a ∈ 𝒜 ∨ s ∉ 𝒜 ∧ insert a s ∈ 𝒜) | null | false |
CompHausLike.pullback._proof_2 | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B),
T2Space
{ x // x ∈ {xy | (CategoryTheory.ConcreteCategory.hom f) xy.1 = (CategoryTheory.ConcreteCategory.hom g) xy.2} } | null | false |
TopModuleCat.instHasForget₂ContinuousLinearMapIdCarrierModuleCatLinearMap._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_2) [inst : Ring R] [inst_1 : TopologicalSpace R] (X : TopModuleCat R),
ModuleCat.ofHom ↑(TopModuleCat.Hom.hom (CategoryTheory.CategoryStruct.id X)) =
CategoryTheory.CategoryStruct.id ↧↑X.toModuleCat | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.getKey?_modify_self._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
AlgCat.tensorAlgebra_map | Mathlib.Algebra.Category.AlgCat.TensorAlgebra | ∀ (R : Type u) [inst : CommRing R] {X Y : ModuleCat R} (f : X ⟶ Y),
(AlgCat.tensorAlgebra R).map f = AlgCat.ofHom ((TensorAlgebra.lift R) (TensorAlgebra.ι R ∘ₗ ModuleCat.Hom.hom f)) | null | true |
CategoryTheory.ShortComplex.instModuleHom._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_3} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(a : R), a • 0 = 0 | null | false |
_private.Mathlib.Dynamics.Ergodic.AddCircle.0.AddCircle.ae_empty_or_univ_of_forall_vadd_ae_eq_self._simp_1_1 | Mathlib.Dynamics.Ergodic.AddCircle | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
descPochhammer_map | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {R : Type u} [inst : Ring R] {T : Type v} [inst_1 : Ring T] (f : R →+* T) (n : ℕ),
Polynomial.map f (descPochhammer R n) = descPochhammer T n | null | true |
matrixEquivTensor._proof_5 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_3) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n] (r : R),
(↑↑(MatrixEquivTensor.toFunAlgHom n R A).toRingHom).toFun ((algebraMap R (TensorProduct R A (Matrix n n R))) r) =
(algebraMap R (Matrix n n A... | null | false |
Polynomial.degree_ne_bot | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.degree ≠ ⊥ ↔ p ≠ 0 | null | true |
bernoulliFun_one | Mathlib.NumberTheory.ZetaValues | ∀ (x : ℝ), bernoulliFun 1 x = x - 1 / 2 | null | true |
AddMonoidHom.op._proof_6 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (x y : M),
AddOpposite.unop ((⇑f ∘ AddOpposite.op) (x + y)) =
AddOpposite.unop
{ unop' := (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) x + (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) y } | null | false |
DFinsupp.lsum | Mathlib.LinearAlgebra.DFinsupp | {ι : Type u_1} →
{R : Type u_3} →
(S : Type u_4) →
{M : ι → Type u_5} →
{N : Type u_6} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[inst_3 : AddCommMonoid N] →
[inst_4 :... | The `DFinsupp` version of `Finsupp.lsum`.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. | true |
Finset.diag_eq_filter | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], s.diag = {a ∈ s ×ˢ s | a.1 = a.2} | null | true |
_private.Mathlib.Logic.Relation.0.Relation.ReflTransGen.total_of_right_unique._proof_1_4 | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} {a c : α},
Relator.RightUnique r →
Relation.ReflTransGen r a c →
∀ {b c_1 : α},
Relation.ReflTransGen r a b →
r b c_1 →
Relation.ReflTransGen r b c ∨ Relation.ReflTransGen r c b →
Relation.ReflTransGen r c_1 c ∨ Relation.ReflTra... | null | false |
Lean.MonadLog.casesOn | Lean.Log | {m : Type → Type} →
{motive : Lean.MonadLog m → Sort u} →
(t : Lean.MonadLog m) →
([toMonadFileMap : Lean.MonadFileMap m] →
(getRef : m Lean.Syntax) →
(getFileName : m String) →
(hasErrors : m Bool) →
(logMessage : Lean.Message → m Unit) →
... | null | false |
NumberField.FinitePlace.mk_eq_iff._simp_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
{v₁ v₂ : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)},
(NumberField.FinitePlace.mk v₁ = NumberField.FinitePlace.mk v₂) = (v₁ = v₂) | null | false |
Array.map_set._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size}, i < (Array.map f xs).size | null | false |
Aesop.Script.DynStructureResult.mk.sizeOf_spec | Aesop.Script.StructureDynamic | ∀ (script : List Aesop.Script.Step) (postState : Lean.Meta.SavedState),
sizeOf { script := script, postState := postState } = 1 + sizeOf script + sizeOf postState | null | true |
CategoryTheory.Over.iteratedSliceForwardNaturalityIso_hom_app | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (p : f ⟶ g)
(X_1 : CategoryTheory.Over f),
(CategoryTheory.Over.iteratedSliceForwardNaturalityIso p).hom.app X_1 =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Over.map (CategoryTheory.Over.Hom.left p)).... | null | true |
cantorToBinary.eq_1 | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ), cantorToBinary x = Stream'.map (fun x => if x ∈ Set.Icc 0 (1 / 3) then false else true) (cantorSequence x) | null | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.linearOrder._proof_6 | Mathlib.Data.Num.Lemmas | ∀ (a b : PosNum), ↑a ≤ ↑b → ↑b ≤ ↑a → ↑a = ↑b | null | false |
Subgroup.comap.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_6} [inst_1 : Group N] (f : G →* N) (H : Subgroup N),
Subgroup.comap f H = { carrier := ⇑f ⁻¹' ↑H, mul_mem' := ⋯, one_mem' := ⋯, inv_mem' := ⋯ } | null | true |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.succ?._sparseCasesOn_2 | Lean.Elab.Tactic.Omega.Frontend | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
PresheafOfModulesOfCommRing.Derivation.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} →
{F : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat} →
{M : Pres... | null | false |
AlgHom.op._proof_3 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (r : R),
(↑↑(RingHom.op f.toRingHom)).toFun ((algebraMap R Aᵐᵒᵖ) r) = (algebraMap R Bᵐᵒᵖ) r | null | false |
_private.Init.Data.SInt.Lemmas.0.ISize.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False | null | false |
_private.Mathlib.LinearAlgebra.SymmetricAlgebra.Basis.0.SymmetricAlgebra.rank_eq.match_1_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basis | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : Nonempty ((I : Type u_1) × Module.Basis I R M) → Prop) (x : Nonempty ((I : Type u_1) × Module.Basis I R M)),
(∀ (κ : Type u_1) (b : Module.Basis κ R M), motive ⋯) → motive x | null | false |
DirectLimit.instAddCommGroupWithOneOfAddMonoidHomClass._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → AddCommGroupWithOne (G i)]
[∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j), AddHomClass (T h) (G i) (G j) | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.WithZero.0.instPosMulMonoWithZeroOfMulLeftMono.match_1 | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Preorder α] (motive : (x : WithZero α) → 0 ≤ x → (x x_1 : WithZero α) → x ≤ x_1 → Prop)
(x : WithZero α) (x_1 : 0 ≤ x) (x_2 x_3 : WithZero α) (x_4 : x_2 ≤ x_3),
(∀ (x : 0 ≤ 0) (a b : WithZero α) (x_5 : a ≤ b), motive none x a b x_5) →
(∀ (x : α) (x_5 : 0 ≤ ↑x) (x_6 : WithZero α) (x_7 : ... | null | false |
instAddGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddGroup β],
instAddGroupUniformOnFun =
{ toAddMonoid := instAddMonoidUniformOnFun, toNeg := instNegUniformOnFun, toSub := instSubUniformOnFun,
toZSMul := ZSMul.ofSMul, sub_eq_add_neg := ⋯, zsmul_zero' := ⋯, zsmul_succ' := ⋯, zsmul_neg' := ⋯,
... | null | true |
Metric.glueMetricApprox._private_3 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (Φ : Z → X) (Ψ : Z → Y)
(ε : ℝ) (x y : X ⊕ Y), Metric.glueDist Φ Ψ ε x y = Metric.glueDist Φ Ψ ε y x | null | false |
IsNonarchimedeanLocalField.valueGroupWithZeroIsoInt._proof_1 | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : TopologicalSpace K]
[IsNonarchimedeanLocalField K], Nonempty (ValuativeRel.ValueGroupWithZero K ≃*o WithZero (Multiplicative ℤ)) | null | false |
Aesop.Frontend.RuleExpr.rec_2 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.... | null | false |
ContinuousMap.HomotopyEquiv | Mathlib.Topology.Homotopy.Equiv | (X : Type u) → (Y : Type v) → [TopologicalSpace X] → [TopologicalSpace Y] → Type (max u v) | A homotopy equivalence between topological spaces `X` and `Y` are a pair of functions
`toFun : C(X, Y)` and `invFun : C(Y, X)` such that `toFun.comp invFun` and `invFun.comp toFun`
are both homotopic to corresponding identity maps.
| true |
SimpleGraph.instDecidableEqWalk.decEq._proof_5 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} (a a_1 a_2 : V) (a_3 : G.Adj a a_2) (a_4 b : G.Walk a_2 a_1),
¬a_4 = b → ¬SimpleGraph.Walk.cons a_3 a_4 = SimpleGraph.Walk.cons a_3 b | null | false |
Lean.Meta.Grind.Arith.CommRing.RingM.Context | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Type | null | true |
TensorProduct.rightComm._proof_16 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R (TensorProduct R M N) P) | null | false |
MulOpposite.instAddGroupWithOne._proof_5 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℕ) (a : Rᵐᵒᵖ), ↑n.succ • a = ↑n • a + a | null | false |
Std.DTreeMap.Internal.Impl.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[Std.LawfulEqOrd α], t.WF → ∀ {k : α} {f : β → β}, (Std.DTreeMap.Internal.Impl.Const.modify k f t).minKey? = t.minKey? | null | true |
_private.Lean.Elab.PreDefinition.Basic.0.Lean.Elab.getLevelParamsPreDecls | Lean.Elab.PreDefinition.Basic | Array Lean.Elab.PreDefinition → List Lean.Name → List Lean.Name → Lean.Elab.TermElabM (List Lean.Name) | Collects all the level parameters in sorted order from the types and values of each predefinition.
Throws an "unused universe parameter" error if there is an unused `.{...}` parameter.
See `Lean.collectLevelParams`.
| true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.lintFile.match_3 | Mathlib.Tactic.Linter.TextBased | (motive : Option (Array String) → Sort u_1) →
(changes : Option (Array String)) →
((c : Array String) → motive (some c)) → ((x : Option (Array String)) → motive x) → motive changes | null | false |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.θ_natDegree_le | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)},
E ≠ ⊥ → (RatFunc.Luroth.θ✝ E).natDegree ≤ RatFunc.Luroth.m✝ E | null | true |
cfcₙ_tsub._auto_9 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
Nat.pos_of_neZero | Init.Data.Nat.Basic | ∀ (n : ℕ) [NeZero n], 0 < n | null | true |
CommRingCat.Colimits.Relation.below.mul_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop}
(x : CommRingCat.Colimits.Prequotient F), CommRingCat.Colimits.Relation.below ⋯ | null | true |
contDiff_const_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] (c : R), ContDiff 𝕜 n fun p => c • p | Scalar multiplication is smooth (as a function of the vector variable). | true |
ContinuousMap.Homotopy.trans._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous fun x => ↑x.1 | null | false |
Lean.RArray.toExpr | Lean.Data.RArray | {α : Type u_1} → Lean.Expr → (α → Lean.Expr) → Lean.RArray α → Lean.MetaM Lean.Expr | null | true |
Std.Mutex.mutex | Std.Sync.Mutex | {α : Type} → Std.Mutex α → Std.BaseMutex | null | true |
two_nsmul_inf_eq_add_sub_abs_sub | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b : α), 2 • (a ⊓ b) = a + b - |b - a| | null | true |
List.isSome_isPrefixOf?_eq_isPrefixOf | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (xs ys : List α), (xs.isPrefixOf? ys).isSome = xs.isPrefixOf ys | null | true |
Lean.Lsp.TextDocumentEdit.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (textDocument : Lean.Lsp.VersionedTextDocumentIdentifier) (edits : Lean.Lsp.TextEditBatch),
sizeOf { textDocument := textDocument, edits := edits } = 1 + sizeOf textDocument + sizeOf edits | null | true |
MulAction.isTopologicallyTransitive_iff | Mathlib.Dynamics.Transitive | ∀ (M : Type u_1) {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : Monoid M] [inst_2 : MulAction M α],
MulAction.IsTopologicallyTransitive M α ↔
∀ {U V : Set α}, IsOpen U → U.Nonempty → IsOpen V → V.Nonempty → ∃ m, (m • U ∩ V).Nonempty | null | true |
toBoolRing_sup | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (a b : α),
toBoolRing (a ⊔ b) = toBoolRing a + toBoolRing b + toBoolRing a * toBoolRing b | null | true |
EuclideanGeometry.inner_pos_or_eq_of_dist_le_radius | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → dist p₂ s.center ≤ s.radius → 0 < inner ℝ (p₁ -ᵥ p₂) (p₁ -ᵥ s.center) ∨ p₁ = p₂ | Given a point on a sphere and a point not outside it, the inner product between the
difference of those points and the radius vector is positive unless the points are equal. | true |
Lean.Compiler.LCNF.CSE.State._sizeOf_1 | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.CSE.State → ℕ | null | false |
Lean.Linter.whenLinterActivated | Mathlib.Lean.Linter | Lean.Option Bool → Lean.Elab.Command.CommandElab → optParam Bool true → Lean.Elab.Command.CommandElab | Processes `set_option ... in`s that wrap the input `stx`, then acts on the inner syntax with
`x` after checking that the provided linter option is `true`.
If `breakOnError` is `true` (the default), avoids running the linter when errors are present.
This is typically used to start off linter code:
```
def myLinter : L... | true |
SpecialLinearGroup.SL2Z_generators | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | Subgroup.closure {ModularGroup.S, ModularGroup.T} = ⊤ | `SL(2, ℤ)` is generated by `S` and `T`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.