name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.Tactic.Omega.MetaProblem.ctorIdx | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → ℕ | null | false |
PEquiv.trans_assoc | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ),
(f.trans g).trans h = f.trans (g.trans h) | null | true |
Path.Homotopic.proj.eq_1 | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i} (i : ι)
(p : Path.Homotopic.Quotient as bs), Path.Homotopic.proj i p = p.map { toFun := fun p => p i, continuous_toFun := ⋯ } | null | true |
UInt16.ofInt_one | Init.Data.UInt.Lemmas | UInt16.ofInt 1 = 1 | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._simp_2 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, (orderOf x ∣ n) = (x ^ n = 1) | null | false |
Order.krullDim_eq_iSup_length | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], Order.krullDim α = ↑(⨆ p, ↑p.length) | A definition of krullDim for nonempty `α` that avoids `WithBot` | true |
FormalMultilinearSeries.id._proof_4 | Mathlib.Analysis.Analytic.Composition | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | null | false |
Equiv.Perm.Basis.toCentralizer_apply | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α), ↑(a.toCentralizer τ) x = a.ofPermHomFun τ x | null | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α fun x => Unit) (h : t.Balanced) (a : α)
(__s : Std.DTreeMap.Internal.Impl.Const.IteratedUnitInsertionInto t)
{P : (Std.DTreeMap.Internal.Impl α fun x => Unit) → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α fun x => Unit) (a : α) (h : t''... | null | false |
GaloisCoinsertion.liftCompleteLattice.eq_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : PartialOrder β] [inst_1 : CompleteLattice α]
(gi : GaloisCoinsertion u l),
gi.liftCompleteLattice =
{ toLattice := gi.liftLattice, sSup := fun s => gi.choice (sSup (u '' s)) ⋯, isLUB_sSup := ⋯,
sInf := fun s => l (sInf (u '' s)), isGLB_sInf := ⋯,... | null | true |
RBTree.RBNode.fold | BatteriesRecycling.RBTree.Basic | {σ : Sort u_1} → {α : Type u_2} → σ → (σ → α → σ → σ) → RBTree.RBNode α → σ | Fold a function in tree order along the nodes. `v₀` is used at `nil` nodes and
`f` is used to combine results at branching nodes.
| true |
Vector.getElem_zero_flatten | Init.Data.Vector.Find | ∀ {α : Type u_1} {m n : ℕ} {xss : Vector (Vector α m) n} (h : 0 < n * m),
xss.flatten[0] = (Vector.findSome? (fun xs => xs[0]?) xss).get ⋯ | null | true |
MonoidHom.coeToMulHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N],
MonoidHom.coeToMulHom = { coe := MonoidHom.toMulHom } | null | true |
String.Pos.lt_of_lt_of_le | Init.Data.String.Basic | ∀ {s : String} {p q r : s.Pos}, p < q → q ≤ r → p < r | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isProofQuickApp | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool | `isProofQuickApp f n` is an "approximate" predicate which returns `LBool.true` if `f` applied to
`n` arguments is a proof.
| true |
HomotopyCategory.instPretriangulatedIntUp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.Limits.HasBinaryBiproducts C] →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
CategoryTheory.Pretriangulated (HomotopyCategory C (ComplexShape.up ℤ)) | null | true |
ClopenUpperSet.ext_iff | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] {s t : ClopenUpperSet α}, s = t ↔ ↑s = ↑t | null | true |
Equiv.ext_iff | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, f = g ↔ ∀ (x : α), f x = g x | null | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C.match_1_4 | Mathlib.Algebra.Polynomial.Derivative | {R : Type u_1} →
{S : Finset R} →
(k : ℕ) →
(motive :
(x : Finset R × R) →
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T} →
Sort u_2) →
(x : Finset R × R) →
(x_1 :
... | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.setInlineAttribute.match_1 | Lean.Meta.Basic | (motive : Except String Lean.Environment → Sort u_1) →
(x : Except String Lean.Environment) →
((env : Lean.Environment) → motive (Except.ok env)) → ((msg : String) → motive (Except.error msg)) → motive x | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.blast | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {w : ℕ} → (aig : Std.Sat.AIG α) → aig.BinaryRefVec w → Std.Sat.AIG.RefVecEntry α w | null | true |
_private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.inner_._proof_1 | Mathlib.Analysis.InnerProductSpace.OfNorm | (3 + 1).AtLeastTwo | null | false |
summable_sigma_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {α : Type u_4} {β : α → Type u_3} {f : (x : α) × β x → ℝ},
(∀ (x : (x : α) × β x), 0 ≤ f x) →
(Summable f ↔ (∀ (x : α), Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), f ⟨x, y⟩) | null | true |
Std.Internal.List.Const.getKeyD_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {k fallback : α} {f : β → β} (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (Std.Internal.List.Const.modifyKey k f l) fallback =
if Std.Internal.List.containsKey k l = true then k else fallback | null | true |
String.Slice.Pattern.ForwardSliceSearcher.instToForwardSearcher | Init.Data.String.Pattern.String | {pat : String.Slice} → String.Slice.Pattern.ToForwardSearcher pat String.Slice.Pattern.ForwardSliceSearcher | null | true |
TopCat.GlueData.MkCore.cocycle | Mathlib.Topology.Gluing | ∀ (self : TopCat.GlueData.MkCore) (i j k : self.J) (x : ↥(self.V i j)) (h : ↑x ∈ self.V i k),
↑((CategoryTheory.ConcreteCategory.hom (self.t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (self.t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (self.t i k)) ⟨↑x, h⟩) | null | true |
Set.toFinset_empty | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} [inst : Fintype ↑∅], ∅.toFinset = ∅ | null | true |
Computability.instDecidableEqΓ'.decEq._proof_3 | Mathlib.Computability.Encoding | ∀ (b : Bool), ¬Computability.Γ'.blank = Computability.Γ'.bit b | null | false |
MonCat.Colimits.monoidColimitType._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (n : ℕ)
(x : MonCat.Colimits.ColimitType F), npowRecAuto (n + 1) x = npowRecAuto n x * x | null | false |
CompleteBooleanAlgebra.himp._inherited_default | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a b : α), le a (sup a b)) →
(∀ (... | null | false |
_private.Mathlib.Data.Countable.Defs.0.Finite.to_countable.match_1 | Mathlib.Data.Countable.Defs | ∀ {α : Sort u_1} (motive : (∃ n, Nonempty (α ≃ Fin n)) → Prop) (x : ∃ n, Nonempty (α ≃ Fin n)),
(∀ (w : ℕ) (e : α ≃ Fin w), motive ⋯) → motive x | null | false |
SSet.innerAnodyneExtensions_eq_llp_rlp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Inner.Basic | SSet.innerAnodyneExtensions = SSet.innerHornInclusions.rlp.llp | null | true |
LocallyConstant.instAddGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x_1 • x) = ⇑(x_1 • x) | null | false |
NormedAddGroupHom.toAddMonoidHomClass | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂],
AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂ | null | true |
ClosedAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [AddGroup G] → [TopologicalSpace G] → Type u | The type of closed subgroups of an additive topological group. | true |
WType.instEncodable | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} → [(a : α) → Fintype (β a)] → [(a : α) → Encodable (β a)] → [Encodable α] → Encodable (WType β) | `WType` is encodable when `α` is an encodable fintype and for every `a : α`, `β a` is
encodable. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{newWidth : ℕ} →
{aig : Std.Sat.AIG α} →
{w : ℕ} → aig.RefVec w → ℕ → (curr : ℕ) → curr ≤ newWidth → aig.RefVec curr → aig.RefVec newWidth | null | true |
_private.Mathlib.RingTheory.TensorProduct.Quotient.0.Algebra.TensorProduct.quotIdealMapEquivTensorQuot._simp_1 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
Commute.tsum_left | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : TopologicalSpace α] [IsTopologicalSemiring α] {f : ι → α} [T2Space α] [L.NeBot] (a : α),
(∀ (i : ι), Commute (f i) a) → Commute (∑'[L] (i : ι), f i) a | null | true |
Submodule.dualCoannihilator | Mathlib.LinearAlgebra.Dual.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R (Module.Dual R M) → Submodule R M | The `dualAnnihilator` of a submodule of the dual space pulled back along the evaluation map
`Module.Dual.eval`. | true |
PredOrder.ofPredLeIff | Mathlib.Order.SuccPred.Basic | {α : Type u_1} → [inst : Preorder α] → (pred : α → α) → (∀ {a b : α}, b ≤ pred a ↔ b < a) → PredOrder α | A constructor for `PredOrder α` usable when `α` has no minimal element. | true |
Module.supportDim_le_of_surjective | Mathlib.RingTheory.KrullDimension.Module | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
Function.Surjective ⇑f → Module.supportDim R N ≤ Module.supportDim R M | null | true |
Std.Internal.Do.Spec.forIn_range | Std.Internal.Do.Triple.SpecLemmas | ∀ {β : Type u} {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.Internal.Do.Assertion Pred]
[inst_2 : Std.Internal.Do.Assertion EPred] [inst_3 : Std.Internal.Do.WPMonad m Pred EPred] {xs : Std.Legacy.Range}
{init : β} {f : ℕ → β → m (ForInStep β)} (inv : Std.Internal.Do.Invariant xs.toList... | null | true |
Matroid.cRk_map_eq | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} {X : Set β} (M : Matroid α) (hf : Set.InjOn f M.E), (M.map f hf).cRk X = M.cRk (f ⁻¹' X) | null | true |
MeasurableEmbedding.measurableSet_range | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → MeasurableSet (Set.range f) | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff_frequently._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter β} {m : α → β}, (Filter.comap m f).NeBot = ∀ t ∈ f, ∃ a, m a ∈ t | null | false |
Subarray.size_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u_1} {s : Subarray α}, Std.Slice.size s ≤ s.array.size | null | true |
_private.Mathlib.CategoryTheory.Category.Pairwise.0.CategoryTheory.instFintypePairwise.match_5.eq_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ (ι : Type u_1) (motive : CategoryTheory.Pairwise ι → Sort u_2) (a a_1 : ι)
(h_1 : (a : ι) → motive (CategoryTheory.Pairwise.single a))
(h_2 : (a a_2 : ι) → motive (CategoryTheory.Pairwise.pair a a_2)),
(match CategoryTheory.Pairwise.pair a a_1 with
| CategoryTheory.Pairwise.single a => h_1 a
| CategoryT... | null | true |
«_aux_ImportGraph_Tools_FindHome___elabRules_command#find_home!__1» | ImportGraph.Tools.FindHome | Lean.Elab.Command.CommandElab | Find locations as high as possible in the import hierarchy
where the named declaration could live.
Using `#find_home!` will forcefully remove the current file.
Note that this works best if used in a file with `import Mathlib`.
The current file could still be the only suggestion, even using `#find_home! lemma`.
The rea... | false |
Option.mem_pmem | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) (x : Option α) {a : α} (h : ∀ a ∈ x, p a)
(ha : a ∈ x), f a ⋯ ∈ Option.pmap f x h | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_34 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length}, 0 < (List.findIdxs (fun x_1 => x_1 == x) (head :: tail)).length | null | false |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_4 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} (n : ℕ) {stop start : ℕ}, start - stop = n + 1 → ¬stop < start → False | null | false |
Equiv.sumSigmaDistrib_symm_apply | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_10} {β : Type u_11} (t : α ⊕ β → Type u_9) (a : (i : α) × t (Sum.inl i) ⊕ (i : β) × t (Sum.inr i)),
(Equiv.sumSigmaDistrib t).symm a = Sum.elim (fun a => ⟨Sum.inl a.fst, a.snd⟩) (fun b => ⟨Sum.inr b.fst, b.snd⟩) a | null | true |
hasFPowerSeriesAt_clog_one | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt Complex.log (FormalMultilinearSeries.ofScalars ℂ fun n => -(-1) ^ n / ↑n) 1 | null | true |
MonoidWithZeroHom.ValueGroup₀.instIsOrderedMonoid | Mathlib.Algebra.Order.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} [inst : MonoidWithZero A] [inst_1 : LinearOrderedCommGroupWithZero B] {f : A →*₀ B},
IsOrderedMonoid f.ValueGroup₀ | null | true |
_private.Mathlib.Order.Atoms.0.IsAtomic.Set.Iic.isAtomic.match_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] (y : α) (motive : (∃ a, IsAtom a ∧ a ≤ y) → Prop)
(x : ∃ a, IsAtom a ∧ a ≤ y), (∀ (a : α) (ha : IsAtom a) (hay : a ≤ y), motive ⋯) → motive x | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.suggestionName.match_1 | Lean.Elab.DocString | (motive : Option Lean.Name → Sort u_1) →
(resolved? : Option Lean.Name) →
((resolved : Lean.Name) → motive (some resolved)) → (Unit → motive none) → motive resolved? | null | false |
Order.IsNormal.exists_map_le_lt_map_succ_of_exists_ge | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [WellFoundedLT α] [inst_2 : SuccOrder α] [inst_3 : LinearOrder β]
[NoMaxOrder α] [inst_5 : OrderBot α] [WellFoundedLT β] {f : α → β} {x : β},
Order.IsNormal f → (∃ y, x ≤ f y) → f ⊥ ≤ x → ∃ a, f a ≤ x ∧ x < f (Order.succ a) | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.TacticContext.ctorIdx | Lean.Elab.Tactic.BVDecide.Frontend.LRAT | Lean.Elab.Tactic.BVDecide.Frontend.TacticContext → ℕ | null | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1.rec | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
((names fvarIds type : Lean.Json) →
(val? isInstance? isType? isInserted? isRemoved? : Option Lean.Json) →
motive
{ names := names, fvarIds := fvarIds, type := type, val? := val?, isInstance? := isInstance?,
isType? := isType?, ... | null | false |
Int.sub_lt_self | Init.Data.Int.Order | ∀ (a : ℤ) {b : ℤ}, 0 < b → a - b < a | null | true |
Topology.IsConstructible.preimage | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f →
(∀ (s : Set Y), IsOpen s → IsRetrocompact s → IsRetrocompact (f ⁻¹' s)) →
Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) | If `f` is continuous and is such that preimages of open retrocompact sets are retrocompact,
then preimages of constructible sets are constructible. | true |
Commute.eq | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b → a * b = b * a | Equality behind `Commute a b`; useful for rewriting. | true |
Lean.Grind.CommRing.Expr.toPolyC_nc.go | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | null | true |
TopologicalSpace.Opens.frameMinimalAxioms._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a b c : TopologicalSpace.Opens α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | null | false |
AddSubmonoid.addUnitsEquivAddUnitsType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M),
Function.LeftInverse (fun x => ⟨{ val := ↑↑x, neg := ↑↑(-x), val_neg := ⋯, neg_val := ⋯ }, ⋯⟩) fun x =>
match x with
| ⟨val, h⟩ =>
{ val := ⟨(AddUnits.coeHom M) val, ⋯⟩, neg := ⟨(AddUnits.coeHom M) (-val), ⋯⟩, val_neg := ⋯, neg_val := ⋯ } | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_some_iff._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible_aux₂ | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {ι : Type u_1} {K : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : CharZero K]
[inst_2 : DecidableEq ι] [inst_3 : Fintype ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsCrystallographic] {b : P.Base}
... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_30 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ)
(h : i < (List.filter p (head :: tail)).length) (h_2 : p head = true) (h_5 : -1 * ↑i + 1 ≤ 0),
(List.findIdxs p tail (s + 1))[i - 1] - (s + 1) < tail.length | null | false |
TensorProduct.smul_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} {R' : Type u_4} [inst : CommSemiring R] [inst_1 : Monoid R'] {M : Type u_7} {N : Type u_8}
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : DistribMulAction R' M] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : DistribMulAction R' N] [TensorProduct.CompatibleSMul R R' M N] (r :... | `smul` can be moved from one side of the product to the other . | true |
RBTree.RBNode.IsCut.lt_trans | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {x y : α} [RBTree.RBNode.IsCut cmp cut]
[Std.TransCmp cmp], cmp x y = Ordering.lt → cut x = Ordering.lt → cut y = Ordering.lt | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_25 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n k : ℕ) (j₁ : Fin (m + n)) (j₂ : Fin m),
(↑j₂ ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + n) ∧ k ≤ ↑j₁ - ↑j₂ → ¬(↑j₂ + k ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + (k + m)) → m < ↑j₁ - ↑j₂ - k | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic), sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx) = 1 + sizeOf stx | null | true |
Mathlib.Tactic.Translate.TranslationInfo.recOn | Mathlib.Tactic.Translate.Core | {motive : Mathlib.Tactic.Translate.TranslationInfo → Sort u} →
(t : Mathlib.Tactic.Translate.TranslationInfo) →
((translation : Lean.Name) →
(reorder : Mathlib.Tactic.Translate.Reorder) →
(relevantArg : Mathlib.Tactic.Translate.RelevantArg) →
motive { translation := translation, reor... | null | false |
MeasurableSet.mem | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {s : Set α} [inst : MeasurableSpace α], MeasurableSet s → Measurable fun x => x ∈ s | **Alias** of the reverse direction of `measurable_mem`. | true |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.instMonadPrettyFormatStateMTaggedState.match_1 | Lean.Widget.TaggedText | (motive : Lean.Widget.TaggedText.TaggedState✝ → Sort u_1) →
(x : Lean.Widget.TaggedText.TaggedState✝) →
((out : Lean.Widget.TaggedText (ℕ × ℕ)) →
(ts : List (ℕ × ℕ × Lean.Widget.TaggedText (ℕ × ℕ))) →
(col : ℕ) → motive { out := out, tagStack := ts, column := col }) →
motive x | null | false |
dist_pi_const_le | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : Fintype β] (a b : α),
(dist (fun x => a) fun x => b) ≤ dist a b | null | true |
CategoryTheory.PreZeroHypercover.sectionsEquivOfHasPullbacks | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} →
(E : CategoryTheory.PreZeroHypercover S) →
[inst_1 : E.HasPullbacks] →
(F : CategoryTheory.Functor Cᵒᵖ (Type u_2)) →
(E.toPreOneHypercover.multicospanIndex F).sections ≃
Subtype (CategoryTh... | If the pre-`0`-hypercover `E` has pairwise pullbacks, the sections over the multifork
associated to a presheaf of types are equivalent to the compatible families on `E`. | true |
_private.Mathlib.Topology.Algebra.Polynomial.0.Polynomial.coeff_le_of_roots_le._simp_1_1 | Mathlib.Topology.Algebra.Polynomial | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.«_aux_Mathlib_Analysis_InnerProductSpace_Defs___macroRules__private_Mathlib_Analysis_InnerProductSpace_Defs_0_InnerProductSpace_Core_term_†_1» | Mathlib.Analysis.InnerProductSpace.Defs | Lean.Macro | null | false |
_private.Mathlib.Util.AtLocation.0.Mathlib.Tactic.instReprBehaviorIfUnchanged.repr.match_1 | Mathlib.Util.AtLocation | (motive : Mathlib.Tactic.BehaviorIfUnchanged → Sort u_1) →
(x : Mathlib.Tactic.BehaviorIfUnchanged) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.silent) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.warning) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.error) → motive x | null | false |
Real.sign_eq_zero_iff._simp_1 | Mathlib.Data.Real.Sign | ∀ {r : ℝ}, (r.sign = 0) = (r = 0) | null | false |
LindelofSpace.mk | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsLindelof Set.univ → LindelofSpace X | null | true |
Set.Finite.wellFoundedOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α}, s.Finite → s.WellFoundedOn r | null | true |
minimal_nonempty_open_eq_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {s : Set X},
IsOpen s → s.Nonempty → (∀ t ⊆ s, t.Nonempty → IsOpen t → t = s) → ∃ x, s = {x} | null | true |
left_iff_dite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Prop} {y : ¬p → Prop}, (x ↔ if h : p then x else y h) ↔ ∀ (h : ¬p), x ↔ y h | null | true |
GradedMonoid.list_prod_map_eq_dProd | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_2} {A : ι → Type u_3} [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (l : List α)
(f : α → GradedMonoid A),
(List.map f l).prod =
GradedMonoid.mk (l.dProdIndex fun i => (f i).fst) (l.dProd (fun i => (f i).fst) fun i => (f i).snd) | A variant of `GradedMonoid.mk_list_dProd` for rewriting in the other direction. | true |
CategoryTheory.IsPullback.of_hasPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasPullback f g],
CategoryTheory.IsPullback (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.Limits.pullback.snd f g) f g | The pullback provided by `HasPullback f g` fits into an `IsPullback`. | true |
Lean.DeclNameGenerator.noConfusionType | Lean.CoreM | Sort u → Lean.DeclNameGenerator → Lean.DeclNameGenerator → Sort u | null | false |
ProbabilityTheory.Kernel.IndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7} {mα : MeasurableSpace α}
{mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {mγ : MeasurableSpace γ} {mγ' ... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey_eraseKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true), some (Std.Internal.List.getKey a l h) = Std.Internal.List.getKey? a l | null | false |
AddSubgroup.addCommutator.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.addCommutator = { bracket := fun H₁ H₂ => AddSubgroup.closure {g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g} } | null | true |
stoneCechEquivalence._proof_5 | Mathlib.Topology.Category.CompHaus.Basic | ∀ (Y : CompHaus), CompactSpace ↑Y.toTop | null | false |
CategoryTheory.Under.pushout_obj | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X),
(CategoryTheory.Under.pushout f).obj x = CategoryTheory.Under.mk (CategoryTheory.Limits.pushout.inr x.hom f) | null | true |
maximal_subset_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Maximal P s ↔ P s ∧ ∀ ⦃t : Set α⦄, P t → s ⊆ t → s = t | null | true |
Order.height_toDual | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), Order.height (OrderDual.toDual x) = Order.coheight x | null | true |
AddLocalization.ind | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop},
(∀ (y : M × ↥S), p (AddLocalization.mk y.1 y.2)) → ∀ (x : AddLocalization S), p x | null | true |
ProbabilityTheory.Kernel.partialTraj_comp_partialTraj | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b c : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))},
a ≤ b →
b ≤ c →
(ProbabilityTheory.Kernel.partialTraj κ b c).comp (ProbabilityTheory.Kernel.partialTraj κ a b) =
ProbabilityTheory.Kernel.par... | Given the trajectory up to time `a`, `partialTraj κ a b` gives the distribution of
the trajectory up to time `b`. Then plugging this into `partialTraj κ b c` gives
the distribution of the trajectory up to time `c`. | true |
Ordinal.bsup_le | Mathlib.SetTheory.Ordinal.Family | ∀ {o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
(∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → o.bsup f ≤ a | null | true |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.coassoc_left._simp_1_1 | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P), TensorProduct.map LinearMap.id f = LinearMap.lTensor M f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.