name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Fin.zero_ne_one' | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [NeZero n], 0 ≠ 1 | true |
Lean.IR.EmitLLVM.emitTag | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} →
LLVM.Builder llvmctx → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.EmitLLVM.M llvmctx (LLVM.Value llvmctx) | true |
instCategoryLightCondensed._aux_1 | Mathlib.Condensed.Light.Basic | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] → LightCondensed C → LightCondensed C → Type (max (u_1 + 1) u_2) | false |
CategoryTheory.effectiveEpiStructIsColimitDescOfEffectiveEpiFamily._proof_1 | Mathlib.CategoryTheory.EffectiveEpi.Coproduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(c : CategoryTheory.Limits.Cofan X) (hc : CategoryTheory.Limits.IsColimit c) (π : (a : α) → X a ⟶ B) {W : C}
(e : c.pt ⟶ W),
(∀ {Z : C} (g₁ g₂ : Z ⟶ c.pt),
CategoryTheory.CategoryStruct.comp g₁ (hc.desc (CategoryTheory.Limits.Cofan.mk B π)) =
CategoryTheory.CategoryStruct.comp g₂ (hc.desc (CategoryTheory.Limits.Cofan.mk B π)) →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e) →
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (c.ι.app { as := a₁ }) e) =
CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.CategoryStruct.comp (c.ι.app { as := a₂ }) e) | false |
_private.Mathlib.Logic.Nonempty.0.Function.Surjective.nonempty.match_1_1 | Mathlib.Logic.Nonempty | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} (y : β) (motive : (∃ a, f a = y) → Prop) (x : ∃ a, f a = y),
(∀ (x : α) (h : f x = y), motive ⋯) → motive x | false |
exists_mem_nhds_isClosed_subset | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {x : X} {s : Set X},
s ∈ nhds x → ∃ t ∈ nhds x, IsClosed t ∧ t ⊆ s | true |
AddSubgroup.sup_eq_closure_add | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (H K : AddSubgroup G), H ⊔ K = AddSubgroup.closure (↑H + ↑K) | true |
_private.Mathlib.Analysis.Convex.Between.0.wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_9} {P : Type u_10} {inst : AddSemigroup G} [self : AddSemigroupAction G P] (g₁ g₂ : G) (p : P),
g₁ +ᵥ g₂ +ᵥ p = (g₁ + g₂) +ᵥ p | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.createModulePreDiscrTree | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} →
Lean.Core.Context →
Lean.NameGenerator →
Lean.Environment →
(Lean.Name →
Lean.ConstantInfo →
Lean.MetaM (List (α × List (Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry)))) →
BaseIO (Lean.Meta.RefinedDiscrTree.InitResults✝ α) | true |
CategoryTheory.Limits.pullback.snd_of_mono | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Mono f],
CategoryTheory.Mono (CategoryTheory.Limits.pullback.snd f g) | true |
HNNExtension.NormalWord.ReducedWord.noConfusionType | Mathlib.GroupTheory.HNNExtension | Sort u →
{G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
HNNExtension.NormalWord.ReducedWord G A B →
{G' : Type u_1} →
[inst' : Group G'] → {A' B' : Subgroup G'} → HNNExtension.NormalWord.ReducedWord G' A' B' → Sort u | false |
CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.HasColimitsOfShape J D] [CategoryTheory.CreatesColimitsOfShape J F],
CategoryTheory.Limits.HasColimitsOfShape J C | true |
CategoryTheory.Pseudofunctor.mapComp_id_right_hom_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)),
(F.mapComp f (CategoryTheory.CategoryStruct.id b)).hom.toNatTrans.app X =
CategoryTheory.CategoryStruct.comp ((F.map₂ (CategoryTheory.Bicategory.rightUnitor f).hom).toNatTrans.app X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
((F.mapId b).inv.toNatTrans.app ((F.map f).toFunctor.obj X))) | true |
Finsupp.piecewise_support | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_12} [inst : Zero M] {P : α → Prop} [inst_1 : DecidablePred P] (f : Subtype P →₀ M)
(g : { a // ¬P a } →₀ M),
(f.piecewise g).support =
(Finset.map (Function.Embedding.subtype P) f.support).disjUnion
(Finset.map (Function.Embedding.subtype fun a => ¬P a) g.support) ⋯ | true |
_private.Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition.0.Submodule.rank_le_one_iff_isPrincipal._simp_1_4 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Submodule R M}
{v₀ : M}, (s ≤ R ∙ v₀) = ∀ v ∈ s, ∃ r, r • v₀ = v | false |
Std.DTreeMap.Const.get?_union_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α}, k ∉ t₁ → Std.DTreeMap.Const.get? (t₁ ∪ t₂) k = Std.DTreeMap.Const.get? t₂ k | true |
AlgebraicGeometry.StructureSheaf.sectionsSubmodule._proof_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} (M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
{a b : (x : ↥U) → AlgebraicGeometry.StructureSheaf.Localizations M ↑x},
a ∈ {f | (AlgebraicGeometry.StructureSheaf.isLocallyFraction R M).pred f} →
b ∈ {f | (AlgebraicGeometry.StructureSheaf.isLocallyFraction R M).pred f} →
∀ (x : ↥U),
∃ V, ∃ (_ : ↑x ∈ V), ∃ i, (AlgebraicGeometry.StructureSheaf.isFractionPrelocal R M).pred fun x => (a + b) (i x) | false |
spinGroup.instStarSubtypeCliffordAlgebraMemSubmonoid._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(spinGroup Q)), star ↑x ∈ spinGroup Q | false |
LinearMap.GeneralLinearGroup.ofLinearEquiv | Mathlib.LinearAlgebra.GeneralLinearGroup.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (M ≃ₗ[R] M) → LinearMap.GeneralLinearGroup R M | true |
SimpleGraph.edgeSet_map | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W) (G : SimpleGraph V),
(SimpleGraph.map (⇑f) G).edgeSet = ⇑f.sym2Map '' G.edgeSet | true |
IsLocalHom.mk | Mathlib.Algebra.Group.Units.Hom | ∀ {R : Type u_2} {S : Type u_3} {F : Type u_5} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : FunLike F R S] {f : F},
(∀ (a : R), IsUnit (f a) → IsUnit a) → IsLocalHom f | true |
_private.Mathlib.RingTheory.Radical.Basic.0.UniqueFactorizationMonoid.mem_primeFactors._simp_1_2 | Mathlib.RingTheory.Radical.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | false |
MonoidAlgebra.counit_single | Mathlib.RingTheory.Coalgebra.MonoidAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] {X : Type u_3} [inst_2 : Module R A]
[inst_3 : Coalgebra R A] (x : X) (a : A), CoalgebraStruct.counit (MonoidAlgebra.single x a) = CoalgebraStruct.counit a | true |
unique_one | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u_1} [inst : Unique α] [inst_1 : One α], default = 1 | true |
Hyperreal.infiniteNeg_def | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*}, x.InfiniteNeg ↔ ∀ (r : ℝ), x < ↑r | true |
Lean.Compiler.LCNF.UnreachableBranches.InterpContext.currFnIdx | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.UnreachableBranches.InterpContext → ℕ | true |
BitVec.reduceRotateLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | true |
BoxIntegral.TaggedPrepartition.isPartition_unionComplToSubordinate | Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction | ∀ {ι : Type u_1} [inst : Fintype ι] {I : BoxIntegral.Box ι} (π₁ : BoxIntegral.TaggedPrepartition I)
(π₂ : BoxIntegral.Prepartition I) (hU : π₂.iUnion = ↑I \ π₁.iUnion) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
(π₁.unionComplToSubordinate π₂ hU r).IsPartition | true |
SkewMonoidAlgebra.lift_unique' | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_4} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
(F : SkewMonoidAlgebra k G →ₐ[k] A), F = (SkewMonoidAlgebra.lift k G A) ((↑F).comp (SkewMonoidAlgebra.of k G)) | true |
AlternatingMap.constLinearEquivOfIsEmpty._proof_3 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {ι : Type u_3} {R' : Type u_4} {M'' : Type u_1} {N'' : Type u_2} [inst : CommSemiring R'] [inst_1 : AddCommMonoid M'']
[inst_2 : AddCommMonoid N''] [inst_3 : Module R' M''] [inst_4 : Module R' N''] [inst_5 : IsEmpty ι] (x : R')
(x_1 : N''), AlternatingMap.constOfIsEmpty R' M'' ι (x • x_1) = AlternatingMap.constOfIsEmpty R' M'' ι (x • x_1) | false |
ZMod.val_ne_zero | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (a : ZMod n), a.val ≠ 0 ↔ a ≠ 0 | true |
Int.subNatNat_add | Init.Data.Int.Lemmas | ∀ (m n k : ℕ), Int.subNatNat (m + n) k = ↑m + Int.subNatNat n k | true |
CoalgEquivClass.toCoalgHomClass | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {F : Type u_5} {R : outParam (Type u_6)} {A : outParam (Type u_7)} {B : outParam (Type u_8)} {inst : CommSemiring R}
{inst_1 : AddCommMonoid A} {inst_2 : AddCommMonoid B} {inst_3 : Module R A} {inst_4 : Module R B}
{inst_5 : CoalgebraStruct R A} {inst_6 : CoalgebraStruct R B} {inst_7 : EquivLike F A B}
[self : CoalgEquivClass F R A B], CoalgHomClass F R A B | true |
instDecidableEqDyadic.decEq._proof_4 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), ¬Dyadic.ofOdd n k hn = Dyadic.zero | false |
IsSimpleModule.casesOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSimpleModule R M → Sort u} →
(t : IsSimpleModule R M) → ([toIsSimpleOrder : IsSimpleOrder (Submodule R M)] → motive ⋯) → motive t | false |
CategoryTheory.Functor.op_iff | Mathlib.CategoryTheory.Localization.Opposite | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C), L.op.IsLocalization W.op ↔ L.IsLocalization W | true |
AlgebraicClosure.instGroupWithZero._proof_9 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (a : MvPolynomial (AlgebraicClosure.Vars k) k ⧸ AlgebraicClosure.maxIdeal k),
Field.zpow 0 a = 1 | false |
NormedCommGroup.toENormedCommMonoid.eq_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : NormedCommGroup E],
NormedCommGroup.toENormedCommMonoid =
{ toESeminormedMonoid := NormedGroup.toENormedMonoid.toESeminormedMonoid, mul_comm := ⋯, enorm_eq_zero := ⋯ } | true |
PartOrd.ofHom_hom | Mathlib.Order.Category.PartOrd | ∀ {X Y : PartOrd} (f : X ⟶ Y), PartOrd.ofHom (PartOrd.Hom.hom f) = f | true |
Lean.Parser.equalA | Init.Guard | Lean.ParserDescr | true |
small_neg | Mathlib.Algebra.Group.Pointwise.Set.Small | ∀ {α : Type u_1} (s : Set α) [inst : InvolutiveNeg α] [Small.{u, u_1} ↑s], Small.{u, u_1} ↑(-s) | true |
EuclideanGeometry.Sphere.sOppSide_faceOpposite_secondInter_of_mem_interior_faceOpposite | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {n : ℕ} [inst_4 : NeZero n]
{sx : Affine.Simplex ℝ P n} {i : Fin (n + 1)},
sx.points i ∈ s →
(∀ (j : Fin (n + 1)), dist (sx.points j) s.center ≤ s.radius) →
∀ {p : P},
p ∈ (sx.faceOpposite i).interior →
(affineSpan ℝ (Set.range (sx.faceOpposite i).points)).SOppSide (sx.points i)
(s.secondInter (sx.points i) (p -ᵥ sx.points i)) | true |
subset_absConvexHull | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, s ⊆ (absConvexHull 𝕜) s | true |
AddSubgroup.instUniqueOfSubsingleton._proof_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] [Subsingleton G] (a : AddSubgroup G), a = default | false |
PointwiseConvergenceCLM.inducingFn._proof_3 | Mathlib.Analysis.LocallyConvex.PointwiseConvergence | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) (E : Type u_3)
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜₂ F] (x : 𝕜₂) (x_1 : E →SLₚₜ[σ] F), ⇑(x • x_1) = ⇑(x • x_1) | false |
IsAddCentral.right_assoc | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Add M] {z : M}, IsAddCentral z → ∀ (a b : M), a + b + z = a + (b + z) | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.updateAppMap | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Meta.Grind.GoalM Unit | true |
Lean.Core.SavedState.snapshotTasks._inherited_default | Lean.CoreM | Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree) | false |
Std.Internal.IO.Async.Signal.sigxcpu.sizeOf_spec | Std.Internal.Async.Signal | sizeOf Std.Internal.IO.Async.Signal.sigxcpu = 1 | true |
Lean.Widget.RpcEncodablePacket.mk.«_@».Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1.noConfusion | Lean.Widget.InteractiveGoal | {P : Sort u} →
{hyps type ctx : Lean.Json} →
{userName? : Option Lean.Json} →
{goalPrefix mvarId : Lean.Json} →
{isInserted? isRemoved? : Option Lean.Json} →
{hyps' type' ctx' : Lean.Json} →
{userName?' : Option Lean.Json} →
{goalPrefix' mvarId' : Lean.Json} →
{isInserted?' isRemoved?' : Option Lean.Json} →
{ hyps := hyps, type := type, ctx := ctx, userName? := userName?, goalPrefix := goalPrefix,
mvarId := mvarId, isInserted? := isInserted?, isRemoved? := isRemoved? } =
{ hyps := hyps', type := type', ctx := ctx', userName? := userName?', goalPrefix := goalPrefix',
mvarId := mvarId', isInserted? := isInserted?', isRemoved? := isRemoved?' } →
(hyps = hyps' →
type = type' →
ctx = ctx' →
userName? = userName?' →
goalPrefix = goalPrefix' →
mvarId = mvarId' → isInserted? = isInserted?' → isRemoved? = isRemoved?' → P) →
P | false |
Ideal.instInhabitedCotangent | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → Inhabited I.Cotangent | true |
Std.Tactic.BVDecide.BVExpr.eval_arithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {a : ℕ} {lhs : Std.Tactic.BVDecide.BVExpr a} {a_1 : ℕ}
{rhs : Std.Tactic.BVDecide.BVExpr a_1},
Std.Tactic.BVDecide.BVExpr.eval assign (lhs.arithShiftRight rhs) =
(Std.Tactic.BVDecide.BVExpr.eval assign lhs).sshiftRight' (Std.Tactic.BVDecide.BVExpr.eval assign rhs) | true |
Cardinal.toENat_nat | Mathlib.SetTheory.Cardinal.ENat | ∀ (n : ℕ), Cardinal.toENat ↑n = ↑n | true |
ContMDiffOn.smul | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {n : WithTop ℕ∞} {V : Type u_12}
[inst_6 : NormedAddCommGroup V] [inst_7 : NormedSpace 𝕜 V] {f : M → 𝕜} {g : M → V},
ContMDiffOn I (modelWithCornersSelf 𝕜 𝕜) n f s →
ContMDiffOn I (modelWithCornersSelf 𝕜 V) n g s → ContMDiffOn I (modelWithCornersSelf 𝕜 V) n (fun p => f p • g p) s | true |
AlgebraicGeometry.IsAffineOpen.comap_primeIdealOf_appLE | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X} (U : Y.Opens) (hU : AlgebraicGeometry.IsAffineOpen U)
(V : X.Opens) (hV : AlgebraicGeometry.IsAffineOpen V) (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U)
(hx : x ∈ V),
PrimeSpectrum.comap (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V hVU)) (hV.primeIdealOf ⟨x, hx⟩) =
hU.primeIdealOf ⟨f x, ⋯⟩ | true |
Multiplicative.leftCancelMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : AddLeftCancelMonoid α], IsLeftCancelMul (Multiplicative α) | false |
instFintypeSymbol.match_5 | Mathlib.Computability.Language | (T : Type u_1) →
(N : Type u_2) →
(motive : Symbol T N → Sort u_3) →
(x : Symbol T N) → ((a : T) → motive (Symbol.terminal a)) → ((a : N) → motive (Symbol.nonterminal a)) → motive x | false |
Std.TreeSet.toList_ric._auto_1 | Std.Data.TreeSet.Slice | Lean.Syntax | false |
contDiffOn_succ_iff_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞},
UniqueDiffOn 𝕜 s →
(ContDiffOn 𝕜 (n + 1) f s ↔
DifferentiableOn 𝕜 f s ∧ (n = ⊤ → AnalyticOn 𝕜 f s) ∧ ContDiffOn 𝕜 n (fderivWithin 𝕜 f s) s) | true |
BoxIntegral.Prepartition.instSemilatticeInf._proof_3 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (x π₁ x_1 : BoxIntegral.Prepartition I),
x ≤ π₁ → x ≤ x_1 → x ≤ π₁.biUnion fun J => x_1.restrict J | false |
String.Model.positionsFrom_eq_cons | Init.Data.String.Lemmas.Iterate | ∀ {s : String} {p : s.Pos} (hp : p ≠ s.endPos),
String.Model.positionsFrom p = ⟨p, hp⟩ :: String.Model.positionsFrom (p.next hp) | true |
ByteArray.get_set_eq._proof_1 | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), ↑i < (a.set (↑i) v ⋯).size | false |
MeasureTheory.Measure.OuterRegular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] (μ : MeasureTheory.Measure α) [μ.OuterRegular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).OuterRegular | true |
CategoryTheory.unop_inv_associator | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : Cᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv.unop =
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop X) (Opposite.unop Y) (Opposite.unop Z)).hom | true |
DFinsupp.erase_neg | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} [inst : DecidableEq ι] {β : ι → Type v} [inst_1 : (i : ι) → AddGroup (β i)] (i : ι)
(f : Π₀ (i : ι), β i), DFinsupp.erase i (-f) = -DFinsupp.erase i f | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{t t' : Lean.Elab.Command.AccLevelState✝} → t = t' → Lean.Elab.Command.AccLevelState.noConfusionType✝ P t t' | false |
MvPolynomial.degrees_map_of_injective | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {S : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] (p : MvPolynomial σ R)
{f : R →+* S}, Function.Injective ⇑f → ((MvPolynomial.map f) p).degrees = p.degrees | true |
Filter.Eventually.exists_lt | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] {a : α} [(nhdsWithin a (Set.Iio a)).NeBot]
{p : α → Prop}, (∀ᶠ (x : α) in nhds a, p x) → ∃ b < a, p b | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_7 | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Analysis.SpecialFunctions.PolarCoord.0.polarCoord._simp_7 | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.State._sizeOf_inst | Lean.Compiler.LCNF.ExplicitRC | SizeOf Lean.Compiler.LCNF.CollectDerivedValInfo.State✝ | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_spectrum_term↑ₐ_2_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | false |
HasFDerivAt.lim_real | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F} {f' : E →L[ℝ] F} {x : E},
HasFDerivAt f f' x → ∀ (v : E), Filter.Tendsto (fun c => c • (f (x + c⁻¹ • v) - f x)) Filter.atTop (nhds (f' v)) | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (clauses : Array (Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)))
(rupUnits ratUnits : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
{ clauses := clauses, rupUnits := rupUnits, ratUnits := ratUnits, assignments := assignments }.clearRupUnits =
{ clauses := clauses, rupUnits := #[], ratUnits := ratUnits,
assignments := Array.foldl Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearUnit assignments rupUnits } | true |
CategoryTheory.Limits.compCoyonedaSectionsEquiv_symm_apply_coe | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] (F : CategoryTheory.Functor J C) (X : C)
(τ : (CategoryTheory.Functor.const J).obj X ⟶ F) (X_1 : J),
↑((CategoryTheory.Limits.compCoyonedaSectionsEquiv F X).symm τ) X_1 = τ.app X_1 | true |
CategoryTheory.BiconeHom.decidableEq._proof_16 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J] (j : J)
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.left (CategoryTheory.Bicone.diagram j)), g ≍ g | false |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Fintype.one_lt_prod_iff_of_one_le._simp_1_1 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : CommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedCancelMonoid M] {f : ι → M}, 1 < f → (1 < ∏ i, f i) = True | false |
derivWithin_pi | Mathlib.Analysis.Calculus.Deriv.Prod | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_1} {E' : ι → Type u_2}
[inst_1 : (i : ι) → NormedAddCommGroup (E' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E' i)] {φ : 𝕜 → (i : ι) → E' i},
(∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => φ x i) s x) →
derivWithin φ s x = fun i => derivWithin (fun x => φ x i) s x | true |
FreeAbelianGroup.distrib._proof_2 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} [inst : Mul α] (x x_1 x_2 : FreeAbelianGroup α),
(FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) (x_1 + x_2) =
(FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) x_1 +
(FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) x_2 | false |
CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeFintypeCatSingleObjInclOfFinite | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {G : Type v} [inst : Group G] [Finite G],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleObj G) FintypeCat.incl | true |
CondensedSet.LocallyConstant.instFaithfulCondensedTypeDiscrete | Mathlib.Condensed.Discrete.LocallyConstant | (Condensed.discrete (Type (u_1 + 1))).Faithful | true |
NonAssocRing.toNonUnitalNonAssocRing | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → [self : NonAssocRing α] → NonUnitalNonAssocRing α | true |
Lean.TraceState | Lean.Util.Trace | Type | true |
_private.Mathlib.Algebra.Lie.Free.0._aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_lift_comp_of_1 | Mathlib.Algebra.Lie.Free | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Option.getD.match_1.eq_1 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | true |
MeasureTheory.Measure.add_right_inj | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ ν₁ ν₂ : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂ | true |
CategoryTheory.regularTopology.isLimit_forkOfι_equiv._proof_4 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X B : C} (π : X ⟶ B)
(c : CategoryTheory.Limits.PullbackCone π π),
∃ Y h g,
CategoryTheory.Presieve.ofArrows (fun x => X) (fun x => π) g ∧
CategoryTheory.CategoryStruct.comp h g = CategoryTheory.CategoryStruct.comp c.fst π | false |
_private.Init.Data.List.ToArray.0.Array.replace.eq_1 | Init.Data.List.ToArray | ∀ {α : Type u} [inst : BEq α] (xs : Array α) (a b : α),
xs.replace a b =
match xs.finIdxOf? a with
| none => xs
| some i => xs.set (↑i) b ⋯ | true |
GenContFract.ext | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {x y : GenContFract α}, x.h = y.h → x.s = y.s → x = y | true |
SpectrumRestricts.of_rightInvOn | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_3} {S : Type u_4} {A : Type u_5} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] {a : A} {f : S → R},
Function.LeftInverse f ⇑(algebraMap R S) → Set.RightInvOn f (⇑(algebraMap R S)) (spectrum S a) → SpectrumRestricts a f | true |
MinimalFor.not_lt | Mathlib.Order.Minimal | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] {Q : ι → Prop} {f : ι → α} {i j : ι},
MinimalFor Q f i → Q j → ¬f j < f i | true |
CompleteDistribLattice.MinimalAxioms.toCoframe | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → CompleteDistribLattice.MinimalAxioms α → Order.Coframe.MinimalAxioms α | true |
Multiset.coe_card | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).card = l.length | true |
Std.LawfulOrderMin.casesOn | Init.Data.Order.Classes | {α : Type u} →
[inst : Min α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderMin α → Sort u_1} →
(t : Std.LawfulOrderMin α) →
([toMinEqOr : Std.MinEqOr α] → [toLawfulOrderInf : Std.LawfulOrderInf α] → motive ⋯) → motive t | false |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.exists_bucket_of_uset._simp_1_2 | Std.Data.DHashMap.Internal.Model | ∀ {x y : Bool}, ((x || y) = false) = (x = false ∧ y = false) | false |
Array.permute! | Mathlib.Data.Array.Defs | {α : Type u} → [Inhabited α] → Array α → List (List ℕ) → Array α | true |
SimplicialObject.Splitting.mk | Mathlib.AlgebraicTopology.SimplicialObject.Split | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} →
(N : ℕ → C) →
(ι : (n : ℕ) → N n ⟶ X.obj (Opposite.op (SimplexCategory.mk n))) →
((Δ : SimplexCategoryᵒᵖ) → CategoryTheory.Limits.IsColimit (SimplicialObject.Splitting.cofan' N X ι Δ)) →
SimplicialObject.Splitting X | true |
FinBddDistLat.Iso.mk._proof_13 | Mathlib.Order.Category.FinBddDistLat | ∀ {α β : FinBddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat), e.symm ⊤ = ⊤ | false |
List.flatMap_eq_nil_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → List β}, List.flatMap f l = [] ↔ ∀ x ∈ l, f x = [] | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram._sizeOf_inst | Mathlib.CategoryTheory.Presentable.Directed | (J : Type w) →
{inst : CategoryTheory.SmallCategory J} →
(κ : Cardinal.{w}) → [SizeOf J] → SizeOf (CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.