name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.exists_basis_of_pairing_eq_zero._simp_1_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M} {s : Set M},
(x ∈ Submodule.span R (insert y s)) = ∃ a, x + a • y ∈ Submodule.span R s |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro |
Unitization.instNeg | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Neg R] → [Neg A] → Neg (Unitization R A) |
List.SortedGE.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → List.IsChain (fun x1 x2 => x1 ≥ x2) l |
Mathlib.Tactic.BicategoryLike.MonadMor₁.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{id₁M : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{id₁M' : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M' :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{ id₁M := id₁M, comp₁M := comp₁M } = { id₁M := id₁M', comp₁M := comp₁M' } →
(id₁M ≍ id₁M' → comp₁M ≍ comp₁M' → P) → P |
HomologicalComplex.instHasColimitDiscreteWalkingPairCompPairEval | Mathlib.Algebra.Homology.HomologicalComplexBiprod | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K L : HomologicalComplex C c)
[∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (L.X i)] (i : ι),
CategoryTheory.Limits.HasColimit ((CategoryTheory.Limits.pair K L).comp (HomologicalComplex.eval C c i)) |
_private.Lean.Meta.InferType.0.Lean.Meta.inferConstType | Lean.Meta.InferType | Lean.Name → List Lean.Level → Lean.MetaM Lean.Expr |
CategoryTheory.Endofunctor.Coalgebra.ctorIdx | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C C} → CategoryTheory.Endofunctor.Coalgebra F → ℕ |
convexHull.eq_1 | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], convexHull 𝕜 = ClosureOperator.ofCompletePred (Convex 𝕜) ⋯ |
_private.Lean.Meta.TryThis.0.Lean.Meta.Tactic.TryThis.Suggestion.processEdit.match_1 | Lean.Meta.TryThis | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((indent column : ℕ) → motive (indent, column)) → motive x |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_eq_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ},
(∃ k',
k ≤ k' ∧
k' ≤ stackPos ∧ String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1)) →
∀ (k' : ℕ), k ≤ k' → ¬k < k' → ¬k = k' → False |
CategoryTheory.Over.fst_left | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
{R S : CategoryTheory.Over X},
(CategoryTheory.SemiCartesianMonoidalCategory.fst R S).left = CategoryTheory.Limits.pullback.fst R.hom S.hom |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_motive._simp_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.Finset.aemeasurable_sum.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {ι : Type u_1} {α : Type u_3} {f : ι → α → M} (s : Finset ι) (_g : α → M)
(motive : (∃ a ∈ s.val, f a = _g) → Prop) (x : ∃ a ∈ s.val, f a = _g),
(∀ (_i : ι) (hi : _i ∈ s.val) (hg : f _i = _g), motive ⋯) → motive x |
CategoryTheory.Limits.inr_comp_pushoutComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : X ⟶ Y) (g : X ⟶ Z)
[inst_2 : CategoryTheory.Limits.HasPushout f g] [inst_3 : CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
{Z_1 : D} (h : G.obj (CategoryTheory.Limits.pushout f g) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr (G.map f) (G.map g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushoutComparison G f g) h) =
CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.pushout.inr f g)) h |
CommRingCat.Under.tensorProductFan' | Mathlib.Algebra.Category.Ring.Under.Limits | {R : CommRingCat} →
(S : CommRingCat) →
[inst : Algebra ↑R ↑S] →
{ι : Type u} →
(P : ι → CategoryTheory.Under R) →
CategoryTheory.Limits.Fan fun i => S.mkUnder (TensorProduct ↑R ↑S ↑(P i).right) |
Std.TreeMap.contains_iff_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α}, t.contains k = true ↔ k ∈ t |
Pi.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (n : ℕ) (x : (i : ι) → R i),
Semiring.npow (n + 1) x = Semiring.npow n x * x |
Mathlib.Tactic.LinearCombination.expandLinearCombo._unsafe_rec | Mathlib.Tactic.LinearCombination | Option Lean.Expr → Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.LinearCombination.Expanded |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.A_c_eq_zero | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} {A : FixedDetMatrix (Fin 2) ℤ m}, ↑A 1 0 = 0 → ↑A 0 0 * ↑A 1 1 = m |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift_self | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (h : D.IsTerminal e),
h.lift ⋯ = CategoryTheory.CategoryStruct.id e |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_34 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n),
(Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ofArray_fold_fn acc (some c)).size = n →
∀ (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
c.isUnit = some (l, false) →
↑i < (acc.modify (↑l) Std.Tactic.BVDecide.LRAT.Internal.Assignment.addNegAssignment).size |
Lean.ReducibilityHints.opaque.sizeOf_spec | Lean.Declaration | sizeOf Lean.ReducibilityHints.opaque = 1 |
Lean.Meta.Simp.Methods.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {pre post : Lean.Meta.Simp.Simproc} {dpre dpost : Lean.Meta.Simp.DSimproc}
{discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge : Bool}
{pre_1 post_1 : Lean.Meta.Simp.Simproc} {dpre_1 dpost_1 : Lean.Meta.Simp.DSimproc}
{discharge?_1 : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge_1 : Bool},
{ pre := pre, post := post, dpre := dpre, dpost := dpost, discharge? := discharge?,
wellBehavedDischarge := wellBehavedDischarge } =
{ pre := pre_1, post := post_1, dpre := dpre_1, dpost := dpost_1, discharge? := discharge?_1,
wellBehavedDischarge := wellBehavedDischarge_1 } →
pre = pre_1 ∧
post = post_1 ∧
dpre = dpre_1 ∧ dpost = dpost_1 ∧ discharge? = discharge?_1 ∧ wellBehavedDischarge = wellBehavedDischarge_1 |
Std.Time.Modifier.z.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.ZoneName} →
Std.Time.Modifier.z presentation = Std.Time.Modifier.z presentation' → (presentation = presentation' → P) → P |
CategoryTheory.equivSmallModel._proof_1 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.EssentiallySmall.{u_1, u_3, u_2} C], Nonempty (C ≌ Classical.choose ⋯) |
Polynomial.revAt_le | Mathlib.Algebra.Polynomial.Reverse | ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i |
IsSolvableByRad.rec | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
{motive : (a : E) → IsSolvableByRad F a → Prop},
(∀ (α : F), motive ((algebraMap F E) α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β), motive α a → motive β a_1 → motive (α + β) ⋯) →
(∀ (α : E) (a : IsSolvableByRad F α), motive α a → motive (-α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β),
motive α a → motive β a_1 → motive (α * β) ⋯) →
(∀ (α : E) (a : IsSolvableByRad F α), motive α a → motive α⁻¹ ⋯) →
(∀ (α : E) (n : ℕ) (hn : n ≠ 0) (a : IsSolvableByRad F (α ^ n)), motive (α ^ n) a → motive α ⋯) →
∀ {a : E} (t : IsSolvableByRad F a), motive a t |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termY₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr |
AddEquiv.strictMono_subsemigroupCongr | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddCommMonoid G] [inst_1 : Preorder G] {S T : AddSubsemigroup G} (h : S = T),
StrictMono ⇑(AddEquiv.subsemigroupCongr h) |
IsEmpty.oriented._proof_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], 1 ≠ 0 |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) |
derivedSet | Mathlib.Topology.DerivedSet | {X : Type u_1} → [TopologicalSpace X] → Set X → Set X |
SupHom.rec | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_sup' }) →
(t : SupHom α β) → motive t |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_5 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n),
(AffineIndependent k fun a => if h : a = 0 then ⋯ ▸ s.centroid else s.points a) →
AffineIndependent k fun x => if x = 0 then s.centroid else s.points x |
BitVec.mk_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {h : 0 < 2 ^ w}, { toFin := ⟨0, h⟩ } = 0#w |
Tropical.le_zero._simp_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : OrderTop R] (x : Tropical R), (x ≤ 0) = True |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Bool → Std.Tactic.BVDecide.LRAT.Internal.Assignment → Std.Tactic.BVDecide.LRAT.Internal.Assignment |
SSet.instIsStableUnderCoproductsMonomorphismsOfHasCoproductsType | Mathlib.AlgebraicTopology.SimplicialSet.Monomorphisms | ∀ [CategoryTheory.Limits.HasCoproducts (Type u)],
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{v', u, u + 1}
(CategoryTheory.MorphismProperty.monomorphisms SSet) |
_private.Mathlib.Analysis.Analytic.Binomial.0.Real.one_div_one_sub_rpow_hasFPowerSeriesOnBall_zero._simp_1_10 | Mathlib.Analysis.Analytic.Binomial | ∀ (r s : ℝ), ↑r - ↑s = ↑(r - s) |
Ideal.fiberIsoOfBijectiveResidueField._proof_7 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommRing R'] [inst_2 : Algebra R R'] {q : Ideal R'}
[inst_3 : q.IsPrime], SMulCommClass R q.ResidueField q.ResidueField |
_private.Mathlib.Analysis.Convex.Segment.0.mem_openSegment_translate._simp_1_2 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} {G : Type u_4} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 E] [inst_6 : AddTorsor G E]
[VAddCommClass G E E] (a : G) (b c : E), openSegment 𝕜 (a +ᵥ b) (a +ᵥ c) = a +ᵥ openSegment 𝕜 b c |
ContinuousLinearEquiv.comp_contDiffWithinAt_iff | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f : E → F} {x : E} {n : WithTop ℕ∞}
(e : F ≃L[𝕜] G), ContDiffWithinAt 𝕜 n (⇑e ∘ f) s x ↔ ContDiffWithinAt 𝕜 n f s x |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_8 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
AlgebraicGeometry.Scheme.ProEt.forget | Mathlib.AlgebraicGeometry.Sites.Proetale | (S : AlgebraicGeometry.Scheme) → CategoryTheory.Functor S.ProEt (CategoryTheory.Over S) |
CategoryTheory.ObjectProperty.isThin_of_isSeparating_bot | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], ⊥.IsSeparating → Quiver.IsThin C |
Vector.append_assoc._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k : ℕ}, n + (m + k) = n + m + k |
Aesop.RuleStatsTotals.empty | Aesop.Stats.Basic | Aesop.RuleStatsTotals |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.SavedState.termState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.SavedState✝ → Lean.Elab.Term.SavedState |
Lean.IR.IRType.usize | Lean.Compiler.IR.Basic | Lean.IR.IRType |
KummerDedekind.quotMapEquivQuotQuotMap._proof_4 | 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}
[inst_3 : IsDomain R] [inst_4 : IsIntegrallyClosed R] [inst_5 : IsDedekindDomain S]
[inst_6 : Module.IsTorsionFree R S] (hx' : IsIntegral R x),
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R (Algebra.adjoin.powerBasis' hx').gen)}).IsTwoSided |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size) →
((hl : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size) →
motive Std.DTreeMap.Internal.Impl.leaf hl hlr) →
((size : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hl : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size r.size) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hl hlr) →
motive l hl hlr |
CategoryTheory.Presieve.singleton_eq_iff_domain._simp_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : Y ⟶ X),
CategoryTheory.Presieve.singleton f g = (f = g) |
sInfHom.ext | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] {f g : sInfHom α β},
(∀ (a : α), f a = g a) → f = g |
Lean.IR.EmitLLVM.constIntSizeT | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → ℕ → Lean.IR.EmitLLVM.M llvmctx (LLVM.Value llvmctx) |
_private.Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence.0.Mathlib.Tactic.BicategoryLike.normalize.match_3 | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | (motive : Mathlib.Tactic.BicategoryLike.Mor₁ → Sort u_1) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
((e : Lean.Expr) → (a : Mathlib.Tactic.BicategoryLike.Obj) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.id e a)) →
((e : Lean.Expr) →
(f g : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.comp e f g)) →
((f : Mathlib.Tactic.BicategoryLike.Atom₁) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.of f)) → motive f |
CategoryTheory.ShortComplex.SnakeInput.functorL₃._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).f₃ = CategoryTheory.CategoryStruct.comp f.f₃ g.f₃ |
Fin.val_mk | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (h : m < n), ↑⟨m, h⟩ = m |
MulOpposite.instAddCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddCommSemigroup α] → AddCommSemigroup αᵐᵒᵖ |
_private.Mathlib.Analysis.InnerProductSpace.l2Space.0.HilbertBasis.dense_span._simp_1_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.ModularGroup.exists_bound_of_invariant_of_isBigO._simp_1_4 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Finset.range_succ | Mathlib.Data.Finset.Range | ∀ {n : ℕ}, Finset.range n.succ = insert n (Finset.range n) |
Std.ExtTreeMap.minKeyD_le_minKeyD_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.Chain.pair.match_1.eq_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (x : ℕ) → motive x),
(x = 0 → False) →
(match x with
| 0 => h_1 ()
| x => h_2 x) =
h_2 x |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.of_le.match_1_3 | Batteries.Data.BinomialHeap.Basic | ∀ {n' : ℕ} {α : Type u_1} {le : α → α → Bool}
(motive : (s : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Prop)
(s : Batteries.BinomialHeap.Imp.Heap α) (h : Batteries.BinomialHeap.Imp.Heap.WF le n' s),
(∀ (h : Batteries.BinomialHeap.Imp.Heap.WF le n' Batteries.BinomialHeap.Imp.Heap.nil),
motive Batteries.BinomialHeap.Imp.Heap.nil h) →
(∀ (rank : ℕ) (val : α) (node : Batteries.BinomialHeap.Imp.HeapNode α) (next : Batteries.BinomialHeap.Imp.Heap α)
(h : Batteries.BinomialHeap.Imp.Heap.WF le n' (Batteries.BinomialHeap.Imp.Heap.cons rank val node next)),
motive (Batteries.BinomialHeap.Imp.Heap.cons rank val node next) h) →
motive s h |
LinearIsometryEquiv.toLinearEquiv_symm | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂), e.symm.toLinearEquiv = e.symm |
Nat.toArray_ric_eq_cons | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = #[0] ++ (1...=n).toArray |
SimpleGraph.Subgraph.IsPerfectMatching.exists_of_isClique_supp | Mathlib.Combinatorics.SimpleGraph.Tutte | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V],
Even (Nat.card V) →
¬G.IsTutteViolator G.universalVerts →
(∀ (K : G.deleteUniversalVerts.coe.ConnectedComponent), G.deleteUniversalVerts.coe.IsClique K.supp) →
∃ M, M.IsPerfectMatching |
SimpleGraph.ediam_eq_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G : SimpleGraph α}, G.ediam = ⊤ ↔ ∀ b < ⊤, ∃ u v, b < G.edist u v |
List.Forall._unsafe_rec | Mathlib.Data.List.Defs | {α : Type u_1} → (α → Prop) → List α → Prop |
Std.DHashMap.Const.get?_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {a : α}, Std.DHashMap.Const.get? ∅ a = none |
NormedAddGroup.toBornology._inherited_default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
(dist : E → E → ℝ) →
(∀ (x y : E), dist x y = dist y x) → (∀ (x y z : E), dist x z ≤ dist x y + dist y z) → Bornology E |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Operations | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size) →
((hl : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size) →
motive Std.DTreeMap.Internal.Impl.leaf hl hlr) →
((size : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hl : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size r.size) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hl hlr) →
motive l hl hlr |
List.modify_eq_nil_iff | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {i : ℕ} {l : List α}, l.modify i f = [] ↔ l = [] |
OrderType.inductionOn₂ | Mathlib.Order.Types.Defs | ∀ {C : OrderType.{u_1} → OrderType.{u_2} → Prop} (o₁ : OrderType.{u_1}) (o₂ : OrderType.{u_2}),
(∀ (α : Type u_1) [inst : LinearOrder α] (β : Type u_2) [inst_1 : LinearOrder β],
C (OrderType.type α) (OrderType.type β)) →
C o₁ o₂ |
_private.Mathlib.RingTheory.Localization.Algebra.0.IsLocalization.ker_map._simp_1_2 | Mathlib.RingTheory.Localization.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (s : ↥M),
(IsLocalization.mk' S x s = 0) = ∃ m, ↑m * x = 0 |
Submodule.finrank_quotient | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_2} R] [StrongRankCondition R] [Module.Finite R M] {S : Type u_1} [inst_6 : Ring S]
[inst_7 : SMul R S] [inst_8 : Module S M] [inst_9 : IsScalarTower R S M] (N : Submodule S M),
Module.finrank R (M ⧸ N) = Module.finrank R M - Module.finrank R ↥N |
BitVec.toNat_mul_toNat_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.toNat * y.toNat < 2 ^ (w * 2) |
Ideal.stabilizerEquiv_symm_apply_smul | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {N : Type u_3}
[inst_3 : Group N] [inst_4 : MulSemiringAction N R] (I : Ideal R) (e : M ≃* N)
(he : ∀ (m : M) (x : R), e m • x = m • x) (n : ↥(MulAction.stabilizer N I)) (x : R),
(I.stabilizerEquiv e he).symm n • x = n • x |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_7 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CochainComplex.HomComplex.Cochain.ofHom
(CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.desc (CochainComplex.mappingCone.inr φ) 0
(CochainComplex.mappingCone.triangle φ).mor₃ ⋯)
(CochainComplex.mappingCone.lift (CochainComplex.mappingCone.inr φ)
(-(CochainComplex.HomComplex.Cocycle.ofHom φ).leftShift 1 1 ⋯)
(-(CochainComplex.mappingCone.inl φ).leftShift 1 0 ⋯) ⋯)) =
CochainComplex.HomComplex.δ (-1) 0
(-(CochainComplex.mappingCone.snd (CochainComplex.mappingCone.inr φ)).comp
((CochainComplex.mappingCone.snd φ).comp (CochainComplex.mappingCone.inl (CochainComplex.mappingCone.inr φ))
⋯)
⋯) +
CochainComplex.HomComplex.Cochain.ofHom
(CategoryTheory.CategoryStruct.id (CochainComplex.mappingCone (CochainComplex.mappingCone.inr φ))) |
Lean.Elab.Term.ElabElim.Context | Lean.Elab.App | Type |
Lean.Elab.Term.Do.ToTerm.reassignToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_4 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
CategoryTheory.Functor.instCommShift₂IntCochainComplexIntMap₂CochainComplex._proof_4 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D))
[inst_6 : F.Additive] [inst_7 : ∀ (X₁ : C₁), (F.obj X₁).Additive]
[inst_8 : ∀ (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ), K₁.HasMapBifunctor K₂ F] (K₁ : CochainComplex C₁ ℤ)
(K₂ : CochainComplex C₂ ℤ) (p q : ℤ),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.commShiftIso
(F.map₂CochainComplex.obj ((CategoryTheory.shiftFunctor (CochainComplex C₁ ℤ) p).obj K₁)) q).hom.app
K₂)
((CategoryTheory.shiftFunctor (CochainComplex D ℤ) q).map
((CategoryTheory.Functor.commShiftIso (F.map₂CochainComplex.flip.obj K₂) p).hom.app K₁)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.commShiftIso
(F.map₂CochainComplex.flip.obj ((CategoryTheory.shiftFunctor (CochainComplex C₂ ℤ) q).obj K₂)) p).hom.app
K₁)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor (CochainComplex D ℤ) p).map
((CategoryTheory.Functor.commShiftIso (F.map₂CochainComplex.obj K₁) q).hom.app K₂))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftComm ((F.map₂CochainComplex.obj K₁).obj K₂) p q).inv
((↑(CategoryTheory.CommShift₂Setup.int.ε p q)).app
((CategoryTheory.shiftFunctor (CochainComplex D ℤ) q).obj
((CategoryTheory.shiftFunctor (CochainComplex D ℤ) p).obj ((F.map₂CochainComplex.obj K₁).obj K₂)))))) |
_private.Init.Data.Nat.Control.0.Nat.forM.loop | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit |
Mathlib.Tactic.LinearCombination'.neg_pf | Mathlib.Tactic.LinearCombination' | ∀ {α : Type u_1} {a b : α} [inst : Neg α], a = b → -a = -b |
Subgroup.instInfSet | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → InfSet (Subgroup G) |
CategoryTheory.Mon.limit_mon_mul | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.IsLimit c),
CategoryTheory.MonObj.mul =
hc.lift
{ pt := CategoryTheory.MonoidalCategoryStruct.tensorObj c.1 c.1,
π :=
{
app := fun X =>
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (c.π.app X) (c.π.app X)) CategoryTheory.MonObj.mul,
naturality := ⋯ } } |
Finset.compls_subset_compls._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s₁ s₂ : Finset α}, (s₁.compls ⊆ s₂.compls) = (s₁ ⊆ s₂) |
Set.EqOn.comp_eq | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_7} {f : ι → α} {g₁ g₂ : α → β},
Set.EqOn g₁ g₂ (Set.range f) → g₁ ∘ f = g₂ ∘ f |
MeasureTheory.Measure.instMeasurableAdd₂ | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_3} {m : MeasurableSpace α}, MeasurableAdd₂ (MeasureTheory.Measure α) |
dimH_empty | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X], dimH ∅ = 0 |
Int8.reduceMul._regBuiltin.Int8.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.76 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
AlgebraicGeometry.Scheme.Modules.restrictStalkNatIso | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
[inst : AlgebraicGeometry.IsOpenImmersion f] →
(x : ↥X) →
(AlgebraicGeometry.Scheme.Modules.restrictFunctor f).comp
((AlgebraicGeometry.Scheme.Modules.toPresheaf X).comp (TopCat.Presheaf.stalkFunctor Ab x)) ≅
(AlgebraicGeometry.Scheme.Modules.toPresheaf Y).comp (TopCat.Presheaf.stalkFunctor Ab (f x)) |
Lagrange.nodal_insert_eq_nodal | Mathlib.LinearAlgebra.Lagrange | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} {s : Finset ι} {v : ι → R} [inst_1 : DecidableEq ι] {i : ι},
i ∉ s → Lagrange.nodal (insert i s) v = (Polynomial.X - Polynomial.C (v i)) * Lagrange.nodal s v |
Std.DHashMap.get_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{f : β k → β k} {h : k ∈ m.modify k f}, (m.modify k f).get k h = f (m.get k ⋯) |
AddAction.nonempty_orbit | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M α] (a : α), (AddAction.orbit M a).Nonempty |
Topology.closure_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr |
Lean.Meta.simpEq.match_6 | Mathlib.Lean.Meta.Simp | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((u : Lean.Level) → (α lhs rhs : Lean.Expr) → motive ((((Lean.Expr.const `Eq [u]).app α).app lhs).app rhs)) →
((x : Lean.Expr) → motive x) → motive type |
BitVec.shiftLeftZeroExtend._proof_1 | Init.Data.BitVec.Basic | ∀ {w x : ℕ}, x < 2 ^ w → ∀ (m : ℕ), x <<< m < 2 ^ (w + m) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.