name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.SymbolKind.interface.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 10 → motive Lean.Lsp.SymbolKind.interface → motive t | false |
ProfiniteAddGrp.hom_ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g → f = g | true |
notMem_nonZeroDivisorsLeft_iff | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, x ∉ nonZeroDivisorsLeft M₀ ↔ {y | x * y = 0 ∧ y ≠ 0}.Nonempty | true |
Lean.RBNode.isSingleton | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β → Bool | true |
Std.Iter.toArray_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toArray = it.toArray.extract n | true |
Ideal.quotientInfToPiQuotient.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {ι : Type u_1} (I : ι → Ideal R) [inst_1 : ∀ (i : ι), (I i).IsTwoSided],
Ideal.quotientInfToPiQuotient I = Ideal.Quotient.lift (⨅ i, I i) (Pi.ringHom fun i => Ideal.Quotient.mk (I i)) ⋯ | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balLeft.match_1.splitter._sparseCasesOn_3 | Batteries.Data.RBMap.Lemmas | {α : Type u} →
{motive : Batteries.RBNode α → Sort u_1} →
(t : Batteries.RBNode α) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{t t' : Lean.Elab.Term.Do.ToCodeBlock.Context} → t = t' → Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusionType P t t' | false |
minpoly.dvd_map_of_isScalarTower | Mathlib.FieldTheory.Minpoly.Field | ∀ (A : Type u_3) (K : Type u_4) {R : Type u_5} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Ring R]
[inst_3 : Algebra A K] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [IsScalarTower A K R] (x : R),
minpoly K x ∣ Polynomial.map (algebraMap A K) (minpoly A x) | true |
Lean.Doc.Block.brecOn_2.eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} {motive_1 : Lean.Doc.Block i b → Sort u_1}
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1}
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1}
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1}
{motive_5 : List (Lean.Doc.L... | true |
Set.fintypeImage2._proof_1 | Mathlib.Data.Finite.Prod | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} (f : α → β → γ) (s : Set α) (t : Set β),
Fintype ↑(Set.image2 f s t) = Fintype ↑((fun x => f x.1 x.2) '' s ×ˢ t) | false |
Algebra.FiniteType.out | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} {inst : CommSemiring R} {inst_1 : Semiring A} {inst_2 : Algebra R A}
[self : Algebra.FiniteType R A], ⊤.FG | true |
GradedMonoid.GMul.casesOn | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
{motive : GradedMonoid.GMul A → Sort u} →
(t : GradedMonoid.GMul A) → ((mul : {i j : ι} → A i → A j → A (i + j)) → motive { mul := mul }) → motive t | false |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1)
{Z : C} (h : (CategoryTheory.unopUnop C).obj ((CategoryTheory.shiftFunctor Cᵒᵖᵒᵖ n).... | true |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape._sizeOf_1 | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : SuccOrder J} →
{inst_3 : OrderBot J} →
{inst_4 : WellFoundedLT J} →
{X Y : C} →
... | false |
MeasureTheory.withDensityᵥ_toReal | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ (hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤), (μ.withDensityᵥ fun x => (f x).toReal) = (μ.withDensity f).toSignedMeasure | true |
Lean.ErrorExplanation.mk.injEq | Lean.ErrorExplanation | ∀ (doc : String) (metadata : Lean.ErrorExplanation.Metadata) (declLoc? : Option Lean.DeclarationLocation)
(doc_1 : String) (metadata_1 : Lean.ErrorExplanation.Metadata) (declLoc?_1 : Option Lean.DeclarationLocation),
({ doc := doc, metadata := metadata, declLoc? := declLoc? } =
{ doc := doc_1, metadata := met... | true |
Ideal.fiberIsoOfBijectiveResidueField | Mathlib.RingTheory.Etale.QuasiFinite | {R : Type u_1} →
{R' : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing R'] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R R'] →
[inst_4 : Algebra R S] →
{p : Ideal R} →
{q : Ideal R'} →
[in... | true |
EReal.add_iInf_le_iInf_add | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {u v : α → EReal}, (⨅ x, u x) + ⨅ x, v x ≤ ⨅ x, (u + v) x | true |
Real.fromBinary_surjective | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | Function.Surjective Real.fromBinary | true |
ULift.distrib | Mathlib.Algebra.Ring.ULift | {R : Type u} → [Distrib R] → Distrib (ULift.{u_1, u} R) | true |
Std.DHashMap.Raw.get?_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | true |
Lean.initFn._@.Lean.DocString.Links.3730308748._hygCtx._hyg.2 | Lean.DocString.Links | IO String | false |
CategoryTheory.Monad.algebraEquivOfIsoMonads_unitIso | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂),
(CategoryTheory.Monad.algebraEquivOfIsoMonads h).unitIso =
CategoryTheory.Monad.algebraFunctorOfMonadHomId.symm ≪≫
CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunc... | true |
_private.Mathlib.Analysis.Normed.Operator.Compact.0.IsCompactOperator.add.match_1_1 | Mathlib.Analysis.Normed.Operator.Compact | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {f g : M₁ → M₂} (A B : Set M₂) (x : M₁) (motive : x ∈ f ⁻¹' A ∩ g ⁻¹' B → Prop)
(x_1 : x ∈ f ⁻¹' A ∩ g ⁻¹' B), (∀ (hxA : x ∈ f ⁻¹' A) (hxB : x ∈ g ⁻¹' B), motive ⋯) → motive x_1 | false |
Set.Icc_union_Icc' | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
c ≤ b → a ≤ d → Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d) | true |
MonadWriter.mk.noConfusion | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} →
{M : Type u → Type v} →
{P : Sort u_1} →
{tell : ω → M PUnit.{u + 1}} →
{listen : {α : Type u} → M α → M (α × ω)} →
{pass : {α : Type u} → M (α × (ω → ω)) → M α} →
{tell' : ω → M PUnit.{u + 1}} →
{listen' : {α : Type u} → M α → M (α × ω)}... | false |
Ring.instDirectLimit._proof_16 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j),
autoParam (∀ (x : Ring.DirectLimit G f), Ring.instDirectLimit._aux_14 G f 0 x = 1) Monoid.npow_zero._autoParam | false |
toIcoDiv_add_left' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1 | true |
Int8.toNatClampNeg_lt | Init.Data.SInt.Lemmas | ∀ (x : Int8), x.toNatClampNeg < 2 ^ 7 | true |
_private.Lean.Meta.ForEachExpr.0.Lean.Meta.forEachExpr'.visit | Lean.Meta.ForEachExpr | {m : Type → Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Bool) →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit m Unit | true |
_private.Init.Data.Nat.Lemmas.0.Nat.one_mod_eq_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.mu'_apply_self | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (a : α), (IncidenceAlgebra.mu'✝ 𝕜) a a = 1 | true |
MeasureTheory.Egorov.notConvergentSeqLTIndex | Mathlib.MeasureTheory.Function.Egorov | {α : Type u_1} →
{β : Type u_2} →
{ι : Type u_3} →
{m : MeasurableSpace α} →
[inst : PseudoEMetricSpace β] →
{μ : MeasureTheory.Measure α} →
{s : Set α} →
{ε : ℝ} →
{f : ι → α → β} →
{g : α → β} →
[inst_1 : Sem... | true |
Lean.Meta.MVarRenaming.map | Lean.Meta.Match.MVarRenaming | Lean.Meta.MVarRenaming → Lean.MVarIdMap Lean.MVarId | true |
SemidirectProduct.inr | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} → {G : Type u_2} → [inst : Group N] → [inst_1 : Group G] → {φ : G →* MulAut N} → G →* N ⋊[φ] G | true |
GroupSeminorm.coe_sSup_apply' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] {s : Set (GroupSeminorm E)},
BddAbove s → ∀ {x : E}, (sSup s) x = sSup ((fun x_1 => x_1 x) '' s) | true |
Algebra.IsPushout.cancelBaseChangeAux.congr_simp | 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] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsSc... | true |
_private.Lean.Server.GoTo.0.Lean.Server.getInstanceProjectionArg?.reduceToProjection?._sparseCasesOn_6 | Lean.Server.GoTo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Array.merge.go._unary | Batteries.Data.Array.Merge | {α : Type u_1} → (α → α → Bool) → Array α → Array α → (_ : Array α) ×' (_ : ℕ) ×' ℕ → Array α | false |
RingSeminormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) → (∀ (f : F) (a b : α), f ... | false |
_private.Init.Data.Fin.Basic.0.Fin.exists_iff.match_1_1 | Init.Data.Fin.Basic | ∀ {n : ℕ} {p : Fin n → Prop} (motive : (∃ i, p i) → Prop) (x : ∃ i, p i),
(∀ (i : ℕ) (hi : i < n) (hpi : p ⟨i, hi⟩), motive ⋯) → motive x | false |
LieModule.Cohomology.twoCocycle.eq_1 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_1) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M],
LieModule.Cohomology.twoCocycle R L M = (LieModule.Cohomology.d₂₃ R L M).ker | true |
Convex.norm_image_sub_le_of_norm_fderiv_le | Mathlib.Analysis.Calculus.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {𝕜 : Type u_3} {G : Type u_4}
[inst_2 : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {C : ℝ} {s : Set E} {x y : E},
(∀ x ∈ s, Diffe... | true |
Std.DTreeMap.Internal.Impl.applyPartition_eq_apply_toListModel | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α]
[inst_3 : Std.LawfulBEqOrd α] {k : α} {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
∀
{f :
List ((a : α) × β a) →
(c : Std.DTreeMap.Internal.Cell α β (compare k)) →
(Std... | true |
Lean.Elab.Do.InferControlInfo.ofSeq | Lean.Elab.Do.InferControlInfo | Lean.TSyntax `Lean.Parser.Term.doSeq → Lean.Elab.TermElabM Lean.Elab.Do.ControlInfo | true |
Mathlib.Tactic.Order.OrderType.lin.sizeOf_spec | Mathlib.Tactic.Order.Preprocessing | sizeOf Mathlib.Tactic.Order.OrderType.lin = 1 | true |
_private.Init.Data.Nat.Control.0.Nat.forM.loop._unsafe_rec | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | false |
SymAlg.instCommMagmaOfInvertibleOfNat | Mathlib.Algebra.Symmetrized | {α : Type u_1} → [inst : Ring α] → [Invertible 2] → CommMagma αˢʸᵐ | true |
LeanSearchClient.instReprSearchResult | LeanSearchClient.Syntax | Repr LeanSearchClient.SearchResult | true |
Nat.mul_left_comm | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m * k) = m * (n * k) | true |
UInt16.toFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), (a % b).toFin = a.toFin % b.toFin | true |
PadicSeq.valuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [Fact (Nat.Prime p)] → PadicSeq p → ℤ | true |
SimpleGraph.sum_incMatrix_apply_of_notMem_edgeSet | Mathlib.Combinatorics.SimpleGraph.IncMatrix | ∀ {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [inst : NonAssocSemiring R] [inst_1 : DecidableEq α]
[inst_2 : DecidableRel G.Adj] {e : Sym2 α} [inst_3 : Fintype α],
e ∉ G.edgeSet → ∑ a, SimpleGraph.incMatrix R G a e = 0 | true |
ValueDistribution.logCounting_const | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {c : E} {e : WithTop E},
ValueDistribution.logCounting (fun x => c) e = 0 | true |
PairReduction.finset_logSizeBallSeq_subset_logSizeBallSeq_init | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {J : Finset T} [inst_1 : DecidableEq T] (hJ : J.Nonempty)
(i : ℕ), (PairReduction.logSizeBallSeq J hJ a c i).finset ⊆ J | true |
RootPairing.coroot_eq_neg_iff | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) {i j : ι},
P.coroot i = -P.coroot j ↔ i = (P.reflectionPerm j) j | true |
UInt8.ext | Batteries.Data.UInt | ∀ {x y : UInt8}, x.toNat = y.toNat → x = y | true |
Std.Roo.size_eq_match_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size =
match Std.PRange.succ? r.lowe... | true |
_private.Mathlib.Data.Nat.Dist.0.Nat.dist_zero_right._proof_1_1 | Mathlib.Data.Nat.Dist | ∀ (n : ℕ), n - 0 + (0 - n) = n | false |
NNRat.divNat_zero | Mathlib.Data.NNRat.Defs | ∀ (n : ℕ), NNRat.divNat n 0 = 0 | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.activateNextGuard.go.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Simp.Result → Sort u_1) →
(__discr : Lean.Meta.Simp.Result) →
((e : Lean.Expr) →
(proof? : Option Lean.Expr) → (cache : Bool) → motive { expr := e, proof? := proof?, cache := cache }) →
motive __discr | false |
Lean.Grind.CommRing.Poly.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} → {t t' : Lean.Grind.CommRing.Poly} → t = t' → Lean.Grind.CommRing.Poly.noConfusionType P t t' | false |
RingHom.CodescendsAlong.algebraMap_tensorProduct | Mathlib.RingTheory.RingHomProperties | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
(Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (R S T : Type u)
[inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T],
(RingHom.Cod... | true |
star_pow | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star (x ^ n) = star x ^ n | true |
Std.Sat.CNF.eval_empty | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (a : α → Bool), Std.Sat.CNF.eval a Std.Sat.CNF.empty = true | true |
DiscreteMeasurableSpace.mk | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} [inst : MeasurableSpace α], (∀ (s : Set α), MeasurableSet s) → DiscreteMeasurableSpace α | true |
LocallyConstant.instCommGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x ^ x_1) = ⇑(x ^ x_1) | false |
Set.OrdConnected.isSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | true |
Lean.Parser.Term.falseVal.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_derivedLits._proof_1_8 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (derivedLits_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(j : Fin derivedLits_arr.size), ↑j + 1 ≤ derivedLits_arr.size → ↑j < derivedLits_arr.size | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.map_symm_eq_iff_eq_map._simp_1_3 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, (L = M) = (↑L = ↑M) | false |
Set.image_affine_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Ico c d = Set.Ico (a * c + b) (a * d + b) | true |
AlgebraicGeometry.Scheme.Modules.pullback._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
(SheafOfModules.pushforward (AlgebraicGeometry.Scheme.Hom.toRingCatSheafHom f)).IsRightAdjoint | false |
Std.HashMap.contains_modify | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : β → β}, (m.modify k f).contains k' = m.contains k' | true |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso... | false |
Lean.PrettyPrinter.Formatter.State.noConfusionType | Lean.PrettyPrinter.Formatter | Sort u → Lean.PrettyPrinter.Formatter.State → Lean.PrettyPrinter.Formatter.State → Sort u | false |
Lean.Meta.MatcherApp.remaining | Lean.Meta.Match.MatcherApp.Basic | Lean.Meta.MatcherApp → Array Lean.Expr | true |
instSubNegAddMonoidLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : SubNegMonoid α] → SubNegMonoid (Lex α) | true |
inv_eq_one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑u⁻¹ = 1 /ₚ u | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.mem_factoredNumbers_iff_forall_le.match_1_3 | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ} (motive : (m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s) → Prop)
(x : m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s),
(∀ (H₀ : m ≠ 0) (H₁ : ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s), motive ⋯) → motive x | false |
PNat.XgcdType.y | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | true |
ContinuousLinearMap.coe_projKerOfRightInverse_apply | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {M : Type u_4} [inst_2 : TopologicalSpace M]
[inst_3 : AddCommGroup M] {M₂ : Type u_5} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂]
[inst_6 : Module R M] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_8 : RingHomInvPai... | true |
PseudoMetricSpace.toUniformSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [self : PseudoMetricSpace α] → UniformSpace α | true |
CategoryTheory.MorphismProperty.llp_rlp_of_hasSmallObjectArgument' | Mathlib.CategoryTheory.SmallObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C)
[inst_1 : I.HasSmallObjectArgument],
I.rlp.llp =
((CategoryTheory.MorphismProperty.coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape
I.smallObjectκ.ord.ToType).retracts | true |
Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P),
f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k) = k | true |
Besicovitch.TauPackage.color.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.color x =
sInf
(Set.univ \
⋃ j,
⋃ (_ :
(Metric.closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩
Metric.closedBall (p.c (p.index x... | true |
PiTensorProduct.dualDistribEquivOfBasis_symm_apply | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b : (i : ι) → Module.Basis (κ i) R (M i))
(a : Module.Dual R (PiTensorProduct R fun i => M i... | true |
FractionalIdeal.ne_zero_of_mul_eq_one | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
(I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → I ≠ 0 | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.x_mul_y_mul_z_eq_u_mul_w_cube._simp_1_8 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [inst_2 : IsCyclotomicExtension {3} ℚ K],
(hζ.toInteger - 1) ^ (3 * FermatLastTheoremForThreeGen.Solution.multiplicity✝ S - 2) *
FermatLastTheoremForThreeGen.Solution.x... | false |
Matrix.isUnit_charpolyRev_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 → IsUnit M.charpolyRev | true |
Polynomial.natDegree_mul_C_eq_of_mul_ne_zero | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
p.leadingCoeff * a ≠ 0 → (p * Polynomial.C a).natDegree = p.natDegree | true |
PartialEquiv.transEquiv._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (e : PartialEquiv α β) (f' : β ≃ γ),
↑(e.trans f'.toPartialEquiv).symm = ↑(e.trans f'.toPartialEquiv).symm | false |
Lean.Meta.Simp.Stats.diag | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Stats → Lean.Meta.Simp.Diagnostics | true |
Stream'.cons_injective2 | Mathlib.Data.Stream.Init | ∀ {α : Type u}, Function.Injective2 Stream'.cons | true |
Homeomorph.toEquiv_piCongrLeft | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_7} {ι' : Type u_8} {Y : ι' → Type u_9} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
(Homeomorph.piCongrLeft e).toEquiv = Equiv.piCongrLeft Y e | true |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_4 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
... | true |
DirectSum.decomposeLinearEquiv_apply | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (ℳ : ι → Submodule R M) [inst_4 : DirectSum.Decomposition ℳ] (m : M),
(DirectSum.decomposeLinearEquiv ℳ) m = (DirectSum.decompose ℳ) m | true |
ContinuousLinearMap.compContinuousMultilinearMapL._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (F : Type u_5) (G : Type u_3) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 ... | false |
Rep.instLinearResFunctor | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u} [inst : CommRing k] {G : Type v1} {H : Type v2} [inst_1 : Monoid G] [inst_2 : Monoid H] (f : H →* G),
CategoryTheory.Functor.Linear k (Rep.resFunctor f) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.