name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.HashSet.«term_~m_» | Std.Data.HashSet.Basic | Lean.TrailingParserDescr | true |
_private.Mathlib.NumberTheory.Padics.PadicVal.Basic.0.padicValNat_add_le_self._proof_1_5 | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p a : ℕ}, p < a → 0 + p ≤ a | false |
CategoryTheory.Pseudofunctor.recOn | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.Pseudofunctor B C → Sort u} →
(t : CategoryTheory.Pseudofunctor B C) →
((toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C) →
... | false |
Mathlib.Tactic.LinearCombination'.c_sub_pf | Mathlib.Tactic.LinearCombination' | ∀ {α : Type u_1} {b c : α} [inst : Sub α], b = c → ∀ (a : α), a - b = a - c | true |
Qq.Impl.mkNAryFunctionType | Qq.Match | ℕ → Lean.MetaM Lean.Expr | true |
Representation.finsupp._proof_1 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_3} {G : Type u_4} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_1} [inst_2 : AddCommMonoid A]
[inst_3 : Module k A] (ρ : Representation k G A) (α : Type u_2) (x : α) (x_1 : A),
(((Finsupp.lsum k) fun i => Finsupp.lsingle i ∘ₗ ρ 1) fun₀ | x => x_1) = 1 fun₀ | x => x_1 | false |
ContinuousOn.finSnoc | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} [inst : TopologicalSpace α] {n : ℕ} {X : Fin (n + 1) → Type u_5}
[inst_1 : (i : Fin (n + 1)) → TopologicalSpace (X i)] {f : α → (j : Fin n) → X j.castSucc} {g : α → X (Fin.last n)}
{s : Set α}, ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun a => Fin.snoc (f a) (g a)) s | true |
Equiv.restrictPreimageFinset | Mathlib.Data.Finset.Preimage | {α : Type u} → {β : Type v} → (e : α ≃ β) → (s : Finset β) → ↥(s.preimage ⇑e ⋯) ≃ ↥s | true |
LieSubmodule.add_eq_sup | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), N + N' = N ⊔ N' | true |
ComplexShape.Embedding.liftExtend | Mathlib.Algebra.Homology.Embedding.HomEquiv | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
(e : c.Embedding c') →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheor... | true |
CategoryTheory.Limits.WidePullbackCone.reindex._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {X : C} {Y : ι → C}
{f : (i : ι) → Y i ⟶ X} (s : CategoryTheory.Limits.WidePullbackCone f) {ι' : Type u_4} (e : ι' ≃ ι) (i : ι'),
CategoryTheory.CategoryStruct.comp ((fun i => s.π (e i)) i) (f (e i)) = s.base | false |
Filter.HasBasis.lift'_interior | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Sort v} {l : Filter X} {p : ι → Prop} {s : ι → Set X},
l.HasBasis p s → (l.lift' interior).HasBasis p fun i => interior (s i) | true |
_private.Mathlib.Tactic.Says.0.Mathlib.Tactic.Says.evalTacticCapturingTryThis.match_13 | Mathlib.Tactic.Says | (motive : Mathlib.Tactic.withResetServerInfo.Result Unit → Sort u_1) →
(__discr : Mathlib.Tactic.withResetServerInfo.Result Unit) →
((result? : Option Unit) →
(msgs : Lean.MessageLog) →
(trees : Lean.PersistentArray Lean.Elab.InfoTree) →
motive { result? := result?, msgs := msgs, tre... | false |
Lean.Elab.Deriving.Context.typeInfos | Lean.Elab.Deriving.Util | Lean.Elab.Deriving.Context → Array Lean.InductiveVal | true |
_private.Mathlib.Control.Traversable.Instances.0.List.next?.match_1.eq_2 | Mathlib.Control.Traversable.Instances | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | true |
CategoryTheory.Abelian.imageFunctor | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C | true |
CategoryTheory.BasedNatTrans | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{𝒳 : CategoryTheory.BasedCategory 𝒮} →
{𝒴 : CategoryTheory.BasedCategory 𝒮} →
CategoryTheory.BasedFunctor 𝒳 𝒴 → CategoryTheory.BasedFunctor 𝒳 𝒴 → Type (max u₂ v₃) | true |
_private.Aesop.Script.StructureDynamic.0.Aesop.Script.structureDynamicCore.applyStepAndSolveRemaining.match_5 | Aesop.Script.StructureDynamic | (motive : Lean.Meta.SavedState × List Lean.MVarId → Sort u_1) →
(__discr : Lean.Meta.SavedState × List Lean.MVarId) →
((postState : Lean.Meta.SavedState) → (postGoals : List Lean.MVarId) → motive (postState, postGoals)) →
motive __discr | false |
Batteries.RBNode.WF_iff | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α},
Batteries.RBNode.WF cmp t ↔ Batteries.RBNode.Ordered cmp t ∧ ∃ c n, t.Balanced c n | true |
_private.Mathlib.Data.List.Lattice.0.List.count_bagInter._proof_1_9 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (a_1 : α) (l₂ : List α) (h_1 : List.elem a_1 l₂ = true) (h_6 : a_1 = a),
(List.findIdxs (fun x => decide (x = a)) l₂)[0] < l₂.length | false |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Grind.AC.Seq.findSimpAC?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.AC.Eq | {motive : Lean.Grind.AC.SubsetResult → Sort u} →
(t : Lean.Grind.AC.SubsetResult) →
motive Lean.Grind.AC.SubsetResult.false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ObjectProperty.IsSerreClass.recOn | Mathlib.CategoryTheory.Abelian.SerreClass.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsSerreClass → Sort u_1} →
(t : P.IsSerreClass) →
([toContainsZero : P.ContainsZero] →
[toIsClosedUnderSubobjects... | false |
ClusterPt.top | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X}, ClusterPt x ⊤ | true |
NumberField.mixedEmbedding.convexBodySum_neg_mem | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ) {x : NumberField.mixedEmbedding.mixedSpace K},
x ∈ NumberField.mixedEmbedding.convexBodySum K B → -x ∈ NumberField.mixedEmbedding.convexBodySum K B | true |
AddGrpCat.of.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ (M : Type u) [inst : AddGroup M], AddGrpCat.of M = { carrier := M, str := inst } | true |
HomotopicalAlgebra.RelativeCellComplex.Cells.j | Mathlib.AlgebraicTopology.RelativeCellComplex.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w'} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
{α : J → Type t} →
{A B : (j : J) → α j → C} →
{ba... | true |
IsIsotypicOfType.of_linearEquiv_type | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} {N : Type u_3} {S : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup S] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R S],
IsIsotypicOfType R M S → ∀ (e : S ≃ₗ[R] N), IsIsotypicOfType R M N | true |
Lean.ParseImports.Parser | Lean.Elab.ParseImportsFast | Type | true |
ZNum.add_zero | Mathlib.Data.Num.ZNum | ∀ (n : ZNum), n + 0 = n | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.Pos.splits_next_right._simp_1_1 | Init.Data.String.Lemmas.Splits | ∀ {s₁ s₂ s₃ : String}, s₁ ++ (s₂ ++ s₃) = s₁ ++ s₂ ++ s₃ | false |
BoxIntegral.TaggedPrepartition.embedBox.congr_simp | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_1} (I J : BoxIntegral.Box ι) (h : I ≤ J),
BoxIntegral.TaggedPrepartition.embedBox I J h = BoxIntegral.TaggedPrepartition.embedBox I J h | true |
Lean.Data.AC.insert._unsafe_rec | Init.Data.AC | ℕ → List ℕ → List ℕ | false |
inv_intCast_smul_comm | Mathlib.Algebra.Module.Basic | ∀ {α : Type u_5} {E : Type u_6} (R : Type u_7) [inst : AddCommGroup E] [inst_1 : DivisionRing R] [inst_2 : Module R E]
[inst_3 : DistribSMul α E] (n : ℤ) (s : α) (x : E), (↑n)⁻¹ • s • x = s • (↑n)⁻¹ • x | true |
NonUnitalNonAssocSemiring.mk | Mathlib.Algebra.Ring.Defs | {α : Type u} →
[toAddCommMonoid : AddCommMonoid α] →
[toMul : Mul α] →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
(∀ (a b c : α), (a + b) * c = a * c + b * c) →
(∀ (a : α), 0 * a = 0) → (∀ (a : α), a * 0 = 0) → NonUnitalNonAssocSemiring α | true |
_private.Mathlib.GroupTheory.PushoutI.0.Monoid.PushoutI.NormalWord.eq_one_of_smul_normalized._simp_1_3 | Mathlib.GroupTheory.PushoutI | ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) | false |
CategoryTheory.ProjectiveResolution.congr_simp | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (Z Z_1 : C),
Z = Z_1 → CategoryTheory.ProjectiveResolution Z = CategoryTheory.ProjectiveResolution Z_1 | true |
ValuationSubring.subMulAction._proof_1 | Mathlib.RingTheory.Valuation.RamificationGroup | ∀ (K : Type u_2) {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (A : ValuationSubring L)
(g : ↥(ValuationSubring.decompositionSubgroup K A)), ∀ x ∈ ↑A, g • x ∈ ↑A | false |
CategoryTheory._aux_Mathlib_CategoryTheory_Adjunction_Parametrized___unexpand_CategoryTheory_ParametrizedAdjunction_1 | Mathlib.CategoryTheory.Adjunction.Parametrized | Lean.PrettyPrinter.Unexpander | false |
Set.eq_empty_of_forall_notMem | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s : Set α}, (∀ (x : α), x ∉ s) → s = ∅ | true |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_5 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.process._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Problem → StateRefT' IO.RealWorld Lean.Meta.Match.State Lean.MetaM Unit | false |
Lean.Meta.Grind.Arith.Cutsat.State.elimEqs | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.State → Lean.PArray (Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) | true |
bihimp_eq_bot | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b : α), bihimp a b = ⊥ ↔ IsCompl a b | true |
CochainComplex.single₀.congr_simp | Mathlib.Algebra.Homology.Single | ∀ (V : Type u) [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V], CochainComplex.single₀ V = CochainComplex.single₀ V | true |
AffineMap.instAdd._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_4} {V1 : Type u_3} {P1 : Type u_2} {V2 : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2]
(f g : P1 →ᵃ[k] V2) (p : P1) (v : V1), (⇑f + ⇑g) (v +ᵥ p) = (f.linear + g.linear) v +ᵥ (⇑f + ⇑g) p | false |
CategoryTheory.MorphismProperty.cancel_left_of_respectsIso | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [hP : P.RespectsIso]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso f], P (CategoryTheory.CategoryStruct.comp f g) ↔ P g | true |
SSet.Truncated.Quasicategory₂.mk | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | ∀ {X : SSet.Truncated 2},
(∀
{x₀ x₁ x₂ :
X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Quasicategory₂._proof_1 })}
(e₀₁ : SSet.Truncated.Edge x₀ x₁) (e₁₂ : SSet.Truncated.Edge x₁ x₂),
Nonempty ((e₀₂ : SSet.Truncated.Edge x₀ x₂) × e₀₁.CompStruct e₁₂ e₀₂)) →
... | true |
Ordering.isLT_swap | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.swap.isLT = o.isGT | true |
Int64.toISize_or | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ||| b).toISize = a.toISize ||| b.toISize | true |
CategoryTheory.Subobject.factorThru | Mathlib.CategoryTheory.Subobject.FactorThru | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
(P : CategoryTheory.Subobject Y) → (f : X ⟶ Y) → P.Factors f → (X ⟶ CategoryTheory.Subobject.underlying.obj P) | true |
Order.Coframe.MinimalAxioms.lt._inherited_default | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → (α → α → Prop) → α → α → Prop | false |
Finsupp.lcomapDomain | Mathlib.LinearAlgebra.Finsupp.Defs | {α : Type u_1} →
{M : Type u_2} →
{R : Type u_5} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {β : Type u_9} → (f : α → β) → Function.Injective f → (β →₀ M) →ₗ[R] α →₀ M | true |
ValuativeRel.instLinearOrderedCommGroupWithZeroValueGroupWithZero._proof_3 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (a : ValuativeRel.ValueGroupWithZero R),
zpowRec npowRec 0 a = 1 | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.One.0.CategoryTheory.PreOneHypercover.sieve₁_inter.match_1_3 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] {i j : E.I₀ × F.I₀} {W : C}
{p₁ : W ⟶ CategoryTheory.Limits.pullback (E.f i.1) (F.f i.2)}
{p₂ : W ⟶ CategoryTheory.... | false |
LocalizedModule.smul'_mul | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {T : Type u_1} [inst_1 : CommSemiring T] [inst_2 : Algebra R T]
[inst_3 : IsLocalization S T] {A : Type u_2} [inst_4 : Semiring A] [inst_5 : Algebra R A] (x : T)
(p₁ p₂ : LocalizedModule S A), x • p₁ * p₂ = x • (p₁ * p₂) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Util.0.Lean.Grind.Linarith.Poly.pickVarToElim?.go._sunfold | Lean.Meta.Tactic.Grind.Arith.Linear.Util | ℤ → Lean.Grind.Linarith.Var → Lean.Grind.Linarith.Poly → ℤ × Lean.Grind.Linarith.Var | false |
csInf_one | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : ConditionallyCompleteLattice M] [inst_1 : One M], sInf 1 = 1 | true |
Lean.Widget.RpcEncodablePacket.mk.injEq._@.Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ (kind info kind_1 info_1 : Lean.Json),
({ kind := kind, info := info } = { kind := kind_1, info := info_1 }) = (kind = kind_1 ∧ info = info_1) | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.isMatchCongrEqConst._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Std.DTreeMap.Internal.Impl.head?_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderOrd α] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α] [Std.LawfulEqOrd α],
t.WF → t.keys.head? = t.minKey? | true |
toIcoDiv_sub' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoDiv hp (a - p) b = toIcoDiv hp a b + 1 | true |
Filter.eventually_pi | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {p : (i : ι) → α i → Prop} [Finite ι],
(∀ (i : ι), ∀ᶠ (x : α i) in f i, p i x) → ∀ᶠ (x : (i : ι) → α i) in Filter.pi f, ∀ (i : ι), p i (x i) | true |
Lean.Grind.IntModule.OfNatModule.nsmul | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] → ℕ → Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α | true |
CategoryTheory.Presheaf.coherentExtensiveEquivalence_counitIso_hom_app_hom_app | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] [inst_2 : CategoryTheory.Preregular C]
[inst_3 : CategoryTheory.FinitaryExtensive C] [inst_4 : ∀ (X : C), CategoryTheory.Projective X]
(X : CategoryTheory.Sheaf (CategoryTheory.extensiveTopol... | true |
Profinite.exists_lift_of_finite_of_injective_of_surjective | Mathlib.Topology.Category.LightProfinite.Injective | ∀ {X : Type u_1} {Y : Type u_2} {S : Type u_3} {T : Type u_4} [inst : TopologicalSpace X] [CompactSpace X]
[inst_2 : TopologicalSpace Y] [CompactSpace Y] [T2Space Y] [TotallyDisconnectedSpace Y] [inst_6 : TopologicalSpace S]
[T2Space S] [Finite S] [inst_9 : TopologicalSpace T] [T2Space T] (f : X → Y),
Continuous ... | true |
_private.Mathlib.RingTheory.MvPolynomial.Expand.0.MvPolynomial.map_iterateFrobenius_expand._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] (p : ℕ) (f : R →+* S)
(φ : MvPolynomial σ R),
(MvPolynomial.expand p) ((MvPolynomial.map f) φ) = (MvPolynomial.map f) ((MvPolynomial.expand p) φ) | false |
Std.Do.WP.readThe_MonadReaderOf | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ρ : Type u} {Q : Std.Do.PostCond ρ ps} [inst : MonadReaderOf ρ m]
[inst_1 : Std.Do.WP m ps], (Std.Do.wp (readThe ρ)).apply Q = (Std.Do.wp MonadReaderOf.read).apply Q | true |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.exists_notMem_dvd_algebraMap_of_primesOver_eq_singleton._simp_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (a ∣ b) = ∃ c, b = a * c | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_384 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
FreeSemigroup.of_tail | Mathlib.Algebra.Free | ∀ {α : Type u} (x : α), (FreeSemigroup.of x).tail = [] | true |
AlgebraicGeometry.Scheme.Cover.add._proof_1 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X Y : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (f : Y ⟶ X),
P f → (𝒰.add f).presieve₀ ∈ (AlgebraicGeometry.Scheme.precoverage P).coverings X | false |
Int16.zero_ne_one | Init.Data.SInt.Lemmas | 0 ≠ 1 | true |
Wbtw.sameRay_vsub_left | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {x y z : P},
Wbtw R x y z → SameRay R (y -ᵥ x) (z -ᵥ x) | true |
isometry_iff_nndist_eq | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f ↔ ∀ (x y : α), nndist (f x) (f y) = nndist x y | true |
Lean.addProjectionFnInfo | Lean.ProjFns | Lean.Environment → Lean.Name → Lean.Name → ℕ → ℕ → Bool → Lean.Environment | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.Mathlib.Meta.Positivity.evalMulNorm._sparseCasesOn_7 | Mathlib.Analysis.Normed.Group.Basic | {α : Type u} →
{motive : Lean.LOption α → Sort u_1} →
(t : Lean.LOption α) → ((a : α) → motive (Lean.LOption.some a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Nat.le_of_sub_eq_zero | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n - m = 0 → n ≤ m | true |
MvPowerSeries.coeff_truncFinset_of_mem | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} {x : σ →₀ ℕ} (p : MvPowerSeries σ R),
x ∈ s → MvPolynomial.coeff x ((MvPowerSeries.truncFinset R s) p) = (MvPowerSeries.coeff x) p | true |
Lean.Doc.Inline.other.noConfusion | Lean.DocString.Types | {i : Type u} →
{P : Sort u_1} →
{container : i} →
{content : Array (Lean.Doc.Inline i)} →
{container' : i} →
{content' : Array (Lean.Doc.Inline i)} →
Lean.Doc.Inline.other container content = Lean.Doc.Inline.other container' content' →
(container ≍ container' → co... | false |
CategoryTheory.ForgetEnrichment.of.eq_1 | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ {C : Type u₁} (W : Type v) [inst : CategoryTheory.Category.{w, v} W] [inst_1 : CategoryTheory.MonoidalCategory W]
[inst_2 : CategoryTheory.EnrichedCategory W C] (X : C), CategoryTheory.ForgetEnrichment.of W X = X | true |
Equiv.symm_subLeft | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddCommGroup G] (a : G), (Equiv.subLeft a).symm = Equiv.subLeft a | true |
Lean.Firefox.Profile.libs | Lean.Util.Profiler | Lean.Firefox.Profile → Array Lean.Json | true |
List.Nodup | Init.Data.List.Basic | {α : Type u} → List α → Prop | true |
eq_inv_iff_mul_eq_one | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a = b⁻¹ ↔ a * b = 1 | true |
Option.isEqSome.match_1 | Init.Data.Option.Basic | {α : Type u_1} →
(motive : Option α → α → Sort u_2) →
(x : Option α) → (x_1 : α) → ((a b : α) → motive (some a) b) → ((x : α) → motive none x) → motive x x_1 | false |
_private.Std.Time.Date.PlainDate.0.Std.Time.instDecidableEqPlainDate.decEq._proof_5 | Std.Time.Date.PlainDate | ∀ (a : Std.Time.Year.Offset) (a_1 : Std.Time.Month.Ordinal) (a_2 : Std.Time.Day.Ordinal) (a_3 : a.Valid a_1 a_2)
(b : Std.Time.Year.Offset) (b_1 : Std.Time.Month.Ordinal) (b_2 : Std.Time.Day.Ordinal) (b_3 : b.Valid b_1 b_2),
¬a = b →
{ year := a, month := a_1, day := a_2, valid := a_3 } = { year := b, month := ... | false |
Mathlib.Tactic.LibraryRewrite.Rewrite.rec | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Mathlib.Tactic.LibraryRewrite.Rewrite → Sort u} →
((symm : Bool) →
(proof replacement : Lean.Expr) →
(stringLength : ℕ) →
(extraGoals : Array (Lean.MVarId × Lean.BinderInfo)) →
(makesNewMVars : Bool) →
motive
{ symm := symm, proof := proof, r... | false |
AffineMap.coe_add | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2]
(f g : P1 →ᵃ[k] V2), ⇑(f + g) = ⇑f + ⇑g | true |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.IsTangent.eq_orthRadius_or_eq_orthRadius_pointReflection_of_parallel_orthRadius._simp_1_1 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ (V : Type u_2) {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (x y : P), ‖x -ᵥ y‖ = dist x y | false |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_inverse_map_left | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
{X Y :
CategoryTheory.Comma (Categor... | true |
CategoryTheory.Groupoid.ofHomUnique._proof_2 | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (all_unique : {X Y : C} → Unique (X ⟶ Y)) {X Y : C}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp default f = CategoryTheory.CategoryStruct.id Y | false |
AddEquiv.toAddSemigrpIso._proof_4 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Type u_1} [inst : AddSemigroup X] [inst_1 : AddSemigroup Y] (e : X ≃+ Y),
CategoryTheory.CategoryStruct.comp (AddSemigrp.ofHom e.symm.toAddHom) (AddSemigrp.ofHom e.toAddHom) =
CategoryTheory.CategoryStruct.id (AddSemigrp.of Y) | false |
FreeMagma.length_toFreeSemigroup | Mathlib.Algebra.Free | ∀ {α : Type u} (x : FreeMagma α), (FreeMagma.toFreeSemigroup x).length = x.length | true |
AddMonCat.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {P : Sort u_1} → {t t' : AddMonCat} → t = t' → AddMonCat.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C._proof_1_15 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : CommRing R] {S : Finset R} (k : ℕ),
(↑k + 1) * ∑ T ∈ Finset.powersetCard (S.card - (k + 1)) S, ∏ a ∈ T, (Polynomial.X - Polynomial.C a) =
↑(k + 1) * ∑ T ∈ Finset.powersetCard (S.card - (k + 1)) S, ∏ a ∈ T, (Polynomial.X - Polynomial.C a) | false |
QuaternionAlgebra.swapEquiv | Mathlib.Algebra.Quaternion | {R : Type u_3} → (c₁ c₃ : R) → [inst : CommRing R] → QuaternionAlgebra R c₁ 0 c₃ ≃ₐ[R] QuaternionAlgebra R c₃ 0 c₁ | true |
Prod.GameAdd.rec | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop}
{motive : (a a_1 : α × β) → Prod.GameAdd rα rβ a a_1 → Prop},
(∀ {a₁ a₂ : α} {b : β} (a : rα a₁ a₂), motive (a₁, b) (a₂, b) ⋯) →
(∀ {a : α} {b₁ b₂ : β} (a_1 : rβ b₁ b₂), motive (a, b₁) (a, b₂) ⋯) →
∀ {a a_1 : α × β} (t : Prod.GameAdd ... | false |
eventuallyEq_toIocDiv_nhdsGT | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜]
[inst_3 : Archimedean 𝕜] [inst_4 : TopologicalSpace 𝕜] [OrderTopology 𝕜] {p : 𝕜} (hp : 0 < p) (a x : 𝕜),
toIocDiv hp a =ᶠ[nhdsWithin x (Set.Ioi x)] fun x_1 => toIcoDiv hp a x | true |
SimpleGraph.componentComplFunctor._proof_4 | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | ∀ {V : Type u_1} (G : SimpleGraph V) (x : (Finset V)ᵒᵖ),
SimpleGraph.ComponentCompl.hom ⋯ = CategoryTheory.CategoryStruct.id (G.ComponentCompl ↑(Opposite.unop x)) | false |
MvPolynomial.ringKrullDim_of_isNoetherianRing | Mathlib.RingTheory.KrullDimension.Polynomial | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {ι : Type u_2} [Finite ι],
ringKrullDim (MvPolynomial ι R) = ringKrullDim R + ↑(Nat.card ι) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.