name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ENormedAddMonoid.rec | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
[inst : TopologicalSpace E] →
{motive : ENormedAddMonoid E → Sort u} →
([toESeminormedAddMonoid : ESeminormedAddMonoid E] →
(enorm_eq_zero : ∀ (x : E), ‖x‖ₑ = 0 ↔ x = 0) →
motive { toESeminormedAddMonoid := toESeminormedAddMonoid, enorm_eq_zero := enorm_eq_zero }) →
(t : ENormedAddMonoid E) → motive t |
eq_of_forall_lt_iff | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ (c : α), c < a ↔ c < b) → a = b |
CategoryTheory.ShortComplex.HomologyMapData.natTransApp_left | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C}
{F G : CategoryTheory.Functor C D} [inst_4 : F.PreservesZeroMorphisms] [inst_5 : G.PreservesZeroMorphisms]
[inst_6 : F.PreservesLeftHomologyOf S] [inst_7 : G.PreservesLeftHomologyOf S] [inst_8 : F.PreservesRightHomologyOf S]
[inst_9 : G.PreservesRightHomologyOf S] (h : S.HomologyData) (τ : F ⟶ G),
(CategoryTheory.ShortComplex.HomologyMapData.natTransApp h τ).left =
CategoryTheory.ShortComplex.LeftHomologyMapData.natTransApp h.left τ |
CategoryTheory.Limits.preservesLimit_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J Cᵒᵖ)
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimit K.leftOp F],
CategoryTheory.Limits.PreservesLimit K F.leftOp |
UniformEquiv.coe_punitProd | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u) [inst : UniformSpace α], ⇑(UniformEquiv.punitProd α) = Prod.snd |
SeminormedAddCommGroup.toSeminormedAddGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [SeminormedAddCommGroup E] → SeminormedAddGroup E |
Turing.TM2Computable.mk.sizeOf_spec | Mathlib.Computability.TuringMachine.Computable | ∀ {α β αΓ βΓ : Type} {ea : α → List αΓ} {eb : β → List βΓ} {f : α → β} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : SizeOf αΓ] [inst_3 : SizeOf βΓ] (toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ)
(outputsFun :
(a : α) →
Turing.TM2Outputs toTM2ComputableAux.tm (List.map toTM2ComputableAux.inputAlphabet.invFun (ea a))
(some (List.map toTM2ComputableAux.outputAlphabet.invFun (eb (f a))))),
sizeOf { toTM2ComputableAux := toTM2ComputableAux, outputsFun := outputsFun } = 1 + sizeOf toTM2ComputableAux |
GradedRing.projZeroRingHom._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜] (x x_1 : A),
↑(((DirectSum.decompose 𝒜) (x + x_1)) 0) = ↑(((DirectSum.decompose 𝒜) x) 0) + ↑(((DirectSum.decompose 𝒜) x_1) 0) |
UInt16.one_mul | Init.Data.UInt.Lemmas | ∀ (a : UInt16), 1 * a = a |
_private.Lean.Meta.GetUnfoldableConst.0.Lean.Meta.getUnfoldableConstNoEx?._sparseCasesOn_1 | Lean.Meta.GetUnfoldableConst | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBit 7 t.ctorIdx → motive t) → motive t |
CategoryTheory.Functor.mapMon_obj_mon_mul | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (A : CategoryTheory.Mon C),
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F A.X A.X)
(F.map CategoryTheory.MonObj.mul) |
maximal_le_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x y : α} [inst : PartialOrder α], Maximal (fun x => x ≤ y) x ↔ x = y |
differentiableAt_iteratedDerivWithin_cexp | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (n a : ℕ) {s : Set ℂ},
IsOpen s →
∀ {r : ℂ},
r ∈ s → DifferentiableAt ℂ (iteratedDerivWithin a (fun z => Complex.exp (2 * ↑Real.pi * Complex.I * z) ^ n) s) r |
ProofWidgets.ExprPresentationProps.mk.inj | ProofWidgets.Presentation.Expr | ∀ {expr expr_1 : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx}, { expr := expr } = { expr := expr_1 } → expr = expr_1 |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileArg.match_4 | Lean.Compiler.IR.SimpleGroundExpr | (motive : Lean.IR.Arg → Sort u_1) →
(arg : Lean.IR.Arg) →
((var : Lean.IR.VarId) → motive (Lean.IR.Arg.var var)) → (Unit → motive Lean.IR.Arg.erased) → motive arg |
Subsemiring.instSetLike | Mathlib.Algebra.Ring.Subsemiring.Defs | {R : Type u} → [inst : NonAssocSemiring R] → SetLike (Subsemiring R) R |
ModularForm.instGCommRing._proof_7 | Mathlib.NumberTheory.ModularForms.Basic | ∀ (Γ : Subgroup (GL (Fin 2) ℝ)) [inst : Γ.HasDetPlusMinusOne] (x : GradedMonoid (ModularForm Γ)), 1 * x = x |
_private.Mathlib.Data.Stream.Init.0.Stream'.cons.match_1.eq_2 | Mathlib.Data.Stream.Init | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n |
Nat.toArray_toList_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...n).toList.toArray = (m<...n).toArray |
LDL.lowerInv_eq_gramSchmidtBasis | Mathlib.Analysis.Matrix.LDL | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : LinearOrder n] [inst_2 : WellFoundedLT n]
[inst_3 : LocallyFiniteOrderBot n] {S : Matrix n n 𝕜} [inst_4 : Fintype n] (hS : S.PosDef),
LDL.lowerInv hS = ((Pi.basisFun 𝕜 n).toMatrix ⇑(InnerProductSpace.gramSchmidtBasis (Pi.basisFun 𝕜 n))).transpose |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.exactAt_op._proof_1_2 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (m : ℤ), (ComplexShape.up ℤ).prev (-m) = -(m + 1) |
String.Pos.Raw.IsValidForSlice | Init.Data.String.Defs | String.Slice → String.Pos.Raw → Prop |
ChartedSpace.sum_of_nonempty.congr_simp | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} {M' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M'] [cm : ChartedSpace H M] [cm' : ChartedSpace H M'] [inst_3 : Nonempty H],
ChartedSpace.sum_of_nonempty = ChartedSpace.sum_of_nonempty |
SimpleGraph.Walk.IsHamiltonian.congr_simp | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] {G : SimpleGraph α} {a b : α} (p p_1 : G.Walk a b),
p = p_1 → p.IsHamiltonian = p_1.IsHamiltonian |
BilinForm.toMatrixAux | Mathlib.LinearAlgebra.Matrix.BilinearForm | {R₁ : Type u_1} →
{M₁ : Type u_2} →
[inst : CommSemiring R₁] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : Module R₁ M₁] → {n : Type u_5} → (n → M₁) → LinearMap.BilinForm R₁ M₁ →ₗ[R₁] Matrix n n R₁ |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.castSucc_lt_or_lt_succ._simp_1_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {a b : Fin n}, (a < b) = (↑a < ↑b) |
Array.find?_eq_bind_findIdx?_getElem? | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, Array.find? p xs = (Array.findIdx? p xs).bind fun x => xs[x]? |
_private.Mathlib.LinearAlgebra.RootSystem.Reduced.0.RootPairing.pairing_neg_one_neg_four_iff'._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (a = -b) = (-a = b) |
MvPowerSeries.rescale_rescale | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_9} [inst : CommSemiring R] (f : MvPowerSeries σ R) (a b : σ → R),
(MvPowerSeries.rescale b) ((MvPowerSeries.rescale a) f) = (MvPowerSeries.rescale (a * b)) f |
CategoryTheory.Subobject.factors_of_le | Mathlib.CategoryTheory.Subobject.FactorThru | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} {P Q : CategoryTheory.Subobject Y} (f : Z ⟶ Y),
P ≤ Q → P.Factors f → Q.Factors f |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.root_mem_span_int._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(x : M), (x ∈ p.toAddSubmonoid) = (x ∈ p) |
lt_mul_inv_iff_mul_lt._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulRightStrictMono α] {a b c : α}, (c < a * b⁻¹) = (c * b < a) |
instWeaklyLawfulMonadAttachStateRefT'OfLawfulMonad | Init.Control.Lawful.MonadAttach.Instances | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m],
WeaklyLawfulMonadAttach (StateRefT' ω σ m) |
Real.logb_nonneg_iff_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 0 < b → b < 1 → 0 < x → (0 ≤ Real.logb b x ↔ x ≤ 1) |
MvPowerSeries.instAlgebra | Mathlib.RingTheory.MvPowerSeries.Basic | {σ : Type u_1} →
{R : Type u_2} →
{A : Type u_3} → [inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra R (MvPowerSeries σ A) |
PresheafOfModules.Hom.app | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{M₁ M₂ : PresheafOfModules R} → M₁.Hom M₂ → (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X |
_private.Mathlib.Data.ENNReal.Operations.0.ENNReal.toNNReal_iInf._simp_1_1 | Mathlib.Data.ENNReal.Operations | ∀ {ι : Sort u_3} [Nonempty ι] (f : ι → NNReal), ⨅ a, ↑(f a) = ↑(iInf f) |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.Sum.dist_comm | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (x y : X ⊕ Y),
Metric.Sum.dist x y = Metric.Sum.dist y x |
Mathlib.Meta.NormNum.asc_factorial_aux | Mathlib.Tactic.NormNum.NatFactorial | ∀ (n l m a b : ℕ), n.ascFactorial l = a → (n + l).ascFactorial m = b → n.ascFactorial (l + m) = a * b |
Specialization.ofEquiv_specializes_ofEquiv | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a b : Specialization α},
Specialization.ofEquiv a ⤳ Specialization.ofEquiv b ↔ b ≤ a |
Lean.Parser.AliasValue.binary.elim | Lean.Parser.Extension | {α : Type} →
{motive : Lean.Parser.AliasValue α → Sort u} →
(t : Lean.Parser.AliasValue α) →
t.ctorIdx = 2 → ((p : α → α → α) → motive (Lean.Parser.AliasValue.binary p)) → motive t |
posPart_max | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a b : α), (a ⊔ b)⁺ = a⁺ ⊔ b⁺ |
Lean.Parser.Command.theorem | Lean.Parser.Command | Lean.Parser.Parser |
Lean.Elab.instInhabitedTerminationBy | Lean.Elab.PreDefinition.TerminationHint | Inhabited Lean.Elab.TerminationBy |
Std.TreeMap.get?_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ ∪ t₂).get? k = (t₂.get? k).or (t₁.get? k) |
ContinuousAt.comp_of_eq | Mathlib.Topology.Continuous | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Y} {x : X} {y : Y} {g : Y → Z},
ContinuousAt g y → ContinuousAt f x → f x = y → ContinuousAt (g ∘ f) x |
Lean.Parser.Attr.export.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer |
RingCon.instRingQuotient._proof_13 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Ring R] (c : RingCon R) (n : ℕ) (a : c.Quotient),
AddGroupWithOne.zsmul (↑n.succ) a = AddGroupWithOne.zsmul (↑n) a + a |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkAndIntroN.go._sunfold | Lean.Meta.AppBuilder | List Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) |
Std.Iter.forIn_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {n : Type w → Type w''} {o : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Monad o] [LawfulMonad o] [inst_5 : MonadAttach n] [WeaklyLawfulMonadAttach n]
[inst_7 : MonadLiftT n o] [LawfulMonadLiftT n o] [Std.Iterators.Finite α Id] [inst_10 : Std.IteratorLoop α Id o]
[Std.LawfulIteratorLoop α Id o] {it : Std.Iter β} {f : β → n (ULift.{w, 0} Bool)} {init : γ}
{g : β → γ → o (ForInStep γ)},
forIn (Std.Iter.filterM f it) init g =
forIn it init fun out acc => do
let __do_lift ← liftM (f out)
if __do_lift.down = true then g out acc else pure (ForInStep.yield acc) |
_private.Init.GrindInstances.Ring.SInt.0.Lean.Grind.instIsCharPInt8HPowNatOfNat._simp_3 | Init.GrindInstances.Ring.SInt | ∀ {m n : ℕ}, (n % m = 0) = (m ∣ n) |
FreeAddMonoid.toList_ofList | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} (l : List α), FreeAddMonoid.toList (FreeAddMonoid.ofList l) = l |
IsConnected.isPreconnected | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsConnected s → IsPreconnected s |
MeasureTheory.L1.integral | Mathlib.MeasureTheory.Integral.Bochner.L1 | {α : Type u_5} →
{E : Type u_6} →
[inst : NormedAddCommGroup E] →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} → [NormedSpace ℝ E] → [CompleteSpace E] → ↥(MeasureTheory.Lp E 1 μ) → E |
SimplexCategory.diag_subinterval_eq | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (j l : ℕ) (hjl : j + l ≤ n),
CategoryTheory.CategoryStruct.comp (SimplexCategory.diag l) (SimplexCategory.subinterval j l hjl) =
SimplexCategory.intervalEdge j l hjl |
Lean.Grind.instAddUInt64UintOfNatNat | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Add UInt64 (Lean.Grind.IntInterval.uint 64) |
Equiv.pSigmaAssoc._proof_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : α → Sort u_2} (γ : (a : α) → β a → Sort u_3),
Function.LeftInverse (fun x => ⟨⟨x.fst, x.snd.fst⟩, x.snd.snd⟩) fun x => ⟨x.fst.fst, ⟨x.fst.snd, x.snd⟩⟩ |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.glueDist_triangle_inl_inr_inr | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u} {Y : Type v} {Z : Type w} [inst : MetricSpace X] [inst_1 : MetricSpace Y] [Nonempty Z] (Φ : Z → X)
(Ψ : Z → Y) (ε : ℝ) (x : X) (y z : Y),
Metric.glueDist Φ Ψ ε (Sum.inl x) (Sum.inr z) ≤
Metric.glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) + Metric.glueDist Φ Ψ ε (Sum.inr y) (Sum.inr z) |
GaussianInt.toComplex_eq_zero | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ {x : GaussianInt}, GaussianInt.toComplex x = 0 ↔ x = 0 |
CategoryTheory.ShortComplex.Splitting.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Limits.HasZeroObject C] (s : S.Splitting),
s.leftHomologyData.π = 0 |
ContinuousLinearMap.norm_id | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] [NontrivialTopology E], ‖ContinuousLinearMap.id 𝕜 E‖ = 1 |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.addAux.match_1.eq_2 | Mathlib.SetTheory.Ordinal.Notation | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.eq with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_2 () |
PositiveLinearMap.zero_apply | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] (x : E₁), 0 x = 0 |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) |
Metric.AreSeparated.subset_compl_right | Mathlib.Topology.MetricSpace.MetricSeparated | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {s t : Set X}, Metric.AreSeparated s t → s ⊆ tᶜ |
Metric.PiNatEmbed.distDenseSeq | Mathlib.Topology.MetricSpace.PiNat | (X : Type u_3) → [inst : MetricSpace X] → [TopologicalSpace.SeparableSpace X] → ℕ → X → ↑unitInterval |
Aesop.IndexingMode.hyps.inj | Aesop.Index.Basic | ∀ {keys keys_1 : Array Lean.Meta.DiscrTree.Key},
Aesop.IndexingMode.hyps keys = Aesop.IndexingMode.hyps keys_1 → keys = keys_1 |
Std.TreeMap.Raw.unitOfList_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {hd : α} {tl : List α},
Std.TreeMap.Raw.unitOfList (hd :: tl) cmp = (∅.insertIfNew hd ()).insertManyIfNewUnit tl |
Set.image_eq_range | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range fun x => f ↑x |
_private.Mathlib.Algebra.Order.AbsoluteValue.Basic.0.AbsoluteValue.nonpos_iff._simp_1_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) |
_private.Init.Data.List.Impl.0.List.filter.match_1.eq_1 | Init.Data.List.Impl | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () |
IsCyclotomicExtension.fromZetaAut.eq_1 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] {L : Type u_2} {μ : L} [inst_2 : CommRing L]
[inst_3 : IsDomain L] (hμ : IsPrimitiveRoot μ n) [inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L]
(h : Irreducible (Polynomial.cyclotomic n K)),
IsCyclotomicExtension.fromZetaAut hμ h = (IsCyclotomicExtension.autEquivPow L h).symm (ZMod.unitOfCoprime ⋯.choose ⋯) |
Batteries.Tactic.GeneralizeProofs.AState.casesOn | Batteries.Tactic.GeneralizeProofs | {motive : Batteries.Tactic.GeneralizeProofs.AState → Sort u} →
(t : Batteries.Tactic.GeneralizeProofs.AState) →
((generalizations : Array (Lean.Expr × Lean.Expr)) →
(propToProof : Lean.ExprMap Lean.Expr) →
motive { generalizations := generalizations, propToProof := propToProof }) →
motive t |
CategoryTheory.Square | Mathlib.CategoryTheory.Square | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max u v) |
MulEquiv.mulDissociated_preimage._simp_2 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} {β : Type u_2} [inst : CommGroup α] [inst_1 : CommGroup β] {s : Set α} (e : β ≃* α),
MulDissociated (⇑e ⁻¹' s) = MulDissociated s |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.extractKeys.match_3 | Lean.Meta.LazyDiscrTree | {α : Type} →
(motive : MProd (Array α) (Lean.Meta.LazyDiscrTree α) → Sort u_1) →
(r : MProd (Array α) (Lean.Meta.LazyDiscrTree α)) →
((allExtracted : Array α) → (tree : Lean.Meta.LazyDiscrTree α) → motive ⟨allExtracted, tree⟩) → motive r |
Equiv.prodPProd_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₂ : Sort u_3} {β₂ : Sort u_6} {α₁ : Type u_9} {β₁ : Type u_10} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (a : α₁ × β₁),
(ea.prodPProd eb) a = ⟨ea a.1, eb a.2⟩ |
Std.IterM.Total.mk.injEq | Init.Data.Iterators.Consumers.Monadic.Total | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (it it_1 : Std.IterM m β),
({ it := it } = { it := it_1 }) = (it = it_1) |
CategoryTheory.WithTerminal.down_id | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.WithTerminal.down (CategoryTheory.CategoryStruct.id (CategoryTheory.WithTerminal.of X)) =
CategoryTheory.CategoryStruct.id X |
Lean.Lsp.instToJsonDocumentHighlightKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.DocumentHighlightKind → Sort u_1) →
(x : Lean.Lsp.DocumentHighlightKind) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.text) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.read) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.write) → motive x |
LinearMap.IsContPerfPair.casesOn | Mathlib.Topology.Algebra.Module.PerfectPairing | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommGroup N] →
[inst_6 : Module R N] →
[inst_7 : TopologicalSpace N] →
{p : M →ₗ[R] N →ₗ[R] R} →
{motive : p.IsContPerfPair → Sort u} →
(t : p.IsContPerfPair) →
((continuous_uncurry :
Continuous fun x =>
match x with
| (x, y) => (p x) y) →
(bijective_left : Function.Bijective fun x => { toLinearMap := p x, cont := ⋯ }) →
(bijective_right :
Function.Bijective fun y => { toLinearMap := p.flip y, cont := ⋯ }) →
motive ⋯) →
motive t |
HasDerivWithinAt.fun_finset_prod | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι]
{𝔸' : Type u_3} [inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'}
{f' : ι → 𝔸'},
(∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) →
HasDerivWithinAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) s x |
Substring.Raw.next | Init.Data.String.Substring | Substring.Raw → String.Pos.Raw → String.Pos.Raw |
FirstOrder.Language.Theory.Imp | Mathlib.ModelTheory.Equivalence | {L : FirstOrder.Language} → {α : Type w} → {n : ℕ} → L.Theory → L.BoundedFormula α n → L.BoundedFormula α n → Prop |
List.sublist_append_of_sublist_right._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l l₂ l₁ : List α}, l.Sublist l₂ → l.Sublist (l₁ ++ l₂) = True |
spectrum.pow_norm_pow_one_div_tendsto_nhds_spectralRadius | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_2} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] [CompleteSpace A] (a : A),
Filter.Tendsto (fun n => ENNReal.ofReal (‖a ^ n‖ ^ (1 / ↑n))) Filter.atTop (nhds (spectralRadius ℂ a)) |
Set.centralizer_empty | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M], ∅.centralizer = ⊤ |
HomologicalComplex.xPrevIso.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xPrevIso r = CategoryTheory.eqToIso ⋯ |
MvPolynomial | Mathlib.Algebra.MvPolynomial.Basic | Type u_1 → (R : Type u_2) → [CommSemiring R] → Type (max u_2 u_1) |
Quot.lift | Init.Prelude | {α : Sort u} → {r : α → α → Prop} → {β : Sort v} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.liftCochain_v_descCochain_v._proof_1_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n m n' m' : ℤ},
n + 1 = m → m' + 1 = n' → ∀ (p₁ p₂ p₃ : ℤ), p₁ + n = p₂ → p₂ + n' = p₃ → ∀ (q : ℤ), p₁ + m = q → q + m' = p₃ |
ISize.ofInt_neg | Init.Data.SInt.Lemmas | ∀ (a : ℤ), ISize.ofInt (-a) = -ISize.ofInt a |
Lean.Compiler.LCNF.LetValue.pap.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fn : Lean.Name} →
{args : Array (Lean.Compiler.LCNF.Arg pu)} →
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15} →
{fn' : Lean.Name} →
{args' : Array (Lean.Compiler.LCNF.Arg pu)} →
{h' : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15} →
Lean.Compiler.LCNF.LetValue.pap fn args h = Lean.Compiler.LCNF.LetValue.pap fn' args' h' →
(fn = fn' → args ≍ args' → P) → P |
List.maxOn?_id | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [inst_2 : DecidableLE α] [Std.LawfulOrderLeftLeaningMax α]
{xs : List α}, List.maxOn? id xs = xs.max? |
TopCat.instFaithfulUliftFunctor | Mathlib.Topology.Category.TopCat.ULift | TopCat.uliftFunctor.Faithful |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.gcdCoeffs.go._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → ℕ → ℕ |
ZMod.AddAutEquivUnits._proof_2 | Mathlib.Data.ZMod.Aut | ∀ (n : ℕ), IsDedekindFiniteMonoid (ZMod n) |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.withRestoreOrSaveFull.match_1 | Lean.Elab.Term.TermElabM | (motive :
Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)) →
Sort u_1) →
(x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))) →
((old : Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)) →
motive (some old)) →
((x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))) →
motive x) →
motive x |
MeasureTheory.SignedMeasure.im_toComplexMeasure | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (s t : MeasureTheory.SignedMeasure α),
MeasureTheory.ComplexMeasure.im (s.toComplexMeasure t) = t |
LatticeHom.dual._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β],
Function.LeftInverse (fun f => { toSupHom := SupHom.dual.symm f.toInfHom, map_inf' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_inf' := ⋯ } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.