name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PresentedMonoid.ext | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_2} {M : Type u_3} [inst : Monoid M] (rels : FreeMonoid α → FreeMonoid α → Prop)
{φ ψ : PresentedMonoid rels →* M}, (∀ (x : α), φ (PresentedMonoid.of rels x) = ψ (PresentedMonoid.of rels x)) → φ = ψ | true |
OrderDual.Ord.dual_dual | Mathlib.Order.OrderDual | ∀ (α : Type u_2) [H : Ord α], OrderDual.instOrd αᵒᵈ = H | true |
ProfiniteAddGrp.limitConePtAux._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{a b : (j : J) → ↑(F.obj j).toProfinite.toTop},
a ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
b ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
∀ (x x_1 : J) (π : x ⟶ x_1), (ProfiniteAddGrp.Hom.hom (F.map π)) ((a + b) x) = (a + b) x_1 | false |
_private.Init.Omega.IntList.0.List.getElem?_cons_succ | Init.Omega.IntList | ∀ {α : Type u_1} {a : α} {i : ℕ} {l : List α}, (a :: l)[i + 1]? = l[i]? | true |
CategoryTheory.eq_of_comp_right_eq | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : Y ⟶ X},
(∀ {Z : C} (h : Z ⟶ Y), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) → f = g | true |
Lean.Language.DynamicSnapshot.casesOn | Lean.Language.Basic | {motive : Lean.Language.DynamicSnapshot → Sort u} →
(t : Lean.Language.DynamicSnapshot) →
((val : Dynamic) → (tree : Thunk Lean.Language.SnapshotTree) → motive { val := val, tree := tree }) → motive t | false |
Order.isPredPrelimitRecOn_of_isPredPrelimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : PartialOrder α] [inst_1 : PredOrder α]
(pred : (a : α) → ¬IsMin a → motive (Order.pred a)) (isPredPrelimit : (a : α) → Order.IsPredPrelimit a → motive a)
(hb : Order.IsPredPrelimit b), Order.isPredPrelimitRecOn b pred isPredPrelimit = isPredPrelimit b hb | true |
CategoryTheory.instLiftingFunctorOppositeSheafPresheafToSheafWCompObjWhiskeringRightComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Functor A B) →
[inst_3 : CategoryTheory.HasWeakSheafify J B] →
[inst_4 : CategoryTheory.HasWeakSheafify J A] →
[J.PreservesSheafification F] →
CategoryTheory.Localization.Lifting (CategoryTheory.presheafToSheaf J A) J.W
(((CategoryTheory.Functor.whiskeringRight Cᵒᵖ A B).obj F).comp
(CategoryTheory.presheafToSheaf J B))
(CategoryTheory.Sheaf.composeAndSheafify J F) | true |
Lean.Compiler.LCNF.isBoxedName | Lean.Compiler.LCNF.Types | Lean.Name → Bool | true |
PrimeSpectrum.exist_mem_one_of_mem_maximal_ideal | Mathlib.RingTheory.Spectrum.Prime.LTSeries | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] [inst_2 : IsLocalRing R] {p₁ p₀ : PrimeSpectrum R},
p₀ < p₁ →
p₁ < IsLocalRing.closedPoint R →
∀ {x : R}, x ∈ IsLocalRing.maximalIdeal R → ∃ q, x ∈ q.asIdeal ∧ p₀ < q ∧ q.asIdeal < IsLocalRing.maximalIdeal R | true |
Std.Tactic.BVDecide.BVBinOp.and | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp | true |
DirectedSystem.mk._flat_ctor | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {f : ⦃i j : ι⦄ → i ≤ j → F i → F j},
(∀ ⦃i : ι⦄ (x : F i), f ⋯ x = x) →
(∀ ⦃k j i : ι⦄ (hij : i ≤ j) (hjk : j ≤ k) (x : F i), f hjk (f hij x) = f ⋯ x) → DirectedSystem F f | false |
Std.Internal.IO.Async.System.instDecidableEqGroupId | Std.Internal.Async.System | DecidableEq Std.Internal.IO.Async.System.GroupId | true |
ZFSet.notMem_sInter_of_notMem | Mathlib.SetTheory.ZFC.Basic | ∀ {x y z : ZFSet.{u_1}}, y ∉ z → z ∈ x → y ∉ x.sInter | true |
Finset.empty_smul | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] (t : Finset β), ∅ • t = ∅ | true |
Std.ExtTreeMap.mem_union_iff._simp_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
(k ∈ t₁ ∪ t₂) = (k ∈ t₁ ∨ k ∈ t₂) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.equation_some._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {W : WeierstrassCurve.Affine R} (x y : R),
W.Equation x y = (y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆) = 0) | false |
CategoryTheory.ShortComplex.abLeftHomologyData_f' | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ (S : CategoryTheory.ShortComplex Ab), S.abLeftHomologyData.f' = AddCommGrpCat.ofHom S.abToCycles | true |
Mathlib.Tactic.TermCongr.CongrType.toCtorIdx | Mathlib.Tactic.TermCongr | Mathlib.Tactic.TermCongr.CongrType → ℕ | false |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashSeq.match_1.eq_2 | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} (motive : Option (GenContFract.Pair K) × Option (GenContFract.Pair K) → Sort u_2)
(x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K))
(h_1 : (gp_n gp_succ_n : GenContFract.Pair K) → motive (some gp_n, some gp_succ_n))
(h_2 : (x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K)) → motive x),
(∀ (gp_n gp_succ_n : GenContFract.Pair K), x = (some gp_n, some gp_succ_n) → False) →
(match x with
| (some gp_n, some gp_succ_n) => h_1 gp_n gp_succ_n
| x => h_2 x) =
h_2 x | true |
AddActionHomClass | Mathlib.GroupTheory.GroupAction.Hom | (F : Type u_8) →
(M : outParam (Type u_9)) →
(X : outParam (Type u_10)) → (Y : outParam (Type u_11)) → [VAdd M X] → [VAdd M Y] → [FunLike F X Y] → Prop | true |
ContinuousLinearEquiv.dimH_univ | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {𝕜 : Type u_4} {E : Type u_5} {F : Type u_6} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (e : E ≃L[𝕜] F),
dimH Set.univ = dimH Set.univ | true |
SSet.Subcomplex.Pairing.dim_p | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [P.IsProper] (x : ↑P.II), (↑(P.p x)).dim = (↑x).dim + 1 | true |
Ideal.quotientToQuotientRangePowQuotSuccAux._proof_1 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R), RingHomSurjective (RingHom.id (R ⧸ p)) | false |
Order.IsNormal.apply_of_isSuccLimit | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : α → β} [inst : ConditionallyCompleteLinearOrderBot α]
[inst_1 : ConditionallyCompleteLinearOrder β], Order.IsNormal f → Order.IsSuccLimit a → f a = ⨆ b, f ↑b | true |
SetLike.GradeZero.coe_mul | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : Monoid R] [inst_2 : AddMonoid ι]
{A : ι → S} [inst_3 : SetLike.GradedMonoid A] (a b : ↥(A 0)), ↑(a * b) = ↑a * ↑b | true |
Action.mkIso._proof_4 | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_3} [inst_1 : Monoid G] {M N : Action V G}
(f : M.V ≅ N.V)
(comm :
∀ (g : G), CategoryTheory.CategoryStruct.comp (M.ρ g) f.hom = CategoryTheory.CategoryStruct.comp f.hom (N.ρ g)),
CategoryTheory.CategoryStruct.comp { hom := f.hom, comm := comm } { hom := f.inv, comm := ⋯ } =
CategoryTheory.CategoryStruct.id M | false |
Homeomorph.finTwoArrow | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} → [inst : TopologicalSpace X] → (Fin 2 → X) ≃ₜ X × X | true |
CategoryTheory.Limits.widePullbackShapeOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y Z : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.widePullbackShapeOpMap J X Z (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.widePullbackShapeOpMap J X Y f)
(CategoryTheory.Limits.widePullbackShapeOpMap J Y Z g) | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.toArray_eq_empty_iff._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α], (r.toList = []) = ¬r.lower ≤ r.upper | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_Iic_castAdd._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.Iic (Fin.castAdd m i) = Finset.map (Fin.castAddEmb m) (Finset.Iic i) | false |
Representation.IntertwiningMap.noConfusionType | Mathlib.RepresentationTheory.Intertwining | Sort u →
{A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
{ρ : Representation A G V} →
{σ : Representation A G W} →
ρ.IntertwiningMap σ →
{A' : Type u_1} →
{G' : Type u_2} →
{V' : Type u_3} →
{W' : Type u_4} →
[inst' : Semiring A'] →
[inst'_1 : Monoid G'] →
[inst'_2 : AddCommMonoid V'] →
[inst'_3 : AddCommMonoid W'] →
[inst'_4 : Module A' V'] →
[inst'_5 : Module A' W'] →
{ρ' : Representation A' G' V'} →
{σ' : Representation A' G' W'} → ρ'.IntertwiningMap σ' → Sort u | false |
Lean.Macro.getCurrNamespace | Init.Prelude | Lean.MacroM Lean.Name | true |
Lean.Lsp.SignatureHelpContext.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.SignatureHelpContext} → t = t' → Lean.Lsp.SignatureHelpContext.noConfusionType P t t' | false |
Lean.Meta.Grind.AC.Struct.vars | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → Lean.PArray Lean.Expr | true |
Std.DTreeMap.Internal.Impl.insertManyIfNew!._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β)
(r : t.IteratedSlowNewInsertionInto) (a : α) (b : β a) {P : Std.DTreeMap.Internal.Impl α β → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α β) (a : α) (b : β a),
P t'' → P (Std.DTreeMap.Internal.Impl.insertIfNew! a b t'')) →
P (Std.DTreeMap.Internal.Impl.insertIfNew! a b ↑r) | false |
ContinuousAddMonoidHom.zero_toFun | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (A : Type u_2) (B : Type u_3) [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] (x : A), 0 x = 0 | true |
CochainComplex.HomComplex.Cochain.InductionUp.sequence_eqUpTo | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {d : ℤ} {X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)}
(φ : (n : ℕ) → ↑(X n) → ↑(X (n + 1))) {p₀ : ℤ},
(∀ (n : ℕ) (x : ↑(X n)), (↑(φ n x)).EqUpTo (↑x) (p₀ + ↑n)) →
∀ (x₀ : ↑(X 0)) (n₁ n₂ : ℕ),
n₁ ≤ n₂ →
(↑(CochainComplex.HomComplex.Cochain.InductionUp.sequence φ x₀ n₁)).EqUpTo
(↑(CochainComplex.HomComplex.Cochain.InductionUp.sequence φ x₀ n₂)) (p₀ + ↑n₁) | true |
TopCommRingCat.isTopologicalRing | Mathlib.Topology.Category.TopCommRingCat | ∀ (self : TopCommRingCat), IsTopologicalRing self.α | true |
SimpleGraph.«term_⊴_» | Mathlib.Combinatorics.SimpleGraph.Copy | Lean.TrailingParserDescr | true |
Std.Do.Spec.forIn'_array._proof_2 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : Array α} (pref : List α) (cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → cur ∈ xs | false |
DomMulAct.instDistribSMulForallOfSMul._proof_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {α : Type u_2} {A : Type u_3} [inst : SMul M α] [inst_1 : AddZeroClass A] (x : Mᵈᵐᵃ) (x_1 x_2 : α → A),
x • (x_1 + x_2) = x • (x_1 + x_2) | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.isStronglyTranscendental_iff_of_field._simp_1_8 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {b a : Prop}, (a ∨ ¬b) = (b → a) | false |
CoalgCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_right | Mathlib.Algebra.Category.CoalgCat.ComonEquivalence | ∀ {R : Type u} [inst : CommRing R] {M N P : Type u} [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P] [inst_7 : Coalgebra R M]
[inst_8 : Coalgebra R N] [inst_9 : Coalgebra R P], CoalgebraStruct.counit = CoalgebraStruct.counit | true |
Std.TreeMap.Raw.getKey_eq_getKeyD | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α} {h' : a ∈ t}, t.getKey a h' = t.getKeyD a fallback | true |
FormalMultilinearSeries.id.match_1 | Mathlib.Analysis.Analytic.Composition | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((x : ℕ) → motive x) → motive x | false |
MeasureTheory.wrapped._@.Mathlib.MeasureTheory.Constructions.Polish.Basic.3011411360._hygCtx._hyg.2 | Mathlib.MeasureTheory.Constructions.Polish.Basic | Subtype (Eq @MeasureTheory.definition✝) | false |
LinearMap.toKerIsLocalized | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
(p : Submonoid R) →
(f : M →ₗ[R] N) →
[inst_5 : IsLocalizedModule p f] →
{P : Type u_5} →
[inst_6 : AddCommMonoid P] →
[inst_7 : Module R P] →
{Q : Type u_6} →
[inst_8 : AddCommMonoid Q] →
[inst_9 : Module R Q] →
(f' : P →ₗ[R] Q) →
[inst_10 : IsLocalizedModule p f'] →
(g : M →ₗ[R] P) → ↥g.ker →ₗ[R] ↥((IsLocalizedModule.map p f f') g).ker | true |
isMinimal_iff_isClosed_vadd_invariant | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : AddMonoid M] [inst_1 : TopologicalSpace α] [inst_2 : AddAction M α]
[ContinuousConstVAdd M α],
AddAction.IsMinimal M α ↔ ∀ (s : Set α), IsClosed s → (∀ (c : M), c +ᵥ s ⊆ s) → s = ∅ ∨ s = Set.univ | true |
UniformSpaceCat.Hom.mk._flat_ctor | Mathlib.Topology.Category.UniformSpace | {X : UniformSpaceCat} → {Y : UniformSpaceCat} → { f // UniformContinuous f } → X.Hom Y | false |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.coverMincard_finite_iff._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ (a : ℕ), (↑a = ⊤) = False | false |
_private.Init.Data.Nat.Fold.0.Nat.dfoldRev.match_1.eq_2 | Init.Data.Nat.Fold | ∀
(motive :
(n : ℕ) →
{α : (i : ℕ) → autoParam (i ≤ n) Nat.dfoldRev._auto_1 → Type u_1} →
((i : ℕ) → (h : i < n) → α (i + 1) ⋯ → α i ⋯) → α n ⋯ → Sort u_2)
(n : ℕ) (α : (i : ℕ) → autoParam (i ≤ n + 1) Nat.dfoldRev._auto_1 → Type u_1)
(f : (i : ℕ) → (h : i < n + 1) → α (i + 1) ⋯ → α i ⋯) (init : α (n + 1) ⋯)
(h_1 :
(α : (i : ℕ) → autoParam (i ≤ 0) Nat.dfoldRev._auto_1 → Type u_1) →
(f : (i : ℕ) → (h : i < 0) → α (i + 1) ⋯ → α i ⋯) → (init : α 0 ⋯) → motive 0 f init)
(h_2 :
(n : ℕ) →
(α : (i : ℕ) → autoParam (i ≤ n + 1) Nat.dfoldRev._auto_1 → Type u_1) →
(f : (i : ℕ) → (h : i < n + 1) → α (i + 1) ⋯ → α i ⋯) → (init : α (n + 1) ⋯) → motive n.succ f init),
(match n.succ, α, f, init with
| 0, α, f, init => h_1 α f init
| n.succ, α, f, init => h_2 n α f init) =
h_2 n α f init | true |
Std.DTreeMap.Internal.Impl.maxKeyD_alter_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α},
(Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.isEmpty = false →
((Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.maxKeyD fallback = k ↔
(f (t.get? k)).isSome = true ∧ ∀ k' ∈ t, (compare k' k).isLE = true) | true |
_private.Mathlib.Topology.GDelta.Basic.0.isMeagre_biUnion.match_1_1 | Mathlib.Topology.GDelta.Basic | ∀ {ι : Type u_1} {I : Set ι} (motive : ↑I → Prop) (h : ↑I), (∀ (i : ι) (hi : i ∈ I), motive ⟨i, hi⟩) → motive h | false |
AlgebraicGeometry.SmoothOfRelativeDimension.casesOn | Mathlib.AlgebraicGeometry.Morphisms.Smooth | {n : ℕ} →
{X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.SmoothOfRelativeDimension n f → Sort u_1} →
(t : AlgebraicGeometry.SmoothOfRelativeDimension n f) →
((exists_isStandardSmoothOfRelativeDimension :
∀ (x : ↥X),
∃ U,
∃ (_ : AlgebraicGeometry.IsAffineOpen U),
∃ V,
∃ (_ : AlgebraicGeometry.IsAffineOpen V) (_ : x ∈ V) (e :
V ≤ (TopologicalSpace.Opens.map f.base).obj U),
RingHom.IsStandardSmoothOfRelativeDimension n
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V e))) →
motive ⋯) →
motive t | false |
PUnit.mulSemiringAction | Mathlib.Algebra.Module.PUnit | {R : Type u_1} → [inst : Semiring R] → MulSemiringAction R PUnit.{u_3 + 1} | true |
Std.ExtDHashMap.get!_insertMany_list_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k k' : α} (k_beq : (k == k') = true) {v : β k} [inst_1 : Inhabited (β k')],
List.Pairwise (fun a b => (a.fst == b.fst) = false) l → ⟨k, v⟩ ∈ l → (m.insertMany l).get! k' = cast ⋯ v | true |
Submonoid.LocalizationMap.lift_mk'_spec | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (x : M) (v : P)
(y : ↥S), (f.lift hg) (f.mk' x y) = v ↔ g x = g ↑y * v | true |
Matroid.sigma._proof_3 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_2} {α : ι → Type u_1} (M : (i : ι) → Matroid (α i)) (I : Set ((i : ι) × α i)),
(∀ (i : ι), (M i).Indep (Sigma.mk i ⁻¹' I)) ↔ ∃ B, (∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B)) ∧ I ⊆ B | false |
LLVM.doubleTypeInContext | Lean.Compiler.IR.LLVMBindings | (ctx : LLVM.Context) → BaseIO (LLVM.LLVMType ctx) | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithAndAscendM._auto_1 | Mathlib.Tactic.DefEqAbuse | Lean.Syntax | false |
Int8.toInt16_neg_of_ne | Init.Data.SInt.Lemmas | ∀ {x : Int8}, x ≠ -128 → (-x).toInt16 = -x.toInt16 | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.stx | Lean.Elab.Tactic.Do.Attr | Lean.Name → Lean.Syntax → Lean.Expr → Lean.Elab.Tactic.Do.SpecAttr.SpecProof | true |
Equiv.toHomeomorph_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(he : ∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s) (x : X), (e.toHomeomorph he) x = e x | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0._regBuiltin.Int.reduceNatCast'.declare_170._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1550967516._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
CategoryTheory.StrictPseudofunctorCore | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | (B : Type u₁) →
[CategoryTheory.Bicategory B] →
(C : Type u₂) → [CategoryTheory.Bicategory C] → Type (max (max (max (max (max u₁ u₂) v₁) v₂) w₁) w₂) | true |
Polynomial.cyclotomic_two | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (R : Type u_1) [inst : Ring R], Polynomial.cyclotomic 2 R = Polynomial.X + 1 | true |
Lean.Elab.Tactic.RCases.RCasesPatt.explicit.sizeOf_spec | Lean.Elab.Tactic.RCases | ∀ (ref : Lean.Syntax) (a : Lean.Elab.Tactic.RCases.RCasesPatt),
sizeOf (Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref a) = 1 + sizeOf ref + sizeOf a | true |
Lean.Compiler.LCNF.PullFunDecls.addToPull._unsafe_rec | Lean.Compiler.LCNF.PullFunDecls | Bool → Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.PullFunDecls.PullM Unit | false |
CompactExhaustion.mk.injEq | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (toFun : ℕ → Set X) (isCompact' : ∀ (n : ℕ), IsCompact (toFun n))
(subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))) (iUnion_eq' : ⋃ n, toFun n = Set.univ)
(toFun_1 : ℕ → Set X) (isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n))
(subset_interior_succ'_1 : ∀ (n : ℕ), toFun_1 n ⊆ interior (toFun_1 (n + 1)))
(iUnion_eq'_1 : ⋃ n, toFun_1 n = Set.univ),
({ toFun := toFun, isCompact' := isCompact', subset_interior_succ' := subset_interior_succ',
iUnion_eq' := iUnion_eq' } =
{ toFun := toFun_1, isCompact' := isCompact'_1, subset_interior_succ' := subset_interior_succ'_1,
iUnion_eq' := iUnion_eq'_1 }) =
(toFun = toFun_1) | true |
ENNReal.orderIsoUnitIntervalBirational_apply_coe | Mathlib.Data.ENNReal.Inv | ∀ (x : ENNReal), ↑(ENNReal.orderIsoUnitIntervalBirational x) = (x⁻¹ + 1)⁻¹.toReal | true |
CategoryTheory.Arrow.finite | Mathlib.CategoryTheory.Comma.CardinalArrow | ∀ {C : Type u} [inst : CategoryTheory.SmallCategory C] [CategoryTheory.FinCategory C], Finite (CategoryTheory.Arrow C) | true |
Stream'.WSeq.destruct.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u},
Stream'.WSeq.destruct =
Computation.corec fun s =>
match Stream'.Seq.destruct s with
| none => Sum.inl none
| some (none, s') => Sum.inr s'
| some (some a, s') => Sum.inl (some (a, s')) | true |
SimpleGraph.isClique_map_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {t : Set β},
(SimpleGraph.map (⇑f) G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter.match_1.splitter._sparseCasesOn_3 | Mathlib.Data.List.Lattice | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Array.getElem_reverse | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} (hi : i < xs.reverse.size), xs.reverse[i] = xs[xs.size - 1 - i] | true |
IsAddUnit.coe_liftRight | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_3} {N : Type u_4} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N)
(hf : ∀ (x : M), IsAddUnit (f x)) (x : M), ↑((IsAddUnit.liftRight f hf) x) = f x | true |
SubmonoidClass.instIsDedekindFiniteMonoidSubtypeMem | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : MulOneClass M] [inst_1 : SetLike A M] [hA : SubmonoidClass A M] (S : A)
[IsDedekindFiniteMonoid M], IsDedekindFiniteMonoid ↥S | true |
Lean.Parser.Command.GrindCnstr.isValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | true |
map_restrict_ae_le_map_indicator_ae | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β],
MeasurableSet s → Filter.map f (MeasureTheory.ae (μ.restrict s)) ≤ Filter.map (s.indicator f) (MeasureTheory.ae μ) | true |
Nat.toArray_ric_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, 0 < n → (*...=n).toArray = (*...=n - 1).toArray.push n | true |
CategoryTheory.kernelUnopUnop_inv | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {A B : Cᵒᵖ}
(g : A ⟶ B),
(CategoryTheory.kernelUnopUnop g).inv =
CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯ | true |
CasesAltInfo.default.noConfusion | Lean.Meta.CasesInfo | {P : Sort u} →
{numHyps numHyps' : ℕ} → CasesAltInfo.default numHyps = CasesAltInfo.default numHyps' → (numHyps = numHyps' → P) → P | false |
Homotopy.mkCoinductiveAux₁.congr_simp | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero zero_1 : P.X 1 ⟶ Q.X 0) (e_zero : zero = zero_1)
(one one_1 : P.X 2 ⟶ Q.X 1) (e_one : one = one_1)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) + CategoryTheory.CategoryStruct.comp (P.d 1 2) one)
(succ succ_1 :
(n : ℕ) →
(p :
(f : P.X (n + 1) ⟶ Q.X n) ×'
(f' : P.X (n + 2) ⟶ Q.X (n + 1)) ×'
e.f (n + 1) =
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) +
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f') →
(f'' : P.X (n + 3) ⟶ Q.X (n + 2)) ×'
e.f (n + 2) =
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) +
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 3)) f''),
succ = succ_1 →
∀ (n : ℕ),
Homotopy.mkCoinductiveAux₁ e zero one comm_one succ n = Homotopy.mkCoinductiveAux₁ e zero_1 one_1 ⋯ succ_1 n | true |
Interval.inv_bot | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : CommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedMonoid α], ⊥⁻¹ = ⊥ | true |
Affine.Simplex.PointsWithCircumcenterIndex._sizeOf_1 | Mathlib.Geometry.Euclidean.Circumcenter | {n : ℕ} → Affine.Simplex.PointsWithCircumcenterIndex n → ℕ | false |
GradedAlgHom.ext_iff | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_6} {B : Type u_7} {ι : Type u_10} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ]
{f₁ f₂ : 𝒜 →ₐᵍ[R] ℬ}, f₁ = f₂ ↔ ∀ (x : A), f₁ x = f₂ x | true |
Mathlib.Tactic.BicategoryLike.AtomIso.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.AtomIso | false |
Polynomial.derivative'._proof_2 | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : Polynomial R),
Polynomial.derivative (x + x_1) = Polynomial.derivative x + Polynomial.derivative x_1 | false |
Set.pi_univ_Ioi_subset | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i) [Nonempty ι],
(Set.univ.pi fun i => Set.Ioi (x i)) ⊆ Set.Ioi x | true |
_private.Mathlib.Algebra.Category.AlgCat.Basic.0.AlgCat.Hom.mk.injEq | Mathlib.Algebra.Category.AlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : AlgCat R} (hom' hom'_1 : ↑A →ₐ[R] ↑B),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | true |
Subgroup.IsComplement.equiv | Mathlib.GroupTheory.Complement | {G : Type u_1} → [inst : Group G] → {S T : Set G} → Subgroup.IsComplement S T → G ≃ ↑S × ↑T | true |
CategoryTheory.MorphismProperty.IsMultiplicative.toIsStableUnderComposition | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W : CategoryTheory.MorphismProperty C}
[self : W.IsMultiplicative], W.IsStableUnderComposition | true |
Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
l.contains k = false →
Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯) = true →
Std.DTreeMap.Internal.Impl.contains k t = true | true |
UInt32.eq_iff_toBitVec_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a = b ↔ a.toBitVec = b.toBitVec | true |
CategoryTheory.Bicategory.eqToHomTransIso_refl_right | Mathlib.CategoryTheory.Bicategory.EqToHom | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {x y : B} (e₁ : x = y),
CategoryTheory.Bicategory.eqToHomTransIso e₁ ⋯ =
(CategoryTheory.Bicategory.rightUnitor (CategoryTheory.eqToHom e₁)).symm | true |
Matrix.diag_neg | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : Neg α] (A : Matrix n n α), (-A).diag = -A.diag | true |
CategoryTheory.DifferentialObject.shiftFunctorAdd_hom_app_f | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_1} [inst : AddCommGroupWithOne S] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (m n : S)
(X : CategoryTheory.DifferentialObject S C),
((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).hom.app X).f =
(CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj | true |
SimpleGraph.edgeSet | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → SimpleGraph V → Set (Sym2 V) | true |
LinearMap.addCommGroup._proof_8 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {M : Type u_3} {N₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommGroup N₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ N₂] {σ₁₂ : R₁ →+* R₂}
(x : M →ₛₗ[σ₁₂] N₂) (x_1 : ℤ), ⇑(x_1 • x) = ⇑(x_1 • x) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.