name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Tactic.NormNum.DivMod.0.Mathlib.Meta.NormNum.evalIntMod.go._proof_1 | Mathlib.Tactic.NormNum.DivMod | ∀ (inst : Q(AddMonoidWithOne ℤ)), «$inst» =Q Int.instRing.toAddGroupWithOne.toAddMonoidWithOne | null | false |
RegularWreathProduct.mk.sizeOf_spec | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} [inst : SizeOf D] [inst_1 : SizeOf Q] (left : Q → D) (right : Q),
sizeOf { left := left, right := right } = 1 + sizeOf right | null | true |
Subalgebra.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {A : Type u_2} [inst : Semiring A] {α : Type u_1} [inst_1 : MulAction A α] (b : α), 1 • b = b | null | false |
ProbabilityTheory.CondIndepSets.iUnion | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {s : ι → Set (Set Ω)} {s' : Set (Set Ω)},
(∀ (n : ι), ProbabilityTheory.CondIndepSets m' hm' (s n) s' μ) →
ProbabilityTheory.CondInde... | null | true |
List.maximum_nil | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DecidableLT α], [].maximum = ⊥ | null | true |
FixedDetMatrices.repsFintype | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | (k : ℤ) → Fintype ↑(FixedDetMatrices.reps k) | null | true |
Sylow.isPretransitive_of_finite | Mathlib.GroupTheory.Sylow | ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [hp : Fact (Nat.Prime p)] [Finite (Sylow p G)],
MulAction.IsPretransitive G (Sylow p G) | A generalization of **Sylow's second theorem**.
If the number of Sylow `p`-subgroups is finite, then all Sylow `p`-subgroups are conjugate. | true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform.0.GaussianFourier.integral_cexp_neg_mul_sum_add._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ (x : ℂ) (n : ℕ) (y : ℂ), (x ^ y) ^ n = x ^ (↑n * y) | null | false |
BoundedRandom.mk | Mathlib.Control.Random | {m : Type u → Type u_1} →
{α : Type u} →
[inst : Preorder α] →
({g : Type} → (lo hi : α) → lo ≤ hi → [RandomGen g] → RandGT g m { a // lo ≤ a ∧ a ≤ hi }) → BoundedRandom m α | null | true |
ByteArray.utf8DecodeChar?.FirstByte.done.sizeOf_spec | Init.Data.String.Decode | sizeOf ByteArray.utf8DecodeChar?.FirstByte.done = 1 | null | true |
isGreatest_mapClusterPt_limsup._auto_1 | Mathlib.Topology.Order.LiminfLimsup | Lean.Syntax | null | false |
Std.DTreeMap.Raw.Const.contains_alter_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Raw.Const.alter t k f).contains k = (f (Std.DTreeMap.Raw.Const.get? t k)).isSome | null | true |
Std.DHashMap.Internal.AssocList._sizeOf_inst | Std.Data.DHashMap.Internal.AssocList.Basic | (α : Type u) → (β : α → Type v) → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DHashMap.Internal.AssocList α β) | null | false |
_private.Mathlib.CategoryTheory.Galois.EssSurj.0.CategoryTheory.PreGaloisCategory.quotientToEndObjectHom | Mathlib.CategoryTheory.Galois.EssSurj | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
[inst_1 : CategoryTheory.GaloisCategory C] →
[CategoryTheory.PreGaloisCategory.FiberFunctor F] →
(V : OpenSubgroup (CategoryTheory.Aut F)) →
{U : OpenSubgroup (CategoryTheo... | null | true |
List.splitLengths.match_1 | Mathlib.Data.List.SplitLengths | {α : Type u_1} →
(motive : List α × List α → Sort u_2) → (x : List α × List α) → ((x0 x1 : List α) → motive (x0, x1)) → motive x | null | false |
CategoryTheory.IsRegularEpi.exists_of_isKernelPair | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (π : X ⟶ Y) [CategoryTheory.IsRegularEpi π] {Z : C}
{fst snd : Z ⟶ X},
CategoryTheory.IsKernelPair π fst snd →
∀ {W : C} (f : X ⟶ W),
CategoryTheory.CategoryStruct.comp fst f = CategoryTheory.CategoryStruct.comp snd f →
∃ g, Catego... | null | true |
SubMulAction.copy | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : SMul R M] → (p : SubMulAction R M) → (s : Set M) → s = ↑p → SubMulAction R M | Copy of a sub_mul_action with a new `carrier` equal to the old one. Useful to fix definitional
equalities. | true |
IsInvariantSubfield.toMulSemiringAction._proof_6 | Mathlib.FieldTheory.Fixed | ∀ (M : Type u_2) [inst : Monoid M] {F : Type u_1} [inst_1 : Field F] [inst_2 : MulSemiringAction M F] (S : Subfield F)
[inst_3 : IsInvariantSubfield M S] (m : M) (s₁ s₂ : ↥S), m • (s₁ + s₂) = m • s₁ + m • s₂ | null | false |
Unitization | Mathlib.Algebra.Algebra.Unitization | Type u_1 → Type u_2 → Type (max u_1 u_2) | The minimal unitization of a non-unital `R`-algebra `A`. This is just a structure wrapper for
`R × A`. | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM.go.eq_def | Init.Data.Vector.OfFn | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} {n : ℕ} [inst : Monad m] (f : Fin n → m α) (i : ℕ) (h' : i ≤ n)
(acc : Array α) (w : acc.size = i),
Vector.ofFnM.go✝ f i h' acc w =
if h : i < n then do
let __do_lift ← f ⟨i, h⟩
Vector.ofFnM.go✝ f (i + 1) ⋯ (acc.push __do_lift) ⋯
else pure (Vector.mk ac... | null | true |
List.Perm.eq_of_pairwise' | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Antisymm r] {l₁ l₂ : List α},
List.Pairwise r l₁ → List.Pairwise r l₂ → l₁.Perm l₂ → l₁ = l₂ | Variant of `Perm.eq_of_pairwise` using relation typeclasses. | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.deduplicate.match_3 | Lean.Elab.Quotation | (motive : Array Lean.Syntax → Sort u_1) →
(__do_lift : Array Lean.Syntax) → (Unit → motive #[]) → ((vars : Array Lean.Syntax) → motive vars) → motive __do_lift | null | false |
Int.cast_negOnePow | Mathlib.Algebra.Field.NegOnePow | ∀ (K : Type u_1) (n : ℤ) [inst : DivisionRing K], ↑↑n.negOnePow = (-1) ^ n | null | true |
Ideal.homogeneousHull_eq_iSup | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜] (I : Ideal A),
Ideal.homogeneousHull 𝒜 I = ⨆ i, { toSubmodule := Ideal.span (⇑(GradedRing.proj 𝒜 i) '' ↑I... | null | true |
Lex.instZero.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Zero α], Lex.instZero = inst | null | true |
Lean.Elab.ComputedFields.mkComputedFieldOverrides | Lean.Elab.ComputedFields | Lean.Name → Array Lean.Name → Lean.MetaM Unit | null | true |
Submodule.factorPowSucc | Mathlib.RingTheory.Ideal.Quotient.PowTransition | {R : Type u_1} →
[inst : Ring R] →
(I : Ideal R) →
(M : Type u_2) →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (m : ℕ) → M ⧸ I ^ (m + 1) • ⊤ →ₗ[R] M ⧸ I ^ m • ⊤ | `factorPow` for `n = m + 1` | true |
RingEquiv.instEquivLike._proof_2 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (f : R ≃+* S),
Function.LeftInverse f.invFun f.toFun | null | false |
CategoryTheory.Presieve.isSheaf_iso | Mathlib.CategoryTheory.Sites.SheafOfTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)}
(J : CategoryTheory.GrothendieckTopology C) {P' : CategoryTheory.Functor Cᵒᵖ (Type w)} (i : P ≅ P'),
CategoryTheory.Presieve.IsSheaf J P → CategoryTheory.Presieve.IsSheaf J P' | The property of being a sheaf is preserved by isomorphism. | true |
Int16.toBitVec.inj | Init.Data.SInt.Basic | ∀ {x y : Int16}, x.toBitVec = y.toBitVec → x = y | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.map_toTriangle_disjoint._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
CategoryTheory.coevaluation_comp_leftAdjointMate | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y] (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (η_ (ᘁY) Y) (CategoryTheory.MonoidalCategoryStruct.whiskerRight (ᘁf) Y) =... | null | true |
Metric.isBounded_closure_iff | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {s : Set α} [inst : PseudoMetricSpace α], Bornology.IsBounded (closure s) ↔ Bornology.IsBounded s | null | true |
zero_ne_one | Mathlib.Algebra.NeZero | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], 0 ≠ 1 | null | true |
LawfulAlternative.recOn | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} →
[inst : Alternative m] →
{motive : LawfulAlternative m → Sort u} →
(t : LawfulAlternative m) →
([toLawfulApplicative : LawfulApplicative m] →
(map_failure : ∀ {α β : Type u_1} (f : α → β), f <$> failure = failure) →
(failure_seq : ∀ {α β : Type u... | null | false |
CochainComplex.HomComplex.Cocycle.precomp_coe | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C ℤ} {n : ℤ} (z : CochainComplex.HomComplex.Cocycle G K n) (f : F ⟶ G),
↑(z.precomp f) = (CochainComplex.HomComplex.Cochain.ofHom f).comp ↑z ⋯ | null | true |
CategoryTheory.Center.ofBraidedObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X U U' : C),
(β_ X (CategoryTheory.MonoidalCategoryStruct.tensorObj U U')).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.asso... | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.findDiscrRefinementPath | Lean.Elab.Match | Lean.Expr → Lean.Expr → OptionT Lean.MetaM (List ℕ) | This method is part of the "discriminant refinement" procedure. It in invoked when the
type of the `pattern` does not match the expected type. The expected type is based on the
motive computed using the `match` discriminants.
It tries to compute a path to an index of the discriminant type.
For example, suppose the user... | true |
Bifunctor.fst_snd | Mathlib.Control.Bifunctor | ∀ {F : Type u₀ → Type u₁ → Type u₂} [inst : Bifunctor F] [LawfulBifunctor F] {α₀ α₁ : Type u₀} {β₀ β₁ : Type u₁}
(f : α₀ → α₁) (f' : β₀ → β₁) (x : F α₀ β₀), Bifunctor.fst f (Bifunctor.snd f' x) = bimap f f' x | null | true |
Std.ExtDHashMap.mem_of_mem_insert | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k}, a ∈ m.insert k v → (k == a) = false → a ∈ m | null | true |
List.minimum_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DecidableLT α] {l : List α} {m : α}, l.minimum = ↑m → m ∈ l | null | true |
QuasiErgodic.ae_eq_const_of_ae_eq_comp_of_ae_range₀ | Mathlib.Dynamics.Ergodic.Function | ∀ {α : Type u_1} {X : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [Nonempty X]
[inst_2 : MeasurableSpace X] {s : Set X} [MeasurableSpace.CountablySeparated ↑s] {f : α → α} {g : α → X},
QuasiErgodic f μ →
(∀ᵐ (x : α) ∂μ, g x ∈ s) → MeasureTheory.NullMeasurable g μ → g ∘ f =ᵐ[μ] g → ∃ c, g ... | Let `f : α → α` be a (quasi)ergodic map. Let `g : α → X` be a null-measurable function
from `α` to a nonempty space with a countable family of measurable sets
separating points of a set `s` such that `g x ∈ s` for a.e. `x`.
If `g` is a.e.-invariant under `f`, then `g` is a.e. constant. | true |
Mathlib.Tactic.IntervalCases.intMethods | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods | A `Methods` implementation for `ℤ`.
This tells `interval_cases` how to work on integers. | true |
Std.IterM.Partial.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM m β → Std.IterM.Partial m β | null | false |
Std.Do.Except.instWPMonad | Std.Do.WP.Monad | {ε : Type u_1} → Std.Do.WPMonad (Except ε) (Std.Do.PostShape.except ε Std.Do.PostShape.pure) | null | true |
SemimoduleCat.Hom.hom | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → [inst : Semiring R] → {A B : SemimoduleCat R} → A.Hom B → ↑A →ₗ[R] ↑B | Turn a morphism in `SemimoduleCat` back into a `LinearMap`. | true |
USize.le_zero_iff._simp_1 | Init.Data.UInt.Lemmas | ∀ {a : USize}, (a ≤ 0) = (a = 0) | null | false |
PrimitiveSpectrum.hull_iSup | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u_1} [inst : CompleteLattice α] {T : Set α} {ι : Sort v} (s : ι → α),
PrimitiveSpectrum.hull T (iSup s) = ⋂ i, PrimitiveSpectrum.hull T (s i) | null | true |
PrimeSpectrum.preimageEquivFiber._proof_11 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : PrimeSpectrum R)
(q : ↑(PrimeSpectrum.comap (algebraMap R S) ⁻¹' {p})),
IsScalarTower R R (IsLocalRing.ResidueField (Localization.AtPrime (↑q).asIdeal)) | null | false |
Lean.Meta.Grind.Origin.fvar.injEq | Lean.Meta.Tactic.Grind.Theorems | ∀ (fvarId fvarId_1 : Lean.FVarId),
(Lean.Meta.Grind.Origin.fvar fvarId = Lean.Meta.Grind.Origin.fvar fvarId_1) = (fvarId = fvarId_1) | null | true |
CategoryTheory.PreGaloisCategory.instGroupAutGalois._proof_20 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat),
autoParam (∀ (n : ℕ) (a : CategoryTheory.PreGaloisCategory.AutGalois F), a ^ ↑n.succ = a ^ ↑n * a)
DivInvMonoid.zpow_succ'._autoParam | null | false |
tsum_congr | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {L : SummationFilter β}
{f g : β → α}, (∀ (b : β), f b = g b) → ∑'[L] (b : β), f b = ∑'[L] (b : β), g b | null | true |
Lean.Parser.Tactic.Grind.next | Init.Grind.Interactive | Lean.ParserDescr | `next => tac` focuses on the next goal and solves it using `tac`, or else fails.
`next x₁ ... xₙ => tac` additionally renames the `n` most recent hypotheses with
inaccessible names to the given names.
| true |
Graph.IsSpanningSubgraph.rfl | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β}, G ≤s G | null | true |
CFC.tendsto_cfc_rpow_sub_one_log | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a : A},
autoParam (IsStrictlyPositive a) CFC.tendsto_cfc_rpow_sub_one_log._auto_1 →
Filter.Tendsto (fun p => cfc (fun x => p⁻¹ * (x ^ p - 1)) a) (nhdsWithin 0 (Set.Ioi 0)) (nhds (CFC.log a)) | null | true |
MeasureTheory.Measure.dense_of_ae | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ : MeasureTheory.Measure X} [μ.IsOpenPosMeasure]
{p : X → Prop}, (∀ᵐ (x : X) ∂μ, p x) → Dense {x | p x} | A property satisfied almost everywhere is satisfied on a dense subset. | true |
Matrix.det_of_lowerTriangular | Mathlib.LinearAlgebra.Matrix.Block | ∀ {m : Type u_2} {R : Type v} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : LinearOrder m]
(M : Matrix m m R), M.IsLowerTriangular → M.det = ∏ i, M i i | **Alias** of `Matrix.det_of_isLowerTriangular`. | true |
MulOpposite.opLinearEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M] (x y : M),
MulOpposite.opAddEquiv.toFun (x + y) = MulOpposite.opAddEquiv.toFun x + MulOpposite.opAddEquiv.toFun y | null | false |
Lean.Elab.Tactic.UnusedSimpArgsInfo.recOn | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.UnusedSimpArgsInfo → Sort u} →
(t : Lean.Elab.Tactic.UnusedSimpArgsInfo) → ((mask : Array Bool) → motive { mask := mask }) → motive t | null | false |
exteriorPower.toTensorPower | Mathlib.LinearAlgebra.ExteriorPower.Pairing | (R : Type u_1) →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (n : ℕ) → ↥(⋀[R]^n M) →ₗ[R] TensorPower R n M | The linear map from the `n`th exterior power to the `n`th tensor power obtained by
`MultilinearMap.alternatization`. | true |
LinearIsometryEquiv.comp_differentiableWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (iso : E ≃ₗᵢ[𝕜] F) {f : G → E} {s : ... | null | true |
CStarAlgebra.norm_mem_spectrum_of_nonneg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] [Nontrivial A] (a : A),
autoParam (0 ≤ a) CStarAlgebra.norm_mem_spectrum_of_nonneg._auto_1 → ‖a‖ ∈ spectrum ℝ a | null | true |
UInt32.toUInt8_toUInt16 | Init.Data.UInt.Lemmas | ∀ (n : UInt32), n.toUInt16.toUInt8 = n.toUInt8 | null | true |
Std.ExtDHashMap.noConfusionType | Std.Data.ExtDHashMap.Basic | Sort u_1 →
{α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
Std.ExtDHashMap α β →
{α' : Type u} →
{β' : α' → Type v} → [inst' : BEq α'] → [inst'_1 : Hashable α'] → Std.ExtDHashMap α' β' → Sort u_1 | null | false |
_private.Mathlib.Tactic.IntervalCases.0.Mathlib.Tactic.IntervalCases.Methods.getBound.match_1 | Mathlib.Tactic.IntervalCases | (motive : ℤ × Lean.Expr × Lean.Expr → Sort u_1) →
(x : ℤ × Lean.Expr × Lean.Expr) → ((z : ℤ) → (a' eq : Lean.Expr) → motive (z, a', eq)) → motive x | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point.0.WeierstrassCurve.Jacobian.Point.ext.match_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Jacobian R} (motive : W'.Point → Prop) (h : W'.Point),
(∀ (point : WeierstrassCurve.Jacobian.PointClass R) (nonsingular : W'.NonsingularLift point),
motive { point := point, nonsingular := nonsingular }) →
motive h | null | false |
FreeGroup.Red.Step.cons_not._simp_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}, FreeGroup.Red.Step ((x, b) :: (x, !b) :: L) L = True | null | false |
Std.Tactic.BVDecide.Reflect.verifyBVExpr | Std.Tactic.BVDecide.Reflect | Std.Tactic.BVDecide.BVLogicalExpr → String → Bool | Verify that `cert` is an UNSAT proof for the SAT problem obtained by bitblasting `bv`.
| true |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxi.instIsAlwaysFiniteOfLawfulHasSize._proof_1 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u_1} [inst : Std.Rxi.HasSize α] (n : ℕ) (a : α),
Std.Rxi.HasSize.size a + 1 = n + 1 → ¬Std.Rxi.HasSize.size a = n → False | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_11 | Init.Data.BitVec.Lemmas | ∀ (n j : ℕ), j ≤ n → ¬j ≤ n + 1 → False | null | false |
MeasureTheory.JordanDecomposition.instInvolutiveNeg._proof_4 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (x : MeasureTheory.JordanDecomposition α),
{ posPart := x.negPart, negPart := x.posPart, posPart_finite := ⋯, negPart_finite := ⋯,
mutuallySingular := ⋯ }.negPart.MutuallySingular
{ posPart := x.negPart, negPart := x.posPart, posPart_finite := ⋯, negPart_finit... | null | false |
WeierstrassCurve.Jacobian.addY_of_Z_eq_zero_right | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation Q → Q 2 = 0 → W'.addY P Q = (-(Q 0 * P 2)) ^ 3 * P 1 | null | true |
Aesop.ForwardClusterStateStats.noConfusionType | Aesop.Stats.Basic | Sort u → Aesop.ForwardClusterStateStats → Aesop.ForwardClusterStateStats → Sort u | null | false |
UniformSpace.Completion.instNormedCommRing._proof_5 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedCommRing A] (a b : UniformSpace.Completion A), a * b = b * a | null | false |
_private.Mathlib.FieldTheory.Galois.Notation.0.delabGal.match_6 | Mathlib.FieldTheory.Galois.Notation | (motive : List Lean.Level → Sort u_1) →
(x : List Lean.Level) →
((u v head : Lean.Level) → motive [u, v, head]) → ((x : List Lean.Level) → motive x) → motive x | null | false |
Std.Http.Protocol.H1.Event.next.elim | Std.Http.Protocol.H1.Event | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Event dir → Sort u} →
(t : Std.Http.Protocol.H1.Event dir) → t.ctorIdx = 6 → motive Std.Http.Protocol.H1.Event.next → motive t | null | false |
WithBot.one_eq_coe._simp_2 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : One α] {a : α}, (1 = ↑a) = (a = 1) | null | false |
NumberField.ComplexEmbedding.involutive_conjugate | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ (K : Type u_1) [inst : Field K], Function.Involutive NumberField.ComplexEmbedding.conjugate | null | true |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentData.0.CategoryTheory.Pseudofunctor.DescentData.Hom.ext.match_1 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_5} {inst : CategoryTheory.Category.{u_3, u_5} C}
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentData f} (motive : D₁.Hom D₂ → Prop) (h : D₁.Hom D₂),
(∀ (hom : (i : ι) → D₁.obj i ⟶... | null | false |
Lean.Compiler.LCNF.Simp.ConstantFold.mkAuxLit | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
α → optParam Lean.Name `_x → Lean.Compiler.LCNF.Simp.ConstantFold.FolderM Lean.FVarId | A wrapper around `mkAuxLetDecl` that also calls `mkLit`.
| true |
IsUniformEmbedding.comapMetricSpace._proof_1 | Mathlib.Topology.MetricSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [m : MetricSpace β] (f : α → β),
IsUniformEmbedding f → Function.Injective f | null | false |
Finset.image₂_singleton_left' | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {t : Finset β} {a : α},
Finset.image₂ f {a} t = Finset.image (f a) t | null | true |
Batteries.DList.append.match_1 | Batteries.Data.DList.Basic | {α : Type u_1} →
(motive : Batteries.DList α → Batteries.DList α → Sort u_2) →
(x x_1 : Batteries.DList α) →
((f : List α → List α) →
(h₁ : ∀ (l : List α), f l = f [] ++ l) →
(g : List α → List α) →
(h₂ : ∀ (l : List α), g l = g [] ++ l) →
motive { apply :... | null | false |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.whiskerLeftIso._proof_3 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ : CategoryTheory.Arrow C) {W : C}
[inst_3 :
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.span (CategoryTheory.MonoidalCategoryS... | null | false |
HasProd.of_subsingleton_cod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {L : SummationFilter β}
[Subsingleton α], HasProd f 1 L | null | true |
Lean.Kernel.Exception.deterministicTimeout.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) → t.ctorIdx = 13 → motive Lean.Kernel.Exception.deterministicTimeout → motive t | null | false |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.ParentGeChildren.set_of_ge._proof_1_5 | Batteries.Data.BinaryHeap.WF | ∀ {sz : ℕ} {i : Fin sz}, 2 * ↑i + 1 < sz → 2 * ↑i + 1 < sz | null | false |
Lean.LLVM.Target.noConfusion | Lean.Compiler.IR.LLVMBindings | {P : Sort u} →
{ctx : Lean.LLVM.Context} →
{t : Lean.LLVM.Target ctx} →
{ctx' : Lean.LLVM.Context} →
{t' : Lean.LLVM.Target ctx'} → ctx = ctx' → t ≍ t' → Lean.LLVM.Target.noConfusionType P t t' | null | false |
SimpleGraph.Hom.sum_sum_comp_sumAssoc | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {U : Type u_1} {U' : Type u_2} {V : Type u_3} {V' : Type u_4} {W : Type u_5} {W' : Type u_6} {G : SimpleGraph V}
{H : SimpleGraph W} {I : SimpleGraph U} {G' : SimpleGraph V'} {H' : SimpleGraph W'} {I' : SimpleGraph U'}
(f : G →g G') (g : H →g H') (h : I →g I'),
(f.sum (g.sum h)).comp SimpleGraph.Iso.sumAssoc.to... | null | true |
QuadraticMap.map_sum' | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] {ι : Type u_8} (Q : QuadraticMap R M N) (s : Finset ι) (f : ι → M),
Q (∑ i ∈ s, f i) = ∑ ij ∈ s.sym2, QuadraticMap.polarSym2 (⇑Q) (Sym2.map f ij) - ∑ i ∈... | null | true |
Ideal.mul_bot | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] (I : Ideal R), I * ⊥ = ⊥ | null | true |
DirectLimit.Algebra.of._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : CommSemiri... | null | false |
InverseSystem.PEquivOn.ext_iff | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_6} {F : ι → Type u_7} {X : ι → Type u_8} {inst : LinearOrder ι} {f : ⦃i j : ι⦄ → i ≤ j → F j → F i}
{inst_1 : SuccOrder ι} {equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} {s : Set ι}
{x y : InverseSystem.PEquivOn f equivSucc s}, x = y ↔ x.equiv = y.equiv | null | true |
Composition.one_le_blocks' | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : Composition n) {i : ℕ} (h : i < c.length), 1 ≤ c.blocks[i] | null | true |
CategoryTheory.ShortComplex.SnakeInput.exact_C₃_up | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
{ X₁ := S.L₀.X₃, X₂ := S.L₁.X₃, X₃ := S.L₂.X₃, f := S.v₀₁.τ₃, g := S.v₁₂.τ₃, zero := ⋯ }.Exact | The upper part of the third column of the snake diagram is exact. | true |
ProbabilityTheory.stronglyMeasurable_uncurry_gaussianPDFReal | Mathlib.Probability.Distributions.Gaussian.Real | MeasureTheory.StronglyMeasurable fun x =>
match x with
| (μ, v, x) => ProbabilityTheory.gaussianPDFReal μ v x | The Gaussian pdf is strongly measurable. | true |
MvPolynomial.degreeOf_sub_le | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (i : σ) (p q : MvPolynomial σ R),
MvPolynomial.degreeOf i (p - q) ≤ max (MvPolynomial.degreeOf i p) (MvPolynomial.degreeOf i q) | null | true |
Function.mulSupport_prodMk' | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : One M] [inst_1 : One N] (f : ι → M × N),
Function.mulSupport f = (Function.mulSupport fun x => (f x).1) ∪ Function.mulSupport fun x => (f x).2 | null | true |
Ordinal.monoid | Mathlib.SetTheory.Ordinal.Arithmetic | Monoid Ordinal.{u} | The multiplication of ordinals `a` and `b` is the order type of the lexicographic order on
`b × a`. | true |
Lean.Elab.ErrorNameInfo.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → Lean.Elab.ErrorNameInfo → Lean.Elab.ErrorNameInfo → Sort u | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.