name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Sat.AIG.Fanin.flip | Std.Sat.AIG.Basic | Std.Sat.AIG.Fanin → Bool → Std.Sat.AIG.Fanin |
Bornology.ofDist._proof_4 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} (dist : α → α → ℝ) (z : α), ∃ C, ∀ ⦃x : α⦄, x ∈ {z} → ∀ ⦃y : α⦄, y ∈ {z} → dist x y ≤ C |
_private.Aesop.Forward.State.0.Aesop.ForwardState.enqueuePatSubsts.match_1 | Aesop.Forward.State | (motive : Aesop.ForwardRule × Aesop.Substitution → Sort u_1) →
(x : Aesop.ForwardRule × Aesop.Substitution) →
((r : Aesop.ForwardRule) → (patSubst : Aesop.Substitution) → motive (r, patSubst)) → motive x |
MeasurableSpace.generateMeasurable_eq_rec | Mathlib.MeasureTheory.MeasurableSpace.Card | ∀ {α : Type u} (s : Set (Set α)),
{t | MeasurableSpace.GenerateMeasurable s t} = MeasurableSpace.generateMeasurableRec s (Ordinal.omega 1) |
Aesop.ScriptGenerated.Method.rec | Aesop.Stats.Basic | {motive : Aesop.ScriptGenerated.Method → Sort u} →
motive Aesop.ScriptGenerated.Method.static →
motive Aesop.ScriptGenerated.Method.dynamic → (t : Aesop.ScriptGenerated.Method) → motive t |
List.infix_append'._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), (l₂ <:+: l₁ ++ (l₂ ++ l₃)) = True |
IsStrictOrderedRing.toContinuousInv₀ | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜] [ContinuousMul 𝕜], ContinuousInv₀ 𝕜 |
ProfiniteAddGrp.limitConePtAux._proof_3 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{x : (j : J) → ↑(F.obj j).toProfinite.toTop},
x ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
∀ (x_1 x_2 : J) (π : x_1 ⟶ x_2), (ProfiniteAddGrp.Hom.hom (F.map π)) ((-x) x_1) = (-x) x_2 |
CategoryTheory.SimplicialThickening.mk.sizeOf_spec | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SizeOf J] (as : J), sizeOf { as := as } = 1 + sizeOf as |
IsClosed.upperSemicontinuousAt_indicator | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s : Set α} {x : α} {y : β} [inst_1 : Zero β]
[inst_2 : Preorder β], IsClosed s → 0 ≤ y → UpperSemicontinuousAt (s.indicator fun _x => y) x |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_of_getElem?.match_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} (motive : (∃ (h : i < n), xs[i] = a) → Prop)
(x : ∃ (h : i < n), xs[i] = a), (∀ (w : i < n) (e : xs[i] = a), motive ⋯) → motive x |
Lean.Server.Test.Runner.Client.instFromJsonInfoPopup.fromJson | Lean.Server.Test.Runner | Lean.Json → Except String Lean.Server.Test.Runner.Client.InfoPopup |
ContinuousMultilinearMap.sum_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂] {α : Type u_1} (f : α → ContinuousMultilinearMap R M₁ M₂) (m : (i : ι) → M₁ i)
{s : Finset α}, (∑ a ∈ s, f a) m = ∑ a ∈ s, (f a) m |
IO.FS.Metadata.numLinks | Init.System.IO | IO.FS.Metadata → UInt64 |
FintypeCat.equivEquivIso_symm_apply_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {A B : FintypeCat} (i : A ≅ B) (a : A.obj),
(FintypeCat.equivEquivIso.symm i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a |
Lean.SourceInfo.none.sizeOf_spec | Init.SizeOf | sizeOf Lean.SourceInfo.none = 1 |
ContinuousMultilinearMap.mk.inj | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {inst : Semiring R}
{inst_1 : (i : ι) → AddCommMonoid (M₁ i)} {inst_2 : AddCommMonoid M₂} {inst_3 : (i : ι) → Module R (M₁ i)}
{inst_4 : Module R M₂} {inst_5 : (i : ι) → TopologicalSpace (M₁ i)} {inst_6 : TopologicalSpace M₂}
{toMultilinearMap : MultilinearMap R M₁ M₂} {cont : Continuous toMultilinearMap.toFun}
{toMultilinearMap_1 : MultilinearMap R M₁ M₂} {cont_1 : Continuous toMultilinearMap_1.toFun},
{ toMultilinearMap := toMultilinearMap, cont := cont } = { toMultilinearMap := toMultilinearMap_1, cont := cont_1 } →
toMultilinearMap = toMultilinearMap_1 |
CategoryTheory.Limits.cokernel.condition_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {F : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F X Y) (carrier X) (carrier Y)} [inst_3 : CategoryTheory.ConcreteCategory C F]
(x : carrier X),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.cokernel.π f))
((CategoryTheory.ConcreteCategory.hom f) x) =
(CategoryTheory.ConcreteCategory.hom 0) x |
UniformContinuous.nndist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => nndist (f b) (g b) |
ComplexShape.σ_def | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (p q : ℤ),
TotalComplexShapeSymmetry.σ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (ComplexShape.up ℤ) p q = (p * q).negOnePow |
Submodule.adjoint._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) |
Valued.instFaithfulSMulCompletionOfUniformContinuousConstSMul | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
{R : Type u_3} [inst_2 : CommSemiring R] [inst_3 : Algebra R K] [UniformContinuousConstSMul R K] [FaithfulSMul R K],
FaithfulSMul R (UniformSpace.Completion K) |
Lean.Lsp.CompletionOptions.allCommitCharacters?._default | Lean.Data.Lsp.LanguageFeatures | Option (Array String) |
CircleDeg1Lift.translationNumber_eq_int_iff | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Continuous ⇑f → ∀ {m : ℤ}, f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m |
Std.DTreeMap.Internal.Impl.isEmpty_inter!_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁.inter! m₂).isEmpty = true |
Setoid.eqvGen_of_setoid | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (r : Setoid α), Relation.EqvGen.setoid ⇑r = r |
AlgCat.HasLimits.limitConeIsLimit._proof_14 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget (AlgCat R)).map
(AlgCat.ofHom
{
toFun := fun v =>
EquivLike.coe (equivShrink ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections)
⟨fun j => ((CategoryTheory.forget (AlgCat R)).mapCone s).π.app j v, ⋯⟩,
map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯, commutes' := ⋯ }) =
(CategoryTheory.forget (AlgCat R)).map
(AlgCat.ofHom
{
toFun := fun v =>
EquivLike.coe (equivShrink ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections)
⟨fun j => ((CategoryTheory.forget (AlgCat R)).mapCone s).π.app j v, ⋯⟩,
map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯, commutes' := ⋯ }) |
Lean.Macro.resolveGlobalName | Init.Prelude | Lean.Name → Lean.MacroM (List (Lean.Name × List String)) |
StrongDual.polar_univ | Mathlib.Analysis.LocallyConvex.Polar | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_5} [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E], StrongDual.polar 𝕜 Set.univ = {0} |
Ideal.polynomialQuotientEquivQuotientPolynomial._proof_4 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f g : Polynomial (R ⧸ I)),
(Polynomial.eval₂RingHom (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
(f * g) =
(Polynomial.eval₂RingHom
(Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
f *
(Polynomial.eval₂RingHom
(Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
g |
Lean.Omega.Constraint.isImpossible.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Sort u_1) →
(x : Lean.Omega.Constraint) →
((x y : ℤ) → motive { lowerBound := some x, upperBound := some y }) →
((x : Lean.Omega.Constraint) → motive x) → motive x |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.parserDescrHasAtom._unsafe_rec | Lean.Elab.DocString.Builtin.Keywords | String → Lean.ParserDescr → Lean.Elab.TermElabM (Option Lean.ParserDescr) |
LawfulBitraversable.const | Mathlib.Control.Bitraversable.Instances | LawfulBitraversable Functor.Const |
NormedRing.algEquivComplexOfComplete._proof_7 | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] (r : ℂ),
(↑↑(Algebra.ofId ℂ A).toRingHom).toFun ((algebraMap ℂ ℂ) r) = (algebraMap ℂ A) r |
CategoryTheory.Limits.Trident.IsLimit.mk'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)}
(t : CategoryTheory.Limits.Trident f)
(create :
(s : CategoryTheory.Limits.Trident f) →
{ l //
CategoryTheory.CategoryStruct.comp l t.ι = s.ι ∧
∀
{m :
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelFamily.zero ⟶
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.WalkingParallelFamily.zero},
CategoryTheory.CategoryStruct.comp m t.ι = s.ι → m = l })
(s : CategoryTheory.Limits.Trident f), CategoryTheory.CategoryStruct.comp (↑(create s)) t.ι = s.ι |
trdeg_eq_zero_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {R : Type u_3} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.trdeg R A = 0 ↔ Algebra.IsAlgebraic R A |
Real.floor_pi_eq_three | Mathlib.Analysis.Real.Pi.Bounds | ⌊Real.pi⌋ = 3 |
RingHom.coe_id | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α}, ⇑(RingHom.id α) = id |
instIsLeftCancelAddOrderDual | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [h : IsLeftCancelAdd α], IsLeftCancelAdd αᵒᵈ |
indepFun_pi_of_prod_bcf | Mathlib.Probability.Independence.BoundedContinuousFunction | ∀ {Ω : Type u_1} {T : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {F : T → Type u_5} {G : Type u_6}
[inst : (t : T) → TopologicalSpace (F t)] [inst_1 : (t : T) → MeasurableSpace (F t)] [∀ (t : T), BorelSpace (F t)]
[∀ (t : T), HasOuterApproxClosed (F t)] [inst_4 : TopologicalSpace G] [inst_5 : MeasurableSpace G] [BorelSpace G]
[HasOuterApproxClosed G] {Y : (t : T) → Ω → F t} {Z : Ω → G} [inst_8 : Fintype T] [MeasureTheory.IsFiniteMeasure P],
AEMeasurable Z P →
(∀ (t : T), AEMeasurable (Y t) P) →
(∀ (f : BoundedContinuousFunction G ℝ) (g : (t : T) → BoundedContinuousFunction (F t) ℝ),
∫ (x : Ω), (⇑f ∘ Z * ∏ t, ⇑(g t) ∘ Y t) x ∂P =
(∫ (x : Ω), (⇑f ∘ Z) x ∂P) * ∫ (x : Ω), (∏ t, ⇑(g t) ∘ Y t) x ∂P) →
ProbabilityTheory.IndepFun Z (fun ω t => Y t ω) P |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.size_eq_size_roi._proof_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} [inst : Std.Rxi.HasSize α] (l : α), Std.Rxi.HasSize.size l = 0 → Std.Rxi.HasSize.size l > 0 → False |
exists_continuous_sum_one_of_isOpen_isCompact | Mathlib.Topology.PartitionOfUnity | ∀ {X : Type v} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {n : ℕ} {t : Set X} {s : Fin n → Set X},
(∀ (i : Fin n), IsOpen (s i)) →
IsCompact t →
t ⊆ ⋃ i, s i →
∃ f,
(∀ (i : Fin n), tsupport ⇑(f i) ⊆ s i) ∧
Set.EqOn (∑ i, ⇑(f i)) 1 t ∧
(∀ (i : Fin n) (x : X), (f i) x ∈ Set.Icc 0 1) ∧ ∀ (i : Fin n), HasCompactSupport ⇑(f i) |
AlgebraicGeometry.IsSchemeTheoreticallyDominant.rec | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsSchemeTheoreticallyDominant f → Sort u} →
((ker_eq_bot : AlgebraicGeometry.Scheme.Hom.ker f = ⊥) → motive ⋯) →
(t : AlgebraicGeometry.IsSchemeTheoreticallyDominant f) → motive t |
OmegaCompletePartialOrder.ContinuousHom.mk | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
[inst_1 : OmegaCompletePartialOrder β] →
(toOrderHom : α →o β) →
(∀ (c : OmegaCompletePartialOrder.Chain α),
toOrderHom.toFun (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSup (c.map toOrderHom)) →
α →𝒄 β |
Set.add_mem_Ico_iff_right | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a b c d : α},
a + b ∈ Set.Ico c d ↔ b ∈ Set.Ico (c - a) (d - a) |
Matroid.eRk_union_ground | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk (X ∪ M.E) = M.eRank |
Std.Tactic.BVDecide.BVExpr.decEq._proof_160 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
¬llhs.arithShiftRight lrhs = lhs.shiftRight rhs |
Pi.Lex.instCompleteLinearOrderLexForall._proof_15 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] (a : Lex ((i : ι) → α i)), ⊤ \ a = ￢a |
Matrix.of.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {m : Type u_2} {n : Type u_3} {α : Type v}, Matrix.of = Equiv.refl (m → n → α) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_maxKey!_eq_maxKey._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) |
CauSeq.Completion.Cauchy.divisionRing._proof_9 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : ℚ≥0) (x_1 : CauSeq.Completion.Cauchy abv),
x • x_1 = ↑x * x_1 |
hasProd_one_add_of_hasSum_prod | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommSemiring α] [inst_1 : TopologicalSpace α] {f : ι → α} {a : α},
HasSum (fun x => ∏ i ∈ x, f i) a → HasProd (fun x => 1 + f x) a |
GroupExtension.Section.mul_mul_mul_inv_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), σ g₁ * σ g₂ * (σ (g₁ * g₂))⁻¹ ∈ S.inl.range |
MeasureTheory.instSigmaFiniteQuotientOrbitRelOfHasFundamentalDomainOfQuotientMeasureEqMeasurePreimageVolume | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasureTheory.MeasureSpace α]
[Countable G] [MeasureTheory.SMulInvariantMeasure G α MeasureTheory.volume] [MeasurableConstSMul G α]
[MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasureTheory.HasFundamentalDomain G α MeasureTheory.volume]
(μ : MeasureTheory.Measure (Quotient (MulAction.orbitRel G α)))
[MeasureTheory.QuotientMeasureEqMeasurePreimage MeasureTheory.volume μ], MeasureTheory.SigmaFinite μ |
Lean.Elab.Command.instMonadLiftTIOCommandElabM | Lean.Elab.Command | MonadLiftT IO Lean.Elab.Command.CommandElabM |
AffineMap.differentiableAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {x : 𝕜}, DifferentiableAt 𝕜 (⇑f) x |
GetElem? | Init.GetElem | (coll : Type u) → (idx : Type v) → outParam (Type w) → outParam (coll → idx → Prop) → Type (max (max u v) w) |
pow_lt_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → m < n → a ^ m < a ^ n |
AddMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) |
_private.Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors.0.MvPowerSeries.mem_nonZeroDivisorsRight_of_constantCoeff._simp_1_3 | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {A : Type u_1} {inst : AddMonoid A} [self : Finset.HasAntidiagonal A] {n : A} {a : A × A},
(a ∈ Finset.antidiagonal n) = (a.1 + a.2 = n) |
Lean.Elab.InlayHint.textEdits._inherited_default | Lean.Elab.InfoTree.InlayHints | Array Lean.Elab.InlayHintTextEdit |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {newWidth : ℕ} {aig : Std.Sat.AIG α} {w : ℕ}
(input : aig.RefVec w) (start curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr),
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input start curr hcurr s =
if h : curr < newWidth then
have falseRef := aig.mkConstCached false;
have nextRef := input.getD (start + curr) falseRef;
have s := s.push nextRef;
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input start (curr + 1) ⋯ s
else
have this := ⋯;
this ▸ s |
Polynomial.recOnHorner._proof_10 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1}, M (0 * Polynomial.X) = M 0 |
sup_eq_of_max | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α}
[inst_2 : Nonempty α] {b : β}, b ∈ Set.range D → Function.invFun D b ∈ s → (∀ a ∈ s, D a ≤ b) → s.sup D = b |
LinearMap.IsRefl.liftQ₂._proof_4 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : CommRing R]
[inst_2 : CommRing S] [inst_3 : Module R M] [inst_4 : AddCommGroup P] [inst_5 : Module S P] {I₁ I₂ : R →+* S}
(f : M →ₛₗ[I₁] M →ₛₗ[I₂] P) (N : Submodule R M), f.IsRefl → N ≤ f.ker → N ≤ f.flip.ker |
Cardinal.fact_isRegular_aleph0 | Mathlib.SetTheory.Cardinal.Regular | Fact Cardinal.aleph0.IsRegular |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf.induct_unfolding | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b)
(f : (out : α) → LargeEnough out → (c : γ) → n { s // Pl out c s })
(motive : γ → (next : α) → LargeEnough next → n γ → Prop),
(∀ (acc : γ) (next : α) (h : LargeEnough next),
(∀ (acc' : γ),
Pl next acc (ForInStep.yield acc') →
∀ (next' : α) (hs : Std.PRange.succ? next = some next'),
motive acc' next' ⋯ (Std.Rxi.Iterator.instIteratorLoop.loop.wf✝ γ Pl wf LargeEnough hl acc' next' ⋯ f)) →
motive acc next h do
let __do_lift ← f next h acc
match __do_lift with
| ⟨ForInStep.yield acc', property⟩ =>
match hs : Std.PRange.succ? next with
| some next' => Std.Rxi.Iterator.instIteratorLoop.loop.wf✝¹ γ Pl wf LargeEnough hl acc' next' ⋯ f
| none => pure acc'
| ⟨ForInStep.done acc', property⟩ => pure acc') →
∀ (acc : γ) (next : α) (h : LargeEnough next),
motive acc next h (Std.Rxi.Iterator.instIteratorLoop.loop.wf✝² γ Pl wf LargeEnough hl acc next h f) |
invertibleOfLeftInverse | Mathlib.Algebra.Group.Invertible.Defs | {α : Type u} → [inst : Monoid α] → [IsDedekindFiniteMonoid α] → (a b : α) → b * a = 1 → Invertible a |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleRing.exists_linearEquiv_ideal_of_isSimpleModule.match_1_3 | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_1) [inst : Ring R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)) → Prop) (x : ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)),
(∀ (J : Ideal R) (left : J.IsMaximal) (e : M ≃ₗ[R] R ⧸ J), motive ⋯) → motive x |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.parseTagged.match_5 | Lean.Data.Json.FromToJson.Basic | (motive : Option (Array Lean.Name) → Sort u_1) →
(fieldNames? : Option (Array Lean.Name)) →
((fieldNames : Array Lean.Name) → motive (some fieldNames)) → (Unit → motive none) → motive fieldNames? |
Set.preimage_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} {s : Set γ},
f ⁻¹' (g ⁻¹' s) = (fun x => g (f x)) ⁻¹' s |
HomotopicalAlgebra.LeftHomotopyClass.whitehead | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
[HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y] [HomotopicalAlgebra.IsFibrant X]
[HomotopicalAlgebra.IsFibrant Y] (f : X ⟶ Y) [HomotopicalAlgebra.WeakEquivalence f],
∃ g,
HomotopicalAlgebra.LeftHomotopyRel (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.id X) ∧
HomotopicalAlgebra.LeftHomotopyRel (CategoryTheory.CategoryStruct.comp g f) (CategoryTheory.CategoryStruct.id Y) |
nontrivial_iff | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1}, Nontrivial α ↔ ∃ x y, x ≠ y |
CategoryTheory.Functor.FullyFaithful.homEquiv.eq_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
hF.homEquiv = { toFun := F.map, invFun := hF.preimage, left_inv := ⋯, right_inv := ⋯ } |
CategoryTheory.overEquivOfIsInitial | Mathlib.CategoryTheory.Comma.Over.StrictInitial | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Limits.HasStrictInitialObjects C] →
(X : C) → CategoryTheory.Limits.IsInitial X → (CategoryTheory.Over X ≌ CategoryTheory.Discrete PUnit.{w + 1}) |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_6 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (M : Type u_1) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
AddSubmonoidClass (LieSubmodule R (↥H) M) M |
ProbabilityTheory.Kernel.lintegral_id | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} [MeasurableSingletonClass α] {f : α → ENNReal} (a : α),
∫⁻ (a : α), f a ∂ProbabilityTheory.Kernel.id a = f a |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionAssocNatIso_hom_app_app_app | 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 X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionAssocNatIso C D).hom.app X).app X_1).app X_2 =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso X X_1 X_2).hom |
CategoryTheory.ObjectProperty.isoClosure_eq_self | Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderIsomorphisms], P.isoClosure = P |
Lean.Grind.CommRing.Expr.toPolyC.go.match_4.congr_eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_5 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_6 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b)) (h_7 : (a : Lean.Grind.CommRing.Expr) → motive a.neg)
(h_8 : (a b : Lean.Grind.CommRing.Expr) → motive (a.sub b))
(h_9 : (a : Lean.Grind.CommRing.Expr) → (k : ℕ) → motive (a.pow k)) (a : Lean.Grind.CommRing.Expr),
x = a.neg →
(match x with
| Lean.Grind.CommRing.Expr.num k => h_1 k
| Lean.Grind.CommRing.Expr.natCast k => h_2 k
| Lean.Grind.CommRing.Expr.intCast k => h_3 k
| Lean.Grind.CommRing.Expr.var x => h_4 x
| a.add b => h_5 a b
| a.mul b => h_6 a b
| a.neg => h_7 a
| a.sub b => h_8 a b
| a.pow k => h_9 a k) ≍
h_7 a |
Lean.Lsp.ApplyWorkspaceEditParams.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (label? : Option String) (edit : Lean.Lsp.WorkspaceEdit),
sizeOf { label? := label?, edit := edit } = 1 + sizeOf label? + sizeOf edit |
PartialFun.instCoeSortType | Mathlib.CategoryTheory.Category.PartialFun | CoeSort PartialFun (Type u_1) |
MvPolynomial.eval₂_comp_left | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] {S₂ : Type u_2}
[inst_2 : CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p : MvPolynomial σ R),
k (MvPolynomial.eval₂ f g p) = MvPolynomial.eval₂ (k.comp f) (⇑k ∘ g) p |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
[inst : String.Slice.Pattern.ForwardPattern pat] →
[String.Slice.Pattern.StrictForwardPattern pat] →
Std.Iterators.FinitenessRelation (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s) Id |
Subtype.orderBot._proof_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (x : { x // p x }), ⊥ ≤ ↑x |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.dist_triangle_nonarch._simp_1_4 | Mathlib.Topology.MetricSpace.PiNat | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 0 < a → ∀ (n : ℕ), (0 < a ^ n) = True |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.EMatchTheoremIds | Lean.Meta.Tactic.Grind.EMatchAction | Type |
Std.DTreeMap.Internal.Impl.Equiv.getKey_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁), t₁.getKey k hk = t₂.getKey k ⋯ |
IsDiscreteValuationRing.toWithBotNat_eq_bot_iff | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (x : R),
IsDiscreteValuationRing.toWithBotNat x = ⊥ ↔ x = 0 |
Tropical.trop_inj_iff | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} (x y : R), Tropical.trop x = Tropical.trop y ↔ x = y |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_5 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Sort u_1}, (∀ (a : α), True) = True |
Std.OrientedCmp.of_gt_iff_lt | Init.Data.Order.PackageFactories | ∀ {α : Type u} {cmp : α → α → Ordering},
(∀ (a b : α), cmp a b = Ordering.gt ↔ cmp b a = Ordering.lt) → Std.OrientedCmp cmp |
Subsemiring._sizeOf_inst | Mathlib.Algebra.Ring.Subsemiring.Defs | (R : Type u) → {inst : NonAssocSemiring R} → [SizeOf R] → SizeOf (Subsemiring R) |
Lean.Meta.Grind.CheckResult.none | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult |
ContDiffMapSupportedInClass.map_zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B),
Set.EqOn (⇑f) 0 (↑K)ᶜ |
HomologicalComplex.truncLE'XIso | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embedding c') →
[inst_2 : e.IsTruncLE] →
[inst_3 : ∀ (i' : ι'), K.HasHomology i'] →
{i : ι} → {i' : ι'} → e.f i = i' → ¬e.BoundaryLE i → ((K.truncLE' e).X i ≅ K.X i') |
AffineSubspace.SSameSide.trans | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.SSameSide x y → s.SSameSide y z → s.SSameSide x z |
CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.ReflectsEffectiveEpiFamilies → Sort u_3} →
((reflects :
∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
(CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) →
CategoryTheory.EffectiveEpiFamily X π) →
motive ⋯) →
(t : F.ReflectsEffectiveEpiFamilies) → motive t |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm.match_4 | Lean.Meta.Sym.Simp.App | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(kind : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → motive Lean.Meta.CongrArgKind.subsingletonInst) →
(Unit → motive Lean.Meta.CongrArgKind.eq) → ((x : Lean.Meta.CongrArgKind) → motive x) → motive kind |
Set.image_inv_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iio a = Set.Ioi a⁻¹ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.