name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.CompletionOptions.allCommitCharacters?._default | Lean.Data.Lsp.LanguageFeatures | Option (Array String) | false |
CircleDeg1Lift.translationNumber_eq_int_iff | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Continuous ⇑f → ∀ {m : ℤ}, f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m | true |
Std.DTreeMap.Internal.Impl.isEmpty_inter!_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁.inter! m₂).isEmpty = true | true |
Setoid.eqvGen_of_setoid | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (r : Setoid α), Relation.EqvGen.setoid ⇑r = r | true |
AlgCat.HasLimits.limitConeIsLimit._proof_14 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget (AlgCat R)).map
... | false |
Lean.Macro.resolveGlobalName | Init.Prelude | Lean.Name → Lean.MacroM (List (Lean.Name × List String)) | true |
StrongDual.polar_univ | Mathlib.Analysis.LocallyConvex.Polar | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_5} [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E], StrongDual.polar 𝕜 Set.univ = {0} | true |
Ideal.polynomialQuotientEquivQuotientPolynomial._proof_4 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f g : Polynomial (R ⧸ I)),
(Polynomial.eval₂RingHom (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
(f * g) =
(Polynomial.eval₂RingHom
... | false |
Lean.Omega.Constraint.isImpossible.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Sort u_1) →
(x : Lean.Omega.Constraint) →
((x y : ℤ) → motive { lowerBound := some x, upperBound := some y }) →
((x : Lean.Omega.Constraint) → motive x) → motive x | false |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.parserDescrHasAtom._unsafe_rec | Lean.Elab.DocString.Builtin.Keywords | String → Lean.ParserDescr → Lean.Elab.TermElabM (Option Lean.ParserDescr) | false |
LawfulBitraversable.const | Mathlib.Control.Bitraversable.Instances | LawfulBitraversable Functor.Const | true |
MonoidAlgebra.addCommGroup._proof_5 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R],
autoParam (∀ (a b : MonoidAlgebra R M), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | false |
NormedRing.algEquivComplexOfComplete._proof_7 | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] (r : ℂ),
(↑↑(Algebra.ofId ℂ A).toRingHom).toFun ((algebraMap ℂ ℂ) r) = (algebraMap ℂ A) r | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon C =
{ obj := fun F => F.mapAddMon.obj (CategoryTheory.AddMon.trivial (CategoryTheory.Discrete PUnit.{w + 1})),
map := fun {X Y} α =... | true |
CategoryTheory.Limits.Trident.IsLimit.mk'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)}
(t : CategoryTheory.Limits.Trident f)
(create :
(s : CategoryTheory.Limits.Trident f) →
{ l //
CategoryTheory.CategoryStruct.comp l t.ι = s.ι ∧
∀
{m :
((Cat... | false |
trdeg_eq_zero_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {R : Type u_3} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.trdeg R A = 0 ↔ Algebra.IsAlgebraic R A | true |
_private.Mathlib.Probability.Kernel.Representation.0.ProbabilityTheory.Kernel.exists_measurable_map_eq_unitInterval_aux._simp_1_6 | Mathlib.Probability.Kernel.Representation | ∀ {q : ℚ} {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], (0 ≤ ↑q) = (0 ≤ q) | false |
Real.floor_pi_eq_three | Mathlib.Analysis.Real.Pi.Bounds | ⌊Real.pi⌋ = 3 | true |
RingHom.coe_id | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α}, ⇑(RingHom.id α) = id | true |
indepFun_pi_of_prod_bcf | Mathlib.Probability.Independence.BoundedContinuousFunction | ∀ {Ω : Type u_1} {T : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {F : T → Type u_5} {G : Type u_6}
[inst : (t : T) → TopologicalSpace (F t)] [inst_1 : (t : T) → MeasurableSpace (F t)] [∀ (t : T), BorelSpace (F t)]
[∀ (t : T), HasOuterApproxClosed (F t)] [inst_4 : TopologicalSpace G] [inst_5 : ... | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.size_eq_size_roi._proof_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} [inst : Std.Rxi.HasSize α] (l : α), Std.Rxi.HasSize.size l = 0 → Std.Rxi.HasSize.size l > 0 → False | false |
exists_continuous_sum_one_of_isOpen_isCompact | Mathlib.Topology.PartitionOfUnity | ∀ {X : Type v} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {n : ℕ} {t : Set X} {s : Fin n → Set X},
(∀ (i : Fin n), IsOpen (s i)) →
IsCompact t →
t ⊆ ⋃ i, s i →
∃ f,
(∀ (i : Fin n), tsupport ⇑(f i) ⊆ s i) ∧
Set.EqOn (∑ i, ⇑(f i)) 1 t ∧
(∀ (i : ... | true |
AlgebraicGeometry.IsSchemeTheoreticallyDominant.rec | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsSchemeTheoreticallyDominant f → Sort u} →
((ker_eq_bot : AlgebraicGeometry.Scheme.Hom.ker f = ⊥) → motive ⋯) →
(t : AlgebraicGeometry.IsSchemeTheoreticallyDominant f) → motive t | false |
OmegaCompletePartialOrder.ContinuousHom.mk | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
[inst_1 : OmegaCompletePartialOrder β] →
(toOrderHom : α →o β) →
(∀ (c : OmegaCompletePartialOrder.Chain α),
toOrderHom.toFun (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSup (c.map to... | true |
Set.add_mem_Ico_iff_right | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a b c d : α},
a + b ∈ Set.Ico c d ↔ b ∈ Set.Ico (c - a) (d - a) | true |
Matroid.eRk_union_ground | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk (X ∪ M.E) = M.eRank | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_160 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
¬llhs.arithShiftRight lrhs = lhs.shiftRight rhs | false |
Pi.Lex.instCompleteLinearOrderLexForall._proof_15 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] (a : Lex ((i : ι) → α i)), ⊤ \ a = ￢a | false |
Matrix.of.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {m : Type u_2} {n : Type u_3} {α : Type v}, Matrix.of = Equiv.refl (m → n → α) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_maxKey!_eq_maxKey._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 |
CauSeq.Completion.Cauchy.divisionRing._proof_9 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : ℚ≥0) (x_1 : CauSeq.Completion.Cauchy abv),
x • x_1 = ↑x * x_1 | false |
hasProd_one_add_of_hasSum_prod | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommSemiring α] [inst_1 : TopologicalSpace α] {f : ι → α} {a : α},
HasSum (fun x => ∏ i ∈ x, f i) a → HasProd (fun x => 1 + f x) a | true |
GroupExtension.Section.mul_mul_mul_inv_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), σ g₁ * σ g₂ * (σ (g₁ * g₂))⁻¹ ∈ S.inl.range | true |
MeasureTheory.instSigmaFiniteQuotientOrbitRelOfHasFundamentalDomainOfQuotientMeasureEqMeasurePreimageVolume | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasureTheory.MeasureSpace α]
[Countable G] [MeasureTheory.SMulInvariantMeasure G α MeasureTheory.volume] [MeasurableConstSMul G α]
[MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasureTheory.HasFundamentalDomain G α MeasureTheo... | true |
Lean.Elab.Command.instMonadLiftTIOCommandElabM | Lean.Elab.Command | MonadLiftT IO Lean.Elab.Command.CommandElabM | true |
AffineMap.differentiableAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {x : 𝕜}, DifferentiableAt 𝕜 (⇑f) x | true |
GetElem? | Init.GetElem | (coll : Type u) → (idx : Type v) → outParam (Type w) → outParam (coll → idx → Prop) → Type (max (max u v) w) | true |
pow_lt_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → m < n → a ^ m < a ^ n | true |
AddMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
NumberField.instCommRingRingOfIntegers._aux_20 | Mathlib.NumberTheory.NumberField.Basic | (K : Type u_1) → [inst : Field K] → NumberField.RingOfIntegers K | false |
Lean.Elab.InlayHint.textEdits._inherited_default | Lean.Elab.InfoTree.InlayHints | Array Lean.Elab.InlayHintTextEdit | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {newWidth : ℕ} {aig : Std.Sat.AIG α} {w : ℕ}
(input : aig.RefVec w) (start curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr),
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input start curr hcurr s =
if h : curr < newWidth then
have fa... | true |
Polynomial.recOnHorner._proof_10 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1}, M (0 * Polynomial.X) = M 0 | false |
sup_eq_of_max | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α}
[inst_2 : Nonempty α] {b : β}, b ∈ Set.range D → Function.invFun D b ∈ s → (∀ a ∈ s, D a ≤ b) → s.sup D = b | true |
LinearMap.IsRefl.liftQ₂._proof_4 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : CommRing R]
[inst_2 : CommRing S] [inst_3 : Module R M] [inst_4 : AddCommGroup P] [inst_5 : Module S P] {I₁ I₂ : R →+* S}
(f : M →ₛₗ[I₁] M →ₛₗ[I₂] P) (N : Submodule R M), f.IsRefl → N ≤ f.ker → N ≤ f.flip.ker | false |
Cardinal.fact_isRegular_aleph0 | Mathlib.SetTheory.Cardinal.Regular | Fact Cardinal.aleph0.IsRegular | true |
Finset.finsuppAntidiagEquivSubtype._proof_2 | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_2} {μ : Type u_1} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] (s : Finset ι) (n : μ)
(f : { P // (P.sum fun x => id) = n }), ((↑f).extendDomain.sum fun x x_1 => x_1) = n | false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf.induct_unfolding | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardE... | true |
invertibleOfLeftInverse | Mathlib.Algebra.Group.Invertible.Defs | {α : Type u} → [inst : Monoid α] → [IsDedekindFiniteMonoid α] → (a b : α) → b * a = 1 → Invertible a | true |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleRing.exists_linearEquiv_ideal_of_isSimpleModule.match_1_3 | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_1) [inst : Ring R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)) → Prop) (x : ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)),
(∀ (J : Ideal R) (left : J.IsMaximal) (e : M ≃ₗ[R] R ⧸ J), motive ⋯) → motive x | false |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.parseTagged.match_5 | Lean.Data.Json.FromToJson.Basic | (motive : Option (Array Lean.Name) → Sort u_1) →
(fieldNames? : Option (Array Lean.Name)) →
((fieldNames : Array Lean.Name) → motive (some fieldNames)) → (Unit → motive none) → motive fieldNames? | false |
Set.preimage_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} {s : Set γ},
f ⁻¹' (g ⁻¹' s) = (fun x => g (f x)) ⁻¹' s | true |
HomotopicalAlgebra.LeftHomotopyClass.whitehead | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
[HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y] [HomotopicalAlgebra.IsFibrant X]
[HomotopicalAlgebra.IsFibrant Y] (f : X ⟶ Y) [HomotopicalAlgebra.WeakEquivalence f],
∃ g,
Homo... | true |
nontrivial_iff | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1}, Nontrivial α ↔ ∃ x y, x ≠ y | true |
AlgebraicGeometry.Scheme.Cover.instCategoryI₀Pullback₁._aux_1 | Mathlib.AlgebraicGeometry.Cover.Directed | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{X : AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) →
[CategoryTheory.Category.{u_1, u_2} 𝒰.I₀] →
{Y : AlgebraicGeometry.Sche... | false |
CategoryTheory.Functor.FullyFaithful.homEquiv.eq_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
hF.homEquiv = { toFun := F.map, invFun := hF.preimage, left_inv := ⋯, right_inv := ⋯ } | true |
CategoryTheory.overEquivOfIsInitial | Mathlib.CategoryTheory.Comma.Over.StrictInitial | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Limits.HasStrictInitialObjects C] →
(X : C) → CategoryTheory.Limits.IsInitial X → (CategoryTheory.Over X ≌ CategoryTheory.Discrete PUnit.{w + 1}) | true |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_6 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (M : Type u_1) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
AddSubmonoidClass (LieSubmodule R (↥H) M) M | false |
ProbabilityTheory.Kernel.lintegral_id | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} [MeasurableSingletonClass α] {f : α → ENNReal} (a : α),
∫⁻ (a : α), f a ∂ProbabilityTheory.Kernel.id a = f a | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionAssocNatIso_hom_app_app_app | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (X X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalLeftAction.... | true |
CategoryTheory.ObjectProperty.isoClosure_eq_self | Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderIsomorphisms], P.isoClosure = P | true |
Lean.Grind.CommRing.Expr.toPolyC.go.match_4.congr_eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | true |
Lean.Lsp.ApplyWorkspaceEditParams.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (label? : Option String) (edit : Lean.Lsp.WorkspaceEdit),
sizeOf { label? := label?, edit := edit } = 1 + sizeOf label? + sizeOf edit | true |
PartialFun.instCoeSortType | Mathlib.CategoryTheory.Category.PartialFun | CoeSort PartialFun (Type u_1) | true |
MvPolynomial.eval₂_comp_left | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] {S₂ : Type u_2}
[inst_2 : CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p : MvPolynomial σ R),
k (MvPolynomial.eval₂ f g p) = MvPolynomial.eval₂ (k.comp f) (⇑k ∘ g) p | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
[inst : String.Slice.Pattern.ForwardPattern pat] →
[String.Slice.Pattern.StrictForwardPattern pat] →
Std.Iterators.FinitenessRelation (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s) Id | true |
Subtype.orderBot._proof_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (x : { x // p x }), ⊥ ≤ ↑x | false |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.dist_triangle_nonarch._simp_1_4 | Mathlib.Topology.MetricSpace.PiNat | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 0 < a → ∀ (n : ℕ), (0 < a ^ n) = True | false |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.EMatchTheoremIds | Lean.Meta.Tactic.Grind.EMatchAction | Type | true |
Std.DTreeMap.Internal.Impl.Equiv.getKey_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁), t₁.getKey k hk = t₂.getKey k ⋯ | true |
IsDiscreteValuationRing.toWithBotNat_eq_bot_iff | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (x : R),
IsDiscreteValuationRing.toWithBotNat x = ⊥ ↔ x = 0 | true |
Tropical.trop_inj_iff | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} (x y : R), Tropical.trop x = Tropical.trop y ↔ x = y | true |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_5 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Sort u_1}, (∀ (a : α), True) = True | false |
Std.OrientedCmp.of_gt_iff_lt | Init.Data.Order.PackageFactories | ∀ {α : Type u} {cmp : α → α → Ordering},
(∀ (a b : α), cmp a b = Ordering.gt ↔ cmp b a = Ordering.lt) → Std.OrientedCmp cmp | true |
Subsemiring._sizeOf_inst | Mathlib.Algebra.Ring.Subsemiring.Defs | (R : Type u) → {inst : NonAssocSemiring R} → [SizeOf R] → SizeOf (Subsemiring R) | false |
Lean.Meta.Grind.CheckResult.none | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult | true |
ContDiffMapSupportedInClass.map_zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B),
Set.EqOn (... | true |
Unitization.instModule._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {S : Type u_3} {R : Type u_1} {A : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid R] [inst_2 : AddCommMonoid A]
[inst_3 : Module S R] [inst_4 : Module S A] (r s : S) (x : Unitization R A), (r + s) • x = r • x + s • x | false |
HomologicalComplex.truncLE'XIso | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | true |
AffineSubspace.SSameSide.trans | 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.SSameSide x y → s.SSameSide y z → s.SSameSide x z | true |
CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.ReflectsEffectiveEpiFamilies → Sort u_3} →
((reflects :
∀ {α : Type u} {B : C} (X... | false |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm.match_4 | Lean.Meta.Sym.Simp.App | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(kind : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → motive Lean.Meta.CongrArgKind.subsingletonInst) →
(Unit → motive Lean.Meta.CongrArgKind.eq) → ((x : Lean.Met... | false |
Set.image_inv_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iio a = Set.Ioi a⁻¹ | true |
sin_pi_mul_ne_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {x : ℂ}, x ∈ Complex.integerComplement → Complex.sin (↑Real.pi * x) ≠ 0 | true |
CommMonCat.forget₂_full | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget₂ CommMonCat MonCat).Full | true |
Preord.ofHom_hom | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (f : X ⟶ Y), Preord.ofHom (Preord.Hom.hom f) = f | true |
FinBoolAlg.Iso.mk._proof_4 | Mathlib.Order.Category.FinBoolAlg | ∀ {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a b : ↑α.1), e (a ⊓ b) = e a ⊓ e b | false |
_private.Batteries.Data.Array.Pairwise.0.Array.pairwise_push._simp_1_2 | Batteries.Data.Array.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | false |
MeasureTheory.VectorMeasure.restrict_add | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousAdd M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α),
(v + w).restrict i = v.restrict i + w.restrict i | true |
Equiv.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} (f : α ≃ β), Finite α ↔ Finite β | true |
ConditionallyCompleteLinearOrderBot.toDecidableEq._inherited_default | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_5} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) → DecidableLE α → DecidableEq α | false |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.morphismRestrict_app._simp_1_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
TopCat.PrelocalPredicate.sheafify_inductionOn | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} {T : ↑X → Type u_2} (P : TopCat.PrelocalPredicate T) (op : {x : ↑X} → T x → T x),
(∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x},
P.pred a → ∀ (p : ↥U), ∃ W i, ↑p ∈ W ∧ P.pred fun x => op (a (i x))) →
∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x}, P.sheafify.pred a → P.she... | true |
Submonoid.instInfSet._proof_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set (Submonoid M)) {a : M}, a ∈ ⋂ t ∈ s, ↑t → ∀ i ∈ s, a ∈ i | false |
instLawfulIdentityInt32HAddOfNat | Init.Data.SInt.Lemmas | Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0 | true |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_4 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (n : ℕ) (x : ArchimedeanClass R),
Int.negSucc n • x = -(↑n.succ • x) | false |
Polynomial.Chebyshev.S | Mathlib.RingTheory.Polynomial.Chebyshev | (R : Type u_1) → [inst : CommRing R] → ℤ → Polynomial R | true |
Std.Do.Spec.forIn'_roo | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LT α] [inst_3 : DecidableLT α] [inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.PRange.LawfulUpwardEnumera... | true |
Subsemigroup.mem_closure | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {x : M}, x ∈ Subsemigroup.closure s ↔ ∀ (S : Subsemigroup M), s ⊆ ↑S → x ∈ S | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.