name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Cardinal.mk_embedding_le_arrow | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) (β' : Type v), Cardinal.mk (α ↪ β') ≤ Cardinal.mk (α → β') | true |
CategoryTheory.Subobject.lower | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{Y : D} →
CategoryTheory.Functor (CategoryTheory.MonoOver X) (CategoryTheory.MonoOver Y) →
CategoryTheory.Functor (CategoryTheor... | true |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.realizeExtIffTheorem | Lean.Elab.Tactic.Ext | Lean.Name → Lean.Elab.Command.CommandElabM Lean.Name | true |
Matrix.PosDef.of_toQuadraticForm' | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] {M : Matrix n n ℝ},
M.IsSymm → M.toQuadraticMap'.PosDef → M.PosDef | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.count_le_one_of_centralizer_le_alternating._simp_1_6 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | false |
SemigroupIdeal.subset_closure | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Mul M] {s : Set M}, s ⊆ ↑(SemigroupIdeal.closure s) | true |
Lean.Grind.NoopConfig.funCC._default | Init.Grind.Config | Bool | false |
ExteriorAlgebra.instGradedMonoidNatSubmoduleExteriorPower | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SetLike.GradedMonoid fun i => ⋀[R]^i M | true |
AlgebraicGeometry.pointsPi.eq_1 | Mathlib.AlgebraicGeometry.PointsPi | ∀ {ι : Type u} (R : ι → CommRingCat) (X : AlgebraicGeometry.Scheme)
(f : AlgebraicGeometry.Spec (CommRingCat.of ((i : ι) → ↑(R i))) ⟶ X) (i : ι),
AlgebraicGeometry.pointsPi R X f i =
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (Pi.evalRingHom (fun x => ↑(R x)) i))) f | true |
Filter.HasBasis.tendstoUniformlyOn_iff_of_uniformity | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace β] {X : Type u_5} {ιβ : Type u_8} {F : X → α → β} {f : α → β}
{l : Filter X} {s : Set α} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)},
(uniformity β).HasBasis pβ sβ →
(TendstoUniformlyOn F f l s ↔ ∀ (i : ιβ), pβ i → ∀ᶠ (n : X) in l, ∀ x ∈ s, (f x, F n x) ∈ sβ i) | true |
Algebra.TensorProduct.lTensor_ker | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_4} [inst : CommRing R] {A : Type u_6} {C : Type u_8} {D : Type u_9} [inst_1 : Ring A] [inst_2 : Ring C]
[inst_3 : Ring D] [inst_4 : Algebra R A] [inst_5 : Algebra R C] [inst_6 : Algebra R D] (g : C →ₐ[R] D),
Function.Surjective ⇑g →
RingHom.ker (Algebra.TensorProduct.map (AlgHom.id R A) g) =
... | true |
Convex.add_smul_sub_mem_interior' | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[AddRightMono 𝕜] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ closure s → y ∈ interior s → ∀ {t : 𝕜}, t... | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.inferResultingUniverse.match_4 | Lean.Elab.MutualInductive | (motive : Lean.Level × ℤ → Sort u_1) →
(x : Lean.Level × ℤ) → ((level : Lean.Level) → (k : ℤ) → motive (level, k)) → motive x | false |
Std.DTreeMap.Raw.Const.getKeyD_insertMany_list_of_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF →
∀ {l : List (α × β)} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Raw... | true |
Lean.Meta.Grind.SolverExtension.mbtc | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → Lean.Meta.Grind.GoalM Bool | true |
isPrimitiveRoot_of_mem_primitiveRoots | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {k : ℕ} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R}, ζ ∈ primitiveRoots k R → IsPrimitiveRoot ζ k | true |
CategoryTheory.Subfunctor.preimage._proof_2 | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F F' : CategoryTheory.Functor C (Type u_3)}
(G : CategoryTheory.Subfunctor F) (p : F' ⟶ F) {U V : C} (f : U ⟶ V),
p.app U ⁻¹' G.obj U ⊆ F'.map f ⁻¹' (p.app V ⁻¹' G.obj V) | false |
LieHom.mem_range | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {L₂ : Type w}
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L →ₗ⁅R⁆ L₂) (x : L₂), x ∈ f.range ↔ ∃ y, f y = x | true |
quotAdjoinEquivQuotMap.congr_simp | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R}
(hx : Ideal.comap (algebraMap R S) (conductor R x) ⊔ I = ⊤) (h_alg : Function.Injective ⇑(algebraMap (↥R[x]) S)),
quotAdjoinEquivQuotMap hx h_alg = quotAdjoinEquivQuotMap hx h_alg | true |
IsLocalization.smul_toInvSubmonoid | Mathlib.RingTheory.Localization.InvSubmonoid | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsLocalization M S] (m : ↥M), m • ↑((IsLocalization.toInvSubmonoid M S) m) = 1 | true |
Sym2.irreflexive_iff_fromRel_subset_diagSet_compl | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (sym : Symmetric r), Std.Irrefl r ↔ Sym2.fromRel sym ⊆ Sym2.diagSetᶜ | true |
LieDerivation.instBracket._proof_3 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L], IsScalarTower R R L | false |
Rat.padicValuation.congr_simp | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p p_1 : ℕ) (e_p : p = p_1) [inst : Fact (Nat.Prime p)], Rat.padicValuation p = Rat.padicValuation p_1 | true |
Lean.Meta.Origin.other.noConfusion | Lean.Meta.Tactic.Simp.SimpTheorems | {P : Sort u} →
{name name' : Lean.Name} → Lean.Meta.Origin.other name = Lean.Meta.Origin.other name' → (name = name' → P) → P | false |
Lean.Doc.Data.instImpl._@.Lean.Elab.DocString.Builtin.984454940._hygCtx._hyg.8 | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.Const | false |
Lean.Elab.InfoTree.brecOn_4 | Lean.Elab.InfoTree.Types | {motive_1 : Lean.Elab.InfoTree → Sort u} →
{motive_2 : Lean.PersistentArray Lean.Elab.InfoTree → Sort u} →
{motive_3 : Lean.PersistentArrayNode Lean.Elab.InfoTree → Sort u} →
{motive_4 : Array Lean.Elab.InfoTree → Sort u} →
{motive_5 : Array (Lean.PersistentArrayNode Lean.Elab.InfoTree) → Sort u} →
... | false |
Turing.TM2to1.addBottom_modifyNth | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} (f : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k))
(L : Turing.ListBlank ((k : K) → Option (Γ k))) (n : ℕ),
Turing.ListBlank.modifyNth (fun a => (a.1, f a.2)) n (Turing.TM2to1.addBottom L) =
Turing.TM2to1.addBottom (Turing.ListBlank.modifyNth f n L) | true |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality.0.groupCohomology.cochainsMap_f_map_mono._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y),
CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | false |
ContinuousOn.strictMonoOn_of_injOn_Icc' | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b →
ContinuousOn f (Set.Icc a b) →
Set.InjOn f (Set.Icc a... | true |
Set.instIsTransSubset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, IsTrans (Set α) fun x1 x2 => x1 ⊆ x2 | true |
CategoryTheory.Limits.cokernelOrderHom._proof_2 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] (X : C) (P Q : CategoryTheory.Subobject X),
P ≤ Q →
CategoryTheory.Subobject.lift (fun x f x_1 => CategoryTheory.Subobject.mk (CategoryTheory.Limits.... | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.sum.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → (Fin x → α) → Sort u_1) (x : Fin 0 → α) (h_1 : (x : Fin 0 → α) → motive 0 x)
(h_2 : (v : Fin 1 → α) → motive 1 v) (h_3 : (n : ℕ) → (v : Fin (n + 2) → α) → motive n.succ.succ v),
(match 0, x with
| 0, x => h_1 x
| 1, v => h_2 v
| n.succ.succ, v => h_3 n v) =
h_1 x | true |
CategoryTheory.IsFiltered.instSmallCategorySmallFilteredIntermediate._aux_1 | Mathlib.CategoryTheory.Filtered.Small | {C : Type u_4} →
[inst : CategoryTheory.Category.{u_2, u_4} C] →
[inst_1 : CategoryTheory.IsFilteredOrEmpty C] →
{D : Type u_1} →
[inst_2 : CategoryTheory.Category.{u_3, u_1} D] →
(F : CategoryTheory.Functor D C) →
CategoryTheory.SmallCategory (CategoryTheory.IsFiltered.SmallFi... | false |
ConvexCone.coe_closure._simp_1 | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] {E : Type u_2} [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : SMul 𝕜 E] [inst_6 : ContinuousConstSMul 𝕜 E]
(K : ConvexCone 𝕜 E), closure ↑K = ↑K.closure | false |
Cardinal.range_aleph | Mathlib.SetTheory.Cardinal.Aleph | Set.range ⇑Cardinal.aleph = Set.Ici Cardinal.aleph0 | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Finset.0.Set.Finite.ciSup_lt_iff._simp_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
Turing.ToPartrec.Cfg.halt.noConfusion | Mathlib.Computability.TuringMachine.Config | {P : Sort u} → {a a' : List ℕ} → Turing.ToPartrec.Cfg.halt a = Turing.ToPartrec.Cfg.halt a' → (a = a' → P) → P | false |
lt_emultiplicity_of_lt_multiplicity | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b : α} {n : ℕ}, n < multiplicity a b → ↑n < emultiplicity a b | true |
Num.pred_succ | Mathlib.Data.Num.ZNum | ∀ (n : ZNum), n.pred.succ = n | true |
BitVec.sshiftRight_eq_sshiftRightRec | Init.Data.BitVec.Bitblast | ∀ {w₁ w₂ i : ℕ} (x : BitVec w₁) (y : BitVec w₂), (x.sshiftRight' y).getLsbD i = (x.sshiftRightRec y (w₂ - 1)).getLsbD i | true |
Graph.ext | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {G₁ G₂ : Graph α β},
G₁.vertexSet = G₂.vertexSet → (∀ (e : β) (x y : α), G₁.IsLink e x y ↔ G₂.IsLink e x y) → G₁ = G₂ | true |
IsometryEquiv.instGroup | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} → [inst : PseudoEMetricSpace α] → Group (α ≃ᵢ α) | true |
and_self | Init.SimpLemmas | ∀ (p : Prop), (p ∧ p) = p | true |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorArbitraryShiftTargetBlastArithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.ArbitraryShiftTarget fun {len} =>
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRight | true |
classifyingSpaceUniversalCover.compForgetAugmented | Mathlib.RepresentationTheory.Homological.Resolution | (G : Type u) → [Monoid G] → CategoryTheory.SimplicialObject.Augmented (Type u) | true |
Fin.Value.noConfusionType | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Sort u → Fin.Value → Fin.Value → Sort u | false |
isIntegralCurveOn_univ | Mathlib.Analysis.ODE.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {γ : ℝ → E} {v : ℝ → E → E},
IsIntegralCurveOn γ v Set.univ ↔ IsIntegralCurve γ v | true |
ISize.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : ISize}, (a ^^^ b = 0) = (a = b) | false |
Lean.Meta.matchFalse | Lean.Meta.MatchUtil | Lean.Expr → Lean.MetaM Bool | true |
_private.Mathlib.Algebra.Category.ModuleCat.ChangeOfRings.0.ModuleCat.extendScalars_assoc'._simp_1_1 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
{G H K : CategoryTheory.Functor D E} (α : G ⟶ H) (β : H ⟶ K) {Z : CategoryTheory.Functor C E} (h : F.co... | false |
_private.Init.Data.List.MinMaxOn.0.List.minOn.eq_1 | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] (f : α → β) (x : α) (xs : List α)
(h_2 : x :: xs ≠ []), List.minOn f (x :: xs) h_2 = List.foldl (minOn f) x xs | true |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization.0.Polynomial.natDegree_of_dvd_cyclotomic_of_irreducible_of_monic._simp_1_1 | Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [IsDomain R] [NeZero ↑n] {μ : R},
IsPrimitiveRoot μ n = (Polynomial.cyclotomic n R).IsRoot μ | false |
LinearMap.toLinearIsometry | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_5} →
{E₂ : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup E₂] →
[inst_4 : Module ... | true |
Finset.isCountablyCompact_biUnion | Mathlib.Topology.Compactness.CountablyCompact | ∀ {ι : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] (s : Finset ι) {f : ι → Set E},
(∀ i ∈ s, IsCountablyCompact (f i)) → IsCountablyCompact (⋃ i ∈ s, f i) | true |
Submonoid.distribMulAction | Mathlib.Algebra.Group.Submonoid.DistribMulAction | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] → [inst_1 : AddMonoid α] → [DistribMulAction M α] → (S : Submonoid M) → DistribMulAction (↥S) α | true |
Int.divisorsAntidiagonal_one | Mathlib.NumberTheory.Divisors | Int.divisorsAntidiag 1 = {(1, 1), (-1, -1)} | true |
CoeDep.noConfusion | Init.Coe | {P : Sort u_1} →
{α : Sort u} →
{x : α} →
{β : Sort v} →
{t : CoeDep α x β} →
{α' : Sort u} →
{x' : α'} →
{β' : Sort v} → {t' : CoeDep α' x' β'} → α = α' → x ≍ x' → β = β' → t ≍ t' → CoeDep.noConfusionType P t t' | false |
Algebra.PreSubmersivePresentation.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] →
Algebra.PreSubmersivePresentation R S ι σ →
{T : Type u_1} →
[inst_3 : CommRing T] →
... | true |
AffineSubspace.coe_vsub._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s] (a b : ↥s), ↑a -ᵥ ↑b = ↑(a -ᵥ b) | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt8.reduceBin.match_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | (motive : Option UInt8 → Sort u_1) →
(__discr : Option UInt8) → ((m : UInt8) → motive (some m)) → ((x : Option UInt8) → motive x) → motive __discr | false |
AkraBazziRecurrence.eventually_one_add_smoothingFn_pos | Mathlib.Computability.AkraBazzi.SumTransform | ∀ᶠ (n : ℕ) in Filter.atTop, 0 < 1 + AkraBazziRecurrence.smoothingFn ↑n | true |
wrapSimpDischarger | Mathlib.Util.DischargerAsTactic | Lean.Meta.Simp.Discharge → Lean.Elab.Tactic.TacticM Unit | true |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.tryTheoremWithHint?.match_1 | Mathlib.Tactic.FunProp.Core | (motive : ℕ × Lean.Expr → Sort u_1) → (x : ℕ × Lean.Expr) → ((id : ℕ) → (v : Lean.Expr) → motive (id, v)) → motive x | false |
Lean.Meta.ExtractLets.State._sizeOf_inst | Lean.Meta.Tactic.Lets | SizeOf Lean.Meta.ExtractLets.State | false |
instLieGroupOfNatWithTopENatOfIsTopologicalGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [IsTopologicalGroup ... | true |
Lean.Grind.Order.eq_of_le_of_le_0 | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [Std.IsPartialOrder α] [inst_2 : Lean.Grind.Ring α] {a b : α},
a ≤ b + ↑0 → b ≤ a + ↑0 → a = b | true |
UpperHalfPlane.IsZeroAtImInfty.eq_1 | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] (f : UpperHalfPlane → α),
UpperHalfPlane.IsZeroAtImInfty f = UpperHalfPlane.atImInfty.ZeroAtFilter f | true |
Irreducible.maximalIdeal_pow_eq_setOf_le_v_coe_pow | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {K : Type u_1} {Γ₀ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
[inst_2 : IsDiscreteValuationRing ↥v.integer] {ϖ : ↥v.integer},
Irreducible ϖ → ∀ (n : ℕ), ↑(IsLocalRing.maximalIdeal ↥v.integer ^ n) = {y | v ↑y ≤ v ↑ϖ ^ n} | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.eq_zero_or_one._simp_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{x : P}, (x ∈ 1) = ∃ x', (algebraMap R P) x' = x | false |
Lean.Meta.ExtractLetsConfig.merge | Init.MetaTypes | Lean.Meta.ExtractLetsConfig → Bool | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isNone_minEntry?_eq_isEmpty._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | false |
SeparationQuotient.continuousOn_lift₂._simp_1 | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Y → Z}
{hf : ∀ (a : X) (b : Y) (c : X) (d : Y), Inseparable a c → Inseparable b d → f a b = f c d}
{s : Set (SeparationQuotient X × SeparationQuotient Y)},
ContinuousOn... | false |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.diagonal_fin_three._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = (P 0 ∧ ∀ (i : Fin n), P i.succ) | false |
ContinuousMultilinearMap.smulRightL._proof_8 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G], ContinuousSMul 𝕜 G | false |
Topology.RelCWComplex.finiteType_mkFiniteType | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (D : outParam (Set X)) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), Contin... | true |
TopHomClass.rec | Mathlib.Order.Hom.Bounded | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : Top α] →
[inst_1 : Top β] →
[inst_2 : FunLike F α β] →
{motive : TopHomClass F α β → Sort u} →
((map_top : ∀ (f : F), f ⊤ = ⊤) → motive ⋯) → (t : TopHomClass F α β) → motive t | false |
List.getLast_range' | Init.Data.List.Nat.Range | ∀ {s n : ℕ} (h : List.range' s n ≠ []), (List.range' s n).getLast h = s + n - 1 | true |
AddLocalization.r'._proof_4 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) {a b c : M × ↥S} (t₁ : ↥S),
↑t₁ + (↑b.2 + a.1) = ↑t₁ + (↑a.2 + b.1) →
∀ (t₂ : ↥S), ↑t₂ + ↑c.2 + (↑t₁ + (↑b.2 + a.1)) = ↑t₁ + ↑a.2 + (↑t₂ + (↑c.2 + b.1)) | false |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.reportSnapshots.match_1 | Lean.Server.FileWorker | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((last : Lean.Syntax.Range) → motive (some last)) → (Unit → motive none) → motive x | false |
CochainComplex.mkHomAux | Mathlib.Algebra.Homology.HomologicalComplex | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
(P Q : CochainComplex V ℕ) →
(zero : P.X 0 ⟶ Q.X 0) →
(one : P.X 1 ⟶ Q.X 1) →
CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp ... | true |
IsDedekindDomain.HeightOneSpectrum.valuedAdicCompletion_eq_valuation' | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (k : K),
Valued.v ↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K v)).symm k) =
(IsDedekindDomain.... | true |
Equiv.toHomeomorphOfContinuousClosed_symm_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(h₁ : Continuous ⇑e) (h₂ : IsClosedMap ⇑e), ⇑(e.toHomeomorphOfContinuousClosed h₁ h₂).symm = ⇑e.symm | true |
Matroid.eRk_le_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk X ≤ X.encard | true |
FintypeCat.botTopology | Mathlib.Topology.Category.Profinite.Basic | (A : FintypeCat) → TopologicalSpace A.obj | true |
Std.DTreeMap.Internal.Impl.toListModel_inner | Std.Data.DTreeMap.Internal.Def | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k v l r).toListModel = l.toListModel ++ ⟨k, v⟩ :: r.toListModel | true |
instCompleteAtomicBooleanAlgebraLanguage | Mathlib.Computability.Language | (α : Type u_1) → CompleteAtomicBooleanAlgebra (Language α) | true |
Real.toNNReal_le_ofNat._simp_1 | Mathlib.Data.NNReal.Defs | ∀ {r : ℝ} {n : ℕ} [inst : n.AtLeastTwo], (r.toNNReal ≤ OfNat.ofNat n) = (r ≤ ↑n) | false |
NonUnitalStarAlgebra.range_eq_top | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : NonUnitalSemiring A] [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : NonUnitalSemiring B]
[inst_6 : StarRing B] [inst_7 : Module R B] [inst_8 : FunLike F A B] [inst_9 : NonUnitalAlgHomClass F R A B]
... | true |
_private.Mathlib.Analysis.Analytic.Within.0.analyticWithinAt_of_singleton_mem._simp_1_7 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
IsSepClosed.of_exists_root | Mathlib.FieldTheory.IsSepClosed | ∀ (k : Type u) [inst : Field k],
(∀ (p : Polynomial k), p.Monic → Irreducible p → p.Separable → ∃ x, Polynomial.eval x p = 0) → IsSepClosed k | true |
Subtype.isEmpty_of_false | Mathlib.Logic.IsEmpty.Defs | ∀ {α : Sort u} {p : α → Prop}, (∀ (a : α), ¬p a) → IsEmpty (Subtype p) | true |
ContinuousLinearMap.range_coeFn_eq | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂],
Set.range DFunLike.... | true |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_5 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
¬Turing.PartrecToTM2.Cont'.halt = Turing.PartrecToTM2.Cont'.comp a a_1 | false |
Lean.CollectMVars.State.rec | Lean.Util.CollectMVars | {motive : Lean.CollectMVars.State → Sort u} →
((visitedExpr : Lean.ExprSet) →
(result : Array Lean.MVarId) → motive { visitedExpr := visitedExpr, result := result }) →
(t : Lean.CollectMVars.State) → motive t | false |
SemidirectProduct.rightHom_eq_right | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
⇑SemidirectProduct.rightHom = SemidirectProduct.right | true |
AlgebraicGeometry.StructureSheaf.sectionsSubmodule._proof_5 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | false |
_private.Lean.Meta.Basic.0.Lean.Meta.lambdaMetaTelescope.process.match_1 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((binderName : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam binderName d b bi)) →
((x : Lean.Expr) → motive x) → motive type | false |
MvPolynomial.degrees_one | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.degrees 1 = 0 | true |
Real.not_summable_indicator_one_div_natCast | Mathlib.Analysis.PSeries | ∀ {m : ℕ}, m ≠ 0 → ∀ (k : ZMod m), ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n) | true |
CategoryTheory.Limits.biproduct.isLimit | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(F : J → C) →
[inst_2 : CategoryTheory.Limits.HasBiproduct F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biproduct.bicone F).toCone | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.