name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Parser.Term.letOpts.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
LieAlgebra.SemiDirectSum.inl | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → K →ₗ⁅R⁆ K ⋊⁅ψ⁆ L |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage | Mathlib.RingTheory.AdicCompletion.Exactness | {R : Type u} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{N : Type w} →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{f : M →ₗ[R] N} →
Function.Surjective ⇑f → (x : AdicCompletion.AdicCauchySequence I N) → (n : ℕ) → ↑(⇑f ⁻¹' {↑x n}) |
CategoryTheory.Cat.equivOfIso._proof_3 | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} (γ : C ≅ D), γ.inv.toFunctor.comp γ.hom.toFunctor = CategoryTheory.Functor.id ↑D |
Finsupp.subtypeDomain_sub | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {G : Type u_8} [inst : AddGroup G] {p : α → Prop} {v v' : α →₀ G},
Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v' |
Std.HashMap.Raw.WF.filterMap | Std.Data.HashMap.AdditionalOperations | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β}
{f : α → β → Option γ}, m.WF → (Std.HashMap.Raw.filterMap f m).WF |
Std.TreeMap.getKey_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{hc : t.minKey! ∈ t}, t.getKey t.minKey! hc = t.minKey! |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.bindMutVarsFromTuple.go._sunfold | Lean.Elab.Do.Basic | Lean.Elab.Do.DoElabM Lean.Expr →
List Lean.Name → Lean.FVarId → Lean.Expr → Array Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr |
MonoidHom.toOneHom_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N), ⇑↑f = ⇑f |
IsAddUnit.add_right_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit b → a + b = c + b → a = c |
_private.Batteries.Data.MLList.Basic.0.MLList.ofArray.go._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type → Type} → {α : Type} → Array α → ℕ → MLList m α |
OrderDual.ofDual_le_ofDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LE α] {a b : αᵒᵈ}, OrderDual.ofDual a ≤ OrderDual.ofDual b ↔ b ≤ a |
List.append_eq | Init.Data.List.Basic | ∀ {α : Type u} {as bs : List α}, as.append bs = as ++ bs |
fderivWithin_of_mem_nhds | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E}, s ∈ nhds x → fderivWithin 𝕜 f s x = fderiv 𝕜 f x |
RingHom.Finite.finiteType | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] {f : A →+* B}, f.Finite → f.FiniteType |
_private.Mathlib.Algebra.DirectSum.Internal.0.listProd_apply_eq_zero._simp_1_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∀ (a : α), a = a' ∨ q a → p a) = (p a' ∧ ∀ (a : α), q a → p a) |
_private.Mathlib.GroupTheory.Coset.Basic.0.Subgroup.quotientiInfSubgroupOfEmbedding._simp_3 | Mathlib.GroupTheory.Coset.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) |
_private.Mathlib.AlgebraicGeometry.Cover.Sigma.0.AlgebraicGeometry.Scheme.Cover.presieve₀_sigma.match_1_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : UnivLE.{u_2, u_1}]
{S : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S)
(motive :
(T : AlgebraicGeometry.Scheme) →
(g : T ⟶ S) → CategoryTheory.Presieve.singleton (CategoryTheory.Limits.Sigma.desc 𝒰.f) g → Prop)
(T : AlgebraicGeometry.Scheme) (g : T ⟶ S)
(x : CategoryTheory.Presieve.singleton (CategoryTheory.Limits.Sigma.desc 𝒰.f) g),
(∀ (a : Unit), motive (∐ 𝒰.X) (CategoryTheory.Limits.Sigma.desc 𝒰.f) ⋯) → motive T g x |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType b binderInfo)) →
((declName : Lean.Name) →
(type v b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type v b nondep)) →
((data : Lean.MData) → (e : Lean.Expr) → motive (Lean.Expr.mdata data e)) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → ((x : Lean.Expr) → motive x) → motive e |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Std.DHashMap.Raw.Const.get?_inter_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → Std.DHashMap.Raw.Const.get? (m₁ ∩ m₂) k = none |
Subalgebra.perfectClosure | Mathlib.FieldTheory.PurelyInseparable.Basic | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → (p : ℕ) → [ExpChar A p] → Subalgebra R A |
Int.modEq_sub_modulus_mul_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a ≡ b - n * c [ZMOD n] ↔ a ≡ b [ZMOD n] |
ProbabilityTheory.Kernel.iIndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
∀ (g : (i : ι) → β i → γ i),
(∀ (i : ι), AEMeasurable (f i) (μ.bind ⇑κ)) →
(∀ (i : ι), AEMeasurable (g i) (MeasureTheory.Measure.map (f i) (μ.bind ⇑κ))) →
ProbabilityTheory.Kernel.iIndepFun (fun i => g i ∘ f i) κ μ |
Submodule.map._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[RingHomSurjective σ₁₂] (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) (c : R₂) {x : M₂}, x ∈ ⇑f '' ↑p → c • x ∈ ⇑f '' ↑p |
Std.Do.Spec.forIn'_list._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : List α}, xs ++ [] = xs |
Std.TreeMap.Raw.minKeyD_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' |
hasFDerivWithinAt_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{Φ' : E →L[𝕜] (i : ι) → F' i},
HasFDerivWithinAt Φ Φ' s x ↔ ∀ (i : ι), HasFDerivWithinAt (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') s x |
Functor.map_unit | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a |
Sym.filterNe._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (m : Sym α n), (↑m).card < n + 1 |
Lean.IR.Expr.proj.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 3 → ((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) → motive t |
SkewMonoidAlgebra.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {P : Sort u} →
{k : Type u_1} →
{G : Type u_2} →
{inst : Zero k} →
{t : SkewMonoidAlgebra k G} →
{k' : Type u_1} →
{G' : Type u_2} →
{inst' : Zero k'} →
{t' : SkewMonoidAlgebra k' G'} →
k = k' → G = G' → inst ≍ inst' → t ≍ t' → SkewMonoidAlgebra.noConfusionType P t t' |
Vector.getElem?_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m i : ℕ} {xs : Vector α n} {ys : Vector α m}, n ≤ i → (xs ++ ys)[i]? = ys[i - n]? |
Lean.Level.collectMVars | Lean.Level | Lean.Level → optParam Lean.LMVarIdSet ∅ → Lean.LMVarIdSet |
NormedAddTorsor | Mathlib.Analysis.Normed.Group.AddTorsor | (V : outParam (Type u_1)) → (P : Type u_2) → [SeminormedAddCommGroup V] → [PseudoMetricSpace P] → Type (max u_1 u_2) |
SubMulAction.instSMulSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : ↥p), c • ↑x ∈ p |
ωCPO._sizeOf_1 | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ |
IsAlgebraic.smul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → ∀ (r : R), IsAlgebraic R (r • a) |
Quiver.Path.nil | Mathlib.Combinatorics.Quiver.Path | {V : Type u} → [inst : Quiver V] → {a : V} → Quiver.Path a a |
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go | Init.Data.List.Impl | ∀ (α : Type u_3) (β : Type u_2) (γ : Type u_1) (f : α → β → γ) (as : List α) (bs : List β) (acc : Array γ),
List.zipWithTR.go✝ f as bs acc = acc.toList ++ List.zipWith f as bs |
WeierstrassCurve.Projective.Point.mk.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { point := point_1, nonsingular := nonsingular_1 } → point = point_1 |
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E}, IsIdempotentElem T → (T.IsSymmetric ↔ T.range ⟂ T.ker) |
dist_le_range_sum_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (f : ℕ → α) (n : ℕ),
dist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, dist (f i) (f (i + 1)) |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheorems |
CStarMatrix.ofMatrixRingEquiv._proof_2 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1) |
PiTensorProduct.mapMultilinear_apply | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ι → Type u_7) [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (t : ι → Type u_11) [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i →ₗ[R] t i),
(PiTensorProduct.mapMultilinear R s t) f = PiTensorProduct.map f |
«term_=_» | Init.Notation | Lean.TrailingParserDescr |
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst Y.hom Z.hom) h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst.left h |
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x |
Matrix.det_of_mem_unitary | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
{A : Matrix n n α}, A ∈ Matrix.unitaryGroup n α → A.det ∈ unitary α |
instAB4AddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | CategoryTheory.AB4 AddCommGrpCat |
ContinuousAt.lineMap | Mathlib.Topology.Algebra.Affine | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace X]
{f₁ f₂ : X → P} {g : X → R} {x : X},
ContinuousAt f₁ x →
ContinuousAt f₂ x → ContinuousAt g x → ContinuousAt (fun x => (AffineMap.lineMap (f₁ x) (f₂ x)) (g x)) x |
AddMonoidAlgebra.le_infDegree_mul | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A →ₙ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMonoidAlgebra.infDegree (⇑D) (f * g) |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a ≤ x ∧ x ≤ b → ¬((x - a).toNat < (b + 1 - a).toNat ∧ a + ↑(x - a).toNat = x) → False |
instCompleteLatticeStructureGroupoid._proof_7 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b ≤ SemilatticeSup.sup a b |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ : ℕ), max n₁ n₂ + 1 + (max n₁ n₂ + 1) ≤ 2 * max n₁ n₂ + 1 + 1 |
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames | Lean.Meta.Tactic.ExposeNames | Lean.MetaM Lean.LocalContext |
List.cons.inj | Init.Core | ∀ {α : Type u} {head : α} {tail : List α} {head_1 : α} {tail_1 : List α},
head :: tail = head_1 :: tail_1 → head = head_1 ∧ tail = tail_1 |
Empty.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | BorelSpace Empty |
QuaternionAlgebra.Basis.k_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).k = F q.k |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : ℕ) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size ≤ { aig := aig_1, vec := expr }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate (↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig
{ w := w_1, n := n, inner := expr, h := h }).aig.decls.size |
Std.Time.Month.Ordinal.january | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal |
Aesop.RuleResult.ctorIdx | Aesop.Search.Expansion | Aesop.RuleResult → ℕ |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {w : ℕ}, ∀ curr < w, curr + 1 ≤ w |
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.LeftHomologyData) [CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂]
(wi : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) S₁.g = 0)
(hi :
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) wi)),
hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯) = CategoryTheory.CategoryStruct.comp φ.τ₁ h.f' →
∀ {Z' : C} (x : h.K ⟶ Z'),
CategoryTheory.CategoryStruct.comp (hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯)) x = 0 →
CategoryTheory.CategoryStruct.comp h.f' x = 0 |
Subsemiring.instTop._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R], 0 ∈ ⊤.carrier |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
RootPairing.Hom.comp._proof_3 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_6} {R : Type u_4} {M : Type u_7} {N : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₁ : Type u_8} {M₁ : Type u_9} {N₁ : Type u_5}
{ι₂ : Type u_2} {M₂ : Type u_10} {N₂ : Type u_3} [inst_5 : AddCommGroup M₁] [inst_6 : Module R M₁]
[inst_7 : AddCommGroup N₁] [inst_8 : Module R N₁] [inst_9 : AddCommGroup M₂] [inst_10 : Module R M₂]
[inst_11 : AddCommGroup N₂] [inst_12 : Module R N₂] {P : RootPairing ι R M N} {P₁ : RootPairing ι₁ R M₁ N₁}
{P₂ : RootPairing ι₂ R M₂ N₂} (g : P₁.Hom P₂) (f : P.Hom P₁),
⇑(f.coweightMap ∘ₗ g.coweightMap) ∘ ⇑P₂.coroot = ⇑P.coroot ∘ ⇑(f.indexEquiv.trans g.indexEquiv).symm |
SchwartzMap.compCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (k n l : ℕ) (C : ℝ),
0 ≤ C →
∀ (kg : ℕ) (Cg : ℝ), 1 ≤ 1 + Cg → 0 ≤ (1 + Cg) ^ (k + l * n) * ((C + 1) ^ n * ↑n.factorial * 2 ^ (kg * (k + l * n))) |
CategoryTheory.MorphismProperty.precoverage_monotone | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P ≤ Q → P.precoverage ≤ Q.precoverage |
RingHom.formallyEtale_algebraMap | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale ↔ Algebra.FormallyEtale R S |
Order.Ideal.coe_sup_eq | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} |
ContinuousMultilinearMap.smulRight_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : CommSemiring 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 : TopologicalSpace R] [inst_6 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_7 : TopologicalSpace M₂] [inst_8 : ContinuousSMul R M₂] (f : ContinuousMultilinearMap R M₁ R) (z : M₂)
(a : (i : ι) → M₁ i), (f.smulRight z) a = f a • z |
Int.negOnePow_two_mul_add_one | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), (2 * n + 1).negOnePow = -1 |
Lean.Server.Watchdog.CallHierarchyItemData | Lean.Server.Watchdog | Type |
Std.Time.FormatPart.noConfusionType | Std.Time.Format.Basic | Sort u → Std.Time.FormatPart → Std.Time.FormatPart → Sort u |
Nat.testBit_ofBits_lt | Batteries.Data.Nat.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ) (h : i < n), (Nat.ofBits f).testBit i = f ⟨i, h⟩ |
HahnSeries.leadingCoeff_abs | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Γ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff| |
isOpenMap_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) |
SimpleGraph.TripartiteFromTriangles.NoAccidental.mk._flat_ctor | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)},
(∀ ⦃a a' : α⦄ ⦃b b' : β⦄ ⦃c c' : γ⦄, (a', b, c) ∈ t → (a, b', c) ∈ t → (a, b, c') ∈ t → a = a' ∨ b = b' ∨ c = c') →
SimpleGraph.TripartiteFromTriangles.NoAccidental t |
Int64.right_eq_add | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, b = a + b ↔ a = 0 |
Std.TreeMap.Raw.mem_union_of_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ → k ∈ t₁ ∪ t₂ |
MvPowerSeries.one_le_order_iff_constCoeff_eq_zero | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {f : MvPowerSeries σ R},
1 ≤ f.order ↔ MvPowerSeries.constantCoeff f = 0 |
CompletelyDistribLattice.top_sdiff | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [self : CompletelyDistribLattice α] (a : α), ⊤ \ a = ￢a |
IsInvariantSubring.toMulSemiringAction._proof_1 | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[IsInvariantSubring M S] (m : M) (x : ↥S), m • ↑x ∈ S |
Lean.Widget.GetInteractiveDiagnosticsParams.mk.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (lineRange? : Option Lean.Lsp.LineRange), sizeOf { lineRange? := lineRange? } = 1 + sizeOf lineRange? |
Std.Net.SocketAddress | Std.Net.Addr | Type |
IsClosedMap.specializingMap | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → SpecializingMap f |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex)
(n : ℕ) (g : P.complex.X n ⟶ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) ⟶ Q.complex.X (n + 2))
(w :
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
{Z_1 : C} (h : Q.complex.X (n + 2) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
(CategoryTheory.CategoryStruct.comp (Q.complex.d (n + 3) (n + 2)) h) =
CategoryTheory.CategoryStruct.comp
(f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g') h |
CategoryTheory.Functor.IsEventuallyConstantFrom.isIso_ι_of_isColimit' | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J},
F.IsEventuallyConstantFrom i₀ →
∀ [CategoryTheory.IsFiltered J] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(j : J) (ι : i₀ ⟶ j), CategoryTheory.IsIso (c.ι.app j) |
_private.Lean.Syntax.0.Lean.Syntax.findStack?.go.match_3 | Lean.Syntax | (motive : Option (Option Lean.Syntax.Stack) → Sort u_1) →
(x : Option (Option Lean.Syntax.Stack)) →
(Unit → motive none) → ((a : Option Lean.Syntax.Stack) → motive (some a)) → motive x |
PUnit.inv_eq | Mathlib.Algebra.Group.PUnit | ∀ (x : PUnit.{u_1 + 1}), x⁻¹ = PUnit.unit |
CategoryTheory.Functor.mapCocone₂_pt | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C] (G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C))
{K₁ : CategoryTheory.Functor J₁ C₁} {K₂ : CategoryTheory.Functor J₂ C₂} (c₁ : CategoryTheory.Limits.Cocone K₁)
(c₂ : CategoryTheory.Limits.Cocone K₂), (G.mapCocone₂ c₁ c₂).pt = (G.obj c₁.pt).obj c₂.pt |
CauSeq.equiv_lim | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] [inst_5 : CauSeq.IsComplete β abv] (s : CauSeq β abv),
s ≈ CauSeq.const abv s.lim |
MontelSpace.rec | Mathlib.Analysis.LocallyConvex.Montel | {𝕜 : Type u_4} →
{E : Type u_5} →
[inst : SeminormedRing 𝕜] →
[inst_1 : Zero E] →
[inst_2 : SMul 𝕜 E] →
[inst_3 : TopologicalSpace E] →
{motive : MontelSpace 𝕜 E → Sort u} →
((heine_borel : ∀ (s : Set E), IsClosed s → Bornology.IsVonNBounded 𝕜 s → IsCompact s) → motive ⋯) →
(t : MontelSpace 𝕜 E) → motive t |
Subgroup.pi | Mathlib.Algebra.Group.Subgroup.Basic | {η : Type u_7} →
{f : η → Type u_8} → [inst : (i : η) → Group (f i)] → Set η → ((i : η) → Subgroup (f i)) → Subgroup ((i : η) → f i) |
Set.zero_notMem_sub_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∉ s - t ↔ Disjoint s t |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr |
List.Subset.antisymm_of_sortedLT | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : PartialOrder α] {l₁ l₂ : List α}, l₁ ⊆ l₂ → l₂ ⊆ l₁ → l₁.SortedLT → l₂.SortedLT → l₁ = l₂ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.