name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
SemiRingCat.FilteredColimits.colimitCocone._proof_5 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] {x x_1 : J} (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (F.map f)
(SemiRingCat.ofHom
{
toMonoidHom :=
MonCat.Hom.hom
((MonCat.FilteredColimits.colimitCocone (F.comp (CategoryTheory.forget₂ SemiRingCat MonCat))).ι.app x_1),
map_zero' := ⋯, map_add' := ⋯ }) =
CategoryTheory.CategoryStruct.comp
(SemiRingCat.ofHom
{
toMonoidHom :=
MonCat.Hom.hom
((MonCat.FilteredColimits.colimitCocone (F.comp (CategoryTheory.forget₂ SemiRingCat MonCat))).ι.app x),
map_zero' := ⋯, map_add' := ⋯ })
(((CategoryTheory.Functor.const J).obj (SemiRingCat.FilteredColimits.colimit F)).map f) | false |
Lean.Elab.Term.Do.ToTerm.Context.casesOn | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Context → Sort u} →
(t : Lean.Elab.Term.Do.ToTerm.Context) →
((m returnType : Lean.Syntax) →
(uvars : Array Lean.Elab.Term.Do.Var) →
(kind : Lean.Elab.Term.Do.ToTerm.Kind) →
motive { m := m, returnType := returnType, uvars := uvars, kind := kind }) →
motive t | false |
Std.DHashMap.isEmpty_toArray | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α],
m.toArray.isEmpty = m.isEmpty | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.alterKey.match_1.splitter | Std.Data.Internal.List.Associative | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((v : β) → motive (some v)) → motive x | true |
CategoryTheory.Functor.mapGrp_obj_X | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (A : CategoryTheory.Grp C), (F.mapGrp.obj A).X = F.obj A.X | true |
Lean.Meta.CasesSubgoal.toInductionSubgoal | Lean.Meta.Tactic.Cases | Lean.Meta.CasesSubgoal → Lean.Meta.InductionSubgoal | true |
_private.Mathlib.RingTheory.Finiteness.Cardinality.0.AddSubmonoid.fg_iff_exists_fin_addMonoidHom.match_1_3 | Mathlib.RingTheory.Finiteness.Cardinality | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} (n : ℕ)
(motive : (∃ f, AddMonoidHom.mrange f = (AddSubmonoid.toNatSubmodule S).toAddSubmonoid) → Prop)
(x : ∃ f, AddMonoidHom.mrange f = (AddSubmonoid.toNatSubmodule S).toAddSubmonoid),
(∀ (f : (Fin n → ℕ) →+ M) (hf : AddMonoidHom.mrange f = (AddSubmonoid.toNatSubmodule S).toAddSubmonoid), motive ⋯) →
motive x | false |
contDiff_prod' | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞} {𝔸' : Type u_4} {ι : Type u_5} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {t : Finset ι} {f : ι → E → 𝔸'},
(∀ i ∈ t, ContDiff 𝕜 n (f i)) → ContDiff 𝕜 n (∏ i ∈ t, f i) | true |
commandDeclare_uint_simprocs_ | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.ParserDescr | true |
isBoundedBilinearMap_compMultilinear | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_3} [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {G : Type u_4} [inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G]
{ι : Type u_5} {E : ι → Type u_6} [inst_5 : Fintype ι] [inst_6 : (i : ι) → NormedAddCommGroup (E i)]
[inst_7 : (i : ι) → NormedSpace 𝕜 (E i)], IsBoundedBilinearMap 𝕜 fun p => p.1.compContinuousMultilinearMap p.2 | true |
CategoryTheory.Idempotents.karoubiChainComplexEquivalence | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(α : Type u_3) →
[inst_2 : AddRightCancelSemigroup α] →
[inst_3 : One α] →
CategoryTheory.Idempotents.Karoubi (ChainComplex C α) ≌
ChainComplex (CategoryTheory.Idempotents.Karoubi C) α | true |
Lean.Meta.Simp.Diagnostics.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {usedThmCounter triedThmCounter : Lean.PHashMap Lean.Meta.Origin ℕ} {congrThmCounter : Lean.PHashMap Lean.Name ℕ}
{thmsWithBadKeys : Lean.PArray Lean.Meta.SimpTheorem}
{usedThmCounter_1 triedThmCounter_1 : Lean.PHashMap Lean.Meta.Origin ℕ}
{congrThmCounter_1 : Lean.PHashMap Lean.Name ℕ} {thmsWithBadKeys_1 : Lean.PArray Lean.Meta.SimpTheorem},
{ usedThmCounter := usedThmCounter, triedThmCounter := triedThmCounter, congrThmCounter := congrThmCounter,
thmsWithBadKeys := thmsWithBadKeys } =
{ usedThmCounter := usedThmCounter_1, triedThmCounter := triedThmCounter_1, congrThmCounter := congrThmCounter_1,
thmsWithBadKeys := thmsWithBadKeys_1 } →
usedThmCounter = usedThmCounter_1 ∧
triedThmCounter = triedThmCounter_1 ∧ congrThmCounter = congrThmCounter_1 ∧ thmsWithBadKeys = thmsWithBadKeys_1 | true |
Mathlib.Meta.Positivity.Strictness.ctorElim | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(ctorIdx : ℕ) →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
ctorIdx = t.ctorIdx → Mathlib.Meta.Positivity.Strictness.ctorElimType ctorIdx → motive t | false |
Bool.instDecidableRelCovBy | Mathlib.Order.Cover | DecidableRel fun x1 x2 => x1 ⋖ x2 | true |
Std.ExtDHashMap.instLawfulSingletonSigma | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α],
LawfulSingleton ((a : α) × β a) (Std.ExtDHashMap α β) | true |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | SizeOf Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval | false |
WithZero.coeMonoidHom | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [inst : MulOneClass α] → α →* WithZero α | true |
tsirelson_inequality | Mathlib.Algebra.Star.CHSH | ∀ {R : Type u} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : Algebra ℝ R] [IsOrderedModule ℝ R] [StarModule ℝ R] (A₀ A₁ B₀ B₁ : R),
IsCHSHTuple A₀ A₁ B₀ B₁ → A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ √2 ^ 3 • 1 | true |
Rat.mul_num_den' | Mathlib.Data.Rat.Lemmas | ∀ (q r : ℚ), (q * r).num * ↑q.den * ↑r.den = q.num * r.num * ↑(q * r).den | true |
Nat.ascFactorial_zero | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ), n.ascFactorial 0 = 1 | true |
«_aux_Mathlib_Algebra_Order_Hom_Monoid___macroRules_term_≃+o__1» | Mathlib.Algebra.Order.Hom.Monoid | Lean.Macro | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearIndependent.pair_symm_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
LinearIndependent R ![x, y] = ∀ (s t : R), s • x + t • y = 0 → s = 0 ∧ t = 0 | false |
_private.Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique.0.exists_isMIntegralCurveAt_of_contMDiffAt.match_1_3 | Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_3} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_2} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : IsManifold I 1 M] {v : (x : M) → TangentSpace I x} (t₀ : ℝ) {x₀ : M} (f : ℝ → E)
(motive :
(∃ ε > 0,
∀ y ∈ Metric.ball t₀ ε,
HasDerivAt f
((↑(extChartAt (I.prod (modelWithCornersSelf ℝ E)) ⟨x₀, v x₀⟩) ∘
(fun x => ⟨x, v x⟩) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y) →
Prop)
(x :
∃ ε > 0,
∀ y ∈ Metric.ball t₀ ε,
HasDerivAt f
((↑(extChartAt (I.prod (modelWithCornersSelf ℝ E)) ⟨x₀, v x₀⟩) ∘
(fun x => ⟨x, v x⟩) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y),
(∀ (a : ℝ) (ha : a > 0)
(hf2' :
∀ y ∈ Metric.ball t₀ a,
HasDerivAt f
((↑(extChartAt (I.prod (modelWithCornersSelf ℝ E)) ⟨x₀, v x₀⟩) ∘
(fun x => ⟨x, v x⟩) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y),
motive ⋯) →
motive x | false |
Set.bijOn_empty | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β), Set.BijOn f ∅ ∅ | true |
Std.Iter.atIdxSlow?_repeat | Std.Data.Iterators.Lemmas.Producers.Repeat | ∀ {α : Type w} {f : α → α} {init : α} {n : ℕ},
Std.Iter.atIdxSlow? n (Std.Iter.repeat f init) = some (Nat.repeat f n init) | true |
Lean.Meta.Simp.ConfigCtx.ground._inherited_default | Init.MetaTypes | Bool | false |
Set.Ico_union_Ico | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
min a b ≤ max c d → min c d ≤ max a b → Set.Ico a b ∪ Set.Ico c d = Set.Ico (min a c) (max b d) | true |
TypeVec.typevecCasesCons₂._proof_1 | Mathlib.Data.TypeVec | ∀ (n : ℕ) (t : Type u_2) (t' : Type u_3) (v : TypeVec.{u_2} n) (v' : TypeVec.{u_3} n)
{β : (v ::: t).Arrow (v' ::: t') → Sort u_1} (fs : (v ::: t).Arrow (v' ::: t')),
β fs = β (TypeVec.splitFun (TypeVec.dropFun fs) (TypeVec.lastFun fs)) | false |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.Seq.superpose?.go._sunfold | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq →
Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Option (Lean.Grind.AC.Seq × Lean.Grind.AC.Seq × Lean.Grind.AC.Seq) | false |
_private.Mathlib.Combinatorics.Matroid.Minor.Contract.0.Matroid.Indep.union_isBasis_union_of_contract_isBasis._simp_1_3 | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
linearIndependent_iUnion_finite | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {η : Type u_6}
{ιs : η → Type u_7} {f : (j : η) → ιs j → M},
(∀ (j : η), LinearIndependent R (f j)) →
(∀ (i : η) (t : Set η),
t.Finite →
i ∉ t → Disjoint (Submodule.span R (Set.range (f i))) (⨆ i ∈ t, Submodule.span R (Set.range (f i)))) →
LinearIndependent R fun ji => f ji.fst ji.snd | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.collectDirectVarsInPattern.go | Lean.Meta.IndPredBelow | Lean.Meta.Match.Pattern → Array Lean.FVarId → Array Lean.FVarId | true |
tsub_tsub_cancel_of_le | Mathlib.Algebra.Order.Sub.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [ExistsAddOfLE α] [AddLeftMono α]
[inst_4 : Sub α] [OrderedSub α] {a b : α} [AddLeftReflectLE α], a ≤ b → b - (b - a) = a | true |
CommCStarAlgebra.casesOn | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : CommCStarAlgebra A → Sort u} →
(t : CommCStarAlgebra A) →
([toNormedCommRing : NormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ A] →
[toStarModule : StarModule ℂ A] →
motive
{ toNormedCommRing := toNormedCommRing, toStarRing := toStarRing,
toCompleteSpace := toCompleteSpace, toCStarRing := toCStarRing,
toNormedAlgebra := toNormedAlgebra, toStarModule := toStarModule }) →
motive t | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.SimpleFunc.exists_le_lowerSemicontinuous_lintegral_ge._simp_1_7 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | false |
HahnSeries.truncLT._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : PartialOrder Γ] [inst_2 : DecidableLT Γ] (c : Γ),
{ coeff := fun i => if i < c then HahnSeries.coeff 0 i else 0, isPWO_support' := ⋯ } = 0 | false |
CategoryTheory.MorphismProperty.Comma.forget_obj | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (P : CategoryTheory.MorphismProperty T)
(Q : CategoryTheory.MorphismProperty A) (W : CategoryTheory.MorphismProperty B) [inst_3 : Q.IsMultiplicative]
[inst_4 : W.IsMultiplicative] (X : CategoryTheory.MorphismProperty.Comma L R P Q W),
(CategoryTheory.MorphismProperty.Comma.forget L R P Q W).obj X = X.toComma | true |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.nthRoots_one_eq_biUnion_primitiveRoots' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R] {n : ℕ} [NeZero n],
Polynomial.nthRootsFinset n 1 = n.divisors.biUnion fun i => primitiveRoots i R | true |
MeasurableEquiv.IicProdIoi | Mathlib.Probability.Kernel.IonescuTulcea.Maps | {ι : Type u_1} →
[inst : LinearOrder ι] →
[DecidableLE ι] →
{X : ι → Type u_2} →
[inst_2 : LocallyFiniteOrderBot ι] →
[inst_3 : (i : ι) → MeasurableSpace (X i)] →
(a : ι) → ((i : ↥(Finset.Iic a)) → X ↑i) × ((i : ↑(Set.Ioi a)) → X ↑i) ≃ᵐ ((n : ι) → X n) | true |
Aesop.NormSimpRule.name | Aesop.Rule | Aesop.NormSimpRule → Aesop.RuleName | true |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_1 | Mathlib.Tactic.DepRewrite | (motive : Array Lean.Expr → Sort u_1) →
(xs : Array Lean.Expr) → ((x h : Lean.Expr) → motive #[x, h]) → ((x : Array Lean.Expr) → motive x) → motive xs | false |
Lean.FileMap.getLastLine | Lean.Data.Position | Lean.FileMap → ℕ | true |
Int.bit_val | Mathlib.Data.Int.Bitwise | ∀ (b : Bool) (n : ℤ), Int.bit b n = 2 * n + bif b then 1 else 0 | true |
forall_and_index | Mathlib.Logic.Basic | ∀ {p q : Prop} {r : p ∧ q → Prop}, (∀ (h : p ∧ q), r h) ↔ ∀ (hp : p) (hq : q), r ⋯ | true |
Vector.attach_append | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m},
(xs ++ ys).attach =
Vector.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach ++
Vector.map
(fun x =>
match x with
| ⟨y, h⟩ => ⟨y, ⋯⟩)
ys.attach | true |
Std.HashMap.Raw.getD_of_isEmpty | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α} {fallback : β}, m.isEmpty = true → m.getD a fallback = fallback | true |
AddMonoidAlgebra.unique.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Subsingleton R],
AddMonoidAlgebra.unique = { toInhabited := AddMonoidAlgebra.inhabited, uniq := ⋯ } | true |
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.isCyclic_units_iff._simp_1_2 | Mathlib.RingTheory.ZMod.UnitsCyclic | IsCyclic (ZMod 1)ˣ = True | false |
SimpleGraph.Walk.IsPath.concat | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v},
p.IsPath → w ∉ p.support → ∀ (h : G.Adj v w), (p.concat h).IsPath | true |
StandardSubspace.recOn | Mathlib.Analysis.InnerProductSpace.StandardSubspace | {H : Type u_1} →
[inst : NormedAddCommGroup H] →
[inst_1 : InnerProductSpace ℂ H] →
{motive : StandardSubspace H → Sort u} →
(t : StandardSubspace H) →
((toClosedSubmodule : ClosedSubmodule ℝ H) →
(IsSeparating : toClosedSubmodule ⊓ toClosedSubmodule.mulI = ⊥) →
(IsCyclic : toClosedSubmodule ⊔ toClosedSubmodule.mulI = ⊤) →
motive
{ toClosedSubmodule := toClosedSubmodule, IsSeparating := IsSeparating, IsCyclic := IsCyclic }) →
motive t | false |
CategoryTheory.Limits.coconeOfDiagramTerminal_pt | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{X : J} (tX : CategoryTheory.Limits.IsTerminal X) (F : CategoryTheory.Functor J C),
(CategoryTheory.Limits.coconeOfDiagramTerminal tX F).pt = F.obj X | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.gcd.match_17 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.qNF M → Mathlib.Tactic.FieldSimp.qNF M → Sort u_1) →
(l₁ l₂ : Mathlib.Tactic.FieldSimp.qNF M) →
(Unit → motive [] []) →
((n : ℤ) → (e : Q(«$M»)) → (i : ℕ) → (t : List ((ℤ × Q(«$M»)) × ℕ)) → motive (((n, e), i) :: t) []) →
((n : ℤ) → (e : Q(«$M»)) → (i : ℕ) → (t : List ((ℤ × Q(«$M»)) × ℕ)) → motive [] (((n, e), i) :: t)) →
((n₁ : ℤ) →
(e₁ : Q(«$M»)) →
(i₁ : ℕ) →
(t₁ : List ((ℤ × Q(«$M»)) × ℕ)) →
(n₂ : ℤ) →
(e₂ : Q(«$M»)) →
(i₂ : ℕ) →
(t₂ : List ((ℤ × Q(«$M»)) × ℕ)) → motive (((n₁, e₁), i₁) :: t₁) (((n₂, e₂), i₂) :: t₂)) →
motive l₁ l₂ | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Formula___delab_app__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Formula_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | Lean.PrettyPrinter.Delaborator.Delab | false |
RCLike.re_add_im_ax | Mathlib.Analysis.RCLike.Basic | ∀ {K : semiOutParam (Type u_1)} [self : RCLike K] (z : K),
(algebraMap ℝ K) (RCLike.re z) + (algebraMap ℝ K) (RCLike.im z) * RCLike.I = z | true |
ClosedSubmodule.coe_bot | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] [inst_4 : T1Space M], ↑⊥ = {0} | true |
Std.Tactic.BVDecide.BoolExpr.Sat.eq_1 | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | ∀ {α : Type} (a : α → Bool) (x : Std.Tactic.BVDecide.BoolExpr α),
Std.Tactic.BVDecide.BoolExpr.Sat a x = (Std.Tactic.BVDecide.BoolExpr.eval a x = true) | true |
StarRing.star_add | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} {inst : NonUnitalNonAssocSemiring R} [self : StarRing R] (r s : R), star (r + s) = star r + star s | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatch.match_3 | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} →
(motive : Option (Lean.Meta.DiscrTree.Trie α) → Sort u_1) →
(x : Option (Lean.Meta.DiscrTree.Trie α)) →
(Unit → motive none) → ((c : Lean.Meta.DiscrTree.Trie α) → motive (some c)) → motive x | false |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat._proof_2 | Mathlib.Tactic.NormNum.IsSquare | ∀ (sa : Q(AddMonoidWithOne ℚ))
(__defeqres : PLift («$sa» =Q Rat.instDivisionRing.toAddGroupWithOne.toAddMonoidWithOne)),
«$sa» =Q Rat.instDivisionRing.toAddGroupWithOne.toAddMonoidWithOne | false |
_private.Lean.Elab.BuiltinEvalCommand.0.Lean.Elab.Command.elabTermForEval | Lean.Elab.BuiltinEvalCommand | Lean.Syntax → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | true |
_private.Std.Sat.AIG.If.0.Std.Sat.AIG.RefVec.ite.go_get_aux._simp_1_2 | Std.Sat.AIG.If | ∀ (n : ℕ), (n ≤ n) = True | false |
Mathlib.Tactic.Order.AtomicFact.isSup.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs res : ℕ),
sizeOf (Mathlib.Tactic.Order.AtomicFact.isSup lhs rhs res) = 1 + sizeOf lhs + sizeOf rhs + sizeOf res | true |
_private.Init.GrindInstances.Ring.UInt.0.UInt64.intCast_ofNat._simp_1_2 | Init.GrindInstances.Ring.UInt | ∀ (a : ℕ), (a ∣ a) = True | false |
Real.natCastle_toNNReal'._simp_1 | Mathlib.Data.NNReal.Defs | ∀ {n : ℕ} {r : ℝ}, (↑n ≤ r.toNNReal) = (↑n ≤ r ∨ n = 0) | false |
CategoryTheory.IsPushout.inl_snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
CategoryTheory.IsPushout CategoryTheory.Limits.biprod.inl 0 CategoryTheory.Limits.biprod.snd 0 | true |
Lean.Lsp.InitializedParams.rec | Lean.Data.Lsp.InitShutdown | {motive : Lean.Lsp.InitializedParams → Sort u} →
motive Lean.Lsp.InitializedParams.mk → (t : Lean.Lsp.InitializedParams) → motive t | false |
Rat.le_iff_lt_or_eq | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a ≤ b ↔ a < b ∨ a = b | true |
derivWithin_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ {f : ℝ → ℝ} {x : ℝ} {s : Set ℝ},
DifferentiableWithinAt ℝ f s x →
UniqueDiffWithinAt ℝ s x → derivWithin (fun x => Real.arctan (f x)) s x = 1 / (1 + f x ^ 2) * derivWithin f s x | true |
WithLp.ofLp_sub | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V] (x y : WithLp p V), (x - y).ofLp = x.ofLp - y.ofLp | true |
Mathlib.Meta.NormNum.NormNumExt.pre._default | Mathlib.Tactic.NormNum.Core | Bool | false |
LinearMap.charpoly._proof_1 | Mathlib.LinearAlgebra.Charpoly.Basic | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
_private.Mathlib.Topology.DenseEmbedding.0.IsDenseInducing.continuousAt_extend._simp_1_1 | Mathlib.Topology.DenseEmbedding | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Array.map_eq_flatMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α}, Array.map f xs = Array.flatMap (fun x => #[f x]) xs | true |
CategoryTheory.Limits.IsLimit.mkConeMorphism_lift | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t)
(uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.IsLimit.mkConeMorphism lift uniq).lift s = (lift s).hom | true |
SkewMonoidAlgebra.distribMulActionHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N]
[inst_3 : DistribMulAction R M] [inst_4 : DistribMulAction R N] {α : Type u_6} {f g : SkewMonoidAlgebra M α →+[R] N},
(∀ (a : α) (m : M), f (SkewMonoidAlgebra.single a m) = g (SkewMonoidAlgebra.single a m)) → f = g | true |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_1 | Mathlib.RingTheory.Support | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | false |
«_aux_Mathlib_Topology_Algebra_Module_LinearMap___macroRules_term_→SL[_]__1» | Mathlib.Topology.Algebra.Module.LinearMap | Lean.Macro | false |
MeasureTheory.analyticSet_iff_exists_polishSpace_range | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α},
MeasureTheory.AnalyticSet s ↔ ∃ β h, ∃ (_ : PolishSpace β), ∃ f, Continuous f ∧ Set.range f = s | true |
AddGroupFilterBasis.casesOn | Mathlib.Topology.Algebra.FilterBasis | {A : Type u} →
[inst : AddGroup A] →
{motive : AddGroupFilterBasis A → Sort u_1} →
(t : AddGroupFilterBasis A) →
((toFilterBasis : FilterBasis A) →
(zero' : ∀ {U : Set A}, U ∈ toFilterBasis.sets → 0 ∈ U) →
(add' : ∀ {U : Set A}, U ∈ toFilterBasis.sets → ∃ V ∈ toFilterBasis.sets, V + V ⊆ U) →
(neg' : ∀ {U : Set A}, U ∈ toFilterBasis.sets → ∃ V ∈ toFilterBasis.sets, V ⊆ (fun x => -x) ⁻¹' U) →
(conj' :
∀ (x₀ : A) {U : Set A},
U ∈ toFilterBasis.sets → ∃ V ∈ toFilterBasis.sets, V ⊆ (fun x => x₀ + x + -x₀) ⁻¹' U) →
motive
{ toFilterBasis := toFilterBasis, zero' := zero', add' := add', neg' := neg', conj' := conj' }) →
motive t | false |
_private.Lean.Server.InfoUtils.0.Lean.Elab.Info.fmtHover?.fmtTermAndModule?._sparseCasesOn_1 | Lean.Server.InfoUtils | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Std.Tactic.BVDecide.Normalize.BitVec.and_contra | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a &&& ~~~a = 0#w | true |
Lean.Elab.Tactic.Do.Uses.toNat | Lean.Elab.Tactic.Do.LetElim | Lean.Elab.Tactic.Do.Uses → ℕ | true |
MulEquiv.isUnit_map._simp_2 | Mathlib.Algebra.Group.Units.Equiv | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : EquivLike F M N]
[MulEquivClass F M N] (f : F) {x : M}, IsUnit (f x) = IsUnit x | false |
CategoryTheory.Limits.Types.isImage | Mathlib.CategoryTheory.Limits.Types.Images | {α β : Type u} → (f : α ⟶ β) → CategoryTheory.Limits.IsImage (CategoryTheory.Limits.Types.monoFactorisation f) | true |
CategoryTheory.monoidalCategoryOp._proof_15 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop W) (Opposite.unop X)
(Opposite.unop Y)).symm.op.hom.unop
(Opposite.unop Z)).op
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop W)
(Opposite.unop
(Opposite.op (CategoryTheory.MonoidalCategoryStruct.tensorObj (Opposite.unop X) (Opposite.unop Y))))
(Opposite.unop Z)).symm.op.hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Opposite.unop W)
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop X) (Opposite.unop Y)
(Opposite.unop Z)).symm.op.hom.unop).op) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator
(Opposite.unop
(Opposite.op (CategoryTheory.MonoidalCategoryStruct.tensorObj (Opposite.unop W) (Opposite.unop X))))
(Opposite.unop Y) (Opposite.unop Z)).symm.op.hom
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop W) (Opposite.unop X)
(Opposite.unop
(Opposite.op
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Opposite.unop Y) (Opposite.unop Z))))).symm.op.hom | false |
CompHausLike.LocallyConstantModule.functor_obj_obj_map_hom_apply_apply | Mathlib.Condensed.Discrete.Module | ∀ {P : TopCat → Prop} (R : Type (max u w)) [inst : Ring R] [inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_2 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
(X : ModuleCat R) {X_1 Y : (CompHausLike P)ᵒᵖ} (f : X_1 ⟶ Y) (g : LocallyConstant ↑(Opposite.unop X_1).toTop ↑X)
(a : ↑(Opposite.unop Y).toTop),
((ModuleCat.Hom.hom (((CompHausLike.LocallyConstantModule.functor R hs).obj X).obj.map f)) g) a =
g ((TopCat.Hom.hom f.unop.hom) a) | true |
RingHom.StableUnderCompositionWithLocalizationAway | Mathlib.RingTheory.LocalProperties.Basic | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop | true |
MonoidAlgebra.cardinalMk_of_fintype | Mathlib.Algebra.MonoidAlgebra.Cardinal | ∀ (R M : Type u) [inst : Semiring R] [inst_1 : Fintype M],
Cardinal.mk (MonoidAlgebra R M) = Cardinal.mk R ^ Fintype.card M | true |
swap_dist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α], Function.swap dist = dist | true |
ProbabilityTheory.bayesRisk.eq_1 | Mathlib.Probability.Decision.Risk.Defs | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_3} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
[inst : MeasurableSpace 𝓨] (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧) (π : MeasureTheory.Measure Θ),
ProbabilityTheory.bayesRisk ℓ P π = ⨅ κ, ⨅ (_ : ProbabilityTheory.IsMarkovKernel κ), ProbabilityTheory.avgRisk ℓ P κ π | true |
Real.expPartialHomeomorph._proof_1 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (x : ℝ), Real.log (Real.exp x) = x | false |
CategoryTheory.Mon.comp.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N O : CategoryTheory.Mon C} (f : M.Hom N) (g : N.Hom O),
CategoryTheory.Mon.comp f g = { hom := CategoryTheory.CategoryStruct.comp f.hom g.hom, isMonHom_hom := ⋯ } | true |
_private.Mathlib.LinearAlgebra.Dual.BaseChange.0.IsBaseChange.toDualBaseChangeAux_tmul | Mathlib.LinearAlgebra.Dual.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] {V : Type u_2} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommMonoid W] [inst_4 : Module R W] {A : Type u_4} [inst_5 : CommSemiring A] [inst_6 : Algebra R A]
[inst_7 : Module A W] [inst_8 : IsScalarTower R A W] {j : V →ₗ[R] W} (ibc : IsBaseChange A j) (a : A)
(f : Module.Dual R V) (v : V),
((IsBaseChange.toDualBaseChangeAux✝ ibc) (a ⊗ₜ[R] f)) (j v) = a * (algebraMap R A) (f v) | true |
_private.Mathlib.Algebra.Group.Defs.0.CommSemigroup.ext.match_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} (motive : CommSemigroup G → Prop) (h : CommSemigroup G),
(∀ (mul : G → G → G) (mul_assoc : ∀ (a b c : G), a * b * c = a * (b * c)) (mul_comm : ∀ (a b : G), a * b = b * a),
motive { mul := mul, mul_assoc := mul_assoc, mul_comm := mul_comm }) →
motive h | false |
HasLineDerivAt.unique | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f₀' f₁' : F}
{x v : E}, HasLineDerivAt 𝕜 f f₀' x v → HasLineDerivAt 𝕜 f f₁' x v → f₀' = f₁' | true |
_private.Lean.Elab.DocString.0.Lean.Doc.genWrapper.build._unary._proof_4 | Lean.Elab.DocString | ∀ (argSpec : Array Lean.Doc.ArgSpec✝) (i : ℕ) (args : Array Lean.Expr),
i < argSpec.size →
∀ (v : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i args => argSpec.size - i) ⟨i + 1, args.push v⟩
⟨i, args⟩ | false |
LinearIsometryEquiv.continuousOn | 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₂) {s : Set E}, ContinuousOn (⇑e) s | true |
inv_mul_lt_iff_lt_mul._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c : α}, (b⁻¹ * a < c) = (a < b * c) | false |
Batteries.RBNode.Balanced.rec | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1}
{motive : (a : Batteries.RBNode α) → (a_1 : Batteries.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop},
motive Batteries.RBNode.nil Batteries.RBColor.black 0 ⋯ →
(∀ {x : Batteries.RBNode α} {n : ℕ} {y : Batteries.RBNode α} {v : α} (a : x.Balanced Batteries.RBColor.black n)
(a_1 : y.Balanced Batteries.RBColor.black n),
motive x Batteries.RBColor.black n a →
motive y Batteries.RBColor.black n a_1 →
motive (Batteries.RBNode.node Batteries.RBColor.red x v y) Batteries.RBColor.red n ⋯) →
(∀ {x : Batteries.RBNode α} {c₁ : Batteries.RBColor} {n : ℕ} {y : Batteries.RBNode α} {c₂ : Batteries.RBColor}
{v : α} (a : x.Balanced c₁ n) (a_1 : y.Balanced c₂ n),
motive x c₁ n a →
motive y c₂ n a_1 →
motive (Batteries.RBNode.node Batteries.RBColor.black x v y) Batteries.RBColor.black (n + 1) ⋯) →
∀ {a : Batteries.RBNode α} {a_1 : Batteries.RBColor} {a_2 : ℕ} (t : a.Balanced a_1 a_2), motive a a_1 a_2 t | false |
Lean.Server.Watchdog.ModuleQueryMatch.rec | Lean.Server.Watchdog | {motive : Lean.Server.Watchdog.ModuleQueryMatch → Sort u} →
((toModuleQueryMatchScore : Lean.Server.Watchdog.ModuleQueryMatchScore) →
(decl : Lean.Name) →
(declAsString : String) →
motive { toModuleQueryMatchScore := toModuleQueryMatchScore, decl := decl, declAsString := declAsString }) →
(t : Lean.Server.Watchdog.ModuleQueryMatch) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.