name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LinearEquiv.arrowCongr_symm_apply | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_9} {R₂ : Type u_10} {R₁' : Type u_12} {R₂' : Type u_13} {M₁ : Type u_17} {M₂ : Type u_18}
{M₁' : Type u_20} {M₂' : Type u_21} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : CommSemiring R₁']
[inst_3 : CommSemiring R₂'] [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂] [inst_6 : AddCommMo... | true |
MeasureTheory.convolution_lsmul | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {F : Type uF} [inst : NormedAddCommGroup F] {x : G} [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_4 : NormedSpace ℝ F]
[inst_5 : Sub G] {f : G → 𝕜} {g : G → F},
MeasureTheory.convolution f g (Cont... | true |
Polynomial.Splits.natDegree_eq_card_roots | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R], f.Splits → f.natDegree = f.roots.card | true |
Lean.Lsp.LeanILeanHeaderSetupInfoParams.rec | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanILeanHeaderSetupInfoParams → Sort u} →
((version : ℕ) →
(isSetupFailure : Bool) →
(directImports : Array Lean.Lsp.ImportInfo) →
motive { version := version, isSetupFailure := isSetupFailure, directImports := directImports }) →
(t : Lean.Lsp.LeanILeanHeaderSetupInfoPa... | false |
Orientation.wrapped._@.Mathlib.Analysis.InnerProductSpace.Orientation.2114562672._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.Orientation | Subtype (Eq @Orientation.definition✝) | false |
Subgroup.multiset_prod_mem | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {G : Type u_3} [inst : CommGroup G] (K : Subgroup G) (g : Multiset G), (∀ a ∈ g, a ∈ K) → g.prod ∈ K | true |
Std.DTreeMap.Internal.Unit.RooSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Unit.RooSliceData α → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit) →
(range : Std.Roo α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Unit.RooSliceData α) → motive t | false |
Lean.Lsp.ImportInfo._sizeOf_1 | Lean.Data.Lsp.Internal | Lean.Lsp.ImportInfo → ℕ | false |
ArithmeticFunction.prodPrimeFactors._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] (f : ℕ → R), (if 0 = 0 then 0 else ∏ p ∈ Nat.primeFactors 0, f p) = 0 | false |
PosNum.commMonoid._proof_2 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), 1 * a = a | false |
Batteries.RBSet.instEmptyCollection | Batteries.Data.RBMap.Basic | (α : Type u) → (cmp : α → α → Ordering) → EmptyCollection (Batteries.RBSet α cmp) | true |
Lean.Doc.WithSyntax.mk | Lean.Elab.DocString | {α : Type u} → α → Lean.Syntax → Lean.Doc.WithSyntax α | true |
_private.Mathlib.MeasureTheory.Function.ConvergenceInDistribution.0.MeasureTheory.tendstoInDistribution_of_tendstoInMeasure_sub._simp_1_9 | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | false |
Profinite.Extend.isColimitCocone | Mathlib.Topology.Category.Profinite.Extend | {I : Type u} →
[inst : CategoryTheory.SmallCategory I] →
[CategoryTheory.IsCofiltered I] →
{F : CategoryTheory.Functor I FintypeCat} →
(c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toProfinite)) →
{C : Type u_1} →
[inst_2 : CategoryTheory.Category.{v_1, u_1} C] →
... | true |
Lean.ConstantInfo.defnInfo.inj | Lean.Declaration | ∀ {val val_1 : Lean.DefinitionVal}, Lean.ConstantInfo.defnInfo val = Lean.ConstantInfo.defnInfo val_1 → val = val_1 | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.nonsingular_add_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} [inst_1 : DecidableEq F] {P Q : Fin 3 → F},
W.Nonsingular P →
W.Nonsingular Q →
P 2 ≠ 0 →
Q 2 ≠ 0 →
¬(P 0 * Q 2 = Q 0 * P 2 ∧ P 1 * Q 2 = W.negY Q * P 2) →
W.Nonsingular
![W.toAffine.addX (P 0 / P... | true |
LinearMap.instIsSimpleModuleEndOfNontrivial | Mathlib.RingTheory.SimpleModule.Basic | ∀ {M : Type u_4} [inst : AddCommGroup M] (R : Type u_6) [inst_1 : DivisionRing R] [inst_2 : Module R M] [Nontrivial M],
IsSimpleModule (Module.End R M) M | true |
_private.Lean.Environment.0.Lean.ImportState.mk.sizeOf_spec | Lean.Environment | ∀ (moduleNameMap : Std.HashMap Lean.Name Lean.ImportedModule✝) (moduleNames : Array Lean.Name),
sizeOf { moduleNameMap := moduleNameMap, moduleNames := moduleNames } = 1 + sizeOf moduleNameMap + sizeOf moduleNames | true |
Lean.Meta.Match.Pattern.as.injEq | Lean.Meta.Match.Basic | ∀ (varId : Lean.FVarId) (p : Lean.Meta.Match.Pattern) (hId varId_1 : Lean.FVarId) (p_1 : Lean.Meta.Match.Pattern)
(hId_1 : Lean.FVarId),
(Lean.Meta.Match.Pattern.as varId p hId = Lean.Meta.Match.Pattern.as varId_1 p_1 hId_1) =
(varId = varId_1 ∧ p = p_1 ∧ hId = hId_1) | true |
_private.Mathlib.CategoryTheory.Comma.Over.Pullback.0.CategoryTheory.Over.isLeftAdjoint_post.match_1 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (motive : F.IsLeftAdjoint → Prop)
(x : F.IsLeftAdjoint), (∀ (G : CategoryTheory.Functor D C) (a : F ⊣ G), motive ⋯) → motive x | false |
ContinuousAlgEquiv.mk._flat_ctor | Mathlib.Topology.Algebra.Algebra.Equiv | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : TopologicalSpace A] →
[inst_3 : Semiring B] →
[inst_4 : TopologicalSpace B] →
[inst_5 : Algebra R A] →
[inst_6 : Algebr... | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.ProofM | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Type → Type | true |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Basic.0.totallyBounded_iff_subset_finite_iUnion_nhds_one._simp_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] (a : α) (t : Set β),
a • t = (fun x => a⁻¹ • x) ⁻¹' t | false |
LieModuleHom.instZero._proof_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_3} {L : Type u_4} {M : Type u_2} {N : Type u_1} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] {x : L} {m : M},
(LinearMap.toAddHom 0).toFun ⁅x, m⁆ = ⁅x... | false |
PadicInt.nthHomSeq.eq_1 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ} {f : (k : ℕ) → R →+* ZMod (p ^ k)} [hp_prime : Fact (Nat.Prime p)]
(f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), (ZMod.castHom ⋯ (ZMod (p ^ k1))).comp (f k2) = f k1) (r : R),
PadicInt.nthHomSeq f_compat r = ⟨fun n => ↑(PadicInt.nthHom f r n), ⋯⟩ | true |
Lean.Widget.HighlightedMsgEmbed._sizeOf_inst | Lean.Server.FileWorker.WidgetRequests | SizeOf Lean.Widget.HighlightedMsgEmbed | false |
BitVec.add_comm | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n), x + y = y + x | true |
StandardEtalePair.equivAwayAdjoinRoot._simp_2 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {M : Type u_4} [inst : Monoid M] (a : M), (a ∈ IsUnit.submonoid M) = IsUnit a | false |
Matrix.isCentralScalar | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : SMul R α] [inst_1 : SMul Rᵐᵒᵖ α]
[IsCentralScalar R α], IsCentralScalar R (Matrix m n α) | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.mk._flat_ctor | Mathlib.NumberTheory.LSeries.Nonvanishing | {N : ℕ} →
[inst : NeZero N] →
(χ : DirichletCharacter ℂ N) →
χ ≠ 1 → χ ^ 2 = 1 → DirichletCharacter.LFunction χ 1 = 0 → DirichletCharacter.BadChar✝ N | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.PreservesLocalization.isOpenImmersion | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} (F : CategoryTheory.Functor X.AffineZariskiSiteᵒᵖ CommRingCat)
(α : (AlgebraicGeometry.Scheme.AffineZariskiSite.toOpensFunctor X).op.comp X.presheaf ⟶ F),
CategoryTheory.NatTrans.Coequifibered α →
∀ ⦃U V : X.AffineZariskiSite⦄ (f : U ⟶ V),
AlgebraicGeometry.IsOpenImmersion... | true |
DoubleCentralizer.add_toProd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A]
(a b : DoubleCentralizer 𝕜 A), (a + b).toProd = a.toProd + b.toProd | true |
Std.Time.instToStringDuration.leftPad | Std.Time.Duration | ℕ → String → String | true |
Multiset.powersetCard | Mathlib.Data.Multiset.Powerset | {α : Type u_1} → ℕ → Multiset α → Multiset (Multiset α) | true |
starMulOfComm._proof_2 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] (a b : R), a * b = b * a | false |
_private.Mathlib.Algebra.Order.ToIntervalMod.0.iUnion_Ico_add_intCast._simp_1_1 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_7 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n),
∀ i < (Array.range f.clauses.size).size, i < f.clauses.size | false |
Lean.Parser.Term.suffices._regBuiltin.Lean.Parser.Term.sufficesDecl.parenthesizer_39 | Lean.Parser.Term | IO Unit | false |
nonempty_invertible_iff_isUnit | Mathlib.Algebra.Group.Invertible.Basic | ∀ {α : Type u} [inst : Monoid α] (a : α), Nonempty (Invertible a) ↔ IsUnit a | true |
Ideal.smithNormalForm | Mathlib.LinearAlgebra.FreeModule.PID | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
[IsDomain R] →
[IsPrincipalIdealRing R] →
{S : Type u_4} →
[inst_3 : CommRing S] →
[IsDomain S] →
[inst_5 : Algebra R S] →
[inst_6 : Fintype ι] →
Module.B... | true |
UnitsInt.fintype | Mathlib.Data.Fintype.Units | Fintype ℤˣ | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_pos_of_nonneg._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | false |
Finset.sum_pow_of_commute | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} {R : Type u_2} [inst : DecidableEq α] [inst_1 : Semiring R] (x : α → R) (s : Finset α)
(hc : (↑s).Pairwise (Function.onFun Commute x)) (n : ℕ),
s.sum x ^ n = ∑ k, ↑(↑↑k).countPerms * (Multiset.map x ↑↑k).noncommProd ⋯ | true |
exists_homeomorph_image_eq | Mathlib.Analysis.Convex.GaugeRescale | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul ℝ E] [T1Space E] {s t : Set E},
Convex ℝ s →
(interior s).Nonempty →
Bornology.IsVonNBounded ℝ s →
Convex ℝ t →
(interior t).Nonempty →
Borno... | true |
ContinuousMapZero.instZero._proof_1 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_2} {R : Type u_1} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : Zero R], 0 0 = 0 0 | false |
BitVec.msb_or | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x ||| y).msb = (x.msb || y.msb) | true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Elab.Tactic.warnRedundantEMatchArg._sparseCasesOn_4 | Lean.Elab.Tactic.Grind.Param | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Char.toLower_eq_of_not_isUpper | Batteries.Data.Char.AsciiCasing | ∀ {c : Char}, ¬c.isUpper = true → c.toLower = c | true |
MultipliableUniformlyOn.exists | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α], MultipliableUniformlyOn f s → ∃ g, HasProdUniformlyOn f g s | true |
Std.Internal.IO.Async.ETask.bind | Std.Internal.Async.Basic | {ε α β : Type} →
Std.Internal.IO.Async.ETask ε α →
(α → Std.Internal.IO.Async.ETask ε β) →
optParam Task.Priority Task.Priority.default → optParam Bool false → Std.Internal.IO.Async.ETask ε β | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.NameMap.fromJson?._sparseCasesOn_1 | Lean.Data.Json.FromToJson.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((kvPairs : Std.TreeMap.Raw String Lean.Json compare) → motive_1 (Lean.Json.obj kvPairs)) →
(Nat.hasNotBit 32 t.ctorIdx → motive_1 t) → motive_1 t | false |
Std.Time.Timestamp.instHSubDuration | Std.Time.DateTime.Timestamp | HSub Std.Time.Timestamp Std.Time.Duration Std.Time.Timestamp | true |
Function.Embedding.smul | Mathlib.GroupTheory.GroupAction.Embedding | {G : Type u_1} → {α : Type u_3} → {β : Type u_4} → [inst : Group G] → [MulAction G β] → SMul G (α ↪ β) | true |
_private.Mathlib.Algebra.Ring.Int.Units.0.Int.units_ne_iff_eq_neg._simp_1_1 | Mathlib.Algebra.Ring.Int.Units | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | false |
DifferentiableOn.star | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [StarModule 𝕜 F] [ContinuousStar F] {f : E → F} {s : Set E} [... | true |
contMDiffWithinAt_finsum | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_3}
[inst_1 : TopologicalSpace H] {E : Type u_4} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E]
{I : ModelWithCorners 𝕜 E H} {G : Type u_5} [inst_4 : AddCommMonoid G] [inst_5 : TopologicalSpace G]
[inst_... | true |
Monoid.CoprodI.mclosure_iUnion_range_of | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)],
Submonoid.closure (⋃ i, Set.range ⇑Monoid.CoprodI.of) = ⊤ | true |
OpenPartialHomeomorph.coe_coe_symm | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y), ↑e.symm = ↑e.symm | true |
Metric.infDist_le_infDist_add_dist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x y : α}, Metric.infDist x s ≤ Metric.infDist y s + dist x y | true |
Lean.Expr.appFn!'._unsafe_rec | Lean.Expr | Lean.Expr → Lean.Expr | false |
OrthonormalBasis.volume_parallelepiped | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ {ι : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F]
[inst_2 : MeasurableSpace F] [inst_3 : BorelSpace F] [inst_4 : Fintype ι] [inst_5 : FiniteDimensional ℝ F]
(b : OrthonormalBasis ι ℝ F), MeasureTheory.volume (parallelepiped ⇑b) = 1 | true |
Lean.Parser.Command.namedPrio.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
Lean.Lsp.CompletionItemKind.enum.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionItemKind → Sort u} →
(t : Lean.Lsp.CompletionItemKind) → t.ctorIdx = 12 → motive Lean.Lsp.CompletionItemKind.enum → motive t | false |
FreeSemigroup.instLawfulMonad | Mathlib.Algebra.Free | LawfulMonad FreeSemigroup | true |
RootPairing.Equiv.id_indexEquiv_apply | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : 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) (a : ι),
(↑(RootPairing.Equiv.id P)).indexEquiv a = a | true |
SlashAction.rec | Mathlib.NumberTheory.ModularForms.SlashActions | {β : Type u_1} →
{G : Type u_2} →
{α : Type u_3} →
[inst : Monoid G] →
[inst_1 : AddMonoid α] →
{motive : SlashAction β G α → Sort u} →
((map : β → G → α → α) →
(zero_slash : ∀ (k : β) (g : G), map k g 0 = 0) →
(slash_one : ∀ (k : β) (a : α), m... | false |
Ring.intCast_ofNat | Mathlib.Algebra.Ring.Defs | ∀ {R : Type u} [self : Ring R] (n : ℕ), IntCast.intCast ↑n = ↑n | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.lt_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.Total fun x1 x2 => x1 ≤ x2] [Std.LawfulOrderLT α] {a b : α},
(b < a) = ¬a ≤ b | false |
Mathlib.Tactic.ITauto.Proof.andLeft.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (ak : Mathlib.Tactic.ITauto.AndKind) (p : Mathlib.Tactic.ITauto.Proof),
sizeOf (Mathlib.Tactic.ITauto.Proof.andLeft ak p) = 1 + sizeOf ak + sizeOf p | true |
CauSeq.Completion.mk_add | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (f g : CauSeq β abv),
CauSeq.Completion.mk f + CauSeq.Completion.mk g = CauSeq.Completion.mk (f + g) | true |
tendsto_algebraMap_inv_atTop_nhds_zero_nat | Mathlib.Analysis.SpecificLimits.Basic | ∀ {𝕜 : Type u_4} (A : Type u_5) [inst : Semifield 𝕜] [inst_1 : CharZero 𝕜] [inst_2 : TopologicalSpace 𝕜]
[ContinuousSMul ℚ≥0 𝕜] [inst_4 : Semiring A] [inst_5 : Algebra 𝕜 A] [inst_6 : TopologicalSpace A]
[ContinuousSMul 𝕜 A], Filter.Tendsto (⇑(algebraMap 𝕜 A) ∘ fun n => (↑n)⁻¹) Filter.atTop (nhds 0) | true |
Aesop.instToMessageDataRuleTerm | Aesop.RuleTac.RuleTerm | Lean.ToMessageData Aesop.RuleTerm | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.IsComplete.union._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {f : Ultrafilter α} {s t : Set α}, (s ∪ t ∈ f) = (s ∈ f ∨ t ∈ f) | false |
TopologicalSpace.Opens.mem_mk | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α} {U : Set α} {h : IsOpen U},
x ∈ { carrier := U, is_open' := h } ↔ x ∈ U | true |
AddSubmonoid.mem_sup | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {N : Type u_4} [inst : AddCommMonoid N] {s t : AddSubmonoid N} {x : N}, x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_def_minFac.match_1_1 | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ} (motive : Nat.minFacProp✝ p p.minFac → Prop) (x : Nat.minFacProp✝ p p.minFac),
(∀ (f2 : 2 ≤ p.minFac) (fd : p.minFac ∣ p) (right : ∀ (m : ℕ), 2 ≤ m → m ∣ p → p.minFac ≤ m), motive ⋯) → motive x | false |
MvPowerSeries.rename_id | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {σ : Type u_1} {R : Type u_4} [inst : CommSemiring R], MvPowerSeries.rename id = AlgHom.id R (MvPowerSeries σ R) | true |
Complex.measurableEquivPi._proof_8 | Mathlib.MeasureTheory.Measure.Lebesgue.Complex | Finite (Fin 2) | false |
NNReal.nnrpow_def | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ (a b : NNReal), a.nnrpow b = a ^ ↑b | true |
Metric.instMetricSpaceInductiveLimit._proof_5 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : ℕ → Type u_1} [inst : (n : ℕ) → MetricSpace (X n)] {f : (n : ℕ) → X n → X (n + 1)}
{I : ∀ (n : ℕ), Isometry (f n)} (x y z : Metric.InductiveLimit I), dist x z ≤ dist x y + dist y z | false |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_eq_one | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Field S] [inst_2 : LinearOrder S]
[inst_3 : TopologicalSpace S] [IsStrictOrderedRing S] [Archimedean S] [OrderTopology S] {ι : Type u_3} [Finite ι]
{v : ι → AbsoluteValue R S} {w : AbsoluteValue R S} {a b : R} {i : ι},
1 < (v i) a →
(∀ (j : ι), j ≠ i ... | true |
Sum.Lex.instSemilatticeInf.match_1 | Mathlib.Data.Sum.Lattice | ∀ {α : Type u_2} {β : Type u_1} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β]
(motive : (x x_1 x_2 : Lex (α ⊕ β)) → x ≤ x_1 → x ≤ x_2 → Prop) (x x_1 x_2 : Lex (α ⊕ β)) (x_3 : x ≤ x_1)
(x_4 : x ≤ x_2),
(∀ (a₁ a₂ a₃ : α) (h₁₃ : a₁ ≤ a₂) (h₂₃ : a₁ ≤ a₃), motive (Sum.inl a₁) (Sum.inl a₂) (Sum.inl a₃) ⋯ ⋯) →
... | false |
ProofWidgets.Html.brecOn.go | ProofWidgets.Data.Html | {motive_1 : ProofWidgets.Html → Sort u} →
{motive_2 : Array ProofWidgets.Html → Sort u} →
{motive_3 : List ProofWidgets.Html → Sort u} →
(t : ProofWidgets.Html) →
((t : ProofWidgets.Html) → t.below → motive_1 t) →
((t : Array ProofWidgets.Html) → ProofWidgets.Html.below_1 t → motive_2 t) →... | true |
PrimeSpectrum.instUnique._proof_1 | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u_1} [inst : Field R], IsDomain R | false |
IsDiscreteValuationRing.addVal_le_iff_dvd | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {a b : R},
(IsDiscreteValuationRing.addVal R) a ≤ (IsDiscreteValuationRing.addVal R) b ↔ a ∣ b | true |
dvd_neg._simp_1 | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : HasDistribNeg α] {a b : α}, (a ∣ -b) = (a ∣ b) | false |
_private.Mathlib.GroupTheory.Schreier.0.Subgroup.closure_mul_image_mul_eq_top._simp_1_5 | Mathlib.GroupTheory.Schreier | ∀ {G : Type u_3} [inst : Group G] (a : G) (m n : ℤ), a ^ m * a ^ n = a ^ (m + n) | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabFunTarget.match_1 | Lean.Elab.Tactic.Induction | (motive : Option (Bool × Subarray Bool) → Sort u_1) →
(x : Option (Bool × Subarray Bool)) →
(Unit → motive none) → ((b : Bool) → (s' : Subarray Bool) → motive (some (b, s'))) → motive x | false |
DividedPowers.SubDPIdeal.instBot | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_1} → [inst : CommSemiring A] → {I : Ideal A} → {hI : DividedPowers I} → Bot hI.SubDPIdeal | true |
MonoidAlgebra.mapAlgHom_id | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {k : Type u_10} {R : Type u_11} {G : Type u_12} [inst : CommSemiring k] [inst_1 : Semiring R] [inst_2 : Algebra k R]
[inst_3 : Monoid G], MonoidAlgebra.mapAlgHom G (AlgHom.id k R) = AlgHom.id k (MonoidAlgebra R G) | true |
Order.pred_le_pred_iff_of_not_isMin | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] {a b : α},
¬IsMin b → ¬IsMin a → (Order.pred b ≤ Order.pred a ↔ b ≤ a) | true |
HahnSeries.addOppositeEquiv_orderTop | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : AddMonoid R] (x : HahnSeries Γ Rᵃᵒᵖ),
(AddOpposite.unop (HahnSeries.addOppositeEquiv x)).orderTop = x.orderTop | true |
Std.TreeMap.Raw.getKey?_modify | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k k' : α} {f : β → β},
(t.modify k f).getKey? k' = if cmp k k' = Ordering.eq then if k ∈ t then some k else none else t.getKey? k' | true |
Stream'.WSeq.head | Mathlib.Data.WSeq.Basic | {α : Type u} → Stream'.WSeq α → Computation (Option α) | true |
_private.Init.Meta.Defs.0.Lean.Syntax.updateLast.match_1 | Init.Meta.Defs | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((v : α) → motive (some v)) → (Unit → motive none) → motive x | false |
CategoryTheory.IsCoreflexivePair.swap | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} [CategoryTheory.IsCoreflexivePair f g],
CategoryTheory.IsCoreflexivePair g f | true |
Lean.ClassEntry.casesOn | Lean.Class | {motive : Lean.ClassEntry → Sort u} →
(t : Lean.ClassEntry) →
((name : Lean.Name) →
(outParams outLevelParams : Array ℕ) →
motive { name := name, outParams := outParams, outLevelParams := outLevelParams }) →
motive t | false |
Matroid.subsingleton_indep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {I : Set α} [M.Loopless],
I.Subsingleton → autoParam (I ⊆ M.E) Matroid.subsingleton_indep._auto_1 → M.Indep I | true |
_private.Mathlib.Data.Bool.Basic.0.Bool.not_eq_true_eq_eq_false._proof_1_1 | Mathlib.Data.Bool.Basic | ∀ (a : Bool), ((!a) = true) = (a = false) | false |
Batteries.instReprRBNode.repr._sunfold | Batteries.Data.RBMap.Basic | {α : Type u_1} → [Repr α] → Batteries.RBNode α → ℕ → Std.Format | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.