name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
SeparationQuotient.instSemiring._proof_9 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [inst_2 : IsTopologicalSemiring R] (c : ℕ) (x : R),
SeparationQuotient.mk (c • x) = c • SeparationQuotient.mk x |
_private.Mathlib.Topology.LocallyConstant.Basic.0.LocallyConstant.piecewise._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x : p → α} {y : α},
((if h : p then x h else y) = y) = ∀ (h : p), x h = y |
Real.expPartialHomeomorph._proof_2 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ x ∈ Set.Ioi 0, Real.log x ∈ Set.univ |
AlgebraicGeometry.PresheafedSpace | Mathlib.Geometry.RingedSpace.PresheafedSpace | (C : Type u_1) → [CategoryTheory.Category.{v_1, u_1} C] → Type (max (max (u + 1) u_1) v_1) |
Std.ExtHashSet.getD_inter_of_not_mem_right | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getD k fallback = fallback |
Orientation.definition._proof_7._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | RingHomCompTriple (RingHom.id ℝ) (RingHom.id ℝ) (RingHom.id ℝ) |
CategoryTheory.instNontrivialEndOfSimple | Mathlib.CategoryTheory.Simple | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
[CategoryTheory.Simple X], Nontrivial (CategoryTheory.End X) |
Sum.elim_intCast_intCast | Mathlib.Data.Int.Cast.Pi | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : IntCast γ] (n : ℤ), Sum.elim ↑n ↑n = ↑n |
ContDiffMapSupportedIn.structureMapLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), BoundedAdd (ContinuousMultilinearMap ℝ (fun i => E) F) |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3._arg_pusher | Mathlib.Combinatorics.Enumerative.Composition | ∀ (motive : (n : ℕ) → Composition n → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x)
(rel : (n : ℕ) → Composition n → α → Prop) (n : ℕ) (c : Composition n)
(h_1 :
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
((y : α) → rel blocks.sum { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ } y → β y) →
motive blocks.sum { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ }),
((match (motive := (n : ℕ) → (c : Composition n) → ((y : α) → rel n c y → β y) → motive n c) n, c with
| .(blocks.sum), { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ } => fun x =>
h_1 blocks blocks_pos x)
fun y h => f y) =
match n, c with
| .(blocks.sum), { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ } =>
h_1 blocks blocks_pos fun y h => f y |
FirstOrder.Language.Structure.funMap | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} → {M : Type w} → [self : L.Structure M] → {n : ℕ} → L.Functions n → (Fin n → M) → M |
Std.HashMap.getKey!_ofList_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.HashMap.ofList l).getKey! k = default |
CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom | Mathlib.CategoryTheory.IsomorphismClasses | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {X Y : C}, CategoryTheory.IsIsomorphic X Y ↔ Nonempty (X ⟶ Y) |
instULiftableId | Mathlib.Control.ULiftable | ULiftable Id Id |
Multiset.rel_add_left | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {as₀ as₁ : Multiset α} {bs : Multiset β},
Multiset.Rel r (as₀ + as₁) bs ↔ ∃ bs₀ bs₁, Multiset.Rel r as₀ bs₀ ∧ Multiset.Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁ |
instFromJsonMessageActionItem | Lean.Data.Lsp.Window | Lean.FromJson MessageActionItem |
Metric.mem_closedEBall._simp_1 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, (y ∈ Metric.closedEBall x ε) = (edist y x ≤ ε) |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.bmod_natAbs_add_one._proof_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ x < 0, ¬- -1 - x = ↑(x.natAbs + 1) * 1 → False |
Std.DTreeMap.Internal.Impl.ordered_insert | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α} {v : β k} {l : Std.DTreeMap.Internal.Impl α β}
(hlb : l.Balanced), l.Ordered → (Std.DTreeMap.Internal.Impl.insert k v l hlb).impl.Ordered |
Int.Linear.instBEqPoly.beq._sparseCasesOn_2 | Init.Data.Int.Linear | {motive : Int.Linear.Poly → Sort u} →
(t : Int.Linear.Poly) →
((k : ℤ) → (v : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add k v p)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Std.Roc.size_eq_match_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxc.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[Std.Rxc.IsAlwaysFinite α] [Std.Rxc.LawfulHasSize α],
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some next => if next ≤ r.upper then (next<...=r.upper).size + 1 else 0 |
Mathlib.Tactic.RingNF.nat_rawCast_0 | Mathlib.Tactic.Ring.RingNF | ∀ {R : Type u_1} [inst : CommSemiring R], Nat.rawCast 0 = 0 |
fderiv_finset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸']
{u : Finset ι} {g : ι → E → 𝔸'} [inst_5 : DecidableEq ι] {x : E},
(∀ i ∈ u, DifferentiableAt 𝕜 (g i) x) →
fderiv 𝕜 (fun x => ∏ i ∈ u, g i x) x = ∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • fderiv 𝕜 (g i) x |
Std.DTreeMap.Const.entryAtIdx | Std.Data.DTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} → {β : Type v} → (t : Std.DTreeMap α (fun x => β) cmp) → (n : ℕ) → n < t.size → α × β |
Finsupp.sum_smul_index_semilinearMap' | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ {α : Type u_1} {R : Type u_3} {R₂ : Type u_4} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] {σ : R →+* R₂} {v : α →₀ M} {c : R} {h : α → M →ₛₗ[σ] M₂},
((c • v).sum fun a => ⇑(h a)) = σ c • v.sum fun a => ⇑(h a) |
Valuation.map_add_of_distinct_val | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v x ≠ v y → v (x + y) = max (v x) (v y) |
_private.Mathlib.Algebra.QuadraticAlgebra.Basic.0.QuadraticAlgebra.norm_eq_zero_iff_eq_zero._proof_1_2 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_1} {a b : R} [inst : Field R] {z : QuadraticAlgebra R a b},
z.re ^ 2 = a * z.im * z.im - b * z.re * z.im → ¬z.im = 0 → (-z.re / z.im) ^ 2 = a + b * (-z.re / z.im) |
LinearMap.rTensor_add | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f g : N →ₗ[R] P), LinearMap.rTensor M (f + g) = LinearMap.rTensor M f + LinearMap.rTensor M g |
Lean.Meta.Grind.SimpGoalResult.noConfusion | Lean.Meta.Sym.Grind | {P : Sort u} → {t t' : Lean.Meta.Grind.SimpGoalResult} → t = t' → Lean.Meta.Grind.SimpGoalResult.noConfusionType P t t' |
Sbtw.angle₂₃₁_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P}, Sbtw ℝ p₁ p₂ p₃ → EuclideanGeometry.angle p₂ p₃ p₁ = 0 |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.exists_iff._simp_1_8 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {n : ℕ} {α : Fin (n + 1) → Sort u} {P : ((i : Fin (n + 1)) → α i) → Prop}, (∃ x, P x) = ∃ a v, P (Fin.cons a v) |
Polynomial.degree_gcd_le_right | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] (p : Polynomial R) {q : Polynomial R},
q ≠ 0 → (gcd p q).degree ≤ q.degree |
Matroid.closure_closure_union_closure_eq_closure_union | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X Y : Set α), M.closure (M.closure X ∪ M.closure Y) = M.closure (X ∪ Y) |
List.length_inits | Mathlib.Data.List.Infix | ∀ {α : Type u_1} (l : List α), l.inits.length = l.length + 1 |
NonUnitalSubsemiring.range_snd | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S],
NonUnitalRingHom.srange (NonUnitalRingHom.snd R S) = ⊤ |
Std.Format.ctorElimType | Init.Data.Format.Basic | {motive : Std.Format → Sort u} → ℕ → Sort (max 1 u) |
DirichletCharacter.Odd.not_even | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {S : Type u_2} [inst : CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) [NeZero 2], ψ.Odd → ¬ψ.Even |
CategoryTheory.ShortComplex.RightHomologyMapData._sizeOf_inst | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(φ : S₁ ⟶ S₂) →
(h₁ : S₁.RightHomologyData) →
(h₂ : S₂.RightHomologyData) → [SizeOf C] → SizeOf (CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂) |
Asymptotics.isLittleO_neg_left._simp_1 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{f' : α → E'} {l : Filter α}, (fun x => -f' x) =o[l] g = f' =o[l] g |
NonUnitalSubring.coe_prod._simp_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (s : NonUnitalSubring R)
(t : NonUnitalSubring S), ↑s ×ˢ ↑t = ↑(s.prod t) |
Std.Internal.List.getEntry?_of_mem | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k k' : α}, (k == k') = true → ∀ {v : β k}, ⟨k, v⟩ ∈ l → Std.Internal.List.getEntry? k' l = some ⟨k, v⟩ |
_private.Mathlib.Algebra.Polynomial.PartialFractions.0.Polynomial.mul_prod_pow_inverse_eq_quo_add_sum_rem_mul_pow_inverse._proof_1_1 | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {ι : Type u_1} (n : ι → ℕ) (i : ι) (j : Fin (n i)), ↑j + 1 ≤ n i |
Equiv.Perm.signBijAux | Mathlib.GroupTheory.Perm.Sign | {n : ℕ} → Equiv.Perm (Fin n) → (_ : Fin n) × Fin n → (_ : Fin n) × Fin n |
CategoryTheory.Limits.Multifork.IsLimit.mk | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
{I : CategoryTheory.Limits.MulticospanIndex J C} →
(K : CategoryTheory.Limits.Multifork I) →
(lift : (E : CategoryTheory.Limits.Multifork I) → E.pt ⟶ K.pt) →
(∀ (E : CategoryTheory.Limits.Multifork I) (i : J.L),
CategoryTheory.CategoryStruct.comp (lift E) (K.ι i) = E.ι i) →
(∀ (E : CategoryTheory.Limits.Multifork I) (m : E.pt ⟶ K.pt),
(∀ (i : J.L), CategoryTheory.CategoryStruct.comp m (K.ι i) = E.ι i) → m = lift E) →
CategoryTheory.Limits.IsLimit K |
CategoryTheory.CostructuredArrow.liftQuotient | Mathlib.CategoryTheory.Subobject.Comma | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S : CategoryTheory.Functor C D} →
{T : D} →
{A : CategoryTheory.CostructuredArrow S T} →
(P : CategoryTheory.Subobject (Opposite.op A.left)) →
{q :
S.obj (Opposite.unop (CategoryTheory.Subobject.underlying.obj P)) ⟶
(CategoryTheory.Functor.fromPUnit T).obj A.right} →
CategoryTheory.CategoryStruct.comp (S.map P.arrow.unop) q = A.hom →
CategoryTheory.Subobject (Opposite.op A) |
Std.DHashMap.Const.mem_ofList._simp_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} [EquivBEq α] [LawfulHashable α] {l : List (α × β)} {k : α},
(k ∈ Std.DHashMap.Const.ofList l) = ((List.map Prod.fst l).contains k = true) |
Set.inter_singleton_nonempty._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ∩ {a}).Nonempty = (a ∈ s) |
NonUnitalStarSubalgebra.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : Star A]
[inst_3 : NonUnitalSemiring A] [inst_4 : Module R A] [ContinuousStar A] (s : NonUnitalStarSubalgebra R A) {a : A},
a ∈ closure ↑s → star a ∈ closure ↑s |
Filter.atTop | Mathlib.Order.Filter.AtTopBot.Defs | {α : Type u_3} → [Preorder α] → Filter α |
CategoryTheory.Limits.biproduct.lift_map_assoc | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f g : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
[inst_3 : CategoryTheory.Limits.HasBiproduct g] {P : C} (k : (j : J) → P ⟶ f j) (p : (j : J) → f j ⟶ g j) {Z : C}
(h : ⨁ g ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.lift k)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.map p) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.lift fun j => CategoryTheory.CategoryStruct.comp (k j) (p j)) h |
ContinuousCohomology.homogeneousCochains._proof_2 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R],
(ContinuousCohomology.invariants R G).PreservesZeroMorphisms |
ContinuousInv₀.mk | Mathlib.Topology.Algebra.GroupWithZero | ∀ {G₀ : Type u_4} [inst : Zero G₀] [inst_1 : Inv G₀] [inst_2 : TopologicalSpace G₀],
(∀ ⦃x : G₀⦄, x ≠ 0 → ContinuousAt Inv.inv x) → ContinuousInv₀ G₀ |
hasDerivAt_exp_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} [inst : NontriviallyNormedField 𝕂] [CompleteSpace 𝕂] [CharZero 𝕂] {x : 𝕂},
x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝕂).radius → HasDerivAt NormedSpace.exp (NormedSpace.exp x) x |
Lean.Server.GoToContext.rec | Lean.Server.GoTo | {motive : Lean.Server.GoToContext → Sort u} →
((doc : Lean.Server.DocumentMeta) →
(kind : Lean.Server.GoToKind) →
(infoTree? : Option Lean.Elab.InfoTree) →
(originInfo? : Option Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) →
motive
{ doc := doc, kind := kind, infoTree? := infoTree?, originInfo? := originInfo?,
children := children }) →
(t : Lean.Server.GoToContext) → motive t |
Lean.Elab.Tactic.Omega.Context.recOn | Lean.Elab.Tactic.Omega.OmegaM | {motive : Lean.Elab.Tactic.Omega.Context → Sort u} →
(t : Lean.Elab.Tactic.Omega.Context) → ((cfg : Lean.Meta.Omega.OmegaConfig) → motive { cfg := cfg }) → motive t |
Pi.seminormedCommRing._proof_19 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedCommRing (R i)] (n : ℕ),
IntCast.intCast (Int.negSucc n) = -↑(n + 1) |
Monoid.Coprod.range_eq | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {K : Type u_3} [inst_2 : Group K]
(f : Monoid.Coprod G H →* K), f.range = (f.comp Monoid.Coprod.inl).range ⊔ (f.comp Monoid.Coprod.inr).range |
TwoSidedIdeal.matrix_ringCon | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} (n : Type u_2) [inst : NonUnitalNonAssocRing R] [inst_1 : Fintype n] (I : TwoSidedIdeal R),
(TwoSidedIdeal.matrix n I).ringCon = RingCon.matrix n I.ringCon |
Std.Iter.flatMap.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α β α₂ γ : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterator α₂ Id γ] (f : β → Std.Iter γ)
(it : Std.Iter β), Std.Iter.flatMap f it = Std.Iter.flatMapAfter f it none |
singleton_add_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), {x} + Metric.closedBall 0 δ = Metric.closedBall x δ |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getContext | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr |
PMF.toOuterMeasure_apply_fintype | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (s : Set α) [inst : Fintype α], p.toOuterMeasure s = ∑ x, s.indicator (⇑p) x |
Mathlib.Tactic.Abel.evalNeg | Mathlib.Tactic.Abel | Mathlib.Tactic.Abel.NormalExpr → Mathlib.Tactic.Abel.M (Mathlib.Tactic.Abel.NormalExpr × Lean.Expr) |
ZMod.sq_add_sq | Mathlib.FieldTheory.Finite.Basic | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x : ZMod p), ∃ a b, a ^ 2 + b ^ 2 = x |
CategoryTheory.FreeBicategory.id_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a : CategoryTheory.FreeBicategory B},
CategoryTheory.FreeBicategory.Hom.id a = CategoryTheory.CategoryStruct.id a |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHomRight_hom_inv' | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (x : C) {y z : D} (f : y ⟶ z)
[inst_4 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight x f)
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight x (CategoryTheory.inv f)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj x y) |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents | Mathlib.Tactic.WithoutCDot | Lean.Parser.Parser |
_private.Mathlib.Analysis.Convex.Combination.0.convex_iff_sum_mem._simp_1_3 | Mathlib.Analysis.Convex.Combination | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) |
convexHull_toCone_eq_sInf | Mathlib.Geometry.Convex.Cone.Basic | ∀ {𝕜 : Type u_1} {M : Type u_4} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup M] [inst_4 : Module 𝕜 M] (s : Set M), Convex.toCone ((convexHull 𝕜) s) ⋯ = sInf {t | s ⊆ ↑t} |
top_unique | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, ⊤ ≤ a → a = ⊤ |
PSet.mem_def | Mathlib.SetTheory.ZFC.PSet | ∀ {x y : PSet.{u_1}}, x ∈ y ↔ ∃ b, x.Equiv (y.Func b) |
ProjectiveSpectrum.sup_vanishingIdeal_le | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (t t' : Set (ProjectiveSpectrum 𝒜)),
ProjectiveSpectrum.vanishingIdeal t ⊔ ProjectiveSpectrum.vanishingIdeal t' ≤
ProjectiveSpectrum.vanishingIdeal (t ∩ t') |
instNonUnitalCommCStarAlgebraProd._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} {B : Type u_2} [inst : NonUnitalCommCStarAlgebra A] [inst_1 : NonUnitalCommCStarAlgebra B] (a : A × B),
0 + a = a |
Std.HashMap.getElem_congr | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] |
Complex.sqrt._proof_1 | Mathlib.Analysis.RCLike.Sqrt | (1 + 1).AtLeastTwo |
Subgroup.mem_ofUnits_iff_exists_isUnit | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Subgroup Mˣ) (x : M), x ∈ S.ofUnits ↔ ∃ (h : IsUnit x), h.unit ∈ S |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to0.trCfg.match_1.splitter | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
[inst : Inhabited Γ] →
(motive : Turing.TM1.Cfg Γ Λ σ → Sort u_4) →
(x : Turing.TM1.Cfg Γ Λ σ) →
((l : Option Λ) → (v : σ) → (T : Turing.Tape Γ) → motive { l := l, var := v, Tape := T }) → motive x |
Num.bit0 | Mathlib.Data.Num.Basic | Num → Num |
AddCommGroup.modEq_iff_intModEq._simp_1 | Mathlib.Data.Int.ModEq | ∀ {a b z : ℤ}, (a ≡ b [PMOD z]) = (a ≡ b [ZMOD z]) |
Polynomial.natDegree_map_lt' | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial R},
f p.leadingCoeff = 0 → 0 < p.natDegree → (Polynomial.map f p).natDegree < p.natDegree |
Std.Format.FlattenBehavior.ctorIdx | Init.Data.Format.Basic | Std.Format.FlattenBehavior → ℕ |
Polynomial.roots_eq_of_degree_le_card_of_ne_zero | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R} {S : Finset R},
(∀ x ∈ S, Polynomial.eval x p = 0) → p.degree ≤ ↑S.card → p ≠ 0 → p.roots = S.val |
Std.Iterators.Types.Flatten.instIterator | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[Std.Iterator α m (Std.IterM m β)] →
[Std.Iterator α₂ m β] → Std.Iterator (Std.Iterators.Types.Flatten α α₂ β m) m β |
SemilatticeInf.ext_inf | Mathlib.Order.Lattice | ∀ {α : Type u_1} {A B : SemilatticeInf α}, (∀ (y x : α), y ≤ x ↔ y ≤ x) → ∀ (x y : α), x ⊓ y = x ⊓ y |
List.Vector.sum_add_sum_eq_sum_zipWith | Mathlib.Data.Vector.Zip | ∀ {α : Type u_1} {n : ℕ} [inst : AddCommMonoid α] (x y : List.Vector α n),
x.toList.sum + y.toList.sum = (List.Vector.zipWith (fun x1 x2 => x1 + x2) x y).toList.sum |
intervalIntegral.integral_same | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a : ℝ} {f : ℝ → E}
{μ : MeasureTheory.Measure ℝ}, ∫ (x : ℝ) in a..a, f x ∂μ = 0 |
ONote.NFBelow.below.oadd' | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : (a : ONote) → (a_1 : Ordinal.{0}) → a.NFBelow a_1 → Prop} {e : ONote} {n : ℕ+} {a : ONote}
{eb b : Ordinal.{0}} (a_1 : e.NFBelow eb) (a_2 : a.NFBelow e.repr) (a_3 : e.repr < b),
ONote.NFBelow.below a_1 → motive e eb a_1 → ONote.NFBelow.below a_2 → motive a e.repr a_2 → ONote.NFBelow.below ⋯ |
FreeRing.hom_ext_iff | Mathlib.RingTheory.FreeRing | ∀ {α : Type u} {R : Type v} [inst : Ring R] {f g : FreeRing α →+* R},
f = g ↔ ∀ (x : α), f (FreeRing.of x) = g (FreeRing.of x) |
_private.Mathlib.Combinatorics.Matroid.Minor.Restrict.0.Matroid.restrictIndepMatroid._simp_7 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Maximal P s = (P s ∧ ∀ ⦃t : Set α⦄, P t → s ⊆ t → s = t) |
Lean.Syntax.instForInTopDownOfMonad.loop._unsafe_rec | Lean.Syntax | {m : Type u_1 → Type u_2} →
[Monad m] →
{β : Type u_1} → (Lean.Syntax → β → m (ForInStep β)) → Bool → Lean.Syntax → β → [Inhabited β] → m (ForInStep β) |
div_div_self | Mathlib.Algebra.GroupWithZero.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] (a : G₀), a / (a / a) = a |
RingSeminorm.exists_index_pow_le | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (p : RingSeminorm R),
IsNonarchimedean ⇑p →
∀ (x y : R) (n : ℕ), ∃ m < n + 1, p ((x + y) ^ n) ^ (1 / ↑n) ≤ (p (x ^ m) * p (y ^ (n - m))) ^ (1 / ↑n) |
_private.Mathlib.Topology.Category.Profinite.Nobeling.Span.0.Profinite.NobelingProof.GoodProducts.spanFin._simp_1_3 | Mathlib.Topology.Category.Profinite.Nobeling.Span | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) |
WittVector.wittPolyProdRemainder.congr_simp | Mathlib.RingTheory.WittVector.MulCoeff | ∀ (p p_1 : ℕ) (e_p : p = p_1) [hp : Fact (Nat.Prime p)] (n n_1 : ℕ),
n = n_1 → WittVector.wittPolyProdRemainder p n = WittVector.wittPolyProdRemainder p_1 n_1 |
Lean.Expr.FindStep.noConfusionType | Lean.Util.FindExpr | Sort v✝ → Lean.Expr.FindStep → Lean.Expr.FindStep → Sort v✝ |
Vector.length_iterM | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {n : ℕ} [LawfulMonad m] {xs : Vector β n},
(xs.iterM m).length = pure { down := n } |
Lean.IRPhases.comptime.sizeOf_spec | Lean.Environment | sizeOf Lean.IRPhases.comptime = 1 |
Insert.recOn | Init.Core | {α : Type u} →
{γ : Type v} →
{motive : Insert α γ → Sort u_1} →
(t : Insert α γ) → ((insert : α → γ → γ) → motive { insert := insert }) → motive t |
Std.PRange.instLawfulUpwardEnumerableInt | Init.Data.Range.Polymorphic.Int | Std.PRange.LawfulUpwardEnumerable ℤ |
SimpleGraph.edgeFinset_eq_empty | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {G : SimpleGraph V} [inst : Fintype ↑G.edgeSet], G.edgeFinset = ∅ ↔ G = ⊥ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.