name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Quotient.comp_natTransLift | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F G H : CategoryTheory.Functor (CategoryTheory.Quotient r) D}
(τ : (CategoryTheory.Quotient.functor r).comp F ⟶ (CategoryTheory.Quotient.functor r).comp G)
(τ' : (CategoryT... | true |
Algebra.Extension.h1Cotangentι_apply | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(self : ↥P.cotangentComplex.ker), Algebra.Extension.h1Cotangentι self = ↑self | true |
_private.Mathlib.Data.Finset.Pi.0.Finset.pi_nonempty._simp_1_1 | Mathlib.Data.Finset.Pi | ∀ {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}, (∀ (x : α), ∃ y, p x y) = ∃ f, ∀ (x : α), p x (f x) | false |
RCLike.ofReal_re_ax | Mathlib.Analysis.RCLike.Basic | ∀ {K : semiOutParam (Type u_1)} [self : RCLike K] (r : ℝ), RCLike.re ((algebraMap ℝ K) r) = r | true |
UInt64.reduceDiv._regBuiltin.UInt64.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.99 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
SSet.Subcomplex.image_comp | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (A : X.Subcomplex) (f : X ⟶ Y) {Z : SSet} (g : Y ⟶ Z),
A.image (CategoryTheory.CategoryStruct.comp f g) = (A.image f).image g | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.idCompletionCore._sparseCasesOn_1 | Lean.Server.Completion.CompletionCollectors | {motive : Lean.SourceInfo → Sort u} →
(t : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) →... | false |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_61 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α), head :: tail = xs → ¬xs ++ [x].dropLast = [] | false |
Mathlib.Tactic.RingNF.instBEqConfig.beq | Mathlib.Tactic.Ring.RingNF | Mathlib.Tactic.RingNF.Config → Mathlib.Tactic.RingNF.Config → Bool | true |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.rootMultiplicity_eq_zero_iff._simp_1_3 | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R}, (Polynomial.X - Polynomial.C a ∣ p) = p.IsRoot a | false |
MulSemiringActionHom.map_one' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S), self.toFun 1 = 1 | true |
HasCompactSupport.convolutionExists_left_of_continuous_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_252 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
WeakDual.CharacterSpace.equivAlgHom_symm_coe | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : CompleteSpace A]
[inst_3 : NormedAlgebra 𝕜 A] (f : A →ₐ[𝕜] 𝕜), ⇑(WeakDual.CharacterSpace.equivAlgHom.symm f) = ⇑f | true |
Simps.ProjectionRule.erase.injEq | Mathlib.Tactic.Simps.Basic | ∀ (a : Lean.Name) (a_1 : Lean.Syntax) (a_2 : Lean.Name) (a_3 : Lean.Syntax),
(Simps.ProjectionRule.erase a a_1 = Simps.ProjectionRule.erase a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unary | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → (_ : ℕ) ×' Array Lean.Expr → Lean.Elab.TermElabM α | false |
mem_residual_iff | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
s ∈ residual X ↔ ∃ S, (∀ t ∈ S, IsOpen t) ∧ (∀ t ∈ S, Dense t) ∧ S.Countable ∧ ⋂₀ S ⊆ s | true |
Submonoid.map_coe_toMonoidHom | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), Submonoid.map (↑f) S = Submonoid.map f S | true |
CategoryTheory.Equivalence.functor_map_ε_inverse_comp_counit_app | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal],
CategoryTheory.C... | true |
lowerSemicontinuous_biSup | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), LowerSemicontinuous (f i hi)) → LowerSemicontinuous fun x' => ⨆ i, ⨆ (hi : p i), f i hi x' | true |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_eq_succ.match_1_1 | Mathlib.Order.SuccPred.WithBot | ∀ {α : Type u_1} (motive : WithBot α → Prop) (x : WithBot α),
(∀ (a : Unit), motive none) → (∀ (a : α), motive (some a)) → motive x | false |
Metric.Snowflaking.dist_ofSnowflaking_ofSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoMetricSpace X]
(x y : Metric.Snowflaking X α hα₀ hα₁),
dist (Metric.Snowflaking.ofSnowflaking x) (Metric.Snowflaking.ofSnowflaking y) = dist x y ^ α⁻¹ | true |
SimpleGraph.Partition.partOfVertex._proof_1 | Mathlib.Combinatorics.SimpleGraph.Partition | ∀ {V : Type u_1} {G : SimpleGraph V} (P : G.Partition) (v : V), ∃! b, b ∈ P.parts ∧ v ∈ b | false |
_private.Mathlib.Data.Sigma.Basic.0.Sigma.eq.match_1_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : (x x_1 : (a : α) × β a) → (x_2 : x.fst = x_1.fst) → Eq.recOn x_2 x.snd = x_1.snd → Prop)
(x x_1 : (a : α) × β a) (x_2 : x.fst = x_1.fst) (x_3 : Eq.recOn x_2 x.snd = x_1.snd),
(∀ (fst : α) (snd : β fst), motive ⟨fst, snd⟩ ⟨fst, snd⟩ ⋯ ⋯) → motive x x_1 x_2 x_3 | false |
Lean.instBEqDeclaration.beq | Lean.Declaration | Lean.Declaration → Lean.Declaration → Bool | true |
HasDerivAt.const_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {d : 𝕜 → 𝔸} {d' : 𝔸} (c : 𝔸),
HasDerivAt d d' x → HasDerivAt (fun y => c * d y) (c * d') x | true |
AlgebraicGeometry.Scheme.IdealSheafData.recOn | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
{motive : X.IdealSheafData → Sort u_1} →
(t : X.IdealSheafData) →
((ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(map_ideal_basicOpen :
∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Idea... | false |
CategoryTheory.projective_iff_llp_epimorphisms_of_isZero | Mathlib.CategoryTheory.Preadditive.Projective.LiftingProperties | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {P Z : C}
(i : Z ⟶ P),
CategoryTheory.Limits.IsZero Z →
(CategoryTheory.Projective P ↔ (CategoryTheory.MorphismProperty.epimorphisms C).llp i) | true |
TwoSidedIdeal.instSubSubtypeMem | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → (I : TwoSidedIdeal R) → Sub ↥I | true |
CategoryTheory.Discrete.productEquiv_functor_map | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete (J × K)} (f : X ⟶ Y),
CategoryTheory.Discrete.productEquiv.functor.map f = ULift.rec (fun down => CategoryTheory.eqToHom ⋯) f | true |
le_inv_iff_mul_le_one_left | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] {a b : α}, a ≤ b⁻¹ ↔ b * a ≤ 1 | true |
Lean.Grind.AC.Seq.endsWithVar_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Var → Bool | true |
WeierstrassCurve.Jacobian.neg_X | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} (P : Fin 3 → R), W'.neg P 0 = P 0 | true |
AddSubgroup.neg_mem_iff | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, -x ∈ H ↔ x ∈ H | true |
Lean.AttributeApplicationTime.afterCompilation.elim | Lean.Attributes | {motive : Lean.AttributeApplicationTime → Sort u} →
(t : Lean.AttributeApplicationTime) → t.ctorIdx = 1 → motive Lean.AttributeApplicationTime.afterCompilation → motive t | false |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_6 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_1}
[inst_3 : CommRing S] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
IsLocalizedModule (PrimeSpectrum.comap σ y).asIdeal.primeCompl
(LocalizedModule.mkLinearMap (PrimeSpectrum.comap σ y).asIdeal.... | false |
Mathlib.Tactic.ModCases.NatMod.onModCases_succ | Mathlib.Tactic.ModCases | {p : Sort u_1} →
{n a : ℕ} →
(b : ℕ) →
(a ≡ b [MOD n] → p) →
Mathlib.Tactic.ModCases.NatMod.OnModCases n a (b.add 1) p → Mathlib.Tactic.ModCases.NatMod.OnModCases n a b p | true |
MeasureTheory.Measure.snd_mono | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{ρ μ : MeasureTheory.Measure (α × β)}, ρ ≤ μ → ρ.snd ≤ μ.snd | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkCasesResultSeq._proof_1 | Lean.Meta.Tactic.Grind.Split | ∀ (alts : Array (List (Lean.TSyntax `grind))), alts.size = 1 → ¬0 < alts.size → False | false |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_5 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (_a : Q(GroupWithZero «$α»)),
«$zα» =Q «$_a».toMulZeroOneClass.toMulZeroClass.toZero | false |
CategoryTheory.HasProjectiveDimensionLT.subsingleton' | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Abelian C} {X : C} {n : ℕ}
[self : CategoryTheory.HasProjectiveDimensionLT X n] (i : ℕ),
n ≤ i → ∀ ⦃Y : C⦄, Subsingleton (CategoryTheory.Abelian.Ext X Y i) | true |
addRightReflectLT_of_addLeftReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : AddCommSemigroup N] [inst_1 : LT N] [AddLeftReflectLT N], AddRightReflectLT N | true |
Int8.reduceDiv._regBuiltin.Int8.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.120 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Batteries.RBSet.mem_toList | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : Batteries.RBSet α cmp}, x ∈ t.toList ↔ x ∈ ↑t | true |
Nat.Partition.powerSeriesMk_card_restricted_eq_powerSeriesMk_card_countRestricted | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] [NoZeroDivisors R] {m : ℕ},
0 < m →
(PowerSeries.mk fun n => ↑(Nat.Partition.restricted n fun x => ¬m ∣ x).card) =
PowerSeries.mk fun n => ↑(Nat.Partition.countRestricted n m).card | true |
groupCohomology.shortComplexH0_g | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u u_1, u, u} k G),
(groupCohomology.shortComplexH0 A).g = groupCohomology.d₀₁ A | true |
HomologicalComplex.homology_π_ι | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K : HomologicalComplex C c} (i : ι) [inst_2 : K.HasHomology i],
CategoryTheory.CategoryStruct.comp (K.homologyπ i) (K.homologyι i) =
CategoryTheory.CategoryStru... | true |
ProbabilityTheory.HasSubgaussianMGF.const_mul | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {c : NNReal},
ProbabilityTheory.HasSubgaussianMGF X c μ →
∀ (r : ℝ), ProbabilityTheory.HasSubgaussianMGF (fun ω => r * X ω) (⟨r ^ 2, ⋯⟩ * c) μ | true |
Mathlib.Tactic.Bicategory.tgtExpr | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Lean.Expr → Lean.MetaM Lean.Expr | true |
ModuleCat.isLimitKernelFork._proof_6 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P)
(H : Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g)) (H₂ : Function.Injective ⇑(ModuleCat.Hom.hom f))
(j : CategoryTheory.Limits.WalkingParallelPair),
(ModuleCat.kernelCone g).π.app j =
CategoryTheory.CategoryStruct.c... | false |
TopologicalSpace.Fiber.sigmaIsoHom.match_1 | Mathlib.Topology.FiberPartition | {S : Type u_1} →
{Y : Type u_2} →
(f : S → Y) →
(motive : (x : Function.Fiber f) × ↑↑x → Sort u_3) →
(x : (x : Function.Fiber f) × ↑↑x) → ((a : Function.Fiber f) → (x : ↑↑a) → motive ⟨a, x⟩) → motive x | false |
SheafOfModules.IsFiniteType.rec | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddComm... | false |
Lean.Lsp.DocumentColorParams.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams : Lean.Lsp.PartialResultParams} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{toWorkDoneProgressParams' : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams' : Lean.Lsp.Parti... | false |
_private.Lean.Server.Test.Runner.0.Lean.Server.Test.Runner.Client.instFromJsonHighlightedMsgEmbed.fromJson.match_1 | Lean.Server.Test.Runner | (motive : String → Sort u_1) →
(tag : String) →
(Unit → motive "highlighted") →
(Unit → motive "expr") →
(Unit → motive "goal") →
(Unit → motive "widget") → (Unit → motive "trace") → ((x : String) → motive x) → motive tag | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageX._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq : κ) (hr : r₀ ≤ r),
data.i₀ r pq ⋯ ≤ data.i₁ pq | false |
Lean.Meta.mkId | Lean.Meta.AppBuilder | Lean.Expr → Lean.MetaM Lean.Expr | true |
Tropical.instLinearOrderTropical._proof_5 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (a b : Tropical R), a + b = if a ≤ b then a else b | false |
AlternatingMap.domCoprod.summand._proof_1 | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_6} {Mᵢ : Type u_3}
{N₁ : Type u_4} {N₂ : Type u_5} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R'... | false |
Subalgebra.mem_saturation_iff._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
{s : Subalgebra R S} {M : Submonoid S} {H : M ≤ s.toSubmonoid} {x : S}, (x ∈ s.saturation M H) = ∃ m ∈ M, m • x ∈ s | false |
Fin.sum_univ_five | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : Fin 5 → M), ∑ i, f i = f 0 + f 1 + f 2 + f 3 + f 4 | true |
Mathlib.Tactic.Widget.StringDiagram.stringEqM? | Mathlib.Tactic.Widget.StringDiagram | Lean.Expr → Lean.MetaM (Option ProofWidgets.Html) | true |
MonadCont.Label.rec | Mathlib.Control.Monad.Cont | {α : Type w} →
{m : Type u → Type v} →
{β : Type u} →
{motive : MonadCont.Label α m β → Sort u_1} →
((apply : α → m β) → motive { apply := apply }) → (t : MonadCont.Label α m β) → motive t | false |
List.take_concat_get | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ} (h : i < l.length), (List.take i l).concat l[i] = List.take (i + 1) l | true |
range_pow_padicValNat_subset_divisors' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p n : ℕ} [hp : Fact (Nat.Prime p)],
Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n)) ⊆ n.divisors.erase 1 | true |
DihedralGroup.oddCommuteEquiv | Mathlib.GroupTheory.SpecificGroups.Dihedral | {n : ℕ} → Odd n → { p // Commute p.1 p.2 } ≃ ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n | true |
Filter.EventuallyEq.fun_comp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {f g : α → β} {l : Filter α}, f =ᶠ[l] g → ∀ (h : β → γ), h ∘ f =ᶠ[l] h ∘ g | true |
ShareCommonT | Init.ShareCommon | ShareCommon.StateFactory → (Type u → Type v) → Type u → Type (max u v) | true |
StarRingEquiv.mk.inj | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} {B : Type u_2} {inst : Add A} {inst_1 : Add B} {inst_2 : Mul A} {inst_3 : Mul B} {inst_4 : Star A}
{inst_5 : Star B} {toRingEquiv : A ≃+* B}
{map_star' : ∀ (a : A), toRingEquiv.toFun (star a) = star (toRingEquiv.toFun a)} {toRingEquiv_1 : A ≃+* B}
{map_star'_1 : ∀ (a : A), toRingEquiv_1.toFun (st... | true |
MeasureTheory.FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.FiniteMeasure Ω) (s : Set Ω), ↑(ν s) = ↑ν s | true |
MonoidAlgebra.coe_add._simp_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {G : Type u_3} [inst : Semiring R] (f g : MonoidAlgebra R G), ⇑f + ⇑g = ⇑(f + g) | false |
ConditionallyCompleteLinearOrderedField.le_inducedMap_mul_self_of_mem_cutMap | Mathlib.Algebra.Order.CompleteField | ∀ {α : Type u_2} {β : Type u_3} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Field β]
[inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [Archimedean α] {a : α},
0 < a →
∀ b ∈ LinearOrderedField.cutMap β (a * a),
b ≤
ConditionallyCompleteLinearOrde... | true |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.isArithOfCastLike | Lean.Meta.Tactic.Grind.PP | Lean.Expr → Bool | true |
Lean.Parser.InputContext.substring | Lean.Parser.Types | Lean.Parser.InputContext → String.Pos.Raw → String.Pos.Raw → Substring.Raw | true |
Std.Time.Duration.addMilliseconds | Std.Time.Duration | Std.Time.Duration → Std.Time.Millisecond.Offset → Std.Time.Duration | true |
_private.Mathlib.Data.Matrix.Invertible.0.Matrix.add_mul_mul_mul_invOf_eq_one._simp_1_2 | Mathlib.Data.Matrix.Invertible | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype m]
(L M : Matrix l m α) (N : Matrix m n α), L * N + M * N = (L + M) * N | false |
Std.DHashMap.Raw.mem_toList_iff_get?_eq_some._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α],
m.WF → ∀ {k : α} {v : β k}, (⟨k, v⟩ ∈ m.toList) = (m.get? k = some v) | false |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.valuationSubring_not_isField._simp_1_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {x : ↥s}, (↑x = 0) = (x = 0) | false |
CategoryTheory.Bicategory.id_whiskerLeft._autoParam | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Syntax | false |
CategoryTheory.Cat.HasLimits.limitCone_pt | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitCone F).pt = CategoryTheory.Cat.HasLimits.limitConeX F | true |
_private.Mathlib.Algebra.Order.BigOperators.Ring.Finset.0.Finset.prod_add_prod_le._simp_1_7 | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
mem_emetric_ball_one_iff | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] {a : E} {r : ENNReal}, a ∈ Metric.eball 1 r ↔ ‖a‖ₑ < r | true |
TensorProduct.ext_iff_inner_right_threefold | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] {x y : TensorProduct 𝕜 (TensorProdu... | true |
Complex.re_nonneg_iff_nonneg | Mathlib.Analysis.Complex.Basic | ∀ {x : ℂ}, IsSelfAdjoint x → (0 ≤ x.re ↔ 0 ≤ x) | true |
CategoryTheory.Limits.KernelFork.IsLimit.ofι'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y K : C} {f : X ⟶ Y} (i : K ⟶ X)
(h :
{A : C} →
(k : A ⟶ X) → CategoryTheory.CategoryStruct.comp k f = 0 → { l // CategoryTheory.CategoryStruct.comp l i = k })
[hi : CategoryTheory.Mono ... | false |
_private.Lean.Declaration.0.Lean.ConstantInfo.value?._sparseCasesOn_1 | Lean.Declaration | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.OpaqueVal) → motive (Lean.ConstantInfo.opaqueInfo val)) →
(Nat.hasNot... | false |
Lean.Meta.PostponedEntry.ctorIdx | Lean.Meta.Basic | Lean.Meta.PostponedEntry → ℕ | false |
Std.TreeSet.getD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a fallback : α},
(t.insert k).getD a fallback = if cmp k a = Ordering.eq ∧ k ∉ t then k else t.getD a fallback | true |
LieDerivation.instLieAlgebra._proof_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (r : R)
(d e : LieDerivation R L L), ⁅d, r • e⁆ = r • ⁅d, e⁆ | false |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.insertAux.match_3 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3) →
(entry : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
(Unit → motive Lean.PersistentHashMap.Entry.null) →
((node : Lean.PersistentHashMap.No... | false |
OrderHomClass | Mathlib.Order.Hom.Basic | (F : Type u_6) → (α : outParam (Type u_7)) → (β : outParam (Type u_8)) → [LE α] → [LE β] → [FunLike F α β] → Prop | true |
lineDerivWithin.eq_1 | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (f : E → F) (s : Set E)
(x v : E), lineDerivWithin 𝕜 f s x v = derivWithin (fun t => f (x + t • v)) ((fun t => x + t • v) ... | true |
Std.Sat.AIG.IsPrefix.of._flat_ctor | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decls1 decls2 : Array (Std.Sat.AIG.Decl α)} (size_le : decls1.size ≤ decls2.size),
(∀ (idx : ℕ) (h : idx < decls1.size), decls2[idx] = decls1[idx]) → Std.Sat.AIG.IsPrefix decls1 decls2 | false |
GenContFract.zeroth_den_eq_one | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K], g.dens 0 = 1 | true |
Lean.MonadCacheT.instAlternative | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Monad m] → [Alternative m] → Alternative (Lean.MonadCacheT α β m) | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_245 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.normFieldInv.declare_24._@.Lean.Meta.Tactic.Grind.Arith.Simproc.1655774764._hygCtx._hyg.12 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit | false |
ZMod.erdos_ginzburg_ziv | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {n : ℕ} {s : Finset ι} (a : ι → ZMod n), 2 * n - 1 ≤ s.card → ∃ t ⊆ s, t.card = n ∧ ∑ i ∈ t, a i = 0 | true |
HomologicalComplex.dgoToHomologicalComplex | 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 (CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V))
... | true |
Lean.Meta.Grind.Arith.Linear.Struct.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive : Lean.Meta.Grind.Arith.Linear.Struct → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.Struct) →
((id : ℕ) →
(ringId? : Option ℕ) →
(type : Lean.Expr) →
(u : Lean.Level) →
(intModuleInst : Lean.Expr) →
(leInst? ltInst? lawfulOrderLTInst? isPreorderI... | false |
CategoryTheory.MorphismProperty.of_pullback_fst_of_descendsAlong | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.DescendsAlong Q] [inst_2 : CategoryTheory.Limits.HasPullback f g],
Q f → P (CategoryTheory.Limits.pullback.fst f g) → P g | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.