name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rio_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) |
List.perm_reverse._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse = l₁.Perm l₂ |
Vector.map_eq_flatMap | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n},
Vector.map f xs = Vector.cast ⋯ (xs.flatMap fun x => #v[f x]) |
Ordnode.map.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
StrictMono f → ∀ {t : Ordnode α}, t.Valid → (Ordnode.map f t).Valid |
CategoryTheory.Factorisation.instCategory | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.Factorisation f) |
OneHom.instCommMonoid | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : One M] → [inst_1 : CommMonoid N] → CommMonoid (OneHom M N) |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool},
m.WF → (m.all p = false ↔ ∃ a, ∃ (h : m.contains a = true), p a (Std.DHashMap.Raw.Const.get m a h) = false) |
iff_self_and._simp_1 | Init.SimpLemmas | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) |
add_eq_zero_iff_eq_neg | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + b = 0 ↔ a = -b |
MvPolynomial.map_eval₂ | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {S₃ : Type x} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
(f : R →+* S₁) (g : S₂ → MvPolynomial S₃ R) (p : MvPolynomial S₂ R),
(MvPolynomial.map f) (MvPolynomial.eval₂ MvPolynomial.C g p) =
MvPolynomial.eval₂ MvPolynomial.C (⇑(MvPolynomial.map f) ∘ g) ((MvPolynomial.map f) p) |
MeasureTheory.integral_comp | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {E' : Type u_2} {F' : Type u_3} {A : Type u_4} [inst : NormedAddCommGroup E'] [inst_1 : InnerProductSpace ℝ E']
[inst_2 : FiniteDimensional ℝ E'] [inst_3 : MeasurableSpace E'] [inst_4 : BorelSpace E']
[inst_5 : NormedAddCommGroup F'] [inst_6 : InnerProductSpace ℝ F'] [inst_7 : FiniteDimensional ℝ F']
[inst_8 : MeasurableSpace F'] [inst_9 : BorelSpace F'] (f : E' ≃ₗᵢ[ℝ] F') [inst_10 : NormedAddCommGroup A]
[inst_11 : NormedSpace ℝ A] (g : F' → A), ∫ (x : E'), g (f x) = ∫ (y : F'), g y |
Std.ExtHashMap.get_union_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' ≤ p.length |
Fin.val_intCast | Mathlib.Data.ZMod.Defs | ∀ {n : ℕ} [inst : NeZero n] (x : ℤ), ↑↑x = (x % ↑n).toNat |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.isEmpty_slice._simp_1_2 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos₁ pos₂ : (s.slice p₀ p₁ h).Pos),
(pos₁ = pos₂) = (String.Pos.ofSlice pos₁ = String.Pos.ofSlice pos₂) |
NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
∃ a ∈ ↑I,
a ≠ 0 ∧
↑|(Algebra.norm ℚ) a| ≤
↑(FractionalIdeal.absNorm ↑I) * (4 / Real.pi) ^ NumberField.InfinitePlace.nrComplexPlaces K *
↑(Module.finrank ℚ K).factorial /
↑(Module.finrank ℚ K) ^ Module.finrank ℚ K *
√|↑(NumberField.discr K)| |
CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Basic___macroRules_CategoryTheory_Bicategory_term_◁ᵢ__1» | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Macro |
AddCommMonCat.equivalence._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom f)))
(CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom g))) |
AlgebraicGeometry.Scheme.Modules.restrictAdjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f], IsOpenMap ⇑f |
Lean.Meta.Grind.Order.Cnstr.v | Lean.Meta.Tactic.Grind.Order.Types | {α : Type} → Lean.Meta.Grind.Order.Cnstr α → α |
pi_norm_le_iff_of_nonempty' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] (f : (i : ι) → G i)
{r : ℝ} [Nonempty ι], ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_2 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval_natCast._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n |
StarAlgEquiv.coe_pow | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f : R ≃⋆ₐ[S] R)
(n : ℕ), ⇑(f ^ n) = (⇑f)^[n] |
RingEquiv.restrict._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σR : Type u_4}
{σS : Type u_2} [inst_2 : SetLike σR R] [inst_3 : SetLike σS S] [inst_4 : SubsemiringClass σR R]
[inst_5 : SubsemiringClass σS S] (e : R ≃+* S) (s' : σR) (s : σS) (h : ∀ (x : R), x ∈ s' ↔ e x ∈ s) (x : ↥s),
(↑↑((↑e).restrict s' s ⋯)).toFun (((↑e.symm).restrict s s' ⋯) x) = x |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι c₁) φ.τ₂ =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Fork.ι c₂) →
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Fork.ι c₂) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι c₁) φ.τ₂ |
ContMDiff.along_snd | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_8}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_9} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_10} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{n : WithTop ℕ∞} {f : M → M' → N} {x : M},
ContMDiff (I.prod I') J n (Function.uncurry f) → ContMDiff I' J n fun y => f x y |
RingHomInvPair.toRingEquiv_apply | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] (σ : R₁ →+* R₂) (σ' : R₂ →+* R₁)
[inst_2 : RingHomInvPair σ σ'] (a : R₁), (RingHomInvPair.toRingEquiv σ σ') a = σ a |
Option.attachWith_some._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {x : α} {P : α → Prop}, (∀ (b : α), some x = some b → P b) → P x |
PrincipalSeg.transInitial_top | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
(f : PrincipalSeg r s) (g : InitialSeg s t), (f.transInitial g).top = g f.top |
Lean.Doc.set_option.getArgs | Lean.Elab.DocString.Builtin | StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) |
AlgebraicGeometry.Scheme.precoverage_le_qcPrecoverage_of_isOpenMap | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
(P ≤ fun x x_1 f => IsOpenMap ⇑f) → AlgebraicGeometry.Scheme.precoverage P ≤ AlgebraicGeometry.Scheme.qcPrecoverage |
ContinuousLinearMapWOT.seminorm._proof_3 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_4} {𝕜₂ : Type u_1} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologicalAddGroup F]
[inst_9 : ContinuousConstSMul 𝕜₂ F] (x : E) (y : StrongDual 𝕜₂ F) (A : E →SWOT[σ] F), ‖y ((-A) x)‖ = ‖y (A x)‖ |
Subspace.dualAnnihilator_dualAnnihilator_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : FiniteDimensional K V] (W : Subspace K V),
(Submodule.dualAnnihilator W).dualAnnihilator = (Module.mapEvalEquiv K V) W |
PadicInt.mahlerSeries_apply | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] [IsUltrametricDist E] [CompleteSpace E] {a : ℕ → E},
Filter.Tendsto a Filter.atTop (nhds 0) → ∀ (x : ℤ_[p]), (PadicInt.mahlerSeries a) x = ∑' (n : ℕ), (mahler n) x • a n |
Real.ofDigitsTerm_le | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, Real.ofDigitsTerm digits n ≤ (↑b - 1) * (↑b ^ (n + 1))⁻¹ |
LieDerivation.SMulBracketCommClass.mk._flat_ctor | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {S : Type u_4} {L : Type u_5} {α : Type u_6} [inst : SMul S α] [inst_1 : LieRing L] [inst_2 : AddCommGroup α]
[inst_3 : LieRingModule L α],
(∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → LieDerivation.SMulBracketCommClass S L α |
_private.Lean.ParserCompiler.0.Lean.ParserCompiler.parserNodeKind?._sparseCasesOn_1 | Lean.ParserCompiler | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 320 t.ctorIdx → motive t) → motive t |
Graph.isLink_self_iff | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsLink e x x ↔ G.IsLoopAt e x |
bernoulli_zero | Mathlib.NumberTheory.Bernoulli | bernoulli 0 = 1 |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.ctorIdx | Lean.Meta.Tactic.Grind.MBTC | Lean.Meta.Grind.Key✝ → ℕ |
ProbabilityTheory.CondIndepSets.bInter | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
{u : Set ι},
(∃ n ∈ u, ProbabilityTheory.CondIndepSets m' hm' (s n) s' μ) →
ProbabilityTheory.CondIndepSets m' hm' (⋂ n ∈ u, s n) s' μ |
MulOpposite.instDivisionMonoid | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid αᵐᵒᵖ |
IsTopologicalGroup.to_continuousDiv | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G], ContinuousDiv G |
Subsemiring.mem_toNonUnitalSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {S : Subsemiring R} {x : R}, x ∈ S.toNonUnitalSubsemiring ↔ x ∈ S |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_singleton._simp_1_2 | Init.Data.String.Basic | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) |
List.prod_nat_mod | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ (l : List ℕ) (n : ℕ), l.prod % n = (List.map (fun x => x % n) l).prod % n |
Archimedean.ratLt'.eq_1 | Mathlib.Data.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : One M] (x : M),
Archimedean.ratLt' x = ⇑(Rat.castHom ℝ) '' Archimedean.ratLt x |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.initCore | Lean.Meta.Tactic.Grind.Main | Lean.MVarId → Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal |
Std.Internal.UV.System.GroupInfo | Std.Internal.UV.System | Type |
CategoryTheory.Limits.IsTerminal.isSplitMono_from | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X)
(f : X ⟶ Y), CategoryTheory.IsSplitMono f |
AddCommGroup.intIsScalarTower | Mathlib.Algebra.Module.NatInt | ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower ℤ R M |
_private.Mathlib.Analysis.Normed.Module.Multilinear.Basic.0.MultilinearMap.continuous_of_bound._simp_1_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True |
StateTransition.tr_eval_rev | Mathlib.Computability.StateTransition | ∀ {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop},
StateTransition.Respects f₁ f₂ tr →
∀ {a₁ : σ₁} {b₂ a₂ : σ₂},
tr a₁ a₂ → b₂ ∈ StateTransition.eval f₂ a₂ → ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁ |
StarSubalgebra.ext_iff | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A},
S = T ↔ ∀ (x : A), x ∈ S ↔ x ∈ T |
Lean.Lsp.ParameterInformation._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ParameterInformation |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.iSup_genWeightSpace_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') |
_private.Mathlib.Order.Atoms.0.IsAtom.Iic.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : Preorder α] {a x : α} (hax : a ≤ x)
(motive : (x_1 : { x_1 // x_1 ∈ Set.Iic x }) → x_1 < ⟨a, hax⟩ → Prop) (x_1 : { x_1 // x_1 ∈ Set.Iic x })
(hba : x_1 < ⟨a, hax⟩),
(∀ (b : α) (property : b ∈ Set.Iic x) (hba : ⟨b, property⟩ < ⟨a, hax⟩), motive ⟨b, property⟩ hba) → motive x_1 hba |
_private.Mathlib.Data.Finset.Basic.0.Equiv.Finset.union_symm_right._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False |
Std.TreeSet.Raw.getD_minD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback |
commGroupOfIsUnit | Mathlib.Algebra.Group.Units.Defs | {M : Type u_1} → [hM : CommMonoid M] → (∀ (a : M), IsUnit a) → CommGroup M |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3 | Lean.Meta.Tactic.Repeat | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) |
Aesop.aesop.dev.generateScript | Aesop.Options.Public | Lean.Option Bool |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.iUnion_prod_of_monotone._simp_1_4 | Mathlib.Data.Set.Lattice.Image | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
UniformSpace.Completion.completeSpace | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α], CompleteSpace (UniformSpace.Completion α) |
PEquiv.injective_of_forall_ne_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} (f : α ≃. β) (a₂ : α), (∀ (a₁ : α), a₁ ≠ a₂ → (f a₁).isSome = true) → Function.Injective ⇑f |
Sum.Ioo_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioo (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioo b₁ b₂) |
Lean.Server.Test.Runner.Client.InteractiveGoal._sizeOf_inst | Lean.Server.Test.Runner | SizeOf Lean.Server.Test.Runner.Client.InteractiveGoal |
CompleteLattice.MulticoequalizerDiagram.multispanIndex._proof_8 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T},
CompleteLattice.MulticoequalizerDiagram x u v →
∀ (x : (CategoryTheory.Limits.MultispanShape.prod ι).L),
(match x with
| (i, j) => v i j) ≤
u ((CategoryTheory.Limits.MultispanShape.prod ι).snd x) |
CategoryTheory.Limits.IsColimit.natIso | 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.Cocone F} →
CategoryTheory.Limits.IsColimit t →
((CategoryTheory.coyoneda.obj (Opposite.op t.pt)).comp CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_2 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} {a : α}, [a, g a, g (g a)].Nodup → ¬g a = a |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {π : kf.pt ⟶ H} {ι : H ⟶ cc.pt}
(fac :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kf) (CategoryTheory.Limits.Cofork.π cc) =
CategoryTheory.CategoryStruct.comp π ι)
[inst_2 : CategoryTheory.Epi π] [inst_3 : CategoryTheory.Mono ι],
(CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData S hkf hcc fac).π = π |
inv_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (a⁻¹ < b ↔ b⁻¹ < a) |
IsBezout.toGCDDomain._proof_6 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsBezout R] {a b c : R}, a ∣ c → a ∣ b → a ∣ IsBezout.gcd c b |
AdjoinRoot.isAdjoinRoot._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R), RingHom.ker (AdjoinRoot.mkₐ f) = Ideal.span {f} |
AddGroupCone.nonneg_toAddSubmonoid | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : AddCommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedAddMonoid H],
(AddGroupCone.nonneg H).toAddSubmonoid = AddSubmonoid.nonneg H |
GenContFract.Pair.noConfusion | Mathlib.Algebra.ContinuedFractions.Basic | {P : Sort u} →
{α : Type u_1} →
{t : GenContFract.Pair α} →
{α' : Type u_1} → {t' : GenContFract.Pair α'} → α = α' → t ≍ t' → GenContFract.Pair.noConfusionType P t t' |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents.parenthesizer | Mathlib.Tactic.WithoutCDot | Lean.PrettyPrinter.Parenthesizer |
Int.preimage_Ioo | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] {a b : R},
Int.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉ |
Real.Angle.sign | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → SignType |
Lean.ScopedEnvExtension.Descr._sizeOf_1 | Lean.ScopedEnvExtension | {α β σ : Type} → [SizeOf α] → [SizeOf β] → [SizeOf σ] → Lean.ScopedEnvExtension.Descr α β σ → ℕ |
continuousOn_const_smul_iff₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {β : Type u_3} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀]
[inst_2 : MulAction G₀ α] [ContinuousConstSMul G₀ α] [inst_4 : TopologicalSpace β] {f : β → α} {c : G₀} {s : Set β},
c ≠ 0 → (ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s) |
Lean.Meta.Rewrites.RewriteResult.mctx | Lean.Meta.Tactic.Rewrites | Lean.Meta.Rewrites.RewriteResult → Lean.MetavarContext |
DirectLimit.instCommRingOfRingHomClass | Mathlib.Algebra.Colimit.DirectLimit | {ι : Type u_2} →
[inst : Preorder ι] →
{G : ι → Type u_3} →
{T : ⦃i j : ι⦄ → i ≤ j → Type u_4} →
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} →
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] →
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] →
[inst_3 : IsDirectedOrder ι] →
[Nonempty ι] →
[inst_5 : (i : ι) → CommRing (G i)] →
[∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)] → CommRing (DirectLimit G f) |
Lean.initFn._@.Lean.ExtraModUses.447004708._hygCtx._hyg.2 | Lean.ExtraModUses | IO (Lean.SimplePersistentEnvExtension Lean.ExtraModUse (Lean.PHashSet Lean.ExtraModUse)) |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False |
NormedGroup.toGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : NormedGroup E] → Group E |
Derivation.compAEval_eq | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (a : A)
(d : Derivation R A M) (f : Polynomial R), (d.compAEval a) f = Polynomial.derivative f • (Module.AEval.of R M a) (d a) |
IsPicardLindelof.mk | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E → E} {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E}
{a r L K : NNReal},
(∀ t ∈ Set.Icc tmin tmax, LipschitzOnWith K (f t) (Metric.closedBall x₀ ↑a)) →
(∀ x ∈ Metric.closedBall x₀ ↑a, ContinuousOn (fun x_1 => f x_1 x) (Set.Icc tmin tmax)) →
(∀ t ∈ Set.Icc tmin tmax, ∀ x ∈ Metric.closedBall x₀ ↑a, ‖f t x‖ ≤ ↑L) →
↑L * max (tmax - ↑t₀) (↑t₀ - tmin) ≤ ↑a - ↑r → IsPicardLindelof f t₀ x₀ a r L K |
_private.Mathlib.Tactic.Relation.Symm.0.Lean.Expr.relSidesIfSymm?.match_6 | Mathlib.Tactic.Relation.Symm | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 rhs : Lean.Expr) → motive (some (fst, lhs, fst_1, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x |
RingQuot.instMonoidWithZero._proof_7 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), 0 * a = 0 |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_6 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit |
Ring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {R : Type u} → (R → R → R) → R → R → ℕ → R |
Lean.Meta.Grind.AC.EqData.noConfusionType | Lean.Meta.Tactic.Grind.AC.Eq | Sort u → Lean.Meta.Grind.AC.EqData → Lean.Meta.Grind.AC.EqData → Sort u |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.mem_shadow_iterate_iff_exists_card._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} [inst : DecidableEq α],
(s.card = n + 1) = ∃ a t, a ∉ t ∧ insert a t = s ∧ t.card = n |
SeparationQuotient.instAddGroup._proof_5 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G] (x : G) (n : ℕ),
SeparationQuotient.mk (n • x) = n • SeparationQuotient.mk x |
CategoryTheory.ComposableArrows.instIsIsoOfNatNatTwoδ₁Toδ₀ | Mathlib.CategoryTheory.ComposableArrows.Two | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i j k : C} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) [CategoryTheory.IsIso f],
CategoryTheory.IsIso (CategoryTheory.ComposableArrows.twoδ₁Toδ₀ f g fg h) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.