name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ext | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | ∀ {numVarsSucc : ℕ} {x y : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula numVarsSucc},
x.clauses = y.clauses → x.rupUnits = y.rupUnits → x.ratUnits = y.ratUnits → x.assignments = y.assignments → x = y |
Matrix.blockDiag'_transpose | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12}
(M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o), M.transpose.blockDiag' k = (M.blockDiag' k).transpose |
Finmap.union_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : AList β), s₁.toFinmap ∪ s₂.toFinmap = (s₁ ∪ s₂).toFinmap |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.registerFailedToInferDefTypeInfo._sparseCasesOn_7 | Lean.Elab.MutualDef | {motive : Lean.Elab.DefKind → Sort u} →
(t : Lean.Elab.DefKind) →
motive Lean.Elab.DefKind.example →
motive Lean.Elab.DefKind.instance →
motive Lean.Elab.DefKind.theorem → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorBinaryRefVecBlastUmod | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.BinaryRefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastUmod |
CategoryTheory.Abelian.LeftResolution.chainComplexMap_f_succ_succ | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} (f : X ⟶ Y) [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5 : CategoryTheory.Abelian A] (n : ℕ),
(Λ.chainComplexMap f).f (n + 2) =
CategoryTheory.CategoryStruct.comp (Λ.chainComplexXIso X n).hom
(CategoryTheory.CategoryStruct.comp
(Λ.F.map
(CategoryTheory.Limits.kernel.map (ι.map ((Λ.chainComplex X).d (n + 1) n))
(ι.map ((Λ.chainComplex Y).d (n + 1) n)) (ι.map ((Λ.chainComplexMap f).f (n + 1)))
(ι.map ((Λ.chainComplexMap f).f n)) ⋯))
(Λ.chainComplexXIso Y n).inv) |
instMulActionRayVector._proof_1 | Mathlib.LinearAlgebra.Ray | ∀ {M : Type u_1} [inst : AddCommMonoid M] {G : Type u_2} [inst_1 : Group G] [inst_2 : DistribMulAction G M] (r : G)
(x : M), x ≠ 0 → r • x ≠ 0 |
AntivaryOn.card_mul_sum_le_sum_mul_sum | Mathlib.Algebra.Order.Chebyshev | ∀ {ι : Type u_1} {α : Type u_2} [inst : Semiring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
{s : Finset ι} {f g : ι → α}, AntivaryOn f g ↑s → ↑s.card * ∑ i ∈ s, f i * g i ≤ (∑ i ∈ s, f i) * ∑ i ∈ s, g i |
PSigma.fintypePropRight.match_5 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} {β : α → Prop} (motive : { a // β a } → Prop) (x : { a // β a }),
(∀ (val : α) (property : β val), motive ⟨val, property⟩) → motive x |
AlgebraicGeometry.IsClosedImmersion.lift_fac | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g H) f = g |
Aesop.CoreRuleBuilderOutput.noConfusion | Aesop.Builder.Basic | {P : Sort u} → {t t' : Aesop.CoreRuleBuilderOutput} → t = t' → Aesop.CoreRuleBuilderOutput.noConfusionType P t t' |
Continuous.compCM | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [LocallyCompactPair Y Z] {X' : Type u_6} [inst_4 : TopologicalSpace X']
{g : X' → C(Y, Z)} {f : X' → C(X, Y)}, Continuous g → Continuous f → Continuous fun x => (g x).comp (f x) |
Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α},
Nat.card ↥(Equiv.Perm.OnCycleFactors.toPermHom g).range =
∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial |
NonUnitalStarAlgebra.elemental.isClosedEmbedding_coe | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] [inst_8 : TopologicalSpace A] [inst_9 : IsTopologicalSemiring A]
[inst_10 : ContinuousConstSMul R A] [inst_11 : ContinuousStar A] (x : A), Topology.IsClosedEmbedding Subtype.val |
CategoryTheory.Conv.instMul | Mathlib.CategoryTheory.Monoidal.Conv | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : C} → [CategoryTheory.ComonObj M] → [CategoryTheory.MonObj N] → Mul (CategoryTheory.Conv M N) |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.getElem?_toList._simp_1_4 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) |
LaurentPolynomial.degree_T_le | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (n : ℤ), (LaurentPolynomial.T n).degree ≤ ↑n |
Real.fderiv_fourier | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E},
MeasureTheory.Integrable f MeasureTheory.volume →
MeasureTheory.Integrable (fun v => ‖v‖ * ‖f v‖) MeasureTheory.volume →
fderiv ℝ (FourierTransform.fourier f) = FourierTransform.fourier (VectorFourier.fourierSMulRight (innerSL ℝ) f) |
CategoryTheory.FinCategory.mk | Mathlib.CategoryTheory.FinCategory.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
autoParam (Fintype J) CategoryTheory.FinCategory.fintypeObj._autoParam →
autoParam ((j j' : J) → Fintype (j ⟶ j')) CategoryTheory.FinCategory.fintypeHom._autoParam →
CategoryTheory.FinCategory J |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.zariskisMainProperty_iff_exists_saturation_eq_top._simp_1 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) |
mem_tangentConeAt_of_add_smul_mem | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : DivisionSemiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace 𝕜] [inst_4 : TopologicalSpace E] [ContinuousSMul 𝕜 E] {s : Set E} {x y : E} {α : Type u_3}
{l : Filter α} [l.NeBot] {c : α → 𝕜},
Filter.Tendsto c l (nhdsWithin 0 {0}ᶜ) → (∀ᶠ (n : α) in l, x + c n • y ∈ s) → y ∈ tangentConeAt 𝕜 s x |
AddSubgroup.index | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : AddGroup G] → AddSubgroup G → ℕ |
NumberField.mixedEmbedding.convexBodyLT'_volume | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex })
[inst_1 : NumberField K],
MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀) =
↑(NumberField.mixedEmbedding.convexBodyLT'Factor K) * ↑(∏ w, f w ^ w.mult) |
Std.ExtTreeMap.toList_inj | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α β cmp},
t₁.toList = t₂.toList ↔ t₁ = t₂ |
Num.commSemiring._proof_4 | Mathlib.Data.Num.Lemmas | ∀ (x x_1 x_2 : Num), (x + x_1) * x_2 = x * x_2 + x_1 * x_2 |
CategoryTheory.HasClassifier.comm | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasClassifier C] {U X : C} (m : U ⟶ X)
[inst_2 : CategoryTheory.Mono m],
CategoryTheory.CategoryStruct.comp m (CategoryTheory.HasClassifier.χ m) =
CategoryTheory.CategoryStruct.comp (⋯.some.χ₀ U) (CategoryTheory.HasClassifier.truth C) |
Lean.PersistentHashMap.findAux | Lean.Data.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → [BEq α] → Lean.PersistentHashMap.Node α β → USize → α → Option β |
MeasureTheory.integrable_stoppedValue_of_mem_finset | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Nonempty ι] {μ : MeasureTheory.Measure Ω}
{τ : Ω → WithTop ι} {E : Type u_4} {u : ι → Ω → E} [inst_1 : PartialOrder ι] {ℱ : MeasureTheory.Filtration ι m}
[inst_2 : NormedAddCommGroup E],
MeasureTheory.IsStoppingTime ℱ τ →
(∀ (n : ι), MeasureTheory.Integrable (u n) μ) →
∀ {s : Finset ι},
(∀ (ω : Ω), τ ω ∈ WithTop.some '' ↑s) → MeasureTheory.Integrable (MeasureTheory.stoppedValue u τ) μ |
Lean.Sym.Nat.eq_eq_true | Init.Sym.Lemmas | ∀ (a b : ℕ), decide (a = b) = true → (a = b) = True |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_top_eq_maxUnifEigenspaceIndex._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True |
Bialgebra.toLinearMap_counitAlgHom | Mathlib.RingTheory.Bialgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Bialgebra.counitAlgHom R A).toLinearMap = CoalgebraStruct.counit |
MeasureTheory.L1.SimpleFunc.setToL1S_add_left | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(T T' : Set α → E →L[ℝ] F) (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
MeasureTheory.L1.SimpleFunc.setToL1S (T + T') f =
MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T' f |
CategoryTheory.ChosenPullbacksAlong.Over.whiskerRight_left_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
{R S T : CategoryTheory.Over X} (f : S ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f R).left
(CategoryTheory.ChosenPullbacksAlong.snd T.hom R.hom) =
CategoryTheory.ChosenPullbacksAlong.snd S.hom R.hom |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.comap_mem_associatedPrimes_of_mem_associatedPrimes_of_isLocalizedModule_of_fg._simp_1_1 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (f x ∈ K) = (x ∈ Ideal.comap f K) |
CategoryTheory.PreZeroHypercoverFamily.noConfusionType | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.PreZeroHypercoverFamily C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.PreZeroHypercoverFamily C' → Sort u_1 |
HomotopicalAlgebra.CofibrantObject.HoCat | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | (C : Type u_1) → [inst : CategoryTheory.Category.{v_1, u_1} C] → [HomotopicalAlgebra.ModelCategory C] → Type u_1 |
PLift.instLawfulFunctor_mathlib | Mathlib.Control.ULift | LawfulFunctor PLift |
RatFunc.X.eq_1 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.X = (algebraMap (Polynomial K) (RatFunc K)) Polynomial.X |
RingCone.mem_mk | Mathlib.Algebra.Order.Ring.Cone | ∀ {R : Type u_1} [inst : Ring R] {toSubsemiring : Subsemiring R}
(eq_zero_of_mem_of_neg_mem : ∀ {a : R}, a ∈ toSubsemiring.carrier → -a ∈ toSubsemiring.carrier → a = 0) {x : R},
x ∈ { toSubsemiring := toSubsemiring, eq_zero_of_mem_of_neg_mem' := eq_zero_of_mem_of_neg_mem } ↔ x ∈ toSubsemiring |
List.lookmap | Batteries.Data.List.Basic | {α : Type u_1} → (α → Option α) → List α → List α |
NormedSpace.invertibleExpOfMemBall._proof_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝕂 : Type u_2} {𝔸 : Type u_1} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸]
[CompleteSpace 𝔸] [CharZero 𝕂] {x : 𝔸},
x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → NormedSpace.exp (-x) * NormedSpace.exp x = 1 |
Array.map_eq_empty_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α}, (Array.map f xs = #[]) = (xs = #[]) |
Associates.prime_mk | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {p : M}, Prime (Associates.mk p) ↔ Prime p |
bne_eq_false_iff_eq._simp_1 | Init.SimpLemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a != b) = false) = (a = b) |
AkraBazziRecurrence.recOn | Mathlib.Computability.AkraBazzi.SumTransform | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : Nonempty α] →
{T : ℕ → ℝ} →
{g : ℝ → ℝ} →
{a b : α → ℝ} →
{r : α → ℕ → ℕ} →
{motive : AkraBazziRecurrence T g a b r → Sort u} →
(t : AkraBazziRecurrence T g a b r) →
((n₀ : ℕ) →
(n₀_gt_zero : 0 < n₀) →
(a_pos : ∀ (i : α), 0 < a i) →
(b_pos : ∀ (i : α), 0 < b i) →
(b_lt_one : ∀ (i : α), b i < 1) →
(g_nonneg : ∀ x ≥ 0, 0 ≤ g x) →
(g_grows_poly : AkraBazziRecurrence.GrowsPolynomially g) →
(h_rec : ∀ (n : ℕ), n₀ ≤ n → T n = ∑ i, a i * T (r i n) + g ↑n) →
(T_gt_zero' : ∀ n < n₀, 0 < T n) →
(r_lt_n : ∀ (i : α) (n : ℕ), n₀ ≤ n → r i n < n) →
(dist_r_b :
∀ (i : α),
(fun n => ↑(r i n) - b i * ↑n) =o[Filter.atTop] fun n =>
↑n / Real.log ↑n ^ 2) →
motive
{ n₀ := n₀, n₀_gt_zero := n₀_gt_zero, a_pos := a_pos, b_pos := b_pos,
b_lt_one := b_lt_one, g_nonneg := g_nonneg, g_grows_poly := g_grows_poly,
h_rec := h_rec, T_gt_zero' := T_gt_zero', r_lt_n := r_lt_n,
dist_r_b := dist_r_b }) →
motive t |
Equiv.trans_toEmbedding | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ),
(e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding |
HomologicalComplex₂.totalShift₁Iso._proof_1 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n n' : ℤ),
CategoryTheory.CategoryStruct.comp ((fun n => K.totalShift₁XIso x n (n + x) ⋯) n).hom
(((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) x).obj (K.total (ComplexShape.up ℤ))).d
n n') =
CategoryTheory.CategoryStruct.comp
((((HomologicalComplex₂.shiftFunctor₁ C x).obj K).total (ComplexShape.up ℤ)).d n n')
((fun n => K.totalShift₁XIso x n (n + x) ⋯) n').hom |
CategoryTheory.NatIso.removeOp_hom | Mathlib.CategoryTheory.Opposites | ∀ {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} (α : F.op ≅ G.op),
(CategoryTheory.NatIso.removeOp α).hom = CategoryTheory.NatTrans.removeOp α.hom |
Lean.Elab.Tactic.Do.State.mk.sizeOf_spec | Lean.Elab.Tactic.Do.VCGen.Basic | ∀ (fuel : Lean.Elab.Tactic.Do.Fuel) (simpState : Lean.Meta.Simp.State) (invariants vcs : Array Lean.MVarId),
sizeOf { fuel := fuel, simpState := simpState, invariants := invariants, vcs := vcs } =
1 + sizeOf fuel + sizeOf simpState + sizeOf invariants + sizeOf vcs |
CategoryTheory.Limits.IsColimit.map | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F G : CategoryTheory.Functor J C} →
{s : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsColimit s → (t : CategoryTheory.Limits.Cocone G) → (F ⟶ G) → (s.pt ⟶ t.pt) |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_11 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) |
Prod.instDivInvMonoid._proof_4 | Mathlib.Algebra.Group.Prod | ∀ {G : Type u_1} {H : Type u_2} [inst : DivInvMonoid G] [inst_1 : DivInvMonoid H] (x : ℕ) (x_1 : G × H),
(DivInvMonoid.zpow (Int.negSucc x) x_1.1, DivInvMonoid.zpow (Int.negSucc x) x_1.2) =
(DivInvMonoid.zpow (↑x.succ) x_1.1, DivInvMonoid.zpow (↑x.succ) x_1.2)⁻¹ |
exists_quadratic_eq_zero | Mathlib.Algebra.QuadraticDiscriminant | ∀ {K : Type u_1} [inst : Field K] [NeZero 2] {a b c : K},
a ≠ 0 → (∃ s, discrim a b c = s * s) → ∃ x, a * (x * x) + b * x + c = 0 |
CategoryTheory.Adjunction.whiskerRight_counit_app_app | Mathlib.CategoryTheory.Adjunction.Whiskering | ∀ (C : Type u_1) {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
{F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor C E)
(X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).counit.app X).app X_1 = adj.counit.app (X.obj X_1) |
_private.Mathlib.Data.Nat.Cast.Order.Ring.0.Nat.neg_cast_eq_cast._simp_1_1 | Mathlib.Data.Nat.Cast.Order.Ring | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (-a = b) = (a + b = 0) |
CategoryTheory.Limits.IsTerminal.strict_hom_ext | Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C}
(hI : CategoryTheory.Limits.IsTerminal I) {A : C} (f g : I ⟶ A), f = g |
Function.const_neg' | Mathlib.Algebra.Order.Pi | ∀ {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : Preorder α] {a : α} [Nonempty β],
Function.const β a < 0 ↔ a < 0 |
LinearMap.compMultilinearMap_compLinearMap | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₁' : ι → Type v₁'} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → AddCommMonoid (M₁' i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : AddCommMonoid M₃] [inst_5 : (i : ι) → Module R (M₁ i)] [inst_6 : (i : ι) → Module R (M₁' i)]
[inst_7 : Module R M₂] [inst_8 : Module R M₃] (g : M₂ →ₗ[R] M₃) (f : MultilinearMap R M₁ M₂)
(f' : (i : ι) → M₁' i →ₗ[R] M₁ i),
g.compMultilinearMap (f.compLinearMap f') = (g.compMultilinearMap f).compLinearMap f' |
Option.instMembership | Init.Data.Option.Instances | {α : Type u_1} → Membership α (Option α) |
mulMulHom._proof_1 | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_1} [inst : CommSemigroup α] (x x_1 : α × α), x.1 * x_1.1 * (x.2 * x_1.2) = x.1 * x.2 * (x_1.1 * x_1.2) |
CategoryTheory.StrictPseudofunctor.mk'._proof_7 | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictPseudofunctorCore B C) {a b : B} (f : a ⟶ b),
S.map₂ (CategoryTheory.CategoryStruct.id f) = CategoryTheory.CategoryStruct.id (S.map f) |
CategoryTheory.Triangulated.AbelianSubcategory.abelian | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | {C : Type u_1} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
[inst_6 : CategoryTheory.Category.{v_2, u_2} A] →
(ι : CategoryTheory.Functor A C) →
(∀ ⦃X Y : A⦄ ⦃n : ℤ⦄ (f : ι.obj X ⟶ (CategoryTheory.shiftFunctor C n).obj (ι.obj Y)),
n < 0 → f = 0) →
[inst_7 : CategoryTheory.Preadditive A] →
[ι.Full] →
[ι.Faithful] →
[CategoryTheory.Limits.HasFiniteProducts A] →
[ι.Additive] →
CategoryTheory.Triangulated.AbelianSubcategory.admissibleMorphism ι = ⊤ →
[CategoryTheory.IsTriangulated C] → CategoryTheory.Abelian A |
Std.Tactic.BVDecide.Normalize.BitVec.not_neg' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (x : BitVec w), ~~~(x + 1#w) = ~~~x + -1#w |
Set.projIci_of_mem | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a x : α} (hx : x ∈ Set.Ici a), Set.projIci a x = ⟨x, hx⟩ |
BoundedContinuousFunction.norm_const_eq | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β] [h : Nonempty α] (b : β),
‖BoundedContinuousFunction.const α b‖ = ‖b‖ |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_add_succ_right_eq_push'._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m ≤ m + n → False |
Std.DHashMap.Raw.Const.get?_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a : α} {v : β},
Std.DHashMap.Raw.Const.get? (m.insertIfNew k v) a =
if (k == a) = true ∧ k ∉ m then some v else Std.DHashMap.Raw.Const.get? m a |
Std.Internal.IO.Async.System.OSInfo.mk.sizeOf_spec | Std.Internal.Async.System | ∀ (name release version machine : String),
sizeOf { name := name, release := release, version := version, machine := machine } =
1 + sizeOf name + sizeOf release + sizeOf version + sizeOf machine |
Lean.Meta.Grind.BuiltinPropagators.recOn | Lean.Meta.Tactic.Grind.PropagatorAttr | {motive : Lean.Meta.Grind.BuiltinPropagators → Sort u} →
(t : Lean.Meta.Grind.BuiltinPropagators) →
((up down : Lean.Meta.Grind.PropagatorMap) → motive { up := up, down := down }) → motive t |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_eq_false_right._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) |
_private.Mathlib.SetTheory.Cardinal.Order.0.Cardinal.le_mk_iff_exists_set.match_1_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {α : Type u_1} (x : Type u_1) (motive : Cardinal.mk x ≤ Cardinal.mk α → Prop) (x_1 : Cardinal.mk x ≤ Cardinal.mk α),
(∀ (f : x → α) (hf : Function.Injective f), motive ⋯) → motive x_1 |
Std.ExtHashMap.isSome_getKey?_iff_mem._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) |
Matrix.replicateRow_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {ι : Type u_1}, Matrix.replicateRow ι ![] = Matrix.of fun x => ![] |
PresheafOfModules.limitPresheafOfModules._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[∀ (X : Cᵒᵖ),
Small.{u_3, max u_2 u_3}
↑((F.comp (PresheafOfModules.evaluation R X)).comp (CategoryTheory.forget (ModuleCat ↑(R.obj X)))).sections]
{x Y : Cᵒᵖ} (f : x ⟶ Y),
CategoryTheory.Limits.PreservesLimit (F.comp (PresheafOfModules.evaluation R Y))
(ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))) |
Lean.Doc.Parser.OrderedListType.numDot.elim | Lean.DocString.Parser | {motive : Lean.Doc.Parser.OrderedListType → Sort u} →
(t : Lean.Doc.Parser.OrderedListType) → t.ctorIdx = 0 → motive Lean.Doc.Parser.OrderedListType.numDot → motive t |
Lean.Meta.Simp.Arith.Nat.instReprExprCnstr_lean.repr | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Nat.Linear.ExprCnstr → ℕ → Std.Format |
ContinuousLinearEquiv.trans_apply | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₃₂ : R₃ →+* R₂} [inst_5 : RingHomInvPair σ₂₃ σ₃₂] [inst_6 : RingHomInvPair σ₃₂ σ₂₃]
{σ₁₃ : R₁ →+* R₃} {σ₃₁ : R₃ →+* R₁} [inst_7 : RingHomInvPair σ₁₃ σ₃₁] [inst_8 : RingHomInvPair σ₃₁ σ₁₃]
[inst_9 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_10 : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁] {M₁ : Type u_4}
[inst_11 : TopologicalSpace M₁] [inst_12 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_13 : TopologicalSpace M₂]
[inst_14 : AddCommMonoid M₂] {M₃ : Type u_6} [inst_15 : TopologicalSpace M₃] [inst_16 : AddCommMonoid M₃]
[inst_17 : Module R₁ M₁] [inst_18 : Module R₂ M₂] [inst_19 : Module R₃ M₃] (e₁ : M₁ ≃SL[σ₁₂] M₂) (e₂ : M₂ ≃SL[σ₂₃] M₃)
(c : M₁), (e₁.trans e₂) c = e₂ (e₁ c) |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
(x ∈ a • A) = (a⁻¹ • x ∈ A) |
AlgEquiv | Mathlib.Algebra.Algebra.Equiv | (R : Type u) →
(A : Type v) →
(B : Type w) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Semiring B] → [Algebra R A] → [Algebra R B] → Type (max v w) |
NonUnitalAlgHom.ext | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B] {f g : A →ₛₙₐ[φ] B}, (∀ (x : A), f x = g x) → f = g |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.copyCount_bot._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {s : Finset α} {a : α}, (s = {a}) = (a ∈ s ∧ ∀ x ∈ s, x = a) |
Array.foldr_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} {b : β} {xs ys : Array α},
Array.foldr f b (xs ++ ys) = Array.foldr f (Array.foldr f b ys) xs |
Std.PRange.InfinitelyUpwardEnumerable.mk._flat_ctor | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α],
(∀ (a : α), (Std.PRange.succ? a).isSome = true) → Std.PRange.InfinitelyUpwardEnumerable α |
Std.DTreeMap.Internal.Impl.IteratedNewInsertionInto | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → [Ord α] → Std.DTreeMap.Internal.Impl α β → Type (max 0 u v) |
KummerDedekind.quotMapEquivQuotQuotMap._proof_5 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R},
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R x)}).IsTwoSided |
PresheafOfModules.Derivation.postcomp._proof_2 | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M N : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R}
(d : M.Derivation φ) (f : M ⟶ N) {X : Dᵒᵖ} (a b : ↑(R.obj X)),
((ModuleCat.Hom.hom (f.app X)).toAddMonoidHom.comp d.d) (a * b) =
a • ((ModuleCat.Hom.hom (f.app X)).toAddMonoidHom.comp d.d) b +
b • ((ModuleCat.Hom.hom (f.app X)).toAddMonoidHom.comp d.d) a |
Std.DTreeMap.Internal.RooSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : α → Type v} → [inst : Ord α] → Std.DTreeMap.Internal.RooSliceData α β → Std.Roo α |
CategoryTheory.Limits.prod | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (X Y : C) → [CategoryTheory.Limits.HasBinaryProduct X Y] → C |
CategoryTheory.eq._proof_7 | Mathlib.CategoryTheory.Monad.Types | ∀ (m : Type u_1 → Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m] (X : CategoryTheory.KleisliCat m),
CategoryTheory.CategoryStruct.comp
({ obj := fun X => { of := X }, map := fun {X Y} f => { of := f }, map_id := ⋯, map_comp := ⋯ }.map
((CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).hom.app X))
((CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).hom.app
({ obj := fun X => { of := X }, map := fun {X Y} f => { of := f }, map_id := ⋯, map_comp := ⋯ }.obj X)) =
CategoryTheory.CategoryStruct.id
({ obj := fun X => { of := X }, map := fun {X Y} f => { of := f }, map_id := ⋯, map_comp := ⋯ }.obj X) |
Fintype.sumRight | Mathlib.Data.Fintype.Card | {α : Type u_4} → {β : Type u_5} → [Fintype (α ⊕ β)] → Fintype β |
Lean.Parser.Command.universe.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
FormalMultilinearSeries.leftInv._proof_36 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E |
Finset.Nat.antidiagonal_filter_fst_le_of_le | Mathlib.Data.Finset.NatAntidiagonal | ∀ {n k : ℕ},
k ≤ n →
{a ∈ Finset.antidiagonal n | a.1 ≤ k} =
Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := fun x => x + (n - k), inj' := ⋯ })
(Finset.antidiagonal k) |
Set.preimage_const_sub_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a - x) ⁻¹' Set.uIcc b c = Set.uIcc (a - b) (a - c) |
_private.Mathlib.RingTheory.Trace.Quotient.0._aux_Mathlib_RingTheory_Trace_Quotient___unexpand_IsLocalRing_maximalIdeal_1 | Mathlib.RingTheory.Trace.Quotient | Lean.PrettyPrinter.Unexpander |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate.0.PSigma.casesOn._arg_pusher | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.BlockMem.instBoundedOrder._simp_1 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {α : Type u} (s : Set α), (s ⊆ Set.univ) = True |
InnerProductSpace.Core.inner_zero_right | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), inner 𝕜 x 0 = 0 |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_zero_unitIso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ),
(CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 0).unitIso.inv.app X =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor C 0).map ((CategoryTheory.shiftFunctorZero Cᵒᵖ ℤ).hom.app X).unop).op
((CategoryTheory.shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op |
WithBot.decidableLT | Mathlib.Order.WithBot | {α : Type u_1} → [inst : LT α] → [DecidableLT α] → DecidableLT (WithBot α) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.