name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IsSemiprimaryRing.mk._flat_ctor | Mathlib.RingTheory.Jacobson.Semiprimary | ∀ {R : Type u_1} [inst : Ring R],
IsSemisimpleRing (R ⧸ Ring.jacobson R) → IsNilpotent (Ring.jacobson R) → IsSemiprimaryRing R | false |
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.exists_finiteIndex_of_leftCoset_cover_aux.match_1_3 | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι} (j : ι)
(motive : (∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x) → Prop) (x : ∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x),
(∀ (x : G) (hx : ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x), motive ⋯) → motive x | false |
Int.dvd_of_tmod_eq_zero | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, b.tmod a = 0 → a ∣ b | true |
Equiv.restrictPreimageFinset_apply_coe | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} (e : α ≃ β) (s : Finset β) (a : ↥(s.preimage ⇑e ⋯)),
↑((e.restrictPreimageFinset s) a) = e ↑a | true |
Real.rpow_add_le_add_rpow | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p a b : ℝ}, 0 ≤ a → 0 ≤ b → 0 ≤ p → p ≤ 1 → (a + b) ^ p ≤ a ^ p + b ^ p | true |
Lean.Meta.Grind.NormalizePattern.State.bvarsFound._default | Lean.Meta.Tactic.Grind.EMatchTheorem | Std.HashSet ℕ | false |
Filter.map_mul_right_nhdsGT | Mathlib.Topology.Algebra.Group.Basic | ∀ {H : Type x} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousMul H] {c a : H},
Filter.map (fun x => x * c) (nhdsWithin a (Set.Ioi a)) = nhdsWithin (a * c) (Set.Ioi (a * c)) | true |
Polynomial.quotientSpanCXSubCXSubCAlgEquiv._proof_5 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R (Polynomial R) (Polynomial R) | false |
Set.fintypeOfFintypeImage._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) {f : α → β} {g : β → Option α} (I : Function.IsPartialInv f g)
[inst : Fintype ↑(f '' s)] (x : α), x ∈ { val := Multiset.filterMap g (f '' s).toFinset.val, nodup := ⋯ } ↔ x ∈ s | false |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderInf.of_lt._simp_1_2 | Init.Data.Order.Factories | ∀ {a b : Prop} [Decidable a] [Decidable b], (¬a ↔ ¬b) = (a ↔ b) | false |
Turing.TM2to1.Λ'.go.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{P : Sort u} →
{k : K} →
{a : Turing.TM2to1.StAct K Γ σ k} →
{a_1 : Turing.TM2.Stmt Γ Λ σ} →
{k' : K} →
{a' : Turing.TM2to1.StAct K Γ σ k'} →
{a'_1 : Turing.TM2.Stmt Γ Λ σ} →
Turing.TM2to1.Λ'.go k a a_1 = Turing.TM2to1.Λ'.go k' a' a'_1 →
(k ≍ k' → a ≍ a' → a_1 ≍ a'_1 → P) → P | false |
CategoryTheory.CatEnrichedOrdinary.Hom.recOn | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] →
{X Y : CategoryTheory.CatEnrichedOrdinary C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.CatEnrichedOrdinary.Hom f g → Sort u_1} →
(t : CategoryTheory.CatEnrichedOrdinary.Hom f g) →
((base' : CategoryTheory.CatEnrichedOrdinary.homEquiv f ⟶ CategoryTheory.CatEnrichedOrdinary.homEquiv g) →
motive { base' := base' }) →
motive t | false |
pow_left_strictMono | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftStrictMono M] [MulRightStrictMono M] {n : ℕ},
n ≠ 0 → StrictMono fun x => x ^ n | true |
MeasureTheory.integrableOn_image_iff_integrableOn_deriv_smul_of_monotoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
MonotoneOn f s →
∀ (g : ℝ → F),
MeasureTheory.IntegrableOn g (f '' s) MeasureTheory.volume ↔
MeasureTheory.IntegrableOn (fun x => f' x • g (f x)) s MeasureTheory.volume | true |
Metric.isCompact_closure_iff_exists_finite_isCover | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : MetricSpace X] [ProperSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → (IsCompact (closure s) ↔ ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N) | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.norm_num_ext.sModNatTR.go.match_1.eq_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (motive : ℕ → ℕ → Sort u_1) (acc : ℕ) (h_1 : (acc : ℕ) → motive 0 acc) (h_2 : (n acc : ℕ) → motive n.succ acc),
(match 0, acc with
| 0, acc => h_1 acc
| n.succ, acc => h_2 n acc) =
h_1 acc | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α | true |
Lean.Doc.Data.Attributes.rec | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.Data.Attributes → Sort u} →
((stx : Lean.Syntax) → motive { stx := stx }) → (t : Lean.Doc.Data.Attributes) → motive t | false |
CategoryTheory.PreGaloisCategory.surjective_of_nonempty_fiber_of_isConnected | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.PreGaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C}
[Nonempty (F.obj X).obj] [CategoryTheory.PreGaloisCategory.IsConnected A] (f : X ⟶ A),
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) | true |
Array.set_eraseIdx._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {w : i < xs.size} {j : ℕ} {a : α} (h' : ¬i ≤ j), i < (xs.set j a ⋯).size | false |
CategoryTheory.MorphismProperty.Comma.mapRightEq_inv_app_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative] [inst_4 : W.IsMultiplicative]
{R₁ R₂ : CategoryTheory.Functor B T} [inst_5 : Q.RespectsIso] [inst_6 : W.RespectsIso] (r r' : R₁ ⟶ R₂) (h : r = r')
(hr :
∀ (X : CategoryTheory.MorphismProperty.Comma L R₁ P Q W),
P (CategoryTheory.CategoryStruct.comp X.hom (r.app X.right)))
(X : CategoryTheory.MorphismProperty.Comma L R₁ P Q W),
((CategoryTheory.MorphismProperty.Comma.mapRightEq L r r' h hr).inv.app X).left =
CategoryTheory.CategoryStruct.id X.left | true |
Ideal.mulQuot._proof_1 | Mathlib.RingTheory.OrderOfVanishing | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | false |
LowerSet.Iic_strictMono | Mathlib.Order.UpperLower.Principal | ∀ (α : Type u_1) [inst : Preorder α], StrictMono LowerSet.Iic | true |
Lean.Meta.instHashableInfoCacheKey._private_1 | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → UInt64 | false |
CategoryTheory.hasExactLimitsOfShape_discrete_of_hasExactLimitsOfShape_finset_discrete_op | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C] (J : Type u_1)
[inst_4 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C]
[inst_5 : CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete J))ᵒᵖ C]
[CategoryTheory.HasExactLimitsOfShape (Finset (CategoryTheory.Discrete J))ᵒᵖ C],
CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete J) C | true |
RootPairing.Hom.weight_coweight_transpose | 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] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Module R N₂]
{P : RootPairing ι R M N} {Q : RootPairing ι₂ R M₂ N₂} (self : P.Hom Q),
self.weightMap.dualMap ∘ₗ ↑Q.flip.toPerfPair = ↑P.flip.toPerfPair ∘ₗ self.coweightMap | true |
Lean.IR.IRType.erased.elim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) → t.ctorIdx = 6 → motive_1 Lean.IR.IRType.erased → motive_1 t | false |
Batteries.Tactic.PrintPrefixConfig.showTypes._default | Batteries.Tactic.PrintPrefix | Bool | false |
LatticeCon.ctorIdx | Mathlib.Order.Lattice.Congruence | {α : Type u_2} → {inst : Lattice α} → LatticeCon α → ℕ | false |
CommSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | Type (u + 1) | true |
CategoryTheory.Limits.map_lift_equalizerComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasEqualizer f g] [inst_3 : CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)]
{Z : C} {h : Z ⟶ X} (w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) {Z_1 : D}
(h_1 : CategoryTheory.Limits.equalizer (G.map f) (G.map g) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.equalizer.lift h w))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerComparison f g G) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.lift (G.map h) ⋯) h_1 | true |
CategoryTheory.Over.iteratedSliceForward_obj | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
(α : CategoryTheory.Over f), f.iteratedSliceForward.obj α = CategoryTheory.Over.mk α.hom.left | true |
MeasureTheory.TendstoInMeasure.congr | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : EDist E]
{l : Filter ι} {f f' : ι → α → E} {g g' : α → E},
(∀ (i : ι), f i =ᵐ[μ] f' i) →
g =ᵐ[μ] g' → MeasureTheory.TendstoInMeasure μ f l g → MeasureTheory.TendstoInMeasure μ f' l g' | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_of_beq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Algebra.PreSubmersivePresentation.jacobian_ofAlgEquiv | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T]
(e : S ≃ₐ[R] T) [inst_5 : Finite σ], (P.ofAlgEquiv e).jacobian = e P.jacobian | true |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Lift.0.SkewMonoidAlgebra.domCongr._simp_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_4} {G'' : Type u_5} (f : G ≃ G') (g : G' ≃ G'')
(l : SkewMonoidAlgebra k G),
SkewMonoidAlgebra.equivMapDomain g (SkewMonoidAlgebra.equivMapDomain f l) =
SkewMonoidAlgebra.equivMapDomain (f.trans g) l | false |
_private.Init.Data.String.Basic.0.String.Pos.lt_of_le_of_ne._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | false |
_private.Mathlib.Order.Filter.Map.0.Filter.frequently_comap._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
AdicCompletion.of_ofAlgEquiv_symm | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_5} [inst : CommRing S] (I : Ideal S) [inst_1 : IsAdicComplete I S] (x : AdicCompletion I S),
(AdicCompletion.of I S) ((AdicCompletion.ofAlgEquiv I).symm x) = x | true |
Lean.Meta.AbstractMVars.instMonadMCtxM | Lean.Meta.AbstractMVars | Lean.MonadMCtx Lean.Meta.AbstractMVars.M | true |
LinearMap.cancel_right | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {f : M₂ →ₛₗ[σ₂₃] M₃}
{g : M₁ →ₛₗ[σ₁₂] M₂} {f' : M₂ →ₛₗ[σ₂₃] M₃}, Function.Surjective ⇑g → (f ∘ₛₗ g = f' ∘ₛₗ g ↔ f = f') | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.encard_maximalSeparatedSet._proof_1_4 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
Metric.packingNumber ε A ≠ ⊤ → (Metric.maximalSeparatedSet ε A).encard = Metric.packingNumber ε A | false |
MeasureTheory.Measure.restrict_mono_measure | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {x : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
μ ≤ ν → ∀ (s : Set α), μ.restrict s ≤ ν.restrict s | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.Transcendental.0.lift_trdeg_add_le._simp_1_1 | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ (α : Type u) (β : Type v),
Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) = Cardinal.mk (α ⊕ β) | false |
Ideal.mapCotangent | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u} →
[inst : CommRing R] →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CommRing A] →
[inst_2 : CommRing B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
(I₁ : Ideal A) →
(I₂ : Ideal B) → (f : A →ₐ[R] B) → I₁ ≤ Ideal.comap f I₂ → I₁.Cotangent →ₗ[R] I₂.Cotangent | true |
ArchimedeanClass.FiniteResidueField.instField._proof_8 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K]
(a b c : ArchimedeanClass.FiniteResidueField K), (a + b) * c = a * c + b * c | false |
Ordnode.split3._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α × Option α × Ordnode α | false |
Cardinal.lt_aleph0_iff_finite | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u}, Cardinal.mk α < Cardinal.aleph0 ↔ Finite α | true |
Matrix.trace_zero | Mathlib.LinearAlgebra.Matrix.Trace | ∀ (n : Type u_3) (R : Type u_6) [inst : Fintype n] [inst_1 : AddCommMonoid R], Matrix.trace 0 = 0 | true |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_5 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
RootPairing.root | 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] → RootPairing ι R M N → ι ↪ M | true |
_private.Mathlib.Data.Int.Basic.0.Int.natCast_dvd._simp_1_2 | Mathlib.Data.Int.Basic | ∀ {a b : ℤ}, (a ∣ -b) = (a ∣ b) | false |
Turing.ListBlank.tail_mk | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), (Turing.ListBlank.mk l).tail = Turing.ListBlank.mk l.tail | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.0._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_extractLsb'_not.declare_198._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.2283078798._hygCtx._hyg.24 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit | false |
CategoryTheory.Mat_.instAddCommGroupHom._proof_20 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N : CategoryTheory.Mat_ C),
autoParam
(∀ (n : ℕ) (a : M ⟶ N),
CategoryTheory.Mat_.instAddCommGroupHom._aux_17 M N (↑n.succ) a =
CategoryTheory.Mat_.instAddCommGroupHom._aux_17 M N (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam | false |
Mathlib.Meta.FunProp.FunctionTheorem.appliedArgs | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.FunctionTheorem → ℕ | true |
RestrictedProduct.instNSMul | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι : Type u_1} →
(R : ι → Type u_2) →
{𝓕 : Filter ι} →
{S : ι → Type u_3} →
[inst : (i : ι) → SetLike (S i) (R i)] →
{B : (i : ι) → S i} →
[inst_1 : (i : ι) → AddMonoid (R i)] →
[∀ (i : ι), AddSubmonoidClass (S i) (R i)] → SMul ℕ (RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) | true |
Lean.Grind.eq_true_of_and_eq_true_right | Init.Grind.Lemmas | ∀ {a b : Prop}, (a ∧ b) = True → b = True | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.remainingBytes.match_1 | Init.Data.String.Iterator | (motive : String.Legacy.Iterator → Sort u_1) →
(x : String.Legacy.Iterator) → ((s : String) → (i : String.Pos.Raw) → motive { s := s, i := i }) → motive x | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.ordered_keys_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
WeierstrassCurve.Jacobian.Point.zero_def | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R],
0 = { point := ⟦![1, 1, 0]⟧, nonsingular := ⋯ } | true |
TestFunction.instAddCommGroup._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (a b c : TestFunction Ω F n),
a + b + c = a + (b + c) | false |
MulAction.IsPreprimitive.of_surjective | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {M : Type u_3} [inst : Group M] {α : Type u_4} [inst_1 : MulAction M α] {N : Type u_5} {β : Type u_6}
[inst_2 : Group N] [inst_3 : MulAction N β] {φ : M → N} {f : α →ₑ[φ] β} [MulAction.IsPreprimitive M α],
Function.Surjective ⇑f → MulAction.IsPreprimitive N β | true |
Std.DTreeMap.Raw.Const.get!_diff | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β],
m₁.WF →
m₂.WF →
∀ {k : α},
Std.DTreeMap.Raw.Const.get! (m₁ \ m₂) k =
if m₂.contains k = true then default else Std.DTreeMap.Raw.Const.get! m₁ k | true |
abs_sub_sup_add_abs_sub_inf | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| + |a ⊓ c - b ⊓ c| = |a - b| | true |
Sigma.isPreconnected_iff | Mathlib.Topology.Connected.Clopen | ∀ {ι : Type u_1} {X : ι → Type u_2} [hι : Nonempty ι] [inst : (i : ι) → TopologicalSpace (X i)]
{s : Set ((i : ι) × X i)}, IsPreconnected s ↔ ∃ i t, IsPreconnected t ∧ s = Sigma.mk i '' t | true |
Module.Basis.constr_basis | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_7} [inst : AddCommMonoid M'] {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_13)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M') (i : ι),
((b.constr S) f) (b i) = f i | true |
CategoryTheory.Reflective.comparison_full | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{R : CategoryTheory.Functor D C} [R.Full] {L : CategoryTheory.Functor C D} (adj : L ⊣ R),
(CategoryTheory.Monad.comparison adj).Full | true |
Finpartition.mem_part_ofSetSetoid_iff_rel | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Setoid α} (x : Finset α) [inst_1 : DecidableRel ⇑s] {b : α},
b ∈ (Finpartition.ofSetSetoid s x).part a ↔ a ∈ x ∧ b ∈ x ∧ s a b | true |
SimplicialObject.Splitting.d.eq_1 | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X) [inst_1 : CategoryTheory.Preadditive C] (i j : ℕ),
s.d i j =
CategoryTheory.CategoryStruct.comp
((s.cofan (Opposite.op (SimplexCategory.mk i))).inj
(SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk i))))
(CategoryTheory.CategoryStruct.comp ((AlgebraicTopology.AlternatingFaceMapComplex.obj X).d i j)
(s.πSummand (SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk j))))) | true |
USize.toUInt64 | Init.Data.UInt.Basic | USize → UInt64 | true |
Aesop.initFn._@.Aesop.Options.Public.1260513527._hygCtx._hyg.4 | Aesop.Options.Public | IO (Lean.Option Bool) | false |
Vector.toArray_zipIdx | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} (k : optParam ℕ 0), (xs.zipIdx k).toArray = xs.toArray.zipIdx k | true |
lp.nonUnitalRing._proof_7 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NonUnitalNormedRing (B i)] (x : ℤ) (x_1 : ↥(lp B ⊤)),
CoeFun.coe (x • x_1) = CoeFun.coe (x • x_1) | false |
CategoryTheory.Functor.Final.colimitCoconeComp_isColimit | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone G),
(CategoryTheory.Functor.Final.colimitCoconeComp F t).isColimit =
(CategoryTheory.Functor.Final.isColimitWhiskerEquiv F t.cocone).symm t.isColimit | true |
Topology.IsLowerSet.closure_singleton | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {a : α},
closure {a} = Set.Ici a | true |
List.prod_hom₂_nonempty | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P]
{l : List ι} (f : M → N → P),
(∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d) →
∀ (f₁ : ι → M) (f₂ : ι → N),
l ≠ [] → (List.map (fun i => f (f₁ i) (f₂ i)) l).prod = f (List.map f₁ l).prod (List.map f₂ l).prod | true |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_3 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | false |
Vector3.nil | Mathlib.Data.Vector3 | {α : Type u_1} → Vector3 α 0 | true |
Mathlib.Meta.Positivity.evalInv | Mathlib.Algebra.Order.Field.Basic | Mathlib.Meta.Positivity.PositivityExt | true |
AddSubgroup.toAddSubmonoid | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_3} → [inst : AddGroup G] → AddSubgroup G → AddSubmonoid G | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.mk.sizeOf_spec | Lean.Elab.MutualInductive | ∀ (levels : Lean.LevelMap ℤ), sizeOf { levels := levels } = 1 + sizeOf levels | true |
Plausible.PNat.sampleableExt | Mathlib.Testing.Plausible.Sampleable | Plausible.SampleableExt ℕ+ | true |
Std.ExtTreeSet.min!_insert_le_self | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, (cmp (t.insert k).min! k).isLE = true | true |
NNReal.strictMono_rpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {z : ℝ}, 0 < z → StrictMono fun x => x ^ z | true |
IsDedekindDomain.selmerGroup.valuation | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
{S : Set (IsDedekindDomain.HeightOneSpectrum R)} →
{n : ℕ} → ↥IsDedekindDomain.selmerGroup →* ↑S → Multiplicative (ZMod n) | true |
ProofWidgets.Jsx.getJsxText | ProofWidgets.Data.Html | Lean.TSyntax `ProofWidgets.Jsx.jsxText → String | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a : Array α} (i_1 : ℕ), i_1 + 1 ≤ (a.extract i j).size → i_1 < (a.extract i j).size | false |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_20 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C} {S' : C} {p : S' ⟶ S}
{ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι} {p' : (j : ι') → X' j ⟶ X (α j)} ⦃Y : C⦄
(q : Y ⟶ S') ⦃j₁ j₂ : ι'⦄ (f₁ : Y ⟶ X' j₁) (f₂ : Y ⟶ X' j₂) (q' : Y ⟶ S) (f₂' : Y ⟶ X (α j₂)),
autoParam (CategoryTheory.CategoryStruct.comp f₁ (f' j₁) = q)
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_1 →
autoParam (CategoryTheory.CategoryStruct.comp f₂ (f' j₂) = q)
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_3 →
autoParam (CategoryTheory.CategoryStruct.comp q p = q')
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_5 →
autoParam (CategoryTheory.CategoryStruct.comp f₂ (p' j₂) = f₂')
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_9 →
CategoryTheory.CategoryStruct.comp (p' j₂).op.toLoc f₂.op.toLoc = f₂'.op.toLoc | false |
_private.Mathlib.Tactic.Observe.0.Mathlib.Tactic.LibrarySearch._aux_Mathlib_Tactic_Observe___elabRules_Mathlib_Tactic_LibrarySearch_observe_1.match_7 | Mathlib.Tactic.Observe | (motive : Option (Array (List Lean.MVarId × Lean.MetavarContext)) → Sort u_1) →
(__do_lift : Option (Array (List Lean.MVarId × Lean.MetavarContext))) →
((val : Array (List Lean.MVarId × Lean.MetavarContext)) → motive (some val)) →
((x : Option (Array (List Lean.MVarId × Lean.MetavarContext))) → motive x) → motive __do_lift | false |
CochainComplex.shiftShortComplexFunctorIso_add'_hom_app._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ (n m mn : ℤ), m + n = mn → ∀ (a a' a'' : ℤ), n + a = a' → m + a' = a'' → mn + a = a'' | false |
Function.Even.left_comp | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] {γ : Type u_3} {g : α → β},
Function.Even g → ∀ (f : β → γ), Function.Even (f ∘ g) | true |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_4 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε | false |
Lean.JsonRpc.MessageMetaData._sizeOf_inst | Lean.Data.JsonRpc | SizeOf Lean.JsonRpc.MessageMetaData | false |
ProofWidgets.RpcEncodablePacket.component.injEq._@.ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1 | ProofWidgets.Data.Html | ∀ (a a_1 a_2 a_3 a_4 a_5 a_6 a_7 : Lean.Json),
(ProofWidgets.RpcEncodablePacket.component✝ a a_1 a_2 a_3 =
ProofWidgets.RpcEncodablePacket.component✝ a_4 a_5 a_6 a_7) =
(a = a_4 ∧ a_1 = a_5 ∧ a_2 = a_6 ∧ a_3 = a_7) | false |
_private.Mathlib.GroupTheory.GroupAction.Basic.0.MulAction.fixedPoints_of_subsingleton._simp_1_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] {a : α},
(a ∈ MulAction.fixedPoints M α) = ∀ (m : M), m • a = a | false |
CategoryTheory.Limits.CatCospanTransform.mkIso_hom_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
{ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'} (left : ψ.left ≅ ψ'.left) (right : ψ.right ≅ ψ'.right)
(base : ψ.base ≅ ψ'.base)
(left_coherence :
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F ψ.left ψ.base F').hom
(CategoryTheory.Functor.whiskerRight left.hom F') =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft base.hom)
(CategoryTheory.CatCommSq.iso F ψ'.left ψ'.base F').hom)
CategoryTheory.Limits.CatCospanTransform.mkIso._auto_1)
(right_coherence :
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso G ψ.right ψ.base G').hom
(CategoryTheory.Functor.whiskerRight right.hom G') =
CategoryTheory.CategoryStruct.comp (G.whiskerLeft base.hom)
(CategoryTheory.CatCommSq.iso G ψ'.right ψ'.base G').hom)
CategoryTheory.Limits.CatCospanTransform.mkIso._auto_3),
(CategoryTheory.Limits.CatCospanTransform.mkIso left right base left_coherence right_coherence).hom.left = left.hom | true |
Lean.Meta.SizeOfSpecNested.Context.mk.noConfusion | Lean.Meta.SizeOf | {P : Sort u} →
{indInfo : Lean.InductiveVal} →
{sizeOfFns : Array Lean.Name} →
{ctorName : Lean.Name} →
{params localInsts : Array Lean.Expr} →
{recMap : Lean.NameMap Lean.Name} →
{indInfo' : Lean.InductiveVal} →
{sizeOfFns' : Array Lean.Name} →
{ctorName' : Lean.Name} →
{params' localInsts' : Array Lean.Expr} →
{recMap' : Lean.NameMap Lean.Name} →
{ indInfo := indInfo, sizeOfFns := sizeOfFns, ctorName := ctorName, params := params,
localInsts := localInsts, recMap := recMap } =
{ indInfo := indInfo', sizeOfFns := sizeOfFns', ctorName := ctorName', params := params',
localInsts := localInsts', recMap := recMap' } →
(indInfo = indInfo' →
sizeOfFns = sizeOfFns' →
ctorName = ctorName' →
params = params' → localInsts = localInsts' → recMap = recMap' → P) →
P | false |
SeparationQuotient.lift'_mk | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : T0Space β] {f : α → β},
UniformContinuous f → ∀ (a : α), SeparationQuotient.lift' f (SeparationQuotient.mk a) = f a | true |
ClosedAddSubgroup.instCoeAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → Coe (ClosedAddSubgroup G) (AddSubgroup G) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.