name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.HashMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂)[k]? = none |
CategoryTheory.Limits.pushout.desc.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] (h h_1 : Y ⟶ W) (e_h : h = h_1) (k k_1 : Z ⟶ W) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limits.pushout.desc h k w = CategoryTheory.Limits.pushout.desc h_1 k_1 ⋯ |
Quiver.Path.comp_inj' | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c},
p₁.length = p₂.length → (p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂) |
Finset.prod_coe_sort | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} (s : Finset ι) [inst : CommMonoid M] (f : ι → M), ∏ i, f ↑i = ∏ i ∈ s, f i |
Lean.Grind.CutsatConfig.locals._inherited_default | Init.Grind.Config | Bool |
CStarAlgebra.norm_le_natCast_iff_of_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax |
Matrix.reindex_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, M ∈ Matrix.colStochastic R n → (Matrix.reindex e₁ e₂) M ∈ Matrix.colStochastic R m |
QuadraticMap.zero_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (x : M), 0 x = 0 |
CategoryTheory.Limits.parallelPairOpIso_inv_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : X ⟶ Y),
(CategoryTheory.Limits.parallelPairOpIso f g).inv.app CategoryTheory.Limits.WalkingParallelPair.zero =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.walkingParallelPairOpEquiv.functor.comp (CategoryTheory.Limits.parallelPair f g).op).obj
CategoryTheory.Limits.WalkingParallelPair.zero) |
initFn._@.Mathlib.Tactic.FieldSimp.Attr.4203525765._hygCtx._hyg.2 | Mathlib.Tactic.FieldSimp.Attr | IO Lean.Meta.Simp.SimprocExtension |
Unitary.toUnits_comp_map | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S] [inst_3 : StarMul S]
(f : R →⋆* S), Unitary.toUnits.comp (Unitary.map f).toMonoidHom = (Units.map f.toMonoidHom).comp Unitary.toUnits |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_7 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
Std.Iterators.Types.ArrayIterator.stepAsHetT_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).stepAsHetT =
if x : pos < array.size then pure (Std.IterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos])
else pure Std.IterStep.done |
SimpContFract.of_isContFract | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} (v : K) [inst : Field K] [inst_1 : LinearOrder K] [inst_2 : IsStrictOrderedRing K]
[inst_3 : FloorRing K], (SimpContFract.of v).IsContFract |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
CategoryTheory.Limits.Types.limit_ext_iff | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)}
[inst_1 : CategoryTheory.Limits.HasLimit F] {x y : CategoryTheory.Limits.limit F},
x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y |
Tactic.ComputeAsymptotics.Seq.Stream'.dist_le_one | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (s t : Stream' α), dist s t ≤ 1 |
DivisionMonoid.toInvolutiveInv | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : DivisionMonoid G] → InvolutiveInv G |
Std.Packages.PreorderOfLEArgs.mk.noConfusion | Init.Data.Order.PackageFactories | {α : Type u} →
{P : Sort u_1} →
{le : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE : autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt :
autoParam
(let this := le;
LT α)
Std.Packages.PreorderOfLEArgs.lt._autoParam} →
{beq :
autoParam
(let this := le;
let this := decidableLE;
BEq α)
Std.Packages.PreorderOfLEArgs.beq._autoParam} →
{lt_iff :
autoParam
(let this := le;
let this_1 := lt;
∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a)
Std.Packages.PreorderOfLEArgs.lt_iff._autoParam} →
{decidableLT :
autoParam
(let this := le;
let this := decidableLE;
let this := lt;
have this_1 := lt_iff;
DecidableLT α)
Std.Packages.PreorderOfLEArgs.decidableLT._autoParam} →
{beq_iff_le_and_ge :
autoParam
(let this := le;
let this_1 := decidableLE;
let this_2 := beq;
∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a)
Std.Packages.PreorderOfLEArgs.beq_iff_le_and_ge._autoParam} →
{le_refl :
autoParam
(let this := le;
∀ (a : α), a ≤ a)
Std.Packages.PreorderOfLEArgs.le_refl._autoParam} →
{le_trans :
autoParam
(let this := le;
∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c)
Std.Packages.PreorderOfLEArgs.le_trans._autoParam} →
{le' : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE' :
autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt' :
autoParam
(let this := le';
LT α)
Std.Packages.PreorderOfLEArgs.lt._autoParam} →
{beq' :
autoParam
(let this := le';
let this := decidableLE';
BEq α)
Std.Packages.PreorderOfLEArgs.beq._autoParam} →
{lt_iff' :
autoParam
(let this := le';
let this_1 := lt';
∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a)
Std.Packages.PreorderOfLEArgs.lt_iff._autoParam} →
{decidableLT' :
autoParam
(let this := le';
let this := decidableLE';
let this := lt';
have this_1 := lt_iff';
DecidableLT α)
Std.Packages.PreorderOfLEArgs.decidableLT._autoParam} →
{beq_iff_le_and_ge' :
autoParam
(let this := le';
let this_1 := decidableLE';
let this_2 := beq';
∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a)
Std.Packages.PreorderOfLEArgs.beq_iff_le_and_ge._autoParam} →
{le_refl' :
autoParam
(let this := le';
∀ (a : α), a ≤ a)
Std.Packages.PreorderOfLEArgs.le_refl._autoParam} →
{le_trans' :
autoParam
(let this := le';
∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c)
Std.Packages.PreorderOfLEArgs.le_trans._autoParam} →
{ le := le, decidableLE := decidableLE, lt := lt, beq := beq, lt_iff := lt_iff,
decidableLT := decidableLT, beq_iff_le_and_ge := beq_iff_le_and_ge,
le_refl := le_refl, le_trans := le_trans } =
{ le := le', decidableLE := decidableLE', lt := lt', beq := beq',
lt_iff := lt_iff', decidableLT := decidableLT',
beq_iff_le_and_ge := beq_iff_le_and_ge', le_refl := le_refl',
le_trans := le_trans' } →
(le ≍ le' →
decidableLE ≍ decidableLE' →
lt ≍ lt' → beq ≍ beq' → decidableLT ≍ decidableLT' → P) →
P |
Field.Emb.cardinal_eq_of_isSeparable | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
Cardinal.mk (Field.Emb F E) = (fun c => if Cardinal.aleph0 ≤ c then 2 ^ c else c) (Module.rank F E) |
PowerSeries.exist_eq_span_eq_ncard_of_X_notMem | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal (PowerSeries R)} [I.IsPrime],
PowerSeries.X ∉ I →
∀ {S : Set R},
Ideal.span S = Ideal.map PowerSeries.constantCoeff I →
S.Finite → ∃ T, I = Ideal.span T ∧ T.Finite ∧ T.ncard = S.ncard |
NonUnitalSubalgebraClass.nonUnitalSeminormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : NonUnitalSeminormedRing E] [inst_1 : SetLike S E]
[inst_2 : NonUnitalSubringClass S E] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c |
ProbabilityTheory.integrable_rpow_mul_cexp_of_re_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => ↑(X ω ^ p) * Complex.exp (z * ↑(X ω))) μ |
SkewMonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] {R : Type u_3}
[inst_3 : Semiring R] (f : k →+* R) (g : G →* R),
(∀ {x : k} {y : G}, f (y • x) * g y = g y * f x) →
∀ (x x_1 : SkewMonoidAlgebra k G),
(SkewMonoidAlgebra.liftNC ↑f ⇑g) (x * x_1) =
(SkewMonoidAlgebra.liftNC ↑f ⇑g) x * (SkewMonoidAlgebra.liftNC ↑f ⇑g) x_1 |
CategoryTheory.Limits.reflexivePair.mkNatIso_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C}
(e₀ : F.obj CategoryTheory.Limits.WalkingReflexivePair.zero ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
(e₁ : F.obj CategoryTheory.Limits.WalkingReflexivePair.one ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.one)
(h₁ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left) e₀.hom =
CategoryTheory.CategoryStruct.comp e₁.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_1)
(h₂ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right) e₀.hom =
CategoryTheory.CategoryStruct.comp e₁.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_3)
(h₃ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.reflexion) e₁.hom =
CategoryTheory.CategoryStruct.comp e₀.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.reflexion))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_5)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.mkNatIso e₀ e₁ h₁ h₂ h₃).inv.app x =
match x with
| CategoryTheory.Limits.WalkingReflexivePair.zero => e₀.inv
| CategoryTheory.Limits.WalkingReflexivePair.one => e₁.inv |
Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty ((k, v) :: tl) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany!
(Std.DTreeMap.Internal.Impl.insert! k v Std.DTreeMap.Internal.Impl.empty) tl) |
HahnSeries.SummableFamily.casesOn | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_8} →
{R : Type u_9} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] →
{α : Type u_7} →
{motive : HahnSeries.SummableFamily Γ R α → Sort u} →
(t : HahnSeries.SummableFamily Γ R α) →
((toFun : α → HahnSeries Γ R) →
(isPWO_iUnion_support' : (⋃ a, (toFun a).support).IsPWO) →
(finite_co_support' : ∀ (g : Γ), {a | (toFun a).coeff g ≠ 0}.Finite) →
motive
{ toFun := toFun, isPWO_iUnion_support' := isPWO_iUnion_support',
finite_co_support' := finite_co_support' }) →
motive t |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_pow._proof_1_2 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ} (n : ℕ), (Even (m ^ n) ↔ Even m ∧ n ≠ 0) → (Even (m ^ (n + 1)) ↔ Even m ∧ ¬n + 1 = 0) |
Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadSemiring | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusionType P t t' |
Real.continuousAt_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, ContinuousAt Real.arctan x |
Std.TreeMap.Raw.Equiv.congr_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp},
t₁.Equiv t₂ → (t₁.Equiv t₃ ↔ t₂.Equiv t₃) |
List.Subperm.idxInj.congr_simp | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} (h : xs.Subperm ys) (i i_1 : Fin xs.length),
i = i_1 → h.idxInj i = h.idxInj i_1 |
Algebra.Generators.Hom.toAlgHom_monomial | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra R R']
[inst_7 : Algebra S S'] (f : P.Hom P') (v : ι →₀ ℕ) (r : R),
f.toAlgHom ((MvPolynomial.monomial v) r) = r • v.prod fun x1 x2 => f.val x1 ^ x2 |
Lean.Meta.Grind.EMatch.State.gmt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → ℕ |
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) |
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) fun f => F.map f) =
CategoryTheory.CategoryStruct.comp (fun f => F.map f) ((F.op.comp (CategoryTheory.yoneda.obj (F.obj X))).map f) |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P |
Int.instAdd | Init.Data.Int.Basic | Add ℤ |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__discr : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __discr |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true |
Turing.TM0.Cfg.q | Mathlib.Computability.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp
(SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (SemimoduleCat.of R R)) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (SemimoduleCat.MonoidalCategory.leftUnitor M).hom f |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) (α : Type u_1) (A : α → PSet.{u_1}) (motive : x ∈ PSet.mk α A → Prop) (x_1 : x ∈ PSet.mk α A),
(∀ (a : (PSet.mk α A).Type) (ha : x.Equiv ((PSet.mk α A).Func a)), motive ⋯) → motive x_1 |
CategoryTheory.ShortComplex.leftHomologyOpIso | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
[inst_2 : S.HasRightHomology] → S.op.leftHomology ≅ Opposite.op S.rightHomology |
instIsPartialOrderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], IsPartialOrder α fun x1 x2 => x1 ≤ x2 |
_private.Lean.Data.Json.Basic.0.Lean.Json.beq'._sparseCasesOn_7 | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible._simp_1_3 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b |
CategoryTheory.hasExt_iff_small_ext | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C],
CategoryTheory.HasExt C ↔ ∀ (X Y : C) (n : ℕ), Small.{w', w} (CategoryTheory.Abelian.Ext X Y n) |
instIsInertiaFieldOfIsGaloisGroupSubtypeAlgEquivMemSubgroupInertia | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (K : Type u_2) (L : Type u_3) {B : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : CommRing B] (P : Ideal B) (D : Type u_5) [inst_4 : Field D] [inst_5 : Algebra D L]
[inst_6 : MulSemiringAction Gal(L/K) B] [h : IsGaloisGroup (↥(Ideal.inertia Gal(L/K) P)) D L], IsInertiaField K L P D |
AlgebraicGeometry.Scheme.Hom.normalizationObjIso_hom_val | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U : Y.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationObjIso f hU).hom
(CommRingCat.ofHom
(integralClosure ↑(Y.presheaf.obj (Opposite.op U))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base).obj U)))).val.toRingHom) =
AlgebraicGeometry.Scheme.Hom.appLE (AlgebraicGeometry.Scheme.Hom.toNormalization f)
((TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.Hom.fromNormalization f).base).obj U)
((TopologicalSpace.Opens.map f.base).obj U) ⋯ |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_15 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashMap α (Task Dynamic) → NonScalar |
WithTop.bot_eq_coe._simp_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Bot α] {a : α}, (⊥ = ↑a) = (⊥ = a) |
SemicontinuousAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] (r : α → β → Prop) (x : α),
SemicontinuousAt r x = ∀ (y : β), r x y → ∀ᶠ (x' : α) in nhds x, r x' y |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).inv.hom = α.inv.app c.pt |
Localization.mapToFractionRing._proof_1 | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_3} (K : Type u_1) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_2) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A) (a : A),
(↑↑(IsLocalization.lift ⋯)).toFun ((algebraMap A B) a) = (algebraMap A K) a |
NormedField.edist._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(dist : α → α → ℝ) →
(∀ (x : α), dist x x = 0) →
(∀ (x y : α), dist x y = dist y x) → (∀ (x y z : α), dist x z ≤ dist x y + dist y z) → α → α → ENNReal |
Finset.inter_singleton_of_mem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → s ∩ {a} = {a} |
CategoryTheory.Limits.MultispanShape.prod_R | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ (ι : Type w), (CategoryTheory.Limits.MultispanShape.prod ι).R = ι |
CircularPartialOrder.ctorIdx | Mathlib.Order.Circular | {α : Type u_1} → CircularPartialOrder α → ℕ |
Set.mul_iInter₂_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : Mul α] (s : Set α) (t : (i : ι) → κ i → Set α),
s * ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s * t i j |
Int.getElem?_toList_roc_eq_none_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m<...=n).toList[i]? = none) = ((n - m).toNat ≤ i) |
_private.Mathlib.Algebra.Polynomial.CoeffList.0.Polynomial.coeffList_eraseLead._proof_1_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] {P : Polynomial R},
¬P.natDegree = 0 →
P.eraseLead.degree.succ = P.eraseLead.natDegree + 1 →
P.eraseLead.natDegree ≤ P.natDegree - 1 →
P.natDegree = P.eraseLead.natDegree + 1 + (P.natDegree - P.eraseLead.natDegree - 1) ∧
P.natDegree - P.eraseLead.natDegree - 1 = P.natDegree - P.eraseLead.degree.succ |
_private.Mathlib.Logic.Encodable.Basic.0.Encodable.decidable_good._proof_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} (n : Option α), n = none → none = n |
Set.preimage_const_mul_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b c : α),
(fun x => a * x) ⁻¹' Set.Ioo b c = Set.Ioo (b / a) (c / a) |
HomologicalComplex.evalCompCoyonedaCorepresentative._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {ι : Type u_1} (c : ComplexShape ι) (j : ι) (hj : ∃ k, c.Rel j k), c.Rel j hj.choose |
Quiver.SingleObj.pathToList._sunfold | Mathlib.Combinatorics.Quiver.SingleObj | {α : Type u_1} → {x : Quiver.SingleObj α} → Quiver.Path (Quiver.SingleObj.star α) x → List α |
AlgebraicGeometry.Scheme.Opens.mem_basicOpen_toScheme._simp_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} {V : (↑U).Opens} {r : ↑((↑U).presheaf.obj (Opposite.op V))} {x : ↥U},
(x ∈ (↑U).basicOpen r) = (↑x ∈ X.basicOpen r) |
IsUltrametricDist.algNormOfAlgEquiv_extends | Mathlib.Analysis.Normed.Unbundled.InvariantExtension | ∀ {K : Type u_1} [inst : NormedField K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hu : IsUltrametricDist K] (σ : Gal(L/K)) (x : K),
(IsUltrametricDist.algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ |
ULift.instT5Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T5Space X], T5Space (ULift.{u_3, u_1} X) |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.0.AlgebraicGeometry.homogeneousLocalizationToStalk_stalkToFiberRingHom._simp_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ |
RelIso.mk.sizeOf_spec | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_5} {β : Type u_6} {r : α → α → Prop} {s : β → β → Prop} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : (a a_1 : α) → SizeOf (r a a_1)] [inst_3 : (a a_1 : β) → SizeOf (s a a_1)] (toEquiv : α ≃ β)
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b),
sizeOf { toEquiv := toEquiv, map_rel_iff' := map_rel_iff' } = 1 + sizeOf toEquiv |
OrderedFinpartition.eraseLeft._proof_7 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (i : Fin (c.length - 1)), 0 < c.partSize (Fin.cast ⋯ i.succ) |
CategoryTheory.Functor.closedSieves_map_coe | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J₁ : CategoryTheory.GrothendieckTopology C) {X Y : Cᵒᵖ}
(f : X ⟶ Y) (S : { S // J₁.IsClosed S }),
↑((CategoryTheory.Functor.closedSieves J₁).map f S) = CategoryTheory.Sieve.pullback f.unop ↑S |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_signExtend._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, ¬w ≥ v → v - w = 0 → False |
AddMonoidHom.injective_codRestrict._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f |
List.any_toArray | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, l.toArray.any p = l.any p |
_private.Mathlib.Data.Option.NAry.0.Option.map₂_eq_some_iff._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ},
Option.map₂ f a b = some c ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c |
Lean.Compiler.LCNF.ToMonoM.State.noConfusionType | Lean.Compiler.LCNF.ToMono | Sort u → Lean.Compiler.LCNF.ToMonoM.State → Lean.Compiler.LCNF.ToMonoM.State → Sort u |
_private.Mathlib.Logic.IsEmpty.Basic.0.leftTotal_iff_isEmpty_left._simp_1_2 | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∃ a, p a) = False |
CategoryTheory.NatTrans.ext | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F G : CategoryTheory.Functor C D} {x y : CategoryTheory.NatTrans F G}, x.app = y.app → x = y |
Ordnode.Bounded.mem_lt | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o : WithBot α} {x : α},
t.Bounded o ↑x → Ordnode.All (fun x_1 => x_1 < x) t |
Lean.Meta.MatcherApp.mk._flat_ctor | Lean.Meta.Match.MatcherApp.Basic | ℕ →
ℕ →
Array Lean.Meta.Match.AltParamInfo →
Option ℕ →
Array Lean.Meta.Match.DiscrInfo →
Lean.Meta.Match.Overlaps →
Lean.Name →
Array Lean.Level →
Array Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.MatcherApp |
Real.normedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (a b : ℝ), a + b = b + a |
Units.liftRight._proof_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (g : M → Nˣ),
(∀ (x : M), ↑(g x) = f x) → g 1 = 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.