name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sumZeroes_T_of_not_dvd._proof_1_9 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | ∀ {n : ℕ} {k : ℤ},
¬2 * ↑n ∣ k →
n ≠ 0 →
Complex.exp (↑k / ↑n * ↑Real.pi * Complex.I) = Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 →
¬Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 - 1 = 0 ∧
¬1 - Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 = 0 | false |
Asymptotics.instTransForallIsBigOIsTheta | Mathlib.Analysis.Asymptotics.Theta | {α : Type u_1} →
{E : Type u_3} →
{G : Type u_5} →
{F' : Type u_7} →
[inst : Norm E] →
[inst_1 : Norm G] →
[inst_2 : SeminormedAddCommGroup F'] →
{l : Filter α} → Trans (Asymptotics.IsBigO l) (Asymptotics.IsTheta l) (Asymptotics.IsBigO l) | true |
FreeGroup.Red.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u}, FreeGroup.Red = Relation.ReflTransGen FreeGroup.Red.Step | true |
String.utf8Len.eq_def | Batteries.Data.String.Lemmas | ∀ (x : List Char),
String.utf8Len x =
match x with
| [] => 0
| c :: cs => String.utf8Len cs + c.utf8Size | true |
_private.Mathlib.Data.EReal.Operations.0.Mathlib.Meta.Positivity.evalERealAdd._proof_2 | Mathlib.Data.EReal.Operations | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q instPartialOrderEReal)),
«$pα» =Q instPartialOrderEReal | false |
Std.Tactic.BVDecide.BVExpr.WithCache.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} → {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} → Std.Tactic.BVDecide.BVExpr.WithCache α aig → ℕ | false |
PrincipalSeg.ofElement_toFun | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} (r : α → α → Prop) (a : α) (self : { x // r x a }), (PrincipalSeg.ofElement r a).toFun self = ↑self | true |
Equiv.Perm.Basis.rec | Mathlib.GroupTheory.Perm.Centralizer | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] →
{g : Equiv.Perm α} →
{motive : g.Basis → Sort u} →
((toFun : ↥g.cycleFactorsFinset → α) →
(mem_support_self' : ∀ (c : ↥g.cycleFactorsFinset), toFun c ∈ (↑c).support) →
motive { toFun := toFun, me... | false |
Nat.dfold_add._proof_16 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i ≤ n, i ≤ n + m | false |
Lean.Grind.CommRing.Mon.revlexFuel.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (motive : ℕ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering → Prop),
(∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), motive 0 m₁ m₂ (m₁.revlexWF m₂)) →
(∀ (fuel : ℕ), motive fuel.succ Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit Ordering.eq) →
(∀ (fuel : ℕ) (p : Lean.Grind.CommRing.Power... | true |
_private.Std.Data.Iterators.Lemmas.Producers.Repeat.0.Nat.repeat.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Repeat | {α : Type u_2} →
(motive : ℕ → α → Sort u_1) →
(x : ℕ) → (x_1 : α) → ((a : α) → motive 0 a) → ((n : ℕ) → (a : α) → motive n.succ a) → motive x x_1 | true |
Ideal.span_range_eq_span_range_support | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α),
Ideal.span (Set.range x) = Ideal.span (Set.range fun i => x ↑i) | true |
MulActionHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ (F : Type u_8) (M : Type u_9) (X : Type u_10) (Y : Type u_11) [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y], MulActionHomClass F M X Y = MulActionSemiHomClass F id X Y | true |
Std.DHashMap.Raw.Equiv.constInsertMany_list | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF →
m₂.WF →
∀ (l : List (α × β)),
m₁.Equiv m₂ → (Std.DHashMap.Raw.Const.insertMany m₁ l).Equiv (Std.DHashMap.Raw.Const.insertMany m₂ l) | true |
CategoryTheory.Functor.isoWhiskerRight_left_assoc | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) {G H : CategoryTheory.Functor C D}
(α : G... | true |
HomologicalComplex.homologicalComplexToDGO | Mathlib.Algebra.Homology.DifferentialObject | {β : Type u_1} →
[inst : AddCommGroup β] →
(b : β) →
(V : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_1, u_2} V] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] →
CategoryTheory.Functor (HomologicalComplex V (ComplexShape.up' b))
(CategoryTheory.Differe... | true |
Lean.Lsp.SymbolInformation.containerName? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolInformation → Option String | true |
Fin.insertNthEquiv_last | Mathlib.Data.Fin.Tuple.Basic | ∀ (n : ℕ) (α : Type u_3), Fin.insertNthEquiv (fun x => α) (Fin.last n) = Fin.snocEquiv fun x => α | true |
Int.inductionOn'_add_one | Mathlib.Data.Int.Basic | ∀ {C : ℤ → Sort u_1} {z b : ℤ} {H0 : C b} {Hs : (k : ℤ) → b ≤ k → C k → C (k + 1)}
{Hp : (k : ℤ) → k ≤ b → C k → C (k - 1)} (hz : b ≤ z),
Int.inductionOn' (z + 1) b H0 Hs Hp = Hs z hz (Int.inductionOn' z b H0 Hs Hp) | true |
ProbabilityTheory.Kernel.integral_deterministic' | Mathlib.Probability.Kernel.Integral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_3}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : β → E} {a : α} [CompleteSpace E] {g : α → β}
(hg : Measurable g),
MeasureTheory.StronglyMeasurable f → ∫ (x : β), f x ∂(ProbabilityTheory.Kernel.determinis... | true |
CategoryTheory.Limits.MonoFactorisation.e | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → (self : CategoryTheory.Limits.MonoFactorisation f) → X ⟶ self.I | true |
List.min_singleton | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] {x : α}, [x].min ⋯ = x | true |
Multiset.zero_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (t : Multiset β), 0 ×ˢ t = 0 | true |
ChevalleyThm.MvPolynomialC.degBound_casesOn_succ._mutual | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (k₀ k : ℕ) (D : ℕ → ℕ) (x : ℕ ⊕' ℕ),
PSum.casesOn x
(fun _x =>
ChevalleyThm.MvPolynomialC.degBound k₀ (fun t => Nat.casesOn t k D) (_x + 1) =
(k₀ * k) ^ (k₀ * k) * ChevalleyThm.MvPolynomialC.degBound (k₀ * k) ((k₀ * k) ^ (k₀ * k) • D) _x)
fun _x =>
ChevalleyThm.MvPolynomialC.numBound k₀ (f... | false |
Directed.le_sequence | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Inhabited α] [inst_2 : Preorder β] {f : α → β}
(hf : Directed (fun x1 x2 => x1 ≤ x2) f) (a : α), f a ≤ f (Directed.sequence f hf (Encodable.encode a + 1)) | true |
List.tailsTR.go.eq_def | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (acc : Array (List α)),
List.tailsTR.go l acc =
match l with
| [] => acc.toListAppend [[]]
| head :: xs => List.tailsTR.go xs (acc.push l) | true |
_private.Mathlib.Data.Finsupp.Indicator.0.Finsupp.indicator_indicator._proof_1_2 | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) {t : Finset ι} (f : (i : ι) → i ∈ s → α)
[inst_1 : DecidableEq ι],
(Finsupp.indicator t fun i x => (Finsupp.indicator s f) i) = Finsupp.indicator (s ∩ t) fun i hi => f i ⋯ | false |
BialgCat.mk | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [instRing : Ring carrier] → [instBialgebra : Bialgebra R carrier] → BialgCat R | true |
Std.TreeSet.Raw.le_maxD_of_contains | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxD fallback)).isLE = true | true |
AffineSubspace.SOppSide.trans_wSameSide | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.SOppSide x y → s.WSameSide y z → s.WOppSide x z | true |
SupBotHom.dual_comp | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β]
[inst_4 : Max γ] [inst_5 : Bot γ] (g : SupBotHom β γ) (f : SupBotHom α β),
SupBotHom.dual (g.comp f) = (SupBotHom.dual g).comp (SupBotHom.dual f) | true |
UInt16.le_refl._simp_1 | Init.Data.UInt.Lemmas | ∀ (a : UInt16), (a ≤ a) = True | false |
AlexDisc.recOn | Mathlib.Topology.Order.Category.AlexDisc | {motive : AlexDisc → Sort u} →
(t : AlexDisc) →
((toTopCat : TopCat) →
[is_alexandrovDiscrete : AlexandrovDiscrete ↑toTopCat] →
motive { toTopCat := toTopCat, is_alexandrovDiscrete := is_alexandrovDiscrete }) →
motive t | false |
_private.Mathlib.Data.Fintype.Prod.0.Finset.product_eq_univ._simp_1_1 | Mathlib.Data.Fintype.Prod | ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, (s = Finset.univ) = ∀ (x : α), x ∈ s | false |
PowerSeries.exp_pow_eq_rescale_exp | Mathlib.RingTheory.PowerSeries.Exp | ∀ {A : Type u_4} [inst : CommRing A] [inst_1 : Algebra ℚ A] (k : ℕ),
PowerSeries.exp A ^ k = (PowerSeries.rescale ↑k) (PowerSeries.exp A) | true |
ContinuousMulEquiv.eq_symm_comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {α : Type u_3} (e : M ≃ₜ* N) (f : α → M) (g : α → N), f = ⇑e.symm ∘ g ↔ ⇑e ∘ f = g | true |
QuotientGroup.preimage_image_mk | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : Group α] (N : Subgroup α) (s : Set α),
QuotientGroup.mk ⁻¹' (QuotientGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s | true |
ZFSet.singleton_inj._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y : ZFSet.{u_1}}, ({x} = {y}) = (x = y) | false |
CategoryTheory.Limits.WalkingMultispan.instSubsingletonHomLeft | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (a b : J.L),
Subsingleton (CategoryTheory.Limits.WalkingMultispan.left a ⟶ CategoryTheory.Limits.WalkingMultispan.left b) | true |
ENNReal.isConjExponent_iff_eq_conjExponent | Mathlib.Data.Real.ConjExponents | ∀ {p q : ENNReal}, 1 ≤ p → (p.HolderConjugate q ↔ q = 1 + (p - 1)⁻¹) | true |
_private.Mathlib.Algebra.Category.Ring.Basic.0.CommSemiRingCat.Hom.ext.match_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (motive : R.Hom S → Prop) (h : R.Hom S),
(∀ (hom' : ↑R →+* ↑S), motive { hom' := hom' }) → motive h | false |
CategoryTheory.MorphismProperty.rlp_isStableUnderProductsOfShape | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type u_1),
T.rlp.IsStableUnderProductsOfShape J | true |
Aesop.GoalData.mvars | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.UnorderedArraySet Lean.MVarId | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
UInt64.toUInt32_toUSize | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUSize.toUInt32 = n.toUInt32 | true |
CategoryTheory.Functor.IsEventuallyConstantFrom.coconeιApp_eq_id | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J}
(h : F.IsEventuallyConstantFrom i₀) [inst_2 : CategoryTheory.IsFiltered J],
h.coconeιApp i₀ = CategoryTheory.CategoryStruct.id (F.obj i₀) | true |
Std.Rcc.Sliceable.recOn | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Rcc.Sliceable α β γ → Sort u_1} →
(t : Std.Rcc.Sliceable α β γ) → ((mkSlice : α → Std.Rcc β → γ) → motive { mkSlice := mkSlice }) → motive t | false |
String.Pos.prev! | Init.Data.String.FindPos | {s : String} → s.Pos → s.Pos | true |
CategoryTheory.Sum.swapCompInl | Mathlib.CategoryTheory.Sums.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(CategoryTheory.Sum.inl_ C D).comp (CategoryTheory.Sum.swap C D) ≅ CategoryTheory.Sum.inr_ D C | true |
Cardinal.power_mul | Mathlib.SetTheory.Cardinal.Order | ∀ {a b c : Cardinal.{u_1}}, a ^ (b * c) = (a ^ b) ^ c | true |
Batteries.BinomialHeap.Imp.FindMin.mk | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
α → Batteries.BinomialHeap.Imp.HeapNode α → Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.FindMin α | true |
Matrix.SpecialLinearGroup.map_intCast_injective | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [CharZero R],
Function.Injective ⇑(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) | true |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} (w : σ → ℕ) {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} {d : σ →₀ ℕ},
↑((Finsupp.weight w) d) < MvPowerSeries.weightedOrder w g →
(MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f | true |
DirichletCharacter.LSeries_ne_zero_of_one_lt_re | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}, 1 < s.re → LSeries (fun n => χ ↑n) s ≠ 0 | true |
ContinuousAffineMap.instSub._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_4} {V : Type u_3} {W : Type u_2} {P : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] [IsTopologicalAddGroup W] (f g : P →ᴬ[R] W),
Continuous... | false |
Equiv.apply_swap_eq_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} [inst : DecidableEq α] {v : α → β} {i j : α},
v i = v j → ∀ (k : α), v ((Equiv.swap i j) k) = v k | true |
Std.Rio.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_empty._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₃.match_5 | Aesop.Util.EqualUpToIds | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(x x_1 : Lean.Expr) →
((i j : ℕ) → motive (Lean.Expr.bvar i) (Lean.Expr.bvar j)) →
((fvarId₁ fvarId₂ : Lean.FVarId) → motive (Lean.Expr.fvar fvarId₁) (Lean.Expr.fvar fvarId₂)) →
((u v : Lean.Level) → motive (Lean.Expr.sort u) (Lean.Expr.sort v)) →
... | false |
Lean.IR.ExpandResetReuse.main | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.Decl → Lean.IR.Decl | true |
Std.TreeMap.isEmpty_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.isEmpty = true | true |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.hasMFDerivAt_inr._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... | false |
Int.neg_modEq_neg._simp_1 | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, (-a ≡ -b [ZMOD n]) = (a ≡ b [ZMOD n]) | false |
SimpleGraph.Walk.isSubwalk_nil_iff_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} (p : G.Walk u v), SimpleGraph.Walk.nil.IsSubwalk p = (v' ∈ p.support) | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.evalPowProd._sparseCasesOn_10 | Mathlib.Tactic.Ring.Common | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
CliffordAlgebra.changeFormEquiv._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q Q' : QuadraticForm R M} {B : LinearMap.BilinForm R M} (h : LinearMap.BilinMap.toQuadraticMap B = Q' - Q)
(x : CliffordAlgebra Q), (CliffordAlgebra.changeForm ⋯) ((CliffordAlgebra.changeForm h) x) = x | false |
Std.DTreeMap.Raw.WF.casesOn | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{t : Std.DTreeMap.Raw α β cmp} →
{motive : t.WF → Sort u_1} → (t_1 : t.WF) → ((out : t.inner.WF) → motive ⋯) → motive t_1 | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_3 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (a b : G), f a - f b = f (a - b) | false |
Part.getOrElse_of_not_dom | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α), ¬a.Dom → ∀ [inst : Decidable a.Dom] (d : α), a.getOrElse d = d | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_left | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A] {X : C}
(data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (i : data.multicospa... | true |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.diff_ae_eq_self._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] {l : Filter α} {f g : α → β}, (f =ᶠ[l] g) = (f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f) | false |
Mathlib.TacticAnalysis.TacticNode.ctxI | Mathlib.Tactic.TacticAnalysis | Mathlib.TacticAnalysis.TacticNode → Lean.Elab.ContextInfo | true |
Set.Ico_subset_Icc_union_Ico | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a c ⊆ Set.Icc a b ∪ Set.Ico b c | true |
_private.Init.Data.String.Decode.0.String.utf8EncodeChar_eq_utf8EncodeCharFast._proof_1_12 | Init.Data.String.Decode | ∀ (c : Char), ¬c.val.toNat ≤ 2047 → c.val.toNat ≤ 65535 → ¬c.val.toNat / 2 ^ 12 < 256 → False | false |
Equiv.group.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Group β], e.group = Function.Injective.group ⇑e ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | true |
Submonoid.orderOf_le_card | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : Group G] (s : Submonoid G), (↑s).Finite → ∀ {x : G}, x ∈ s → orderOf x ≤ Nat.card ↥s | true |
_private.Mathlib.Data.Fintype.Quotient.0.Quotient.list_ind.match_1_1 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (motive : (a : ι) → a ∈ [] → Prop) (a : ι) (a_1 : a ∈ []), motive a a_1 | false |
IsCoveringMap.exists_path_lifts | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X},
IsCoveringMap p → ∀ (γ : C(↑unitInterval, X)) (e : E), γ 0 = p e → ∃ Γ, p ∘ ⇑Γ = ⇑γ ∧ Γ 0 = e | true |
MvPolynomial.algebraTensorAlgEquiv_symm_monomial | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(m : σ →₀ ℕ) (a : A),
(MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.monomial m) a) = a ⊗ₜ[R] (MvPolynomial.monomial m) 1 | true |
Nat.doubleFactorial.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | Nat.doubleFactorial 1 = 1 | true |
PresentedGroup.mk_eq_mk_of_inv_mul_mem | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {rels : Set (FreeGroup α)} {x y : FreeGroup α},
x⁻¹ * y ∈ rels → (PresentedGroup.mk rels) x = (PresentedGroup.mk rels) y | true |
Std.Ric.LawfulRcoIntersection.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Ric.HasRcoIntersection α],
(∀ {a : α} {r : Std.Ric α} {s : Std.Rco α}, a ∈ Std.Ric.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Ric.LawfulRcoIntersection α | true |
CategoryTheory.MorphismProperty.RightFraction.rec | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.RightFraction X Y → Sort u} →
({X' : C} → (s : X' ⟶ X) → (hs : W s) → (f : X' ⟶ Y) → motive { X' := X', s := s, hs := hs, f := f }) →
(t : W.RightF... | false |
CategoryTheory.ObjectProperty.ContainsUnit.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{P : CategoryTheory.ObjectProperty C}, P (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) → P.ContainsUnit | true |
MeasureTheory.Measure.ext_prod₃_iff' | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_6} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {μ ν : MeasureTheory.Measure ((α × β) × γ)} [MeasureTheory.IsFiniteMeasure μ],
μ = ν ↔
∀ {s : Set α} {t : Set β} {u : Set γ},
MeasurableSet s → MeasurableSet t → MeasurableSet u → μ ((... | true |
Std.Iterators.Types.Map | Init.Data.Iterators.Combinators.Monadic.FilterMap | Type w →
{β γ : Type w} →
(m : Type w → Type w') →
(n : Type w → Type w'') →
(⦃α : Type w⦄ → m α → n α) → [Functor n] → (β → Std.Iterators.PostconditionT n γ) → Type w | true |
Qq.SortLocalDecls.Context | Qq.SortLocalDecls | Type | true |
Std.TreeSet.max!_erase_eq_of_not_compare_max!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → ¬cmp k t.max! = Ordering.eq → (t.erase k).max! = t.max! | true |
List.length_sym._unary | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (_x : (_ : ℕ) ×' List α), (List.sym _x.1 _x.2).length = _x.2.length.multichoose _x.1 | false |
Lean.Elab.WF.GuessLex.RecCallWithContext.mk.injEq | Lean.Elab.PreDefinition.WF.GuessLex | ∀ (ref : Lean.Syntax) (caller : ℕ) (params : Array Lean.Expr) (callee : ℕ) (args : Array Lean.Expr)
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) (ref_1 : Lean.Syntax) (caller_1 : ℕ) (params_1 : Array Lean.Expr)
(callee_1 : ℕ) (args_1 : Array Lean.Expr) (ctxt_1 : Lean.Elab.WF.GuessLex.SavedLocalContext),
({ re... | true |
Fin.add.match_1 | Init.Data.Fin.Basic | {n : ℕ} →
(motive : Fin n → Fin n → Sort u_1) →
(x x_1 : Fin n) → ((a : ℕ) → (h : a < n) → (b : ℕ) → (isLt : b < n) → motive ⟨a, h⟩ ⟨b, isLt⟩) → motive x x_1 | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go | Lean.Data.RArray | {α : Type u_1} → {n : ℕ} → (Fin n → α) → (lb ub : ℕ) → lb < ub → ub ≤ n → Lean.RArray α | true |
Polynomial.Chebyshev.coeff_le_of_forall_abs_le_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n : ℕ} {P : Polynomial ℝ},
P.degree ≤ ↑n → (∀ x ∈ Set.Icc (-1) 1, |Polynomial.eval x P| ≤ 1) → P.coeff n ≤ 2 ^ (n - 1) | true |
Lean.instReprBinderInfo | Lean.Expr | Repr Lean.BinderInfo | true |
CategoryTheory.Arrow.augmentedCechNerve._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
⦃X Y : SimplexCategoryᵒᵖ⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.id (CategoryT... | false |
Mathlib.Meta.FunProp.Mor.isCoeFunName | Mathlib.Tactic.FunProp.Mor | Lean.Name → Lean.CoreM Bool | true |
BitVec._sizeOf_1 | Init.SizeOf | {w : ℕ} → BitVec w → ℕ | false |
QuadraticModuleCat.mk | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → [inst : CommRing R] → (toModuleCat : ModuleCat R) → QuadraticForm R ↑toModuleCat → QuadraticModuleCat R | true |
_private.Lean.Class.0.Lean.addClass._sparseCasesOn_1 | Lean.Class | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBit 33 t.ctorIdx → motive t) → motive t | false |
irrational_sqrt_of_multiplicity_odd | Mathlib.NumberTheory.Real.Irrational | ∀ (m : ℤ), 0 < m → ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], multiplicity (↑p) m % 2 = 1 → Irrational √↑m | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.