name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Composition.reverse_eq_ones._simp_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, (c.reverse = Composition.ones n) = (c = Composition.ones n) | false |
CategoryTheory.Limits.Cone.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor J C) {X Y : CategoryTheory.Limits.Cone F}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.const J).map f.hom)
(CategoryTheory.CostructuredArrow.mk Y.π).hom =
(CategoryTheory.CostructuredArrow.mk X.π).hom | false |
MeasureTheory.cylinderEvents_mono | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} {X : ι → Type u_3} [m : (i : ι) → MeasurableSpace (X i)] {Δ₁ Δ₂ : Set ι},
Δ₁ ⊆ Δ₂ → MeasureTheory.cylinderEvents Δ₁ ≤ MeasureTheory.cylinderEvents Δ₂ | true |
BoolAlg.Iso.mk._proof_6 | Mathlib.Order.Category.BoolAlg | ∀ {α β : BoolAlg} (e : ↑α ≃o ↑β) (a b : ↑α),
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | false |
LLVM.CodegenFileType.rec | Lean.Compiler.IR.LLVMBindings | {motive : LLVM.CodegenFileType → Sort u} →
((val : UInt64) → motive { val := val }) → (t : LLVM.CodegenFileType) → motive t | false |
MeasureTheory.snd_integral_withLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)} [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [CompleteSpace E],
MeasureTheory.Integrable f μ → (∫ (x : X), f x ∂μ).snd = ∫ (x : X), (f x).snd ∂μ | true |
Std.DTreeMap.Internal.Impl.balance!.match_1.congr_eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3)
(r : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf))
(h_3 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(rr : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
rr = Std.DTreeMap.Internal.Impl.inner size_1 k v l r →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 k v l r)))
(h_4 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(size_1 : ℕ) →
(rlk : α) →
(rlv : β rlk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf))
(h_5 :
(rs : ℕ) →
(rk : α) →
(rv : β rk) →
(rls : ℕ) →
(rlk : α) →
(rlv : β rlk) →
(rll rlr rr : Std.DTreeMap.Internal.Impl α β) →
(size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
rr = Std.DTreeMap.Internal.Impl.inner size k v l r →
motive
(Std.DTreeMap.Internal.Impl.inner rs rk rv
(Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner size k v l r)))
(rs : ℕ) (rk : α) (rv : β rk) (rls : ℕ) (rlk : α) (rlv : β rlk) (rll rlr : Std.DTreeMap.Internal.Impl α β) (size : ℕ)
(k : α) (v : β k) (l r_1 : Std.DTreeMap.Internal.Impl α β),
r =
Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner size k v l r_1) →
(match r with
| Std.DTreeMap.Internal.Impl.leaf => h_1 ()
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf =>
h_2 size k v
|
Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
rr@h:(Std.DTreeMap.Internal.Impl.inner size_1 k v l r) =>
h_3 size rk rv rr size_1 k v l r h
|
Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf =>
h_4 size rk rv size_1 rlk rlv l r
|
Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
rr@h:(Std.DTreeMap.Internal.Impl.inner size k v l r) =>
h_5 rs rk rv rls rlk rlv rll rlr rr size k v l r h) ≍
h_5 rs rk rv rls rlk rlv rll rlr (Std.DTreeMap.Internal.Impl.inner size k v l r_1) size k v l r_1 ⋯ | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.card_edgeFinset_turanGraph._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r : ℕ},
(n - r) % r * ((n - r) / r + 1) * (r - 1) + r.choose 2 * ((n - r) / r + 1) ^ 2 =
(n - r) % r * ((n - r) / r + 1) * (r - 1) + r.choose 2 + r.choose 2 * 2 * ((n - r) / r) +
r.choose 2 * ((n - r) / r) ^ 2 | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (k : α) (v : β k),
Std.DTreeMap.Internal.Impl.leaf.size ≤
(Std.DTreeMap.Internal.Impl.inner 1 k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | false |
instFiniteConjClasses | Mathlib.Algebra.Group.ConjFinite | ∀ {α : Type u_1} [inst : Monoid α] [Finite α], Finite (ConjClasses α) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr.0.Lean.Grind.Linarith.Expr.denoteExpr.go._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr | {M : Type → Type} →
[Monad M] → [Lean.Meta.Grind.Arith.Linear.MonadGetStruct M] → Lean.Meta.Grind.Arith.Linear.LinExpr → M Lean.Expr | false |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.mk._flat_ctor | Lean.Meta.Sym.Simp.Forall | Lean.Name → Lean.BinderInfo → Lean.Level → Lean.Level → Lean.Meta.Sym.Simp.ArrowInfo✝ | false |
Batteries.TransOrd | Batteries.Classes.Deprecated | (α : Type u_1) → [Ord α] → Prop | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
MulEquiv.withOneCongr | Mathlib.Algebra.Group.WithOne.Basic | {α : Type u} → {β : Type v} → [inst : Mul α] → [inst_1 : Mul β] → α ≃* β → WithOne α ≃* WithOne β | true |
Int32.sub_eq_iff_eq_add | Init.Data.SInt.Lemmas | ∀ {a b c : Int32}, a - b = c ↔ a = c + b | true |
Submodule.FG.lTensor.directedSystem | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (M : Type u_1) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N],
DirectedSystem (fun Q => TensorProduct R M ↥↑Q) fun x x_1 hPQ => ⇑(LinearMap.lTensor M (Submodule.inclusion hPQ)) | true |
CochainComplex.mappingCone.inl_snd_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain G K d) (he : 0 + d = e) (hf : -1 + e = f),
(CochainComplex.mappingCone.inl φ).comp ((CochainComplex.mappingCone.snd φ).comp γ he) hf = 0 | true |
_private.Lean.Meta.SizeOf.0.Lean.Meta.mkLocalInstances.loop | Lean.Meta.SizeOf | {α : Type} → Array Lean.Expr → (Array Lean.Expr → Lean.MetaM α) → ℕ → Array Lean.Expr → Lean.MetaM α | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomLeft_tensor | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {z z' : D} (f : z ⟶ z') (x y : C),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso z x y).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f x) y)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso z' x y).inv) | true |
MvPolynomial.mem_degreesLE | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : Multiset σ},
p ∈ MvPolynomial.degreesLE R σ s ↔ p.degrees ≤ s | true |
SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint.inj₁ | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)}
[self : SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint t] ⦃a : α⦄ ⦃b : β⦄ ⦃c : γ⦄ ⦃b' : β⦄,
(a, b, c) ∈ t → (a, b', c) ∈ t → b = b' | true |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkLawfulDayConvolutionMonoidalCategoryStruct._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore C V D]
[inst_6 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorLeft v)]
[inst_7 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorRight v)]
[inst_8 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow
(CategoryTheory.Functor.fromPUnit (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) d)
(CategoryTheory.MonoidalCategory.tensorRight v)]
[inst_9 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow
(CategoryTheory.Functor.fromPUnit (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) d)
(CategoryTheory.MonoidalCategory.tensorLeft v)]
{d₁ d₂ d₁' d₂' : D} (f₁ : d₁ ⟶ d₁') (f₂ : d₂ ⟶ d₂') (x y : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.DayConvolution.unit
((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).obj d₁)
((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).obj
d₂)).app
(x, y))
(((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).map
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂)).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).map f₁).app x)
(((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).map f₂).app
y))
((CategoryTheory.MonoidalCategory.DayConvolution.unit
((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).obj d₁')
((CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ι C V D).obj
d₂')).app
(x, y)) | false |
CliffordAlgebra.EvenHom.mk.noConfusion | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
{inst : CommRing R} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{Q : QuadraticForm R M} →
{A : Type u_3} →
{inst_3 : Ring A} →
{inst_4 : Algebra R A} →
{P : Sort u} →
{bilin : M →ₗ[R] M →ₗ[R] A} →
{contract : ∀ (m : M), (bilin m) m = (algebraMap R A) (Q m)} →
{contract_mid : ∀ (m₁ m₂ m₃ : M), (bilin m₁) m₂ * (bilin m₂) m₃ = Q m₂ • (bilin m₁) m₃} →
{bilin' : M →ₗ[R] M →ₗ[R] A} →
{contract' : ∀ (m : M), (bilin' m) m = (algebraMap R A) (Q m)} →
{contract_mid' :
∀ (m₁ m₂ m₃ : M), (bilin' m₁) m₂ * (bilin' m₂) m₃ = Q m₂ • (bilin' m₁) m₃} →
{ bilin := bilin, contract := contract, contract_mid := contract_mid } =
{ bilin := bilin', contract := contract', contract_mid := contract_mid' } →
(bilin ≍ bilin' → P) → P | false |
ProbabilityTheory.Kernel.partialTraj.eq_1 | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)}
(κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))) (a b : ℕ),
ProbabilityTheory.Kernel.partialTraj κ a b =
if h : b ≤ a then ProbabilityTheory.Kernel.deterministic (Preorder.frestrictLe₂ h) ⋯
else
Nat.leRec ProbabilityTheory.Kernel.id
(fun k x κ_k =>
((ProbabilityTheory.Kernel.id.prod ((κ k).map ⇑(MeasurableEquiv.piSingleton k))).comp κ_k).map
(IicProdIoc k (k + 1)))
⋯ | true |
Mathlib.Tactic.Ring.ExProd.recOn | Mathlib.Tactic.Ring.Common | {motive_1 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExBase a e → Sort u} →
{motive_2 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExProd a e → Sort u} →
{motive_3 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExSum a e → Sort u} →
{u : Lean.Level} →
{α : Q(Type u)} →
{a : Q(CommSemiring «$α»)} →
{e : Q(«$α»)} →
(t : Mathlib.Tactic.Ring.ExProd a e) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{e : Q(«$α»)} → (id : ℕ) → motive_1 sα e (Mathlib.Tactic.Ring.ExBase.atom id)) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{e : Q(«$α»)} →
(x : Mathlib.Tactic.Ring.ExSum sα e) →
motive_3 sα e x → motive_1 sα e (Mathlib.Tactic.Ring.ExBase.sum x)) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{e : Q(«$α»)} →
(value : ℚ) →
(hyp : Option Lean.Expr) → motive_2 sα e (Mathlib.Tactic.Ring.ExProd.const value hyp)) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{x : Q(«$α»)} →
{e : Q(ℕ)} →
{b : Q(«$α»)} →
(a : Mathlib.Tactic.Ring.ExBase sα x) →
(a_1 : Mathlib.Tactic.Ring.ExProd Mathlib.Tactic.Ring.sℕ e) →
(a_2 : Mathlib.Tactic.Ring.ExProd sα b) →
motive_1 sα x a →
motive_2 Mathlib.Tactic.Ring.sℕ e a_1 →
motive_2 sα b a_2 →
motive_2 sα q(«$x» ^ «$e» * «$b»)
(Mathlib.Tactic.Ring.ExProd.mul a a_1 a_2)) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} → motive_3 sα q(0) Mathlib.Tactic.Ring.ExSum.zero) →
({u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{a b : Q(«$α»)} →
(a_1 : Mathlib.Tactic.Ring.ExProd sα a) →
(a_2 : Mathlib.Tactic.Ring.ExSum sα b) →
motive_2 sα a a_1 →
motive_3 sα b a_2 →
motive_3 sα q(«$a» + «$b») (Mathlib.Tactic.Ring.ExSum.add a_1 a_2)) →
motive_2 a e t | false |
NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul_smul_coe | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : ↥(NumberField.Units.torsion K))
(x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)), ↑(x • x_1) = ↑x • ↑x_1 | true |
Lean.Elab.Term.Quotation.MatchResult.covered.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{f : Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM Lean.Elab.Term.Quotation.Alt} →
{exhaustive : Bool} →
{f' : Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM Lean.Elab.Term.Quotation.Alt} →
{exhaustive' : Bool} →
Lean.Elab.Term.Quotation.MatchResult.covered f exhaustive =
Lean.Elab.Term.Quotation.MatchResult.covered f' exhaustive' →
(f = f' → exhaustive = exhaustive' → P) → P | false |
_private.Mathlib.Geometry.Euclidean.PerpBisector.0.AffineSubspace.midpoint_mem_perpBisector._simp_1_1 | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
(c ∈ AffineSubspace.perpBisector p₁ p₂) = (inner ℝ (c -ᵥ midpoint ℝ p₁ p₂) (p₂ -ᵥ p₁) = 0) | false |
Polynomial.exists_iff_exists_finsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (P : Polynomial R → Prop), (∃ p, P p) ↔ ∃ q, P { toFinsupp := q } | true |
LipschitzOnWith.mk_one | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {s : Set α} {f : α → β},
(∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ dist x y) → LipschitzOnWith 1 f s | true |
ContinuousMonoidHom.comp._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (g : B →ₜ* C) (f : A →ₜ* B),
Continuous (⇑g ∘ ⇑f.toMonoidHom) | false |
CategoryTheory.ObjectProperty.instIsClosedUnderIsomorphisms_1 | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderQuotients], P.IsClosedUnderIsomorphisms | true |
WithBot.bot_lt_mul | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] [inst_2 : LT α] {a b : WithBot α},
⊥ < a → ⊥ < b → ⊥ < a * b | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_lintegral_of_nonneg_ae._simp_1_4 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) | false |
instNegInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : AddCommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedAddMonoid α] → Neg (Interval α) | true |
_private.Mathlib.Algebra.Star.Center.0.Set.star_centralizer._simp_1_5 | Mathlib.Algebra.Star.Center | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∀ y ∈ f '' s, p y) = ∀ ⦃x : α⦄, x ∈ s → p (f x) | false |
Std.Do.SPred.not_nil | Std.Do.SPred.SPred | ∀ {P : Std.Do.SPred []}, spred(¬P) = { down := ¬P.down } | true |
CategoryTheory.Triangulated.TStructure.liftTruncLT | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
(t : CategoryTheory.Triangulated.TStructure C) →
{X Y : C} → (X ⟶ Y) → (n₀ n₁ : ℤ) → n₀ + 1 = n₁ → [t.IsLE X n₀] → X ⟶ (t.truncLT n₁).obj Y | true |
Std.Time.TimeZone.TZif.Header.isutcnt | Std.Time.Zoned.Database.TzIf | Std.Time.TimeZone.TZif.Header → UInt32 | true |
BitVec.instDecidableExistsBitVecSucc | Init.Data.BitVec.Decidable | {n : ℕ} →
(P : BitVec (n + 1) → Prop) →
[DecidablePred P] → [Decidable (∀ (x : Bool) (v : BitVec n), ¬P (BitVec.cons x v))] → Decidable (∃ v, P v) | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.foldl.match_1.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {σ : Sort u_3} {α : Type u_1} (motive : σ → Batteries.RBNode α → Sort u_2) (b : σ) (c : Batteries.RBColor)
(l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α) (h_1 : (b : σ) → motive b Batteries.RBNode.nil)
(h_2 :
(b : σ) →
(c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive b (Batteries.RBNode.node c l v r)),
(match b, Batteries.RBNode.node c l v r with
| b, Batteries.RBNode.nil => h_1 b
| b, Batteries.RBNode.node c l v r => h_2 b c l v r) =
h_2 b c l v r | true |
DividedPowers.ofRingEquiv._proof_2 | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] {I : Ideal A} [inst_1 : CommSemiring B] {J : Ideal B}
{e : A ≃+* B}, Ideal.map e I = J → ∀ (hI : DividedPowers I) {x : B}, x ∈ J → e (hI.dpow 0 (e.symm x)) = 1 | false |
ArithmeticFunction.pdiv._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : GroupWithZero R] (f g : ArithmeticFunction R), (fun n => f n / g n) 0 = 0 | false |
Lean.mkRawNatLit | Lean.Expr | ℕ → Lean.Expr | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdxD_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
CategoryTheory.Limits.Cone.mk.inj | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} J} {C : Type u₃} {inst_1 : CategoryTheory.Category.{v₃, u₃} C}
{F : CategoryTheory.Functor J C} {pt : C} {π : (CategoryTheory.Functor.const J).obj pt ⟶ F} {pt_1 : C}
{π_1 : (CategoryTheory.Functor.const J).obj pt_1 ⟶ F},
{ pt := pt, π := π } = { pt := pt_1, π := π_1 } → pt = pt_1 ∧ π ≍ π_1 | true |
NumberField.mixedEmbedding.indexEquiv._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] (φ : K →+* ℂ) (hφ : NumberField.ComplexEmbedding.IsReal φ),
(fun c =>
Sum.casesOn (motive := fun t => c = t → K →+* ℂ) c (fun w h => (↑w).embedding)
(fun wj h =>
Prod.casesOn wj fun w j =>
if j = 0 then (↑w).embedding else NumberField.ComplexEmbedding.conjugate (↑w).embedding)
⋯)
(Sum.inl (NumberField.InfinitePlace.mkReal ⟨φ, hφ⟩)) =
φ | false |
star_le_iff | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{x y : R}, star x ≤ y ↔ x ≤ star y | true |
Bimod.Hom.casesOn | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A B : CategoryTheory.Mon C} →
{M N : Bimod A B} →
{motive : M.Hom N → Sort u} →
(t : M.Hom N) →
((hom : M.X ⟶ N.X) →
(left_act_hom :
CategoryTheory.CategoryStruct.comp M.actLeft hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft A.X hom)
N.actLeft) →
(right_act_hom :
CategoryTheory.CategoryStruct.comp M.actRight hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight hom B.X) N.actRight) →
motive { hom := hom, left_act_hom := left_act_hom, right_act_hom := right_act_hom }) →
motive t | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs.0.posMulReflectLE_iff_mulPosReflectLE._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ (α : Type u_1) [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
MulPosReflectLE α = ContravariantClass { x // 0 < x } α (fun x y => y * ↑x) fun x1 x2 => x1 ≤ x2 | false |
Lean.PrettyPrinter.Parenthesizer.node.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.SyntaxNodeKind → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | true |
instDecidableEqSum | Init.Core | {α : Type u_1} → {β : Type u_2} → [DecidableEq α] → [DecidableEq β] → DecidableEq (α ⊕ β) | true |
CategoryTheory.GradedObject.instIsIsoMapBifunctorMapMap | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6}
(p : I × J → K) {X₁ X₂ : CategoryTheory.GradedObject I C₁} {Y₁ Y₂ : CategoryTheory.GradedObject J C₂}
[inst_3 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₁).obj Y₁).HasMap p]
[inst_4 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₂).obj Y₂).HasMap p] (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂)
[CategoryTheory.IsIso f] [CategoryTheory.IsIso g],
CategoryTheory.IsIso (CategoryTheory.GradedObject.mapBifunctorMapMap F p f g) | true |
Vector.countP_false | Init.Data.Vector.Count | ∀ {α : Type u_1} {n : ℕ}, (Vector.countP fun x => false) = fun x => 0 | true |
Std.DTreeMap.Raw.getKey?_maxKeyD | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback) | true |
CategoryTheory.ObjectProperty.createsCokernels | Mathlib.CategoryTheory.ObjectProperty.Kernels | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(P : CategoryTheory.ObjectProperty C) →
[P.IsClosedUnderCokernels] →
{X Y : P.FullSubcategory} →
(f : X ⟶ Y) →
[CategoryTheory.Limits.HasCokernel f.hom] →
CategoryTheory.CreatesColimit (CategoryTheory.Limits.parallelPair f 0) P.ι | true |
FourierTransformInv.fourierInv | Mathlib.Analysis.Fourier.Notation | {E : Type u} → {F : outParam (Type v)} → [self : FourierTransformInv E F] → E → F | true |
ArithmeticFunction.instCommRing._proof_7 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (a : ArithmeticFunction R), -a + a = 0 | false |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.All.balLeft._simp_1_3 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {p : α → Prop} {t : Batteries.RBNode α},
Batteries.RBNode.All p t → Batteries.RBNode.All p t.setRed = True | false |
AddMonoidAlgebra.smul_single' | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (r' : R) (m : M) (r : R),
r' • AddMonoidAlgebra.single m r = AddMonoidAlgebra.single m (r' * r) | true |
CochainComplex.ConnectData.homologyIsoNeg._proof_6 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (n : ℕ) (m : ℤ), m = -↑(n + 1) → (ComplexShape.embeddingUpIntLE (-1)).f n = m | false |
CategoryTheory.WithInitial.Hom.eq_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X Y : C),
(CategoryTheory.WithInitial.of X).Hom (CategoryTheory.WithInitial.of Y) = (X ⟶ Y) | true |
_private.Mathlib.NumberTheory.FLT.Three.0.«termλ» | Mathlib.NumberTheory.FLT.Three | Lean.ParserDescr | true |
Std.DTreeMap.Internal.Impl.Ordered.compare_left_beq_gt | Std.Data.DTreeMap.Internal.Ordered | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α → Ordering} [Std.Internal.IsStrictCut compare k]
{sz : ℕ} {k' : α} {v' : β k'} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Ordered →
(k k').isGE = true → ∀ p ∈ l.toListModel, (k p.fst == Ordering.gt) = true | true |
CategoryTheory.rightRigidCategoryOfEquivalence | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
[F.Monoidal] →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
[F.IsEquivalence] → [CategoryTheory.RightRigidCategory D] → CategoryTheory.RightRigidCategory C | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.isSupportedMatch.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis | (motive : Option Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind → Sort u_1) →
(__do_lift : Option Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) →
((kind : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) → motive (some kind)) →
((x : Option Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) → motive x) → motive __do_lift | false |
Set.Ico._proof_2 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), {x | b < x ∧ x ≤ a} = {x | x ≤ a ∧ b < x} | false |
Expr.instZero | Mathlib.Algebra.Expr | {u : Lean.Level} → (α : Q(Type u)) → Q(Zero «$α») → Zero Q(«$α») | true |
Quantale.mk.sizeOf_spec | Mathlib.Algebra.Order.Quantale | ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : CompleteLattice α] [inst_2 : IsQuantale α] [inst_3 : SizeOf α],
sizeOf { } = 1 | true |
Lean.resetTraceState | Lean.Util.Trace | {m : Type → Type} → [Lean.MonadTrace m] → m Unit | true |
Turing.TM2.Stmt.halt | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} → {Γ : K → Type u_2} → {Λ : Type u_3} → {σ : Type u_4} → Turing.TM2.Stmt Γ Λ σ | true |
MvPolynomial.aeval_injective_iff_of_isEmpty._simp_1 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [IsEmpty σ] [inst_2 : CommSemiring S₁]
[inst_3 : Algebra R S₁] {f : σ → S₁},
Function.Injective ⇑(MvPolynomial.aeval f) = Function.Injective ⇑(algebraMap R S₁) | false |
CategoryTheory.typesCartesianMonoidalCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Types.Basic | ∀ (X₁ X₂ : Type u_1),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ X₂) | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.contains'.match_1.splitter | Std.Data.DTreeMap.Internal.WF.Lemmas | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.gt) → (Unit → motive Ordering.eq) → motive x | true |
ContinuousMap.unitsLift_apply_inv_apply | Mathlib.Topology.ContinuousMap.Units | ∀ {X : Type u_1} {M : Type u_2} [inst : TopologicalSpace X] [inst_1 : Monoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousMul M] (f : C(X, Mˣ)) (x : X), ↑(ContinuousMap.unitsLift f)⁻¹ x = ↑(f x)⁻¹ | true |
Lean.Elab.Term.LetRecDeclView.docString?._default | Lean.Elab.LetRec | Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) | false |
Std.Sat.AIG.relabel_unsat_iff | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
{idx : ℕ} {invert : Bool} {aig : Std.Sat.AIG α} {r : α → β} {hidx1 : idx < (Std.Sat.AIG.relabel r aig).decls.size}
{hidx2 : idx < aig.decls.size},
(∀ (x y : α), x ∈ aig → y ∈ aig → r x = r y → x = y) →
((Std.Sat.AIG.relabel r aig).UnsatAt idx invert hidx1 ↔ aig.UnsatAt idx invert hidx2) | true |
tsum_sq_fourierCoeffOn | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} {f : ℝ → ℂ} (hab : a < b),
MeasureTheory.MemLp f 2 (MeasureTheory.volume.restrict (Set.Ioc a b)) →
∑' (i : ℤ), ‖fourierCoeffOn hab f i‖ ^ 2 = (b - a)⁻¹ • ∫ (x : ℝ) in a..b, ‖f x‖ ^ 2 | true |
_aux_Mathlib_Algebra_Module_Equiv_Defs___unexpand_LinearEquiv_1 | Mathlib.Algebra.Module.Equiv.Defs | Lean.PrettyPrinter.Unexpander | false |
Polynomial.eval₂RingHom | Mathlib.Algebra.Polynomial.Eval.Defs | {R : Type u} → {S : Type v} → [inst : Semiring R] → [inst_1 : CommSemiring S] → (R →+* S) → S → Polynomial R →+* S | true |
Mathlib.Meta.NormNum.proveAscFactorial._unsafe_rec | Mathlib.Tactic.NormNum.NatFactorial | ℕ → ℕ → (en el : Q(ℕ)) → ℕ × (eresult : Q(ℕ)) × Q(«$en».ascFactorial «$el» = «$eresult») | false |
Lean.Lsp.CodeActionOptions.resolveProvider? | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionOptions → Option Bool | true |
Quaternion.normSq_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), Quaternion.normSq (star a) = Quaternion.normSq a | true |
Lean.Elab.Term.MatchExpr.Alt._sizeOf_1 | Lean.Elab.MatchExpr | Lean.Elab.Term.MatchExpr.Alt → ℕ | false |
RingQuot.noConfusion | Mathlib.Algebra.RingQuot | {P : Sort u} →
{R : Type uR} →
{inst : Semiring R} →
{r : R → R → Prop} →
{t : RingQuot r} →
{R' : Type uR} →
{inst' : Semiring R'} →
{r' : R' → R' → Prop} →
{t' : RingQuot r'} → R = R' → inst ≍ inst' → r ≍ r' → t ≍ t' → RingQuot.noConfusionType P t t' | false |
TopologicalSpace.instSecondCountableTopologyOfLindelofSpaceOfPseudoMetrizableSpace | Mathlib.Topology.Metrizable.Basic | ∀ (X : Type u_5) [inst : TopologicalSpace X] [LindelofSpace X] [TopologicalSpace.PseudoMetrizableSpace X],
SecondCountableTopology X | true |
«term_→ₗc_» | Mathlib.RingTheory.Coalgebra.Hom | Lean.TrailingParserDescr | true |
_private.Lean.Environment.0.Lean.VisibilityMap.const | Lean.Environment | {α : Type} → α → Lean.VisibilityMap✝ α | true |
Aesop.PhaseName.norm | Aesop.Rule.Name | Aesop.PhaseName | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listDecode.match_1.eq_3 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3}
(motive : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ) → Sort u_4) (n : ℕ) (R : L.Relations n)
(k : ℕ) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ))
(h_1 :
(n : ℕ) →
(l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) →
motive (Sum.inr (Sum.inr n.succ.succ) :: l))
(h_2 :
(n₁ : ℕ) →
(t₁ : L.Term (α ⊕ Fin n₁)) →
(n₂ : ℕ) →
(t₂ : L.Term (α ⊕ Fin n₂)) →
(l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) →
motive (Sum.inl ⟨n₁, t₁⟩ :: Sum.inl ⟨n₂, t₂⟩ :: l))
(h_3 :
(n : ℕ) →
(R : L.Relations n) →
(k : ℕ) →
(l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) →
motive (Sum.inr (Sum.inl ⟨n, R⟩) :: Sum.inr (Sum.inr k) :: l))
(h_4 : (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) → motive (Sum.inr (Sum.inr 0) :: l))
(h_5 : (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) → motive (Sum.inr (Sum.inr 1) :: l))
(h_6 : (x : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) → motive x),
(match Sum.inr (Sum.inl ⟨n, R⟩) :: Sum.inr (Sum.inr k) :: l with
| Sum.inr (Sum.inr n.succ.succ) :: l => h_1 n l
| Sum.inl ⟨n₁, t₁⟩ :: Sum.inl ⟨n₂, t₂⟩ :: l => h_2 n₁ t₁ n₂ t₂ l
| Sum.inr (Sum.inl ⟨n, R⟩) :: Sum.inr (Sum.inr k) :: l => h_3 n R k l
| Sum.inr (Sum.inr 0) :: l => h_4 l
| Sum.inr (Sum.inr 1) :: l => h_5 l
| x => h_6 x) =
h_3 n R k l | true |
Order.succ_le_iff_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, ¬IsMax a → (Order.succ a ≤ b ↔ a < b) | true |
Equiv.subtypeEquiv._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a))
(a : { a // p a }), ↑((fun b => ⟨e.symm ↑b, ⋯⟩) ((fun a => ⟨e ↑a, ⋯⟩) a)) = ↑a | false |
Equiv.toHomeomorphOfContinuousOpen_symm_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(h₁ : Continuous ⇑e) (h₂ : IsOpenMap ⇑e), ⇑(e.toHomeomorphOfContinuousOpen h₁ h₂).symm = ⇑e.symm | true |
DenseRange.piMap | Mathlib.Topology.NhdsWithin | ∀ {ι : Type u_5} {X : ι → Type u_6} {Y : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (Y i)]
{f : (i : ι) → X i → Y i}, (∀ (i : ι), DenseRange (f i)) → DenseRange (Pi.map f) | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.ParentKind.genPattern.sizeOf_spec | Lean.Meta.Tactic.Grind.EMatchTheorem | sizeOf Lean.Meta.Grind.NormalizePattern.ParentKind.genPattern✝ = 1 | true |
Std.DHashMap.union_insert_right_equiv_union_insert | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {p : (a : α) × β a}, (m₁ ∪ m₂.insert p.fst p.snd).Equiv ((m₁ ∪ m₂).insert p.fst p.snd) | true |
CategoryTheory.Limits.HasBinaryBiproduct.mk'._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C}, Nonempty (CategoryTheory.Limits.BinaryBiproductData P Q) → CategoryTheory.Limits.HasBinaryBiproduct P Q | false |
LinearEquiv.rTensor_pow | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (f : M ≃ₗ[R] M) (n : ℕ),
LinearEquiv.rTensor N f ^ n = LinearEquiv.rTensor N (f ^ n) | true |
Lean.IR.FnBody.unreachable | Lean.Compiler.IR.Basic | Lean.IR.FnBody | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.