name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Std.Sat.AIG.denote_idx_gate
|
Std.Sat.AIG.Lemmas
|
∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG α} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ =
(⟦assign, { aig := aig, ref := { gate := lhs.gate, invert := lhs.invert, hgate := ⋯ } }⟧ &&
⟦assign, { aig := aig, ref := { gate := rhs.gate, invert := rhs.invert, hgate := ⋯ } }⟧ ^^
invert)
|
TopologicalSpace.DiscreteTopology.metrizableSpace
|
Mathlib.Topology.Metrizable.Basic
|
∀ {X : Type u_2} [inst : TopologicalSpace X] [DiscreteTopology X], TopologicalSpace.MetrizableSpace X
|
CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit
|
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] →
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G] →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (G.map CategoryTheory.Limits.prod.fst)
(G.map CategoryTheory.Limits.prod.snd))
|
Real.fourierIntegralInv_comp_linearIsometry
|
Mathlib.Analysis.Fourier.FourierTransform
|
∀ {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 : MeasurableSpace V] [inst_5 : BorelSpace V] {W : Type u_3}
[inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace ℝ W] [inst_8 : MeasurableSpace W] [inst_9 : BorelSpace W]
[inst_10 : FiniteDimensional ℝ W] [inst_11 : FiniteDimensional ℝ V] (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W),
FourierTransformInv.fourierInv (f ∘ ⇑A) w = FourierTransformInv.fourierInv f (A w)
|
convexHull_empty_iff
|
Mathlib.Analysis.Convex.Hull
|
∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E}, (convexHull 𝕜) s = ∅ ↔ s = ∅
|
CategoryTheory.ShortComplex.Splitting.mk._flat_ctor
|
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} →
(r : S.X₂ ⟶ S.X₁) →
(s : S.X₃ ⟶ S.X₂) →
autoParam (CategoryTheory.CategoryStruct.comp S.f r = CategoryTheory.CategoryStruct.id S.X₁)
CategoryTheory.ShortComplex.Splitting.f_r._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp s S.g = CategoryTheory.CategoryStruct.id S.X₃)
CategoryTheory.ShortComplex.Splitting.s_g._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp r S.f + CategoryTheory.CategoryStruct.comp S.g s =
CategoryTheory.CategoryStruct.id S.X₂)
CategoryTheory.ShortComplex.Splitting.id._autoParam →
S.Splitting
|
Mathlib.Tactic.ITauto.Proof.orImpL.sizeOf_spec
|
Mathlib.Tactic.ITauto
|
∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orImpL = 1 + sizeOf p
|
Dense.eq_of_inner_right
|
Mathlib.Analysis.InnerProductSpace.Projection.Submodule
|
∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} {x y : E}, Dense ↑K → (∀ (v : ↥K), inner 𝕜 (↑v) x = inner 𝕜 (↑v) y) → x = y
|
iteratedDerivWithin_add
|
Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas
|
∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
∀ {f g : 𝕜 → F},
ContDiffWithinAt 𝕜 (↑n) f s x →
ContDiffWithinAt 𝕜 (↑n) g s x →
iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x
|
FermatLastTheoremForThreeGen.Solution.toSolution'
|
Mathlib.NumberTheory.FLT.Three
|
{K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution hζ → FermatLastTheoremForThreeGen.Solution' hζ
|
MeasureTheory.lintegral_def
|
Mathlib.MeasureTheory.Integral.Lebesgue.Basic
|
∀ {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
MeasureTheory.lintegral μ f = ⨆ g, ⨆ (_ : ⇑g ≤ f), g.lintegral μ
|
Polynomial.Splits.X_pow
|
Mathlib.Algebra.Polynomial.Splits
|
∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (Polynomial.X ^ n).Splits
|
Lean.Compiler.LCNF.Phase.le_refl._simp_1
|
Lean.Compiler.LCNF.PassManager
|
∀ (p : Lean.Compiler.LCNF.Phase), (p ≤ p) = True
|
ENNReal.continuousAt_const_mul
|
Mathlib.Topology.Instances.ENNReal.Lemmas
|
∀ {a b : ENNReal}, a ≠ ⊤ ∨ b ≠ 0 → ContinuousAt (fun x => a * x) b
|
DirectSum.Decomposition.mk.noConfusion
|
Mathlib.Algebra.DirectSum.Decomposition
|
{ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
{inst : DecidableEq ι} →
{inst_1 : AddCommMonoid M} →
{inst_2 : SetLike σ M} →
{inst_3 : AddSubmonoidClass σ M} →
{ℳ : ι → σ} →
{P : Sort u} →
{decompose' : M → DirectSum ι fun i => ↥(ℳ i)} →
{left_inv : Function.LeftInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose'} →
{right_inv : Function.RightInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose'} →
{decompose'' : M → DirectSum ι fun i => ↥(ℳ i)} →
{left_inv' : Function.LeftInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose''} →
{right_inv' : Function.RightInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose''} →
{ decompose' := decompose', left_inv := left_inv, right_inv := right_inv } =
{ decompose' := decompose'', left_inv := left_inv', right_inv := right_inv' } →
(decompose' ≍ decompose'' → P) → P
|
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_1
|
Mathlib.RingTheory.Adjoin.Field
|
∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : ↥S}, (x = 0) = (↑x = 0)
|
intervalIntegral.FTCFilter.le_nhds
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
|
∀ {a : outParam ℝ} (outer : Filter ℝ) {inner : outParam (Filter ℝ)} [self : intervalIntegral.FTCFilter a outer inner],
inner ≤ nhds a
|
Mathlib.Meta.Positivity.evalNNRealSqrt
|
Mathlib.Data.Real.Sqrt
|
Mathlib.Meta.Positivity.PositivityExt
|
Submonoid.units._proof_2
|
Mathlib.Algebra.Group.Submonoid.Units
|
∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ},
x ∈ (Submonoid.comap (Units.coeHom M) S ⊓ (Submonoid.comap (Units.coeHom M) S)⁻¹).carrier →
x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S) ∧ x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S)⁻¹
|
Order.isPredLimitRecOn_pred_of_not_isMin
|
Mathlib.Order.SuccPred.Limit
|
∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : PredOrder α]
(isMax : (a : α) → IsMax a → motive a) (pred : (a : α) → ¬IsMin a → motive (Order.pred a))
(isPredLimit : (a : α) → Order.IsPredLimit a → motive a) (hb : ¬IsMin b),
Order.isPredLimitRecOn (Order.pred b) isMax pred isPredLimit = pred b hb
|
CategoryTheory.ObjectProperty.isSeparating_unop_iff
|
Mathlib.CategoryTheory.Generator.Basic
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
P.unop.IsSeparating ↔ P.IsCoseparating
|
_private.Mathlib.Algebra.BigOperators.Group.Finset.Gaps.0.Finset.sum_eq_sum_range_intervalGapsWithin._proof_1_5
|
Mathlib.Algebra.BigOperators.Group.Finset.Gaps
|
∀ {k : ℕ}, ∀ i ∈ Set.Iio k, i ∈ Finset.range k
|
Std.DTreeMap.Internal.Impl.get?ₘ_eq_getValueCast?
|
Std.Data.DTreeMap.Internal.WF.Lemmas
|
∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : Std.LawfulEqOrd α] [inst_3 : BEq α]
[inst_4 : Std.LawfulBEqOrd α] {k : α} {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get?ₘ k = Std.Internal.List.getValueCast? k t.toListModel
|
MeasureTheory.SignedMeasure.null_of_totalVariation_zero
|
Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan
|
∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) {i : Set α},
s.totalVariation i = 0 → ↑s i = 0
|
Module.Free.chooseBasis._proof_1
|
Mathlib.LinearAlgebra.FreeModule.Basic
|
∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M], Nonempty (Module.Basis (↑⋯.choose) R M)
|
Affine.Simplex.excenterWeights_compl
|
Mathlib.Geometry.Euclidean.Incenter
|
∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.excenterWeights signsᶜ = s.excenterWeights signs
|
_private.Mathlib.NumberTheory.SumFourSquares.0.Int.sq_add_sq_of_two_mul_sq_add_sq._simp_1_1
|
Mathlib.NumberTheory.SumFourSquares
|
∀ {α : Type u_2} [inst : Semiring α] {a : α}, (2 ∣ a) = Even a
|
Representation.Coinvariants.hom_ext_iff
|
Mathlib.RepresentationTheory.Coinvariants
|
∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing k] [inst_1 : Monoid G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
{ρ : Representation k G V} {f g : ρ.Coinvariants →ₗ[k] W},
f = g ↔ f ∘ₗ Representation.Coinvariants.mk ρ = g ∘ₗ Representation.Coinvariants.mk ρ
|
ValuativeRel.IsRankLeOne.mk
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R],
Nonempty (ValuativeRel.RankLeOneStruct R) → ValuativeRel.IsRankLeOne R
|
Function.Antiperiodic.funext'
|
Mathlib.Algebra.Ring.Periodic
|
∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Add α] [inst_1 : InvolutiveNeg β],
Function.Antiperiodic f c → (fun x => -f (x + c)) = f
|
Array.getElem?_zip_eq_some
|
Init.Data.Array.Zip
|
∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β} {z : α × β} {i : ℕ},
(as.zip bs)[i]? = some z ↔ as[i]? = some z.1 ∧ bs[i]? = some z.2
|
Std.TreeMap.Raw.maxKey!_insert
|
Std.Data.TreeMap.Raw.Lemmas
|
∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).maxKey! = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k'
|
FirstOrder.Language.PartialEquiv.mk.injEq
|
Mathlib.ModelTheory.PartialEquiv
|
∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(dom : L.Substructure M) (cod : L.Substructure N) (toEquiv : L.Equiv ↥dom ↥cod) (dom_1 : L.Substructure M)
(cod_1 : L.Substructure N) (toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1),
({ dom := dom, cod := cod, toEquiv := toEquiv } = { dom := dom_1, cod := cod_1, toEquiv := toEquiv_1 }) =
(dom = dom_1 ∧ cod = cod_1 ∧ toEquiv ≍ toEquiv_1)
|
Std.TreeMap.keys.eq_1
|
Std.Data.TreeSet.Iterator
|
∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp), t.keys = t.inner.keys
|
List.unattach_append
|
Init.Data.List.Attach
|
∀ {α : Type u_1} {p : α → Prop} {l₁ l₂ : List { x // p x }}, (l₁ ++ l₂).unattach = l₁.unattach ++ l₂.unattach
|
TopologicalSpace.Opens.coe_eq_univ._simp_1
|
Mathlib.Topology.Sets.Opens
|
∀ {α : Type u_2} [inst : TopologicalSpace α] {U : TopologicalSpace.Opens α}, (↑U = Set.univ) = (U = ⊤)
|
AddMonoidAlgebra.sup_support_list_prod_le
|
Mathlib.Algebra.MonoidAlgebra.Degree
|
∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid B] [AddLeftMono B] [AddRightMono B] {degb : A → B},
degb 0 ≤ 0 →
(∀ (a b : A), degb (a + b) ≤ degb a + degb b) →
∀ (l : List (AddMonoidAlgebra R A)), l.prod.support.sup degb ≤ (List.map (fun f => f.support.sup degb) l).sum
|
Primrec.fst
|
Mathlib.Computability.Primrec.Basic
|
∀ {α : Type u_2} {β : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec Prod.fst
|
_private.Mathlib.Data.List.InsertIdx.0.List.take_eraseIdx_eq_take_of_le._proof_1_1
|
Mathlib.Data.List.InsertIdx
|
∀ {α : Type u_1} (l : List α) (i j : ℕ), i ≤ j → (List.take i (l.eraseIdx j)).length = (List.take i l).length
|
Mathlib.Linter.linter.upstreamableDecl.private
|
Mathlib.Tactic.Linter.UpstreamableDecl
|
Lean.Option Bool
|
QuadraticMap.proj_apply
|
Mathlib.LinearAlgebra.QuadraticForm.Basic
|
∀ {R : Type u_3} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {n : Type u_9} (i j : n) (x : n → A),
(QuadraticMap.proj i j) x = x i * x j
|
UInt8.xor_right_inj
|
Init.Data.UInt.Bitwise
|
∀ {a b : UInt8} (c : UInt8), c ^^^ a = c ^^^ b ↔ a = b
|
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.instInhabitedStartsWithResult
|
Lean.Meta.Tactic.Grind.AC.Seq
|
Inhabited Lean.Grind.AC.StartsWithResult✝
|
AbsoluteValue.casesOn
|
Mathlib.Algebra.Order.AbsoluteValue.Basic
|
{R : Type u_5} →
{S : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : PartialOrder S] →
{motive : AbsoluteValue R S → Sort u} →
(t : AbsoluteValue R S) →
((toMulHom : R →ₙ* S) →
(nonneg' : ∀ (x : R), 0 ≤ toMulHom.toFun x) →
(eq_zero' : ∀ (x : R), toMulHom.toFun x = 0 ↔ x = 0) →
(add_le' : ∀ (x y : R), toMulHom.toFun (x + y) ≤ toMulHom.toFun x + toMulHom.toFun y) →
motive { toMulHom := toMulHom, nonneg' := nonneg', eq_zero' := eq_zero', add_le' := add_le' }) →
motive t
|
Aesop.GoalId.mk
|
Aesop.Tree.Data
|
ℕ → Aesop.GoalId
|
Lean.mkPropEq
|
Lean.Expr
|
Lean.Expr → Lean.Expr → Lean.Expr
|
Lean.Elab.Term.elabWaitIfContainsMVar._regBuiltin.Lean.Elab.Term.elabWaitIfContainsMVar_1
|
Lean.Elab.BuiltinTerm
|
IO Unit
|
CochainComplex.HomComplex.δ_comp_zero_cochain
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C ℤ} {n₁ : ℤ} (z₁ : CochainComplex.HomComplex.Cochain F G n₁)
(z₂ : CochainComplex.HomComplex.Cochain G K 0) (m₁ : ℤ) (h₁ : n₁ + 1 = m₁),
CochainComplex.HomComplex.δ n₁ m₁ (z₁.comp z₂ ⋯) =
z₁.comp (CochainComplex.HomComplex.δ 0 1 z₂) h₁ + (CochainComplex.HomComplex.δ n₁ m₁ z₁).comp z₂ ⋯
|
CompTriple.instIsIdId
|
Mathlib.Logic.Function.CompTypeclasses
|
∀ {M : Type u_1}, CompTriple.IsId id
|
SimpleGraph.Walk.support_concat
|
Mathlib.Combinatorics.SimpleGraph.Walks.Operations
|
∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w),
(p.concat h).support = p.support.concat w
|
CategoryTheory.Limits.pullbackConeOfRightIso_π_app_none
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso g], (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app none = f
|
List.Vector.snoc.eq_1
|
Mathlib.Data.Vector.Snoc
|
∀ {α : Type u_1} {n : ℕ} (xs : List.Vector α n) (x : α), xs.snoc x = xs ++ x ::ᵥ List.Vector.nil
|
Finsupp.equivMapDomain.eq_1
|
Mathlib.Data.Finsupp.Basic
|
∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M),
Finsupp.equivMapDomain f l =
{ support := Finset.map f.toEmbedding l.support, toFun := fun a => l (f.symm a), mem_support_toFun := ⋯ }
|
AlgHom.ext
|
Mathlib.Algebra.Algebra.Hom
|
∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {φ₁ φ₂ : A →ₐ[R] B}, (∀ (x : A), φ₁ x = φ₂ x) → φ₁ = φ₂
|
Associated.instIsTrans
|
Mathlib.Algebra.GroupWithZero.Associated
|
∀ {M : Type u_1} [inst : Monoid M], IsTrans M Associated
|
IsFiniteLength.brecOn
|
Mathlib.RingTheory.FiniteLength
|
∀ {R : Type u_1} [inst : Ring R]
{motive : (M : Type u_2) → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → IsFiniteLength R M → Prop}
{M : Type u_2} {inst_1 : AddCommGroup M} {inst_2 : Module R M} (t : IsFiniteLength R M),
(∀ (M : Type u_2) [inst_3 : AddCommGroup M] [inst_4 : Module R M] (t : IsFiniteLength R M),
IsFiniteLength.below t → motive M t) →
motive M t
|
Int.ModEq.of_mul_right
|
Mathlib.Data.Int.ModEq
|
∀ {n a b : ℤ} (m : ℤ), a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n]
|
Std.Notify.wait
|
Std.Sync.Notify
|
Std.Notify → IO (Std.Internal.IO.Async.AsyncTask Unit)
|
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_1
|
Mathlib.CategoryTheory.Bicategory.CatEnriched
|
∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b)
|
Matrix.mulVec_surjective_iff_isUnit
|
Mathlib.LinearAlgebra.Matrix.NonsingularInverse
|
∀ {m : Type u} [inst : DecidableEq m] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Fintype m] {A : Matrix m m R},
Function.Surjective A.mulVec ↔ IsUnit A
|
_private.Mathlib.Data.Nat.Factorization.PrimePow.0.isPrimePow_iff_card_primeFactors_eq_one._simp_1_2
|
Mathlib.Data.Nat.Factorization.PrimePow
|
∀ (n : ℕ), n.primeFactors = n.factorization.support
|
CategoryTheory.Bicategory.Pseudofunctor.ofLaxFunctorToLocallyGroupoid._proof_4
|
Mathlib.CategoryTheory.Bicategory.LocallyGroupoid
|
∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {B' : Type u_5} [inst_1 : CategoryTheory.Bicategory B']
[CategoryTheory.Bicategory.IsLocallyGroupoid B] (F : CategoryTheory.LaxFunctor B' B) {a b c : B'} (f : a ⟶ b)
(g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g)
|
StrictConvexSpace.of_norm_add_ne_two
|
Mathlib.Analysis.Convex.StrictConvexSpace
|
∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
(∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) → StrictConvexSpace ℝ E
|
CompHausLike.LocallyConstant.adjunction
|
Mathlib.Condensed.Discrete.LocallyConstant
|
(P : TopCat → Prop) →
[∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
[inst : CompHausLike.HasProp P PUnit.{u + 1}] →
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P] →
[inst_2 : CompHausLike.HasExplicitPullbacks P] →
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) →
[CompHausLike.HasExplicitFiniteCoproducts P] →
CompHausLike.LocallyConstant.functor P hs ⊣
(CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj
(Opposite.op (CompHausLike.of P PUnit.{u + 1}))
|
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.pderiv_inr_universalFactorizationMap_X._proof_1_9
|
Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
|
∀ (n k : ℕ) (i : Fin k) (j : Fin n), ↑i ≤ ↑j → ∀ (a b : ℕ), a + b = ↑j → ¬(a = ↑j - ↑i ∧ b = ↑i) → ¬b = ↑i
|
Int.subNatNat_sub
|
Init.Data.Int.Lemmas
|
∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), Int.subNatNat (m - n) k = Int.subNatNat m (k + n)
|
Manifold.«_aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termHasMFDerivAt%_______1»
|
Mathlib.Geometry.Manifold.Notation
|
Lean.Elab.Term.TermElab
|
Ordinal.veblen_left_monotone
|
Mathlib.SetTheory.Ordinal.Veblen
|
∀ (o : Ordinal.{u_1}), Monotone fun x => Ordinal.veblen x o
|
Ideal.primeHeight_eq_ringKrullDim_iff
|
Mathlib.RingTheory.Ideal.Height
|
∀ {R : Type u_1} [inst : CommRing R] [FiniteRingKrullDim R] [inst_2 : IsLocalRing R] {I : Ideal R} [inst_3 : I.IsPrime],
↑I.primeHeight = ringKrullDim R ↔ I = IsLocalRing.maximalIdeal R
|
Aesop.EqualUpToIdsM.Context._sizeOf_1
|
Aesop.Util.EqualUpToIds
|
Aesop.EqualUpToIdsM.Context → ℕ
|
Lean.Meta.Grind.CnstrRHS.mk.inj
|
Lean.Meta.Tactic.Grind.Extension
|
∀ {levelNames : Array Lean.Name} {numMVars : ℕ} {expr : Lean.Expr} {levelNames_1 : Array Lean.Name} {numMVars_1 : ℕ}
{expr_1 : Lean.Expr},
{ levelNames := levelNames, numMVars := numMVars, expr := expr } =
{ levelNames := levelNames_1, numMVars := numMVars_1, expr := expr_1 } →
levelNames = levelNames_1 ∧ numMVars = numMVars_1 ∧ expr = expr_1
|
CategoryTheory.Lax.LaxTrans.StrongCore.mk.inj
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax
|
∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η : F ⟶ G}
{naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (η.app b)}
{naturality_hom :
autoParam (∀ {a b : B} (f : a ⟶ b), (naturality f).hom = η.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam}
{naturality_1 :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (η.app b)}
{naturality_hom_1 :
autoParam (∀ {a b : B} (f : a ⟶ b), (naturality_1 f).hom = η.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam},
{ naturality := naturality, naturality_hom := naturality_hom } =
{ naturality := naturality_1, naturality_hom := naturality_hom_1 } →
naturality = naturality_1
|
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_11
|
Batteries.Data.List.Lemmas
|
∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length
|
AddConstMap.instMonoid
|
Mathlib.Algebra.AddConstMap.Basic
|
{G : Type u_1} → [inst : Add G] → {a : G} → Monoid (AddConstMap G G a a)
|
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_principal._simp_1_2
|
Mathlib.Order.Filter.Basic
|
∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x
|
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx
|
Lean.Elab.Tactic.Induction
|
Lean.Meta.ElimInfo →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) →
Array Lean.Syntax → ℕ → Lean.Syntax → Lean.Elab.Tactic.ElimApp.Alt → Lean.Elab.Tactic.TacticM PUnit.{1}
|
Finset.compls_inter
|
Mathlib.Data.Finset.Sups
|
∀ {α : Type u_2} [inst : BooleanAlgebra α] [inst_1 : DecidableEq α] (s t : Finset α),
(s ∩ t).compls = s.compls ∩ t.compls
|
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_6
|
Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation
|
∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → ∀ r ∈ quasispectrum ℝ a, r ∈ Set.Ici 0
|
AlgebraicGeometry.Scheme.Modules.Hom.mapPresheaf
|
Mathlib.AlgebraicGeometry.Modules.Sheaf
|
{X : AlgebraicGeometry.Scheme} → {M N : X.Modules} → (M ⟶ N) → (M.presheaf ⟶ N.presheaf)
|
add_neg_lt_iff_lt_add
|
Mathlib.Algebra.Order.Group.Unbundled.Basic
|
∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, a + -b < c ↔ a < c + b
|
instHasColimitsCommAlgCat
|
Mathlib.Algebra.Category.CommAlgCat.Basic
|
∀ {R : Type u} [inst : CommRing R], CategoryTheory.Limits.HasColimits (CommAlgCat R)
|
BoundedLatticeHom.toInfTopHom._proof_1
|
Mathlib.Order.Hom.BoundedLattice
|
∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom α β) (a b : α), f.toFun (a ⊓ b) = f.toFun a ⊓ f.toFun b
|
BitVec.toInt_not
|
Init.Data.BitVec.Lemmas
|
∀ {w : ℕ} {x : BitVec w}, (~~~x).toInt = (2 ^ w - 1 - ↑x.toNat).bmod (2 ^ w)
|
CategoryTheory.MorphismProperty.colimitsOfShape_discrete_le_llp_rlp
|
Mathlib.CategoryTheory.MorphismProperty.LiftingProperty
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type w),
T.colimitsOfShape (CategoryTheory.Discrete J) ≤ T.rlp.llp
|
_private.Lean.Elab.Deriving.Nonempty.0.Lean.Elab.Deriving.initFn._@.Lean.Elab.Deriving.Nonempty.1889502729._hygCtx._hyg.2
|
Lean.Elab.Deriving.Nonempty
|
IO Unit
|
String.toList.eq_1
|
Init.Data.String.Basic
|
∀ (s : String), s.toList = (String.Internal.toArray s).toList
|
SchwartzMap.evalCLM._proof_3
|
Mathlib.Analysis.Distribution.SchwartzSpace.Basic
|
∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NormedField 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G],
ContinuousConstSMul 𝕜 G
|
CoxeterMatrix.ext
|
Mathlib.GroupTheory.Coxeter.Matrix
|
∀ {B : Type u_1} {x y : CoxeterMatrix B}, x.M = y.M → x = y
|
Invertible.mulRight
|
Mathlib.Algebra.Group.Invertible.Basic
|
{α : Type u} → [inst : Monoid α] → (a : α) → {b : α} → Invertible b → Invertible a ≃ Invertible (a * b)
|
Multiset.right_notMem_Ioo
|
Mathlib.Order.Interval.Multiset
|
∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∉ Multiset.Ioo a b
|
_private.Lean.Server.FileWorker.SetupFile.0.Lean.Server.FileWorker.runLakeSetupFile._sparseCasesOn_1
|
Lean.Server.FileWorker.SetupFile
|
{motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.never → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t
|
WeierstrassCurve.coe_variableChange_Δ'
|
Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange
|
∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], ↑(C • W).Δ' = ↑C.u⁻¹ ^ 12 * ↑W.Δ'
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits
|
Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation
|
{n : ℕ} → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n
|
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_452
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital
|
Lean.Syntax
|
instDecidableEqZNum.decEq._proof_10
|
Mathlib.Data.Num.Basic
|
∀ (a b : PosNum), ¬a = b → ¬ZNum.neg a = ZNum.neg b
|
AbstractCompletion.closure_range
|
Mathlib.Topology.UniformSpace.AbstractCompletion
|
∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α), closure (Set.range pkg.coe) = Set.univ
|
Lean.KVMap.entries
|
Lean.Data.KVMap
|
Lean.KVMap → List (Lean.Name × Lean.DataValue)
|
ULift.leftCancelMonoid.eq_1
|
Mathlib.Algebra.Group.ULift
|
∀ {α : Type u} [inst : LeftCancelMonoid α],
ULift.leftCancelMonoid = Function.Injective.leftCancelMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯
|
Aesop.LocalRuleSet.simprocsArray
|
Aesop.RuleSet
|
Aesop.LocalRuleSet → Array (Lean.Name × Lean.Meta.Simprocs)
|
isTotallyDisconnected_iff_lt
|
Mathlib.Topology.Order.IntermediateValue
|
∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsTotallyDisconnected s ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Set.Ioo x y
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.