name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
List.Vector.ofFn.match_1 | Mathlib.Data.Vector.Defs | {α : Type u_2} →
(motive : (x : ℕ) → (Fin x → α) → Sort u_1) →
(x : ℕ) →
(x_1 : Fin x → α) →
((x : Fin 0 → α) → motive 0 x) → ((n : ℕ) → (f : Fin (n + 1) → α) → motive n.succ f) → motive x x_1 |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.State.ctorIdx | Lean.Compiler.LCNF.InferBorrow | Lean.Compiler.LCNF.State✝ → ℕ |
Lean.Meta.Match.Example.arrayLit.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : List Lean.Meta.Match.Example),
(Lean.Meta.Match.Example.arrayLit a = Lean.Meta.Match.Example.arrayLit a_1) = (a = a_1) |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.grind.match_6 | Lean.Elab.Tactic.Grind.Main | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) → Sort u_1) →
(seq? : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) →
((seq : Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) → motive (some seq)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) → motive x) → motive seq? |
Std.DTreeMap.Internal.Impl.Const.get!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {δ : Type w} [inst : Ord α] [inst_1 : Inhabited δ] (k : α),
Std.DTreeMap.Internal.Impl.Const.get! Std.DTreeMap.Internal.Impl.leaf k =
panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.Const.get!" 227 13
"Key is not present in map" |
SchwartzMap.mkLM._proof_4 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_5} {D : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜]
[inst_5 : NormedAddCommGroup D] [inst_6 : NormedSpace ℝ D] [inst_7 : NormedSpace 𝕜 E] [inst_8 : SMulCommClass ℝ 𝕜 E]
[inst_9 : NormedAddCommGroup G] [inst_10 : NormedSpace ℝ G] (A : SchwartzMap D E → F → G),
(∀ (f g : SchwartzMap D E) (x : F), A (f + g) x = A f x + A g x) →
∀ (hsmooth : ∀ (f : SchwartzMap D E), ContDiff ℝ (↑⊤) (A f))
(hbound :
∀ (n : ℕ × ℕ),
∃ s C,
0 ≤ C ∧
∀ (f : SchwartzMap D E) (x : F),
‖x‖ ^ n.1 * ‖iteratedFDeriv ℝ n.2 (A f) x‖ ≤ C * (s.sup (schwartzSeminormFamily 𝕜 D E)) f)
(f g : SchwartzMap D E),
{ toFun := A (f + g), smooth' := ⋯, decay' := ⋯ } =
{ toFun := A f, smooth' := ⋯, decay' := ⋯ } + { toFun := A g, smooth' := ⋯, decay' := ⋯ } |
AlgEquiv.toLinearEquiv_symm | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), e.symm.toLinearEquiv = e.toLinearEquiv.symm |
Lean.Parser.Command.syntaxCat._regBuiltin.Lean.Parser.Command.syntaxCat.formatter_17 | Lean.Parser.Syntax | IO Unit |
_private.Mathlib.Combinatorics.Matroid.Rank.Finite.0.Matroid.isRkFinite_inter_ground_iff.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ I, M.IsBasis' I X) → Prop) (x : ∃ I, M.IsBasis' I X),
(∀ (_I : Set α) (hI : M.IsBasis' _I X), motive ⋯) → motive x |
Pi.instPosSMulReflectLE | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {ι : Type u_3} {β : ι → Type u_4} [inst : Zero α] [inst_1 : Preorder α]
[inst_2 : (i : ι) → Preorder (β i)] [inst_3 : (i : ι) → SMul α (β i)] [∀ (i : ι), PosSMulReflectLE α (β i)],
PosSMulReflectLE α ((i : ι) → β i) |
ContinuousMultilinearMap.instInhabited | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
[inst_5 : (i : ι) → TopologicalSpace (M₁ i)] →
[inst_6 : TopologicalSpace M₂] → Inhabited (ContinuousMultilinearMap R M₁ M₂) |
_private.Mathlib.Algebra.Category.Ring.Basic.0.CommSemiRingCat.Hom.mk | Mathlib.Algebra.Category.Ring.Basic | {R S : CommSemiRingCat} → (↑R →+* ↑S) → R.Hom S |
CategoryTheory.ComposableArrows.sc'._proof_7 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i j k : ℕ), i + 1 = j → j + 1 = k → k ≤ n → i < n + 1 |
CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse_map_right_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) {X Y : CategoryTheory.Comma ((CategoryTheory.Under.forget c).comp F) G}
(g : X ⟶ Y), ((CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse F G c).map g).right.right = g.right |
Aesop.MVarCluster.setState | Aesop.Tree.Data | Aesop.NodeState → Aesop.MVarCluster → Aesop.MVarCluster |
sup_congr_left | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, b ≤ a ⊔ c → c ≤ a ⊔ b → a ⊔ b = a ⊔ c |
ONote.NFBelow.rec | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : (a : ONote) → (a_1 : Ordinal.{0}) → a.NFBelow a_1 → Prop},
(∀ {b : Ordinal.{0}}, motive 0 b ⋯) →
(∀ {e : ONote} {n : ℕ+} {a : ONote} {eb b : Ordinal.{0}} (a_1 : e.NFBelow eb) (a_2 : a.NFBelow e.repr)
(a_3 : e.repr < b), motive e eb a_1 → motive a e.repr a_2 → motive (e.oadd n a) b ⋯) →
∀ {a : ONote} {a_1 : Ordinal.{0}} (t : a.NFBelow a_1), motive a a_1 t |
ImplicitFunctionData.leftDeriv_fderiv_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 : NormedSpace 𝕜 G] [inst_9 : CompleteSpace G] (φ : ImplicitFunctionData 𝕜 E F G) (x : G),
φ.leftDeriv ((fderiv 𝕜 (φ.implicitFunction (φ.leftFun φ.pt)) (φ.rightFun φ.pt)) x) = 0 |
Std.TreeSet.Raw.min?_toList | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Min α] [inst_1 : LE α]
[Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α] [Std.LawfulEqCmp cmp],
t.WF → t.toList.min? = t.min? |
Std.DTreeMap.Raw.get!_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst_1 : Inhabited (β k)], k ∉ t₁ → (t₁ ∪ t₂).get! k = t₂.get! k |
Std.DTreeMap.Raw.get_alter_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ t.alter k f},
(t.alter k f).get k hc = (f (t.get? k)).get ⋯ |
Fin.consEquivL._proof_3 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {n : ℕ} (M : Fin n.succ → Type u_1) [inst : (i : Fin n.succ) → TopologicalSpace (M i)],
Continuous fun a => Fin.cons (id a).1 a.2 |
CategoryTheory.Functor.PreservesRightKanExtension.mk_of_preserves_isRightKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B)
(L : CategoryTheory.Functor A C) (F' : CategoryTheory.Functor C B) (α : L.comp F' ⟶ F) [F'.IsRightKanExtension α],
(F'.comp G).IsRightKanExtension
(CategoryTheory.CategoryStruct.comp (L.associator F' G).inv (CategoryTheory.Functor.whiskerRight α G)) →
G.PreservesRightKanExtension F L |
_private.Mathlib.Analysis.SpecialFunctions.Log.NegMulLog.0.Real.continuous_mul_log._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) |
Lean.Grind.instAddIntIi | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Add ℤ Lean.Grind.IntInterval.ii |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getElem_sdiv.match_1.eq_4 | Init.Data.BitVec.Bitblast | ∀ (motive : Bool → Bool → Sort u_1) (h_1 : Unit → motive false false) (h_2 : Unit → motive false true)
(h_3 : Unit → motive true false) (h_4 : Unit → motive true true),
(match true, true with
| false, false => h_1 ()
| false, true => h_2 ()
| true, false => h_3 ()
| true, true => h_4 ()) =
h_4 () |
Int.noConfusionType | Init.Data.Int.Basic | Sort u → ℤ → ℤ → Sort u |
_private.Init.Data.Vector.Algebra.0.Vector.add_hmul._proof_1_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {n : ℕ} [inst : Add α] [inst_1 : Add γ] [inst_2 : HMul α β γ],
(∀ (c d : α) (x : β), (c + d) * x = c * x + d * x) → ∀ (c d : α) (xs : Vector β n), (c + d) * xs = c * xs + d * xs |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_flatMap_eq_false._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {x y : Bool}, ((x || y) = false) = (x = false ∧ y = false) |
CategoryTheory.Functor.IsDense.mk | Mathlib.CategoryTheory.Functor.KanExtension.Dense | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D}, (∀ (Y : D), F.isDenseAt Y) → F.IsDense |
Finset.disjiUnion_cons | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : Finset α) (ha : a ∉ s) (f : α → Finset β)
(H : (↑(Finset.cons a s ha)).PairwiseDisjoint f),
(Finset.cons a s ha).disjiUnion f H = (f a).disjUnion (s.disjiUnion f ⋯) ⋯ |
HahnSeries.one_minus_single_neg_mul | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x y : HahnSeries Γ R} {r : R},
r * x.leadingCoeff = 1 →
x = y + (HahnSeries.single x.order) x.leadingCoeff →
∀ (oinv : Γ), oinv + x.order = 0 → 1 - (HahnSeries.single oinv) r * x = -((HahnSeries.single oinv) r * y) |
Lean.Meta.Grind.mkEqCongrProof | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr |
Polynomial.natDegree_eq_of_natDegree_add_eq_zero | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R), (p + q).natDegree = 0 → p.natDegree = q.natDegree |
sup_sdiff_left_self | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (a ⊔ b) \ a = b \ a |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.removeRanges.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : MProd String.Pos.Raw (MProd Substring.Raw String) → Sort u_1) →
(r : MProd String.Pos.Raw (MProd Substring.Raw String)) →
((curr : String.Pos.Raw) → (fileSubstring : Substring.Raw) → (tot : String) → motive ⟨curr, fileSubstring, tot⟩) →
motive r |
Finmap.union_assoc | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {s₁ s₂ s₃ : Finmap β}, s₁ ∪ s₂ ∪ s₃ = s₁ ∪ (s₂ ∪ s₃) |
_private.Init.Data.UInt.Lemmas.0.UInt64.toUSize_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) |
Lean.Parser.Term.paren.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
_private.Mathlib.RingTheory.Bialgebra.Equiv.0.BialgEquiv.toEquiv_injective.match_1_3 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(x : A ≃ₐc[R] B) (motive : (x_1 : A ≃ₐc[R] B) → x_1.toEquiv = x.toEquiv → Prop) (x_1 : A ≃ₐc[R] B)
(h : x_1.toEquiv = x.toEquiv),
(∀ (toCoalgEquiv : A ≃ₗc[R] B)
(map_mul' : ∀ (x y : A), toCoalgEquiv.toFun (x * y) = toCoalgEquiv.toFun x * toCoalgEquiv.toFun y)
(h : { toCoalgEquiv := toCoalgEquiv, map_mul' := map_mul' }.toEquiv = x.toEquiv),
motive { toCoalgEquiv := toCoalgEquiv, map_mul' := map_mul' } h) →
motive x_1 h |
SimpleGraph.deleteIncidenceSet.eq_1 | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G : SimpleGraph V) (x : V), G.deleteIncidenceSet x = G.deleteEdges (G.incidenceSet x) |
Prod.Lex.instDecidableRelOfDecidableEq._proof_3 | Init.WF | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (a : α) (b : β) (a' : α) (b' : β),
¬r a a' → ¬a = a' → Prod.Lex r s (a, b) (a', b') → False |
Prod.instInv | Mathlib.Algebra.Notation.Prod | {G : Type u_8} → {H : Type u_9} → [Inv G] → [Inv H] → Inv (G × H) |
Bialgebra.ofAlgHom._proof_25 | Mathlib.RingTheory.Bialgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(comul : A →ₐ[R] TensorProduct R A A) {a b : A}, comul (a * b) = comul a * comul b |
CategoryTheory.Oplax.OplaxTrans.StrongCore.casesOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} →
{motive : CategoryTheory.Oplax.OplaxTrans.StrongCore η → Sort u} →
(t : CategoryTheory.Oplax.OplaxTrans.StrongCore η) →
((naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.map f) (η.app b) ≅
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f)) →
(naturality_hom : ∀ {a b : B} (f : a ⟶ b), (naturality f).hom = η.naturality f) →
motive { naturality := naturality, naturality_hom := naturality_hom }) →
motive t |
_private.Mathlib.CategoryTheory.Adjunction.Lifting.Right.0.CategoryTheory.LiftRightAdjoint.instIsCoreflexivePairMapAppUnitOtherMap._simp_1 | Mathlib.CategoryTheory.Adjunction.Lifting.Right | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
_private.Mathlib.NumberTheory.FLT.Basic.0.isCoprime_of_gcd_eq_one_of_FLT._simp_1_2 | Mathlib.NumberTheory.FLT.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [IsReduced M₀], n ≠ 0 → (a ^ n = 0) = (a = 0) |
instIsTopologicalSemiringMatrix | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : Fintype n] [inst_2 : NonUnitalNonAssocSemiring R]
[IsTopologicalSemiring R], IsTopologicalSemiring (Matrix n n R) |
Finset.mem_toLeft | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u : Finset (α ⊕ β)} {a : α}, a ∈ u.toLeft ↔ Sum.inl a ∈ u |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.handleQueryModule.match_1 | Lean.Server.Watchdog | (motive : Lean.Server.References.MatchedDefinition Lean.Server.Watchdog.ModuleQueryMatch → Sort u_1) →
(x : Lean.Server.References.MatchedDefinition Lean.Server.Watchdog.ModuleQueryMatch) →
((mod : Lean.Name) →
(modUri : Lean.Lsp.DocumentUri) →
(m2 : Lean.Server.Watchdog.ModuleQueryMatch) →
(range : Lean.Lsp.Range) → motive { mod := mod, modUri := modUri, ident := m2, range := range }) →
motive x |
Lean.Expr.isAppOf'.match_1 | Batteries.Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) → ((x : Lean.Expr) → motive x) → motive x |
CochainComplex.HomComplex.Cocycle.shift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
CochainComplex.HomComplex.Cocycle K L n →
(a : ℤ) →
CochainComplex.HomComplex.Cocycle ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K)
((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n |
PiTensorProduct.ofFinsuppEquiv_apply | Mathlib.LinearAlgebra.PiTensorProduct.Finsupp | ∀ {R : Type u_1} {ι : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommSemiring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : (i : ι) → DecidableEq (κ i)] [inst_4 : (i : ι) → AddCommMonoid (M i)]
[inst_5 : (i : ι) → Module R (M i)] [inst_6 : (i : ι) → DecidableEq (M i)] (f : (i : ι) → κ i →₀ M i)
(p : (i : ι) → κ i),
(PiTensorProduct.ofFinsuppEquiv ((PiTensorProduct.tprod R) fun i => f i)) p = ⨂ₜ[R] (i : ι), (f i) (p i) |
MeasureTheory.SimpleFunc.lintegralₗ._proof_2 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} (f : MeasureTheory.SimpleFunc α ENNReal) (x y : MeasureTheory.Measure α),
f.lintegral (x + y) = f.lintegral x + f.lintegral y |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.toExpr | Lean.Elab.Extra | Lean.Elab.Term.Op.Tree✝ → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr |
Nonneg.mk_eq_one | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [inst_3 : ZeroLEOneClass α] {x : α} (hx : 0 ≤ x),
⟨x, hx⟩ = 1 ↔ x = 1 |
Valuation.IsNontrivial.exists_val_nontrivial | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} {inst : Ring R} {inst_1 : LinearOrderedCommMonoidWithZero Γ₀} {v : Valuation R Γ₀}
[self : v.IsNontrivial], ∃ x, v x ≠ 0 ∧ v x ≠ 1 |
CategoryTheory.Functor.toOplaxFunctor_mapComp | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {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] (F : CategoryTheory.Functor C D)
{a b c : CategoryTheory.LocallyDiscrete C} (f : a ⟶ b) (g : b ⟶ c),
F.toOplaxFunctor.mapComp f g = CategoryTheory.eqToHom ⋯ |
Module.exists_surjective_quotient_of_finite | Mathlib.RingTheory.TensorProduct.Finite | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M]
[Nontrivial M], ∃ I f, I ≠ ⊤ ∧ Function.Surjective ⇑f |
Ring.directSumGRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddMonoid ι] → [inst_1 : Ring R] → DirectSum.GRing fun x => R |
AddEquiv.toRealLinearEquiv._proof_3 | Mathlib.Topology.Instances.RealVectorSpace | ∀ {E : Type u_1} [inst : AddCommGroup E] {F : Type u_2} [inst_1 : AddCommGroup F] (e : E ≃+ F),
Function.LeftInverse e.invFun e.toFun |
MonoidHom.coe_compAddChar._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {M : Type u_3} [inst : AddMonoid A] [inst_1 : Monoid M] {N : Type u_5} [inst_2 : Monoid N] (f : M →* N)
(φ : AddChar A M), ⇑f ∘ ⇑φ = ⇑(f.compAddChar φ) |
CategoryTheory.Pseudofunctor.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
[inst_2 : SizeOf B] [inst_3 : SizeOf C] (toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C)
(mapId :
(a : B) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.CategoryStruct.id (toPrelaxFunctor.obj a))
(mapComp :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.comp f g) ≅
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor.map f) (toPrelaxFunctor.map g))
(map₂_whisker_left :
autoParam
(∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerLeft f η) =
CategoryTheory.CategoryStruct.comp (mapComp f g).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (toPrelaxFunctor.map₂ η))
(mapComp f h).inv))
CategoryTheory.Pseudofunctor.map₂_whisker_left._autoParam)
(map₂_whisker_right :
autoParam
(∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerRight η h) =
CategoryTheory.CategoryStruct.comp (mapComp f h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor.map₂ η) (toPrelaxFunctor.map h))
(mapComp g h).inv))
CategoryTheory.Pseudofunctor.map₂_whisker_right._autoParam)
(map₂_associator :
autoParam
(∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.associator f g h).hom =
CategoryTheory.CategoryStruct.comp (mapComp (CategoryTheory.CategoryStruct.comp f g) h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp f g).hom (toPrelaxFunctor.map h))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor.map f) (toPrelaxFunctor.map g)
(toPrelaxFunctor.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapComp g h).inv)
(mapComp f (CategoryTheory.CategoryStruct.comp g h)).inv))))
CategoryTheory.Pseudofunctor.map₂_associator._autoParam)
(map₂_left_unitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom =
CategoryTheory.CategoryStruct.comp (mapComp (CategoryTheory.CategoryStruct.id a) f).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId a).hom (toPrelaxFunctor.map f))
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor.map f)).hom))
CategoryTheory.Pseudofunctor.map₂_left_unitor._autoParam)
(map₂_right_unitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.rightUnitor f).hom =
CategoryTheory.CategoryStruct.comp (mapComp f (CategoryTheory.CategoryStruct.id b)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapId b).hom)
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor.map f)).hom))
CategoryTheory.Pseudofunctor.map₂_right_unitor._autoParam),
sizeOf
{ toPrelaxFunctor := toPrelaxFunctor, mapId := mapId, mapComp := mapComp, map₂_whisker_left := map₂_whisker_left,
map₂_whisker_right := map₂_whisker_right, map₂_associator := map₂_associator,
map₂_left_unitor := map₂_left_unitor, map₂_right_unitor := map₂_right_unitor } =
1 + sizeOf toPrelaxFunctor |
AdjoinRoot.liftAlgHom.eq_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra S R] [inst_4 : Algebra S T] (p : Polynomial R) (i : R →ₐ[S] T) (x : T)
(h : Polynomial.eval₂ (↑i) x p = 0),
AdjoinRoot.liftAlgHom p i x h = { toRingHom := AdjoinRoot.lift i.toRingHom x h, commutes' := ⋯ } |
instHashable | Init.Data.Hashable | (P : Prop) → Hashable P |
IsPrimitiveRoot.iff_orderOf | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k ↔ orderOf ζ = k |
Std.ExtHashMap.getD_congr | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α} {fallback : β}, (a == b) = true → m.getD a fallback = m.getD b fallback |
CategoryTheory.OverPresheafAux.unit._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.OverPresheafAux.restrictedYoneda A).comp
(CategoryTheory.OverPresheafAux.costructuredArrowPresheafToOver A)).map
f)
(CategoryTheory.OverPresheafAux.unitAux Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.OverPresheafAux.unitAux X).hom
((CategoryTheory.Functor.id (CategoryTheory.Over A)).map f) |
ContinuousMap.instMonoidWithZeroOfContinuousMul._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MonoidWithZero β]
[inst_3 : ContinuousMul β] (f g : C(α, β)), ⇑(f * g) = ⇑f * ⇑g |
Module.Basis.coe_algebraMapCoeffs | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)),
⇑(Module.Basis.algebraMapCoeffs A b h) = ⇑b |
_private.Mathlib.MeasureTheory.Constructions.HaarToSphere.0.MeasureTheory.Measure.toSphere_ne_zero._simp_1_2 | Mathlib.MeasureTheory.Constructions.HaarToSphere | ∀ (α : Type u_3) [Nontrivial α], Subsingleton α = False |
_private.Mathlib.Algebra.BigOperators.Ring.Finset.0.Finset.prod_add._simp_1_11 | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
continuousWithinAt_Icc_iff_Ici._simp_1 | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α]
[inst_3 : TopologicalSpace β] {a b : α} {f : α → β},
a < b → ContinuousWithinAt f (Set.Icc a b) a = ContinuousWithinAt f (Set.Ici a) a |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift | Mathlib.CategoryTheory.Localization.Prod | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{E : Type u₅} →
[inst_2 : CategoryTheory.Category.{v₅, u₅} E] →
(F : CategoryTheory.Functor (C₁ × C₂) E) →
(W₁.prod W₂).IsInvertedBy F →
[W₁.ContainsIdentities] →
[W₂.ContainsIdentities] → CategoryTheory.Functor (W₁.Localization × W₂.Localization) E |
CategoryTheory.Arrow.comp_left_assoc | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z)
{Z_1 : T} (h : Z.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g).left h =
CategoryTheory.CategoryStruct.comp f.left (CategoryTheory.CategoryStruct.comp g.left h) |
List.filter_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {L : List (List α)}, List.filter p L.flatten = (List.map (List.filter p) L).flatten |
CategoryTheory.Functor.whiskerLeft | Mathlib.CategoryTheory.Whiskering | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
(F : CategoryTheory.Functor C D) → {G H : CategoryTheory.Functor D E} → (G ⟶ H) → (F.comp G ⟶ F.comp H) |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K} {p : ℕ} [inst_1 : Fact (Nat.Prime p)]
[inst_2 : NumberField K] (hp : ¬p ∣ RingOfIntegers.exponent θ) {Q : Polynomial (ZMod p)}
(hQ : Q ∈ RingOfIntegers.monicFactorsMod θ p),
↑((NumberField.Ideal.primesOverSpanEquivMonicFactorsMod hp).symm ⟨Q, hQ⟩) =
↑((KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk ⋯ ⋯ ⋯ ⋯).symm
⟨Polynomial.map (↑(Int.quotientSpanNatEquivZMod p).symm) Q, ⋯⟩) |
Aesop.RawHyp.fvarId.inj | Aesop.Forward.State | ∀ {fvarId fvarId_1 : Lean.FVarId}, Aesop.RawHyp.fvarId fvarId = Aesop.RawHyp.fvarId fvarId_1 → fvarId = fvarId_1 |
CategoryTheory.Pi.monoidalPi'._proof_6 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [inst_4 : (i : I) → (F i).Monoidal] (X Y : D),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Functor.pi' F) X Y)
(CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Functor.pi' F) X Y) =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((CategoryTheory.Functor.pi' F).obj X)
((CategoryTheory.Functor.pi' F).obj Y)) |
CauSeq.Completion.ofRat_ratCast | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (q : ℚ), CauSeq.Completion.ofRat ↑q = ↑q |
CategoryTheory.Adjunction.leftAdjointCompNatTrans₀₂₃_eq_conjugateEquiv_symm | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} {C₁ : Type u_2} {C₂ : Type u_3} {C₃ : Type u_4} [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₂]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₃] {F₀₁ : CategoryTheory.Functor C₀ C₁}
{F₁₂ : CategoryTheory.Functor C₁ C₂} {F₂₃ : CategoryTheory.Functor C₂ C₃} {F₀₂ : CategoryTheory.Functor C₀ C₂}
{F₀₃ : CategoryTheory.Functor C₀ C₃} {G₁₀ : CategoryTheory.Functor C₁ C₀} {G₂₁ : CategoryTheory.Functor C₂ C₁}
{G₃₂ : CategoryTheory.Functor C₃ C₂} {G₂₀ : CategoryTheory.Functor C₂ C₀} {G₃₀ : CategoryTheory.Functor C₃ C₀}
(adj₀₁ : F₀₁ ⊣ G₁₀) (adj₁₂ : F₁₂ ⊣ G₂₁) (adj₂₃ : F₂₃ ⊣ G₃₂) (adj₀₂ : F₀₂ ⊣ G₂₀) (adj₀₃ : F₀₃ ⊣ G₃₀)
(τ₀₁₂ : G₂₀ ⟶ G₂₁.comp G₁₀) (τ₀₂₃ : G₃₀ ⟶ G₃₂.comp G₂₀),
CategoryTheory.CategoryStruct.comp (F₀₁.associator F₁₂ F₂₃).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight (adj₀₁.leftAdjointCompNatTrans adj₁₂ adj₀₂ τ₀₁₂) F₂₃)
(adj₀₂.leftAdjointCompNatTrans adj₂₃ adj₀₃ τ₀₂₃)) =
(CategoryTheory.conjugateEquiv adj₀₃ (adj₀₁.comp (adj₁₂.comp adj₂₃))).symm
(CategoryTheory.CategoryStruct.comp τ₀₂₃
(CategoryTheory.CategoryStruct.comp (G₃₂.whiskerLeft τ₀₁₂) (G₃₂.associator G₂₁ G₁₀).inv)) |
_aux_Mathlib_Algebra_Algebra_NonUnitalHom___unexpand_NonUnitalAlgHom_2 | Mathlib.Algebra.Algebra.NonUnitalHom | Lean.PrettyPrinter.Unexpander |
UniformSpace.Core.mk._flat_ctor | Mathlib.Topology.UniformSpace.Defs | {α : Type u} →
(uniformity : Filter (α × α)) →
Filter.principal SetRel.id ≤ uniformity →
Filter.Tendsto Prod.swap uniformity uniformity →
(uniformity.lift' fun s => SetRel.comp s s) ≤ uniformity → UniformSpace.Core α |
specializes_of_eq | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x = y → x ⤳ y |
ContDiffAt.comp | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : 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] {f : E → F} {g : F → G} {n : WithTop ℕ∞} (x : E),
ContDiffAt 𝕜 n g (f x) → ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n (g ∘ f) x |
_private.Lean.Meta.Sym.ReplaceS.0.Lean.Meta.Sym.visitChild.match_1 | Lean.Meta.Sym.ReplaceS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((e : Lean.Expr) → motive e) → motive e |
Set.mem_one._simp_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : One α] {a : α}, (a ∈ 1) = (a = 1) |
val_inv_unitsNonZeroDivisorsEquiv_symm_apply_coe | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (u : M₀ˣ), ↑↑(unitsNonZeroDivisorsEquiv.symm u)⁻¹ = ↑u⁻¹ |
TopologicalSpace.vietoris.isClosed_inter_nonempty_of_isClosed | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {F : Set α}, IsClosed F → IsClosed {s | (s ∩ F).Nonempty} |
_private.Lean.Meta.Canonicalizer.0.Lean.Meta.Canonicalizer.canon.unsafe_impl_3 | Lean.Meta.Canonicalizer | UInt64 → Lean.Meta.Canonicalizer.State → Option (List Lean.Expr) |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.mem_iff_fract_eq_and_floor_nonneg.match_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ)
(motive :
(IsProperLinearSet.fract✝ hs x = IsProperLinearSet.base✝ hs ∧
∀ (i : ↑(IsProperLinearSet.basisSet✝ hs)),
0 ≤ IsProperLinearSet.floor✝ hs x i ∧
(↑i ∉ IsProperLinearSet.periods✝ hs → IsProperLinearSet.floor✝¹ hs x i = 0)) →
Prop)
(h :
IsProperLinearSet.fract✝¹ hs x = IsProperLinearSet.base✝¹ hs ∧
∀ (i : ↑(IsProperLinearSet.basisSet✝¹ hs)),
0 ≤ IsProperLinearSet.floor✝² hs x i ∧
(↑i ∉ IsProperLinearSet.periods✝¹ hs → IsProperLinearSet.floor✝³ hs x i = 0)),
(∀ (hx₁ : IsProperLinearSet.fract✝² hs x = IsProperLinearSet.base✝² hs)
(hx₂ :
∀ (i : ↑(IsProperLinearSet.basisSet✝² hs)),
0 ≤ IsProperLinearSet.floor✝⁴ hs x i ∧
(↑i ∉ IsProperLinearSet.periods✝² hs → IsProperLinearSet.floor✝⁵ hs x i = 0)),
motive ⋯) →
motive h |
UInt8.toBitVec_mod | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a % b).toBitVec = a.toBitVec % b.toBitVec |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_findIdxNth_of_lt_countP._proof_1_28 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α),
(∀ {n : ℕ}, n < List.countP p tail → List.countPBefore p tail (List.findIdxNth p tail n) = n) →
∀ {n : ℕ},
n < List.countP p (head :: tail) → List.countPBefore p (head :: tail) (List.findIdxNth p (head :: tail) n) = n |
Lean.Elab.Do.ControlStack.rec | Lean.Elab.Do.Control | {motive : Lean.Elab.Do.ControlStack → Sort u} →
((description : Unit → Lean.MessageData) →
(m : Lean.Elab.Do.DoElabM Lean.Expr) →
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) →
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont) →
motive
{ description := description, m := m, stM := stM, runInBase := runInBase, restoreCont := restoreCont }) →
(t : Lean.Elab.Do.ControlStack) → motive t |
not_isBot._simp_3 | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] [NoBotOrder α] (a : α), IsBot a = False |
AbsoluteValue.toNormedRing._proof_9 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_1} [inst : Ring R] (v : AbsoluteValue R ℝ) (x y : R), v (x * y) ≤ v x * v y |
Metric.sphere.instHasDistribNeg._proof_2 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] (x : ↑(Metric.sphere 0 1)), ↑(-x) = ↑(-x) |
RingEquiv.rec | Mathlib.Algebra.Ring.Equiv | {R : Type u_7} →
{S : Type u_8} →
[inst : Mul R] →
[inst_1 : Mul S] →
[inst_2 : Add R] →
[inst_3 : Add S] →
{motive : R ≃+* S → Sort u} →
((toEquiv : R ≃ S) →
(map_mul' : ∀ (x y : R), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
(map_add' : ∀ (x y : R), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y) →
motive { toEquiv := toEquiv, map_mul' := map_mul', map_add' := map_add' }) →
(t : R ≃+* S) → motive t |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_def_odd._simp_1_4 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {ι : Type u_1} {G : Type u_5} {s : Finset ι} [inst : SubtractionCommMonoid G] (f : ι → G),
-∑ x ∈ s, f x = ∑ x ∈ s, -f x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.