name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HasEnoughRootsOfUnity.natCard_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Nat.card ↥(rootsOfUnity n M) = n | If `M` satisfies `HasEnoughRootsOfUnity`, then the group of `n`th roots of unity
in `M` (is cyclic and) has order `n`. | true |
ENNReal.ofReal_ne_top._simp_1 | Mathlib.Basic.ENNReal.Basic | ∀ {r : ℝ}, (ENNReal.ofReal r = ⊤) = False | null | false |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.mem_associatedPrimes_of_comap_mem_associatedPrimes_of_isLocalizedModule._simp_1_9 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{x : M} {r : R}, (r • x ∈ N) = (r ∈ N.colon {x}) | null | false |
_private.Mathlib.GroupTheory.Subgroup.Center.0.Subgroup.center_eq_top_iff._simp_1_2 | Mathlib.GroupTheory.Subgroup.Center | ∀ {M : Type u_2} [inst : Mul M], IsMulCommutative M = ∀ (a b : M), a * b = b * a | null | false |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_6 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [IsOrderedRing R], IsStrictOrderedRing R | null | false |
Aesop.Match.casesOn | Aesop.Forward.Match.Types | {motive : Aesop.Match → Sort u} →
(t : Aesop.Match) →
((subst : Aesop.Substitution) →
(patInstSubsts : Array Aesop.Substitution) →
(level : Aesop.SlotIndex) →
(forwardDeps conclusionDeps : Array Aesop.PremiseIndex) →
motive
{ subst := subst, patInstSubst... | null | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.mdifferentiableWithinAt_pi_space._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
CategoryTheory.SimplicialObject.Splitting.PInfty_toNondegComplex | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C],
CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.PInfty s.toNondegComplex = s.toNondegComplex | null | true |
Std.DHashMap.Internal.AssocList.getCast?._f | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
(a : α) → (x : Std.DHashMap.Internal.AssocList α β) → Std.DHashMap.Internal.AssocList.below x → Option (β a) | null | false |
Set.preimage_const_mul_Iic | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => a * x) ⁻¹' Set.Iic b = Set.Iic (b / a) | null | true |
RootPairingCat.coweightIsAddCommGroup | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} → [inst : CommRing R] → (self : RootPairingCat R) → AddCommGroup self.coweight | null | true |
Finset.falling.eq_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] (k : ℕ) (𝒜 : Finset (Finset α)),
Finset.falling k 𝒜 = 𝒜.sup (Finset.powersetCard k) | null | true |
lTensor.inverse_of_rightInverse._proof_10 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_1} {P : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_2) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUInt8_lt._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a < b) = (a.toNat < b.toNat) | null | false |
Holor.instModule._proof_5 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Semiring α] (r s : α) (x : Holor α ds), (r + s) • x = r • x + s • x | null | false |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurableSet_inl_image._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set (α ⊕ β)},
MeasurableSet s = (MeasurableSet (Sum.inl ⁻¹' s) ∧ MeasurableSet (Sum.inr ⁻¹' s)) | null | false |
List.isChain_cons_eq_iff_eq_replicate | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} {l : List α}, List.IsChain (fun x1 x2 => x1 = x2) (a :: l) ↔ l = List.replicate l.length a | null | true |
iSupIndep_iff_pairwiseDisjoint | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Order.Frame α] {f : ι → α}, iSupIndep f ↔ Pairwise (Function.onFun Disjoint f) | null | true |
Vitali.exists_disjoint_subfamily_covering_enlargement_closedBall | Mathlib.MeasureTheory.Covering.Vitali | ∀ {α : Type u_1} {ι : Type u_2} [inst : PseudoMetricSpace α] (t : Set ι) (x : ι → α) (r : ι → ℝ) (R : ℝ),
(∀ a ∈ t, r a ≤ R) →
∀ (τ : ℝ),
3 < τ →
∃ u ⊆ t,
(u.PairwiseDisjoint fun a => Metric.closedBall (x a) (r a)) ∧
∀ a ∈ t, ∃ b ∈ u, Metric.closedBall (x a) (r a) ⊆ Metric.clos... | Vitali covering theorem, closed balls version: given a family `t` of closed balls, one can
extract a disjoint subfamily `u ⊆ t` so that all balls in `t` are covered by the τ-times
dilations of balls in `u`, for some `τ > 3`. | true |
Std.DTreeMap.Internal.Impl.foldr_eq_foldr_keysArray | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t : Std.DTreeMap.Internal.Impl α β} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.DTreeMap.Internal.Impl.foldr (fun a x d => f a d) init t = Array.foldr f init t.keysArray | null | true |
Algebra.IsPushout.cancelBaseChange | Mathlib.RingTheory.IsTensorProduct | (R : Type u_1) →
(S : Type v₃) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
(A : Type u_8) →
(B : Type u_9) →
[inst_3 : CommRing A] →
[inst_4 : CommRing B] →
[inst_5 : Algebra R A] →
... | If `B = S ⊗[R] A`, this is the canonical `S`-isomorphism: `B ⊗[A] M ≃ₗ[S] S ⊗[R] M`.
This is the cancelling on the left version of
`TensorProduct.AlgebraTensorModule.cancelBaseChange`. | true |
Prod.lex_iff | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {x y : α × β},
Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2 | null | true |
SemiNormedGrp.Hom.mk | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp} → NormedAddGroupHom M.carrier N.carrier → M.Hom N | null | true |
AlgebraicGeometry.StructureSheaf.IsLocalization.to_basicOpen | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R] (r : R),
IsLocalization.Away r ↑((AlgebraicGeometry.Spec.structureSheaf R).obj.obj (Opposite.op (PrimeSpectrum.basicOpen r))) | Sections of the structure sheaf of Spec R on a basic open as localization of R | true |
Metric.PiNatEmbed.continuous_distDenseSeq_inv | Mathlib.Topology.MetricSpace.PiNat | ∀ {X : Type u_3} [inst : MetricSpace X] [inst_1 : TopologicalSpace.SeparableSpace X],
Continuous Metric.PiNatEmbed.ofPiNat | null | true |
LieIdeal.lieAlgebra._proof_3 | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u_2) (L : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
SMulMemClass (LieSubmodule R L L) R L | null | false |
Real.instField._proof_5 | Mathlib.Basic.Real.Basic | ∀ (a : ℝ), a ≠ 0 → a * a⁻¹ = 1 | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.Element.fun | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.ToLCNF.Element✝ | null | true |
FiniteGaloisIntermediateField.noConfusionType | Mathlib.FieldTheory.Galois.GaloisClosure | Sort u →
{k : Type u_1} →
{K : Type u_2} →
[inst : Field k] →
[inst_1 : Field K] →
[inst_2 : Algebra k K] →
FiniteGaloisIntermediateField k K →
{k' : Type u_1} →
{K' : Type u_2} →
[inst' : Field k'] →
[inst'_1 ... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.getVert_dropLast._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
p.length - 1 ≤ p.length → p.length - 1 < p.support.length | null | false |
Ideal.Fiber.algEquivAux₂._proof_5 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal (p.Fiber S)) [q.IsPrime], (Ideal.comap Algebra.TensorProduct.includeRight q).IsPrime | null | false |
MonoidWithZeroHom.ValueGroup₀ | Mathlib.Algebra.GroupWithZero.Range | {A : Type u_1} → {B : Type u_2} → [inst : MonoidWithZero A] → [inst_1 : MonoidWithZero B] → (A →*₀ B) → Type u_2 | For a morphism of monoids with zero `f`, this is a smallest subgroup with zero of the
codomain containing the range of `f`. | true |
HasDerivWithinAt.hasFDerivWithinAt | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} [inst_4 : ContinuousSMul 𝕜 F] {f' : F},
HasDerivWithinAt f f' s x → HasFDerivWithinAt f (ContinuousLinearMap.toSpanSingleton 𝕜 f') s x | **Alias** of the forward direction of `hasDerivWithinAt_iff_hasFDerivWithinAt`.
---
Expressing `HasDerivWithinAt f f' s x` in terms of `HasFDerivWithinAt` | true |
Std.DHashMap.Raw.getKey | Std.Data.DHashMap.Raw | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → (m : Std.DHashMap.Raw α β) → (a : α) → a ∈ m → α | Retrieves the key from the mapping that matches `a`. Ensures that such a mapping exists by
requiring a proof of `a ∈ m`. The result is guaranteed to be pointer equal to the key in the map.
| true |
Std.IterM.toListRev.go | Init.Data.Iterators.Consumers.Monadic.Collect | {α : Type w} →
{m : Type w → Type w'} → [Monad m] → {β : Type w} → [Std.Iterator α m β] → Std.IterM m β → List β → m (List β) | null | true |
Finset.inf_mem_of_nonempty | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] [inst_1 : OrderTop α] {s : Finset ι} {f : ι → α},
s.Nonempty → s.inf f ∈ f '' ↑s | null | true |
Std.DTreeMap.Internal.Impl.ordered_containsThenInsertIfNew! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α} {v : β k} {l : Std.DTreeMap.Internal.Impl α β},
l.Balanced → l.Ordered → (Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! k v l).2.Ordered | null | true |
Lean.Meta.Occurrences.noConfusionType | Init.MetaTypes | Sort u → Lean.Meta.Occurrences → Lean.Meta.Occurrences → Sort u | null | false |
List.cons_diff_of_not_mem | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l₂ : List α},
a ∉ l₂ → ∀ (l₁ : List α), (a :: l₁).diff l₂ = a :: l₁.diff l₂ | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Affine.CoordinateRing.mk_ψ._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | null | false |
RingEquivClass.toLinearEquivClassRat | Mathlib.Algebra.Algebra.Rat | ∀ {F : Type u_1} {R : Type u_2} {S : Type u_3} [inst : DivisionRing R] [inst_1 : CharZero R] [inst_2 : DivisionRing S]
[inst_3 : CharZero S] [inst_4 : EquivLike F R S] [RingEquivClass F R S], LinearEquivClass F ℚ R S | null | true |
FunLike.compMonoidWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.FunLike | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α α] [inst_1 : Mul F] [IsMulApplyEqComp F α] (x x_1 x_2 : F),
x * x_1 * x_2 = x * (x_1 * x_2) | null | false |
Std.Http.Protocol.H1.parseRequestLine | Std.Http.Protocol.H1.Parser | Std.Http.Protocol.H1.Config → Std.Internal.Parsec.ByteArray.Parser Std.Http.Request.Head | Parses a request line and returns a fully-typed `Request.Head`.
`request-line = method SP request-target SP HTTP-version`
| true |
_private.Init.Data.Int.Order.0.Int.mem_toNat?.match_1_9 | Init.Data.Int.Order | ∀ (m n : ℕ) (motive : Int.negSucc m = ↑n → Prop) (a : Int.negSucc m = ↑n), motive a | null | false |
Std.Time.Day.Offset.toMinutes | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Minute.Offset | Convert `Day.Offset` into `Minute.Offset`.
| true |
Turing.proj | Mathlib.Computability.TuringMachine.Tape | {ι : Type u_1} →
{Γ : ι → Type u_2} → [inst : (i : ι) → Inhabited (Γ i)] → (i : ι) → Turing.PointedMap ((i : ι) → Γ i) (Γ i) | The `i`-th projection as a pointed map. | true |
Std.DTreeMap.Internal.Impl.balance!.match_1 | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
motive
... | null | false |
CategoryTheory.Arrow.augmentedCechConerve_right | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom],
f.augmentedCechConerve.right = f.cechConerve | null | true |
ENNReal.tsum_eq_zero._simp_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 | null | false |
Lean.Elab.Do.withRefinedResultType | Lean.Elab.Do.Basic | {α : Type} → Lean.Expr → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α | Refine the result type of the `do` block and its `return` continuation for the scope of `k`,
as needed for a dependent `match` branch where a bare `return` targets the refined branch type.
Relies on the `return` continuation result type coinciding with the `do` block result type, which
holds for the tail-position depe... | true |
_private.Mathlib.Data.List.TFAE.0.List.forall_tfae._simp_1_2 | Mathlib.Data.List.TFAE | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop}, (∀ i ∈ List.map f l, P i) = ∀ j ∈ l, P (f j) | null | false |
Std.Format.defUnicode | Init.Data.Format.Basic | Bool | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.nonemptyCompacts.match_1_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {B : Set (Set α)} ⦃u : Set (Set α)⦄ (motive : u ∈ {u | u.Finite ∧ u ⊆ B} → Prop)
(h : u ∈ {u | u.Finite ∧ u ⊆ B}), (∀ (hu : u.Finite) (huB : u ⊆ B), motive ⋯) → motive h | null | false |
Std.DTreeMap.Internal.Impl.recOn | Std.Data.DTreeMap.Internal.Def | {α : Type u} →
{β : α → Type v} →
{motive : Std.DTreeMap.Internal.Impl α β → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl α β) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive l → motive r → motive (Std.D... | null | false |
one_div_pow | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℕ), (1 / a) ^ n = 1 / a ^ n | null | true |
QuadraticMap.polar_sub_right | 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] (Q : QuadraticMap R M N) (x y y' : M),
QuadraticMap.polar (⇑Q) x (y - y') = QuadraticMap.polar (⇑Q) x y - QuadraticMap.polar (⇑Q) x y' | null | true |
LinearEquiv.uniqueProd_symm_apply | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] [inst_5 : Unique M₂] (a : M),
LinearEquiv.uniqueProd.symm a = (default, a) | null | true |
isOrderedModule_iff_smul_one_mono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : Preorder α]
[inst_4 : Preorder β] [inst_5 : MulOneClass β] [ZeroLEOneClass β] [PosMulMono β] [MulPosMono β] [IsScalarTower α β β],
IsOrderedModule α β ↔ Monotone fun x => x • 1 | null | true |
Int.eq_mul_of_fdiv_eq_left | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → a.fdiv b = c → a = c * b | null | true |
LightProfinite.instHasPropAndTotallyDisconnectedSpaceCarrierSecondCountableTopology | Mathlib.Topology.Category.LightProfinite.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] [TotallyDisconnectedSpace X] [SecondCountableTopology X],
CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y ∧ SecondCountableTopology ↑Y) X | null | true |
PFun.image_mono | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) {s t : Set α}, s ⊆ t → f.image s ⊆ f.image t | null | true |
noZeroSMulDivisors_iff | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ (R : Type u_4) (M : Type u_5) [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMul R M],
NoZeroSMulDivisors R M ↔ ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0 | null | true |
Std.Internal.List.getValueD_filter_not_contains_map_fst_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValueD k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) fallback =
S... | null | true |
neg_add_nonpos_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a b : α}, -a + b ≤ 0 ↔ b ≤ a | null | true |
Ordinal.familyOfBFamily'._proof_1 | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_1} (r : ι → ι → Prop) [inst : IsWellOrder ι r] {o : Ordinal.{u_1}},
Ordinal.type r = o → ∀ (i : ι), (Ordinal.typein r).toRelEmbedding i < o | null | false |
Monoid.CoprodI.NeWord.replaceHead.congr_simp | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i j : ι} (x x_1 : M i) (e_x : x = x_1)
(_hnotone : x ≠ 1) (_w _w_1 : Monoid.CoprodI.NeWord M i j),
_w = _w_1 → Monoid.CoprodI.NeWord.replaceHead x _hnotone _w = Monoid.CoprodI.NeWord.replaceHead x_1 ⋯ _w_1 | null | true |
CategoryTheory.Limits.preservesColimitsOfShape_of_reflects_of_preserves | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] {E : Type u₃} [ℰ : CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E)
[CategoryTheory... | If `F ⋙ G` preserves colimits of shape `J` and `G` reflects colimits of shape `J`, then `F`
preserves colimits of shape `J`.
| true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.rec | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimApp.State✝ → Sort u} →
((argPos targetPos : ℕ) →
(motive_1 : Option Lean.MVarId) →
(f fType : Lean.Expr) →
(alts : Array Lean.Elab.Tactic.ElimApp.Alt) →
(insts : Array Lean.MVarId) →
motive
{ argPos := argPos, targetPos :... | null | false |
Lean.Lsp.ColorInformation.range | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ColorInformation → Lean.Lsp.Range | null | true |
Fin.dfoldlM.loop._unary._proof_3 | Batteries.Data.Fin.Basic | ∀ {m : Type u_2 → Type u_1} (n : ℕ) (α : Fin (n + 1) → Type u_2) (i : ℕ) (h : i < n + 1),
¬i < n → m (α ⟨i, h⟩) = m (α (Fin.last n)) | null | false |
Equiv.coe_inj | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {e₁ e₂ : α ≃ β}, ⇑e₁ = ⇑e₂ ↔ e₁ = e₂ | null | true |
Plausible.RandT.up | Plausible.Random | {α : Type u} →
{m : Type u → Type w} →
{m' : Type (max u v) → Type w'} →
{g : Type} →
[RandomGen g] →
[Monad m] →
[Monad m'] →
({α : Type u} → m α → m' (ULift.{v, u} α)) →
Plausible.RandGT g m α → Plausible.RandGT g m' (ULift.{v, u} α) | Given a random generator for `α`, we can convert it to a random generator for `ULift α`. | true |
Lean.Elab.Command.ElabHeaderResult.ctorIdx | Lean.Elab.MutualInductive | Lean.Elab.Command.ElabHeaderResult → ℕ | null | false |
Finset.addCommMonoid._proof_3 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommMonoid α] (s : Finset α) (n : ℕ), ↑(n • s) = n • ↑s | null | false |
Simps.findZeroArgs | Mathlib.Tactic.Simps.NotationClass | Simps.findArgType | Find arguments for the `Zero` class. | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.Corec.f.match_1.eq_2 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} {β : Type u_2} (motive : α ⊕ β → Sort u_3) (val : β) (h_1 : (a : α) → motive (Sum.inl a))
(h_2 : (val : β) → motive (Sum.inr val)),
(match Sum.inr val with
| Sum.inl a => h_1 a
| Sum.inr val => h_2 val) =
h_2 val | null | true |
String.Pos.le_ofSliceFrom_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {q : s.Pos},
q ≤ String.Pos.ofSliceFrom p ↔ ∀ (h : p₀ ≤ q), p₀.sliceFrom q h ≤ p | null | true |
Lean.Meta.RefinedDiscrTree.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{α : Type} →
{t : Lean.Meta.RefinedDiscrTree α} →
{α' : Type} →
{t' : Lean.Meta.RefinedDiscrTree α'} → α = α' → t ≍ t' → Lean.Meta.RefinedDiscrTree.noConfusionType P t t' | null | false |
List.erase._sunfold | Init.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → α → List α | null | false |
AddMonoidHom.toOpposite._proof_2 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N),
AddOpposite.op (f 0) = AddOpposite.op 0 | null | false |
Multiset.filterMap_eq_map | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → β), Multiset.filterMap (some ∘ f) = Multiset.map f | null | true |
BitVec.le_def | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x ≤ y ↔ x.toNat ≤ y.toNat | null | true |
Std.TreeSet.empty_equiv_iff_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp}, Std.TreeSet.empty.Equiv t ↔ t.isEmpty = true | null | true |
PolyEquivTensor.toFunLinear_mul_tmul_mul_aux_1 | Mathlib.RingTheory.PolynomialAlgebra | ∀ (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (p : Polynomial R)
(k : ℕ) (h : Decidable ¬p.coeff k = 0) (a : A),
(if ¬p.coeff k = 0 then a * (algebraMap R A) (p.coeff k) else 0) = a * (algebraMap R A) (p.coeff k) | null | true |
Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {F : Type u_1} {K : Type u_2} (A : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field A]
[inst_3 : Algebra F K] [inst_4 : Algebra F A] [Algebra.IsAlgebraic F K] [IsAlgClosed A] (x : K),
(Set.range fun ψ => ψ x) = (minpoly F x).rootSet A | Let `A` be an algebraically closed field and let `x ∈ K`, with `K/F` an algebraic extension
of fields. Then the images of `x` by the `F`-algebra morphisms from `K` to `A` are exactly
the roots in `A` of the minimal polynomial of `x` over `F`. | true |
MvPolynomial.lcoeff | Mathlib.Algebra.MvPolynomial.Basic | (R : Type u) → {σ : Type u_1} → [inst : CommSemiring R] → (σ →₀ ℕ) → MvPolynomial σ R →ₗ[R] R | `AddMonoidAlgebra.coeff · m` but promoted to a `LinearMap`. | true |
CategoryTheory.ShortComplex.nullHomotopic | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S₁ S₂ : CategoryTheory.ShortComplex C) →
(h₀ : S₁.X₁ ⟶ S₂.X₁) →
CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0 →
(S₁.X₂ ⟶ S₂.X₁) →
(S₁.X₃ ⟶ S₂.X₂) → (h₃ : S... | Constructor for null homotopic morphisms, see also `Homotopy.ofNullHomotopic`
and `Homotopy.eq_add_nullHomotopic`. | true |
Set.Icc.semilatticeSup.eq_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a b : α} [inst : SemilatticeSup α], Set.Icc.semilatticeSup = Subtype.semilatticeSup ⋯ | null | true |
IsAddQuotientCoveringMap.fundamentalGroupToMulOpposite_apply_eq_iff | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] (hp : IsAddQuotientCoveringMap p G) {x : X} {e : ↑(p ⁻¹' {x})}
{γ : FundamentalGroup X x} {g : (Multiplicative G)ᵐᵒᵖ},
(hp.fundamentalGroupToMulOpposi... | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.any_eq_false'._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, (as.any p = false) = ∀ x ∈ as, ¬p x = true | null | false |
Nat.Coprime.symm | Init.Data.Nat.Coprime | ∀ {n m : ℕ}, n.Coprime m → m.Coprime n | null | true |
IncidenceAlgebra.instAddCommGroup._proof_4 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LE α] (f : IncidenceAlgebra 𝕜 α), ⇑(-f) = -⇑f | null | false |
Nat.add_one_ne_zero | Init.Data.Nat.Basic | ∀ (n : ℕ), n + 1 ≠ 0 | null | true |
VonNeumannAlgebra.mk.injEq | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
(toStarSubalgebra : StarSubalgebra ℂ (H →L[ℂ] H))
(centralizer_centralizer' : toStarSubalgebra.carrier.centralizer.centralizer = toStarSubalgebra.carrier)
(toStarSubalgebra_1 : StarSubalgebra ℂ (H →L[ℂ] H))
... | null | true |
instDecidableEqPosNum.decEq._proof_3 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬PosNum.one = a.bit1 | null | false |
AddSubsemigroup.map_iInf_comap_of_surjective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {ι : Type u_5} {f : M →ₙ+ N},
Function.Surjective ⇑f →
∀ (S : ι → AddSubsemigroup N), AddSubsemigroup.map f (⨅ i, AddSubsemigroup.comap f (S i)) = iInf S | null | true |
Lean.Meta.Grind.Params.mk.noConfusion | Lean.Meta.Tactic.Grind.Main | {P : Sort u} →
{config : Lean.Grind.Config} →
{extensions : Lean.Meta.Grind.ExtensionStateArray} →
{extra : Lean.PArray Lean.Meta.Grind.EMatchTheorem} →
{extraInj : Lean.PArray Lean.Meta.Grind.InjectiveTheorem} →
{extraFacts : Lean.PArray Lean.Expr} →
{symPrios : Lean.Meta.Grin... | null | false |
Ideal.IsMinimalPrime.le | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {I p : Ideal R}, I.IsMinimalPrime p → I ≤ p | null | true |
Finset.mulEnergy_univ_right | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommGroup α] [inst_2 : Fintype α] (s : Finset α),
s.mulEnergy Finset.univ = Fintype.card α * s.card ^ 2 | null | true |
_private.Mathlib.Data.Nat.ModEq.0.Nat.ModEq.mul_left_cancel'._simp_1_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a ≡ b [MOD n]) = (↑n ∣ ↑b - ↑a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.