name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Sylow.exists_subgroup_card_pow_prime | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] (p : ℕ) {n : ℕ} [Fact (Nat.Prime p)],
p ^ n ∣ Nat.card G → ∃ K, Nat.card ↥K = p ^ n | A generalisation of **Sylow's first theorem**. If `p ^ n` divides
the cardinality of `G`, then there is a subgroup of cardinality `p ^ n` | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.smul_ball''._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
Matrix.diagonal_smul | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {R : Type u_4} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : SMulZeroClass R α]
(r : R) (d : n → α), Matrix.diagonal (r • d) = r • Matrix.diagonal d | null | true |
Set.Finite.inter_of_right | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∀ (t : Set α), (t ∩ s).Finite | null | true |
CliffordAlgebra.toProd_one_tmul_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Prod | ∀ {R : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] (Q₁ : QuadraticForm R M₁)
(Q₂ : QuadraticForm R M₂) (m₂ : M₂),
(CliffordAlgebra.toProd Q₁ Q₂) (1 ᵍ⊗ₜ[R] (CliffordAlgebra.ι Q₂) m₂) =
(Cliffor... | null | true |
ack_mono_left | Mathlib.Computability.Ackermann | ∀ (n : ℕ), Monotone fun m => ack m n | null | true |
Seminorm.mem_ball._simp_1 | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
(p : Seminorm 𝕜 E) {x y : E} {r : ℝ}, (y ∈ p.ball x r) = (p (y - x) < r) | null | false |
_private.Mathlib.FieldTheory.Galois.Profinite.0.InfiniteGalois.krullTopology_mem_nhds_one_iff_of_isGalois.match_1_3 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_2} {K : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (A : Set Gal(K/k))
(motive : (∃ L, ↑L.fixingSubgroup ⊆ A) → Prop) (x : ∃ L, ↑L.fixingSubgroup ⊆ A),
(∀ (L : FiniteGaloisIntermediateField k K) (hL : ↑L.fixingSubgroup ⊆ A), motive ⋯) → motive x | null | false |
Set.IsPWO.image_of_monotoneOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
s.IsPWO → ∀ {f : α → β}, MonotoneOn f s → (f '' s).IsPWO | null | true |
Pell.pellZd.eq_1 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.pellZd a1 n = { re := ↑(Pell.xn a1 n), im := ↑(Pell.yn a1 n) } | null | true |
ArithmeticFunction.LSeriesHasSum_zeta | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {s : ℂ}, 1 < s.re → LSeriesHasSum (fun n => ↑(ArithmeticFunction.zeta n)) s (riemannZeta s) | The L-series of the arithmetic function `ζ` equals the Riemann Zeta Function on its
domain of convergence `1 < re s`. | true |
EuclideanDomain.mod_add_div' | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [inst : EuclideanDomain R] (m k : R), m % k + m / k * k = m | null | true |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.VarMem_add._simp_1_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {atom : α} {pol : Bool} {c : Std.Sat.CNF.Clause α},
Std.Sat.CNF.Clause.VarMem atom (c.add atom pol) = True | null | false |
IO.getTID | Init.System.IO | BaseIO UInt64 | Returns the thread ID of the calling thread. | true |
NumberField.mixedEmbedding.euclidean.integerLattice.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.euclidean.integerLattice K =
ZLattice.comap ℝ (NumberField.mixedEmbedding.integerLattice K) ↑↑(NumberField.mixedEmbedding.euclidean.toMixed K) | null | true |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.mulHeight_pow._simp_1_1 | Mathlib.NumberTheory.Height.Basic | ∀ {ι : Type u_2} {M : Type u_5} [inst : CommMonoid M] {m : Multiset ι} {f : ι → M} {n : ℕ},
(Multiset.map f m).prod ^ n = (Multiset.map (fun i => f i ^ n) m).prod | null | false |
Lean.CodeAction.FindTacticResult.tactic.sizeOf_spec | Lean.Server.CodeActions.Provider | ∀ (a : Lean.Syntax.Stack), sizeOf (Lean.CodeAction.FindTacticResult.tactic a) = 1 + sizeOf a | null | true |
PiFin.hasRepr | Mathlib.Data.Fin.VecNotation | {α : Type u} → {n : ℕ} → [Repr α] → Repr (Fin n → α) | Use `![...]` notation for displaying a vector `Fin n → α`, for example:
```
#eval ![1, 2] + ![3, 4] -- ![4, 6]
```
| true |
Right.mul_lt_mul_of_nonneg | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b c d : α} [inst_1 : Preorder α] [PosMulMono α] [MulPosStrictMono α],
a < b → c < d → 0 ≤ a → 0 ≤ c → a * c < b * d | Assumes right strict covariance. | true |
Mathlib.Tactic.GRewrite.Config.useRewrite | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.Config → Bool | When `useRewrite = true`, switch to using the default `rewrite` tactic when the goal is
and equality or iff. | true |
Module.basisUnique_repr_eq_zero_iff | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [inst_4 : StrongRankCondition R] {ι : Type u_2} [inst_5 : Unique ι]
{h : Module.finrank R M = 1} {v : M} {i : ι}, ((Module.basisUnique ι h).repr v) i = 0 ↔ v = 0 | null | true |
Matrix.isNilpotent_trace_of_isNilpotent | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] {M : Matrix n n R},
IsNilpotent M → IsNilpotent M.trace | null | true |
ite_eq_ite | Init.PropLemmas | ∀ {α : Sort u_1} (p : Prop) {h h' : Decidable p} (x y : α), ((if p then x else y) = if p then x else y) ↔ True | If two if-then-else statements only differ by the `Decidable` instances, they are equal. | true |
UpperSet.coe_mk | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s : Set α) (hs : IsUpperSet s), ↑{ carrier := s, upper' := hs } = s | null | true |
NonUnitalNormedCommRing.toNonUnitalSeminormedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NonUnitalNormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | null | false |
Mathlib.Tactic.ITauto.Proof.orInR.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orInR = 1 + sizeOf p | null | true |
CategoryTheory.FreeMonoidalCategory.instMonoidalCategory._proof_1 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : W ⟶ X) (g : Y ⟶ Z),
Quotient.map₂ CategoryTheory.FreeMonoidalCategory.Hom.tensor ⋯ f g =
CategoryTheory.CategoryStruct.comp (Quot.map (fun f => f.whiskerRight Y) ⋯ f)
(Quot.map (fun f => CategoryTheory.FreeMonoidalCategory.Hom.whiskerLe... | null | false |
Turing.PartrecToTM2.codeSupp_cons | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f fs : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.codeSupp (f.cons fs) k =
Turing.PartrecToTM2.trStmts₁ (Turing.PartrecToTM2.trNormal (f.cons fs) k) ∪
Turing.PartrecToTM2.codeSupp f (Turing.PartrecToTM2.Cont'.cons₁ fs k) | null | true |
PolynomialLaw.add._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f g : M →ₚₗ[R] N) {S : Type u_1} [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] {S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S... | null | false |
Int.Internal.Linear.Expr.num.elim | Init.Data.Int.Linear | {motive : Int.Internal.Linear.Expr → Sort u} →
(t : Int.Internal.Linear.Expr) → t.ctorIdx = 0 → ((v : ℤ) → motive (Int.Internal.Linear.Expr.num v)) → motive t | null | false |
NontriviallyNormedField.ofNormNeOne._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ {𝕜 : Type u_1} [h' : NormedField 𝕜], (∃ x, x ≠ 0 ∧ ‖x‖ ≠ 1) → ∃ x, 1 < ‖x‖ | null | false |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.isColoop_iff_sdiff_not_spanning._proof_1_1 | Mathlib.Combinatorics.Matroid.Loop | 1 ≠ 0 | null | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE.0.CategoryTheory.Triangulated.TStructure.isLE_iff_orthogonal._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ (n₀ n₁ : ℤ), n₀ + 1 = n₁ → n₀ < n₁ | null | false |
CategoryTheory.Sieve.generate_of_singleton_isSplitEpi | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) [CategoryTheory.IsSplitEpi f],
CategoryTheory.Sieve.generate (CategoryTheory.Presieve.singleton f) = ⊤ | null | true |
Rep.coinvariantsTensorFreeLEquiv._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (α : Type u_1)
[inst_2 : DecidableEq α] (i : α) (x : ↑A),
((A.coinvariantsTensorFreeToFinsupp α ∘ₗ A.finsuppToCoinvariantsTensorFree α) fun₀ | i => x) =
LinearMap.id fun₀ | i => x | null | false |
CategoryTheory.Abelian.SpectralObject.isIso_map._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
EStateM.run'_get | Batteries.Lean.EStateM | ∀ {σ ε : Type u_1} (s : σ), get.run' s = some s | null | true |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.3334728626._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO (IO.Ref (Array Lean.Linter.IgnoreFunction)) | null | false |
_private.Mathlib.Analysis.RCLike.Basic.0.RCLike.conj_eq_iff_re._proof_1_2 | Mathlib.Analysis.RCLike.Basic | 3 ≠ 0 | null | false |
MeasureTheory.OuterMeasure.le_boundedBy' | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {m : Set α → ENNReal} {μ : MeasureTheory.OuterMeasure α},
μ ≤ MeasureTheory.OuterMeasure.boundedBy m ↔ ∀ (s : Set α), s.Nonempty → μ s ≤ m s | null | true |
algebraMap.smul' | Mathlib.Algebra.Algebra.Defs | ∀ {A : Type u_1} {B : Type u_2} (a : A) (b : B) (C : Type u_3) [inst : SMul A B] [inst_1 : CommSemiring B]
[inst_2 : Semiring C] [inst_3 : Algebra B C] [inst_4 : Monoid A] [inst_5 : MulDistribMulAction A C]
[SMulDistribClass A B C], (algebraMap B C) (a • b) = a • (algebraMap B C) b | null | true |
Lean.Compiler.LCNF.normCode | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{t : Bool} →
[MonadLiftT Lean.Compiler.LCNF.CompilerM m] →
[Monad m] →
[Lean.Compiler.LCNF.MonadFVarSubst m pu t] → Lean.Compiler.LCNF.Code pu → m (Lean.Compiler.LCNF.Code pu) | Similar to `internalize`, but does not refresh `FVarId`s. | true |
MeasureTheory.uniformIntegrable_subsingleton | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] {p : ENNReal} {f : ι → α → β} [Subsingleton ι],
1 ≤ p → p ≠ ⊤ → (∀ (i : ι), MeasureTheory.MemLp (f i) p μ) → MeasureTheory.UniformIntegrable f p μ | A single function is uniformly integrable in the probability sense. | true |
upperClosure_union | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s t : Set α), upperClosure (s ∪ t) = upperClosure s ⊓ upperClosure t | null | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Atlas.0.OpenPartialHomeomorph.mem_maximalAtlas_of_contMDiffOn._proof_1_6 | Mathlib.Geometry.Manifold.ContMDiff.Atlas | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_2} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] (φ e : OpenPartialHomeomorph M H),
↑I.symm ⁻¹' φ.target ∩ ↑I.symm... | null | false |
OrderDual.instSemifield._proof_5 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [Semifield K], Nontrivial Kᵒᵈ | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.addSubMapCoeff._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | (7 + 1).AtLeastTwo | null | false |
Lean.Meta.NormCast.countCoes | Lean.Meta.Tactic.NormCast | Lean.Expr → Lean.MetaM ℕ | Counts how many coercions are inside the expression, including the head ones. | true |
ofDual_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : αᵒᵈ), OrderDual.ofDual (￢a) = (OrderDual.ofDual a)ᶜ | null | true |
CategoryTheory.evaluationAdjunctionLeft._proof_4 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (F : CategoryTheory.Functor C D)
(d : D),
Function.RightInverse
(fun f =>
CategoryTheory.Cate... | null | false |
Turing.TM0to1.Λ' | Mathlib.Computability.TuringMachine.PostTuringMachine | Type u_1 → Type u_2 → Type (max u_1 u_2) | The machine states for a TM1 emulating a TM0 machine. States of the TM0 machine are embedded
as `normal q` states, but the actual operation is split into two parts, a jump to `act s q`
followed by the action and a jump to the next `normal` state. | true |
_private.Mathlib.MeasureTheory.Measure.CompleteLattice.0.MeasureTheory.Measure.lt_iff._simp_1_3 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
_private.Mathlib.Topology.Filter.0.Filter.nhds_eq._simp_1_1 | Mathlib.Topology.Filter | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | null | false |
Relation.comp_assoc | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {r : α → β → Prop} {p : β → γ → Prop} {q : γ → δ → Prop},
Relation.Comp (Relation.Comp r p) q = Relation.Comp r (Relation.Comp p q) | null | true |
Preorder.restrictLe | Mathlib.Order.Restriction | {α : Type u_1} → [inst : Preorder α] → {π : α → Type u_2} → (a : α) → ((a : α) → π a) → (a_1 : ↑(Set.Iic a)) → π ↑a_1 | Restrict domain of a function `f` indexed by `α` to elements `≤ a`. | true |
analyticOrderAt_deriv_eq_top_iff_of_eq_zero | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CharZero 𝕜] [CompleteSpace E] {z₀ : 𝕜} {f : 𝕜 → E},
AnalyticAt 𝕜 f z₀ → f z₀ = 0 → (analyticOrderAt (deriv f) z₀ = ⊤ ↔ analyticOrderAt f z₀ = ⊤) | The derivative of an analytic function `f` has infinite analytic order at a zero `z₀` if and
only if `f` has infinite analytic order at `z₀`. | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.isReaderComplete.match_1 | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} →
(motive : Std.Http.Protocol.H1.Reader.State dir → Sort u_1) →
(x : Std.Http.Protocol.H1.Reader.State dir) →
(Unit → motive Std.Http.Protocol.H1.Reader.State.complete) →
((x : Std.Http.Protocol.H1.Reader.State dir) → motive x) → motive x | null | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.max._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (max a b ≤ c) = (a ≤ c ∧ b ≤ c) | null | false |
Aesop.PhaseSpec.norm.noConfusion | Aesop.Builder.Basic | {P : Sort u} →
{info info' : Aesop.NormRuleInfo} → Aesop.PhaseSpec.norm info = Aesop.PhaseSpec.norm info' → (info = info' → P) → P | null | false |
_private.Init.Data.Order.LemmasExtra.0.Std.instLawfulEqOrdOfLawfulOrderOrdOfIsPartialOrder._simp_1 | Init.Data.Order.LemmasExtra | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α] {a b : α}, (a ≤ b) = ((compare a b).isLE = true) | null | false |
Ideal.KerLift.map_smul | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R₁ : Type u_1} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A]
[inst_3 : Semiring B] [inst_4 : Algebra R₁ B] (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ RingHom.ker f),
f.kerLift (r • x) = r • f.kerLift x | null | true |
monTypeEquivalenceMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (A : MonCat) (x x_1 : (MonTypeEquivalenceMon.inverse.obj A).X),
(Equiv.refl (MonTypeEquivalenceMon.inverse.obj A).X).toFun (x * x_1) =
(Equiv.refl (MonTypeEquivalenceMon.inverse.obj A).X).toFun (x * x_1) | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._simp_9 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ min a b) = (c ≤ a ∧ c ≤ b) | null | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Add.0.MeasureTheory.lintegral_iSup._simp_1_4 | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} (f : MeasureTheory.SimpleFunc α ENNReal) (μ : MeasureTheory.Measure α),
f.lintegral μ = ∫⁻ (a : α), f a ∂μ | null | false |
ModularGroup.stabilizer_of_ne | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fd →
g • z = z → z ≠ UpperHalfPlane.I → z ≠ UpperHalfPlane.ρ → z ≠ 1 +ᵥ UpperHalfPlane.ρ → g = 1 ∨ g = -1 | If `z ∈ 𝒟` and `z ≠ I, ρ, 1 + ρ`, then the stabilizer of `z` in `SL(2, ℤ)` is `± 1`. | true |
bihimp_le_iff_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b : α), bihimp a b ≤ a ↔ Codisjoint a b | null | true |
_private.Mathlib.Algebra.Algebra.Subalgebra.Lattice.0.AlgHom.equalizer_eq_top._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = ∀ (x : B), x ∈ p ↔ x ∈ q | null | false |
Lean.instCoeNatDataValue | Lean.Data.KVMap | Coe ℕ Lean.DataValue | null | true |
Lean.NamingContext.ctorIdx | Lean.Message | Lean.NamingContext → ℕ | null | false |
Vector.mem_zipIdx._proof_2 | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α} {i : ℕ} {xs : Vector α n} {k : ℕ}, (x, i) ∈ xs.zipIdx k → i - k < n | null | false |
symmDiff_of_le | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ≤ b → symmDiff a b = b \ a | null | true |
CategoryTheory.Limits.isColimitOfUnop.eq_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F.op} (P : CategoryTheory.Limits.IsLimit t.unop),
CategoryTheory.Limits.isColimitOfUnop P = P.op | null | true |
Ring.zsmul_succ' | Mathlib.Algebra.Ring.Defs | ∀ {R : Type u} [self : Ring R] (n : ℕ) (a : R), ↑n.succ • a = ↑n • a + a | null | true |
Asymptotics.IsBigOWith.norm_left | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c : ℝ} {g : α → F}
{f' : α → E'} {l : Filter α}, Asymptotics.IsBigOWith c l f' g → Asymptotics.IsBigOWith c l (fun x => ‖f' x‖) g | **Alias** of the reverse direction of `Asymptotics.isBigOWith_norm_left`. | true |
Differentiable.rpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {p : ℝ},
Differentiable ℝ f → (∀ (x : E), f x ≠ 0 ∨ 1 ≤ p) → Differentiable ℝ fun x => f x ^ p | null | true |
MeasureTheory.Measure.map_mono_of_aemeasurable | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {δ : Type u_5} {m0 : MeasurableSpace α} [inst : MeasurableSpace δ] {μ ν : MeasureTheory.Measure α}
{f : α → δ}, μ ≤ ν → AEMeasurable f ν → MeasureTheory.Measure.map f μ ≤ MeasureTheory.Measure.map f ν | null | true |
IO.setStderr | Init.System.IO | IO.FS.Stream → BaseIO IO.FS.Stream | Replaces the standard error stream of the current thread and returns its previous value.
Use `IO.getStderr` to get the current standard error stream.
| true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceLE.declare_111._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.4077095358._hygCtx._hyg.28 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
Lean.Meta.InjectionsResult._sizeOf_1 | Lean.Meta.Tactic.Injection | Lean.Meta.InjectionsResult → ℕ | null | false |
Aesop.GoalState.isProvenByNormalization | Aesop.Tree.Data | Aesop.GoalState → Bool | null | true |
CategoryTheory.Pretriangulated.Triangle.instNegHom._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} [inst_2 : CategoryTheory.Preadditive C] (f : T₁ ⟶ T₂),
CategoryTheory.CategoryStruct.comp T₁.mor₁ (-f.hom₂) = CategoryTheory.CategoryStruct.comp (-f.hom₁) T₂.mor₁ | null | false |
_private.Std.Data.DTreeMap.Raw.Lemmas.0.Std.DTreeMap.Raw.Equiv.union_right.match_1_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₂ t₃ : Std.DTreeMap.Raw α β cmp}
(motive : t₂.Equiv t₃ → Prop) (equiv : t₂.Equiv t₃), (∀ (equiv : t₂.inner.Equiv t₃.inner), motive ⋯) → motive equiv | null | false |
Std.Time.FormatPart.string | Std.Time.Format.Basic | String → Std.Time.FormatPart | A string literal.
| true |
Lean.Macro.Exception.ctorElim | Init.Prelude | {motive : Lean.Macro.Exception → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Macro.Exception) → ctorIdx = t.ctorIdx → Lean.Macro.Exception.ctorElimType ctorIdx → motive t | null | false |
fderivWithin_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E), fderivWithin 𝕜 (fun x => f (x - a)) s x = fderivWithin 𝕜 f (-a +ᵥ s) ... | null | true |
HomologicalComplex.extendOpIso._proof_1 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_4} {ι' : Type u_1} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) (e : c.Embedding c') (x x_1 : ι'),
c'.symm.Rel... | null | false |
Lean.Compiler.LCNF.CSE.State.subst._default | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure | null | false |
CategoryTheory.EffectiveEpi.uniq | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y W : C} (f : Y ⟶ X)
[inst_1 : CategoryTheory.EffectiveEpi f] (e : Y ⟶ W)
(h :
∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ e = ... | null | true |
MeasureTheory.MeasurePreserving.add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Add G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddLeftInvariant] (g : G) {X : Type u_3} [inst_4 : MeasurableSpace X] {μ' : MeasureTheory.Measure X} {f : X → G},
MeasureTheory.MeasurePreserving f μ' μ → MeasureTheory.MeasurePreserving (fun x => g + f... | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal.0.SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂._proof_1_9 | Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal | ∀ {n : ℕ} (k i j : ℕ), i + (k + 1) = j → ¬i + k ≤ j → False | null | false |
CategoryTheory.Precoverage.Saturate.casesOn | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} {X : C} {a : CategoryTheory.Sieve X}
(t : J.Saturate X a),
(∀ (X : C) (S : CategoryTheory.Presieve X) (hS : S ∈ J.coverings X), motive X (Cate... | null | false |
Int.Internal.Linear.Poly.div.eq_def | Init.Data.Int.Linear | ∀ (k : ℤ) (x : Int.Internal.Linear.Poly),
Int.Internal.Linear.Poly.div k x =
match x with
| Int.Internal.Linear.Poly.num k' => Int.Internal.Linear.Poly.num (Int.Internal.Linear.cdiv k' k)
| Int.Internal.Linear.Poly.add k' x p => Int.Internal.Linear.Poly.add (k' / k) x (Int.Internal.Linear.Poly.div k p) | null | true |
Filter.Subsingleton.of_subsingleton._simp_1 | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1} {l : Filter α} [Subsingleton α], l.Subsingleton = True | null | false |
subset_interior_vadd | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace β] [inst_1 : AddGroup α] [inst_2 : AddAction α β]
[ContinuousConstVAdd α β] {s : Set α} {t : Set β} [inst_4 : TopologicalSpace α],
interior s +ᵥ interior t ⊆ interior (s +ᵥ t) | null | true |
Mathlib.Meta.FunProp.transitionTheoremsExt | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.GeneralTheoremsExt | Environment extension for transition theorems. | true |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt_apply_zero | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : Ring R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], (Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt v) 0 = 0 | null | true |
Lean.MonadCacheT.instMonadRef | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Lean.MonadRef m] → Lean.MonadRef (Lean.MonadCacheT α β m) | null | true |
AddMonoidAlgebra.nonAssocSemiring._proof_3 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddZeroClass M], AddMonoidAlgebra.single 0 ↑0 = 0 | null | false |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_pos_of_ne_zero._proof_1_2 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {p : Polynomial ℂ}, p ≠ 0 → 0 < p.mahlerMeasure | null | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidal_obj | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.AddMon C),
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidal C).obj A =
CategoryTheory.LaxMonoidalFunctor.of (CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addM... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.