1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlgebraicGeometry.Scheme.map_basicOpen'
File: Mathlib/AlgebraicGeometry/Restrict.lean

tactic: refine (Scheme.image_basicOpen (X.ofRestrict U.openEmbedding) r).trans ?_
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ ιOpens U ''ᵁ (X ∣_ᵤ U).basicOpen r = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

tactic: erw [← Scheme.basicOpen_res_eq _ _ (eqToHom U.openEmbedding_obj_top).op]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) =
    X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) ((X.presheaf.map (eqToHom ⋯).op) r))

tactic: rw [← comp_apply, ← CategoryTheory.Functor.map_comp, ← op_comp, eqToHom_trans, eqToHom_refl,
  op_id, CategoryTheory.Functor.map_id]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) =
    X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) ((X.presheaf.map (eqToHom ⋯).op) r))
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((𝟙 Γ(X, ⋯.functor.obj ⊤)) r)

tactic: congr
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((𝟙 Γ(X, ⋯.functor.obj ⊤)) r)
state_after: case e_f.e_a
C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ Hom.invApp (X.ofRestrict ⋯) ⊤ = 𝟙 Γ(X, ⋯.functor.obj ⊤)

tactic: exact PresheafedSpace.IsOpenImmersion.ofRestrict_invApp _ _ _
state_before: case e_f.e_a
C : Type u₁
inst✝ : Category.{v, u₁} C
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
r : ↑Γ(X ∣_ᵤ U, ⊤)
⊢ Hom.invApp (X.ofRestrict ⋯) ⊤ = 𝟙 Γ(X, ⋯.functor.obj ⊤)
state_after: no goals
Theorem: Mathlib.Meta.Positivity.log_nz_of_isRat
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [eq, invOf_eq_inv, ← div_eq_mul_inv]
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
⊢ Real.log e ≠ 0
state_after: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
⊢ Real.log (↑n / ↑d) ≠ 0

tactic: have h₁' : 0 < (n : ℝ) / d := by exact_mod_cast of_decide_eq_true h₁
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
⊢ Real.log (↑n / ↑d) ≠ 0
state_after: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
h₁' : 0 < ↑n / ↑d
⊢ Real.log (↑n / ↑d) ≠ 0

tactic: have h₂' : (n : ℝ) / d < 1 := by exact_mod_cast of_decide_eq_true h₂
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
h₁' : 0 < ↑n / ↑d
⊢ Real.log (↑n / ↑d) ≠ 0
state_after: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
h₁' : 0 < ↑n / ↑d
h₂' : ↑n / ↑d < 1
⊢ Real.log (↑n / ↑d) ≠ 0

tactic: exact ne_of_lt <| Real.log_neg h₁' h₂'
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
h₁' : 0 < ↑n / ↑d
h₂' : ↑n / ↑d < 1
⊢ Real.log (↑n / ↑d) ≠ 0
state_after: no goals

tactic: exact_mod_cast of_decide_eq_true h₁
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
⊢ 0 < ↑n / ↑d
state_after: no goals

tactic: exact_mod_cast of_decide_eq_true h₂
state_before: e : ℝ
d : ℕ
n : ℤ
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h₁ : decide (0 < ↑n / ↑d) = true
h₂ : decide (↑n / ↑d < 1) = true
h₁' : 0 < ↑n / ↑d
⊢ ↑n / ↑d < 1
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean

tactic: rw [← hf.map_eq, h₂.aestronglyMeasurable_map_iff]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : TopologicalSpace β✝
inst✝ : TopologicalSpace γ
f✝ g✝ : α → β✝
β : Type u_4
f : α → β
mα : MeasurableSpace α
μa : Measure α
mβ : MeasurableSpace β
μb : Measure β
hf : MeasurePreserving f μa μb
h₂ : MeasurableEmbedding f
g : β → γ
⊢ AEStronglyMeasurable (g ∘ f) μa ↔ AEStronglyMeasurable g μb
state_after: no goals
Theorem: LieSubalgebra.isNilpotent_ad_of_isNilpotent_ad
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: obtain ⟨n, hn⟩ := h
state_before: R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
h : IsNilpotent ((LieAlgebra.ad R L) ↑x)
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)
state_after: case intro
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)

tactic: use n
state_before: case intro
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)
state_after: case h
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ (LieAlgebra.ad R ↥K) x ^ n = 0

tactic: exact LinearMap.submodule_pow_eq_zero_of_pow_eq_zero (K.ad_comp_incl_eq x) hn
state_before: case h
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ (LieAlgebra.ad R ↥K) x ^ n = 0
state_after: no goals
Theorem: LieModule.iSup_ucs_le_weightSpace_zero
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: simpa using LieSubmodule.ucs_le_of_normalizer_eq_self (weightSpace_zero_normalizer_eq_self R L M)
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ ⨆ k, LieSubmodule.ucs k ⊥ ≤ weightSpace M 0
state_after: no goals
Theorem: Set.encard_singleton_inter
File: Mathlib/Data/Set/Card.lean

tactic: rw [← encard_singleton x]
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ ({x} ∩ s).encard ≤ 1
state_after: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ ({x} ∩ s).encard ≤ {x}.encard

tactic: exact encard_le_card inter_subset_left
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ ({x} ∩ s).encard ≤ {x}.encard
state_after: no goals
Theorem: Set.univ_prod
File: Mathlib/Data/Set/Prod.lean

tactic: simp [prod_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
t : Set β
⊢ univ ×ˢ t = Prod.snd ⁻¹' t
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.selfProdProj_fiber
File: Mathlib/CategoryTheory/Galois/Decomposition.lean

tactic: simp only [selfProdProj, selfProd, F.map_comp, FintypeCat.comp_apply, h]
state_before: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝² : FiberFunctor F
X A : C
inst✝¹ : IsConnected A
u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X
inst✝ : Mono u
a : ↑(F.obj A)
h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X
x : ↑(F.obj X)
⊢ F.map (CategoryTheory.PreGaloisCategory.selfProdProj u x) a = x
state_after: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝² : FiberFunctor F
X A : C
inst✝¹ : IsConnected A
u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X
inst✝ : Mono u
a : ↑(F.obj A)
h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X
x : ↑(F.obj X)
⊢ F.map (Pi.π (fun x => X) x) (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) = x

tactic: rw [mkSelfProdFib_map_π F X x]
state_before: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝² : FiberFunctor F
X A : C
inst✝¹ : IsConnected A
u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X
inst✝ : Mono u
a : ↑(F.obj A)
h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X
x : ↑(F.obj X)
⊢ F.map (Pi.π (fun x => X) x) (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) = x
state_after: no goals
Theorem: DoubleQuot.quotQuotEquivComm_symmₐ
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: ext
state_before: R : Type u
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommRing A
inst✝ : Algebra R A
I J : Ideal A
⊢ (quotQuotEquivCommₐ R I J).symm = quotQuotEquivCommₐ R J I
state_after: case h
R : Type u
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommRing A
inst✝ : Algebra R A
I J : Ideal A
a✝ : (A ⧸ J) ⧸ map (Quotient.mkₐ R J) I
⊢ (quotQuotEquivCommₐ R I J).symm a✝ = (quotQuotEquivCommₐ R J I) a✝

tactic: unfold quotQuotEquivCommₐ
state_before: case h
R : Type u
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommRing A
inst✝ : Algebra R A
I J : Ideal A
a✝ : (A ⧸ J) ⧸ map (Quotient.mkₐ R J) I
⊢ (quotQuotEquivCommₐ R I J).symm a✝ = (quotQuotEquivCommₐ R J I) a✝
state_after: case h
R : Type u
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommRing A
inst✝ : Algebra R A
I J : Ideal A
a✝ : (A ⧸ J) ⧸ map (Quotient.mkₐ R J) I
⊢ (AlgEquiv.ofRingEquiv ⋯).symm a✝ = (AlgEquiv.ofRingEquiv ⋯) a✝

tactic: congr
state_before: case h
R : Type u
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommRing A
inst✝ : Algebra R A
I J : Ideal A
a✝ : (A ⧸ J) ⧸ map (Quotient.mkₐ R J) I
⊢ (AlgEquiv.ofRingEquiv ⋯).symm a✝ = (AlgEquiv.ofRingEquiv ⋯) a✝
state_after: no goals
Theorem: Booleanisation.comp_le_comp
File: Mathlib/Order/Booleanisation.lean

tactic: rintro ⟨_⟩
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
⊢ comp a ≤ comp b → b ≤ a
state_after: case comp
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : b ≤ a
⊢ b ≤ a

tactic: assumption
state_before: case comp
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : b ≤ a
⊢ b ≤ a
state_after: no goals
Theorem: Bool.and_le_left
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (x y : Bool), (x && y) ≤ x
state_after: no goals
Theorem: isUpperSet_iff_Ioi_subset
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [isUpperSet_iff_forall_lt, subset_def, @forall_swap (_ ∈ s)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : PartialOrder α
s : Set α
⊢ IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Ioi a ⊆ s
state_after: no goals
Theorem: ZMod.χ₈_int_eq_if_mod_eight
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: have help :
  ∀ m : ℤ, 0 ≤ m → m < 8 → χ₈ m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1 := by
  decide
state_before: n : ℤ
⊢ χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
state_after: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1

tactic: rw [← Int.emod_emod_of_dvd n (by omega : (2 : ℤ) ∣ 8), ← ZMod.intCast_mod n 8]
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
state_after: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ χ₈ ↑(n % ↑8) = if n % 8 % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1

tactic: exact help (n % 8) (Int.emod_nonneg n (by omega)) (Int.emod_lt n (by omega))
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ χ₈ ↑(n % ↑8) = if n % 8 % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
state_after: no goals

tactic: decide
state_before: n : ℤ
⊢ ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
state_after: no goals

tactic: omega
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ 2 ∣ 8
state_after: no goals

tactic: omega
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → χ₈ ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 7 then 1 else -1
⊢ 8 ≠ 0
state_after: no goals
Theorem: Set.image2_range
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [← image_univ, image2_image_left, image2_image_right, ← image_prod, univ_prod_univ]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α' → β' → γ
g : α → α'
h : β → β'
⊢ image2 f (range g) (range h) = range fun x => f (g x.1) (h x.2)
state_after: no goals
Theorem: Ordinal.add_log_le_log_mul
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: by_cases hb : 1 < b
state_before: x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
⊢ log b x + log b y ≤ log b (x * y)
state_after: case pos
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : 1 < b
⊢ log b x + log b y ≤ log b (x * y)

case neg
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : ¬1 < b
⊢ log b x + log b y ≤ log b (x * y)

tactic: simp only [log_of_not_one_lt_left hb, zero_add, le_refl]
state_before: case neg
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : ¬1 < b
⊢ log b x + log b y ≤ log b (x * y)
state_after: no goals

tactic: rw [← opow_le_iff_le_log hb (mul_ne_zero hx hy), opow_add]
state_before: case pos
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : 1 < b
⊢ log b x + log b y ≤ log b (x * y)
state_after: case pos
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : 1 < b
⊢ b ^ log b x * b ^ log b y ≤ x * y

tactic: exact mul_le_mul' (opow_log_le_self b hx) (opow_log_le_self b hy)
state_before: case pos
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : 1 < b
⊢ b ^ log b x * b ^ log b y ≤ x * y
state_after: no goals
Theorem: SimpleGraph.Subgraph.spanningCoe_inj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [Subgraph.spanningCoe]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
⊢ G₁.spanningCoe = G₂.spanningCoe ↔ G₁.Adj = G₂.Adj
state_after: no goals
Theorem: ENNReal.essSup_indicator_eq_essSup_restrict
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: classical
simp only [← piecewise_eq_indicator, essSup_piecewise hs, max_eq_left_iff]
exact limsup_const_bot.trans_le (zero_le _)
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
s : Set α
f : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup (s.indicator f) μ = essSup f (μ.restrict s)
state_after: no goals

tactic: simp only [← piecewise_eq_indicator, essSup_piecewise hs, max_eq_left_iff]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
s : Set α
f : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup (s.indicator f) μ = essSup f (μ.restrict s)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
s : Set α
f : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup 0 (μ.restrict sᶜ) ≤ essSup f (μ.restrict s)

tactic: exact limsup_const_bot.trans_le (zero_le _)
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
s : Set α
f : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup 0 (μ.restrict sᶜ) ≤ essSup f (μ.restrict s)
state_after: no goals
Theorem: Polynomial.Chebyshev.U_add_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: linear_combination (norm := (simp [Int.negSucc_eq]; ring_nf)) U.eq_4 R k
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
⊢ U R (-↑(k + 1) + 2) = 2 * X * U R (-↑(k + 1) + 1) - U R (-↑(k + 1))
state_after: no goals

tactic: simp [Int.negSucc_eq]
state_before: case a
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
⊢ U R (-↑(k + 1) + 2) - (2 * X * U R (-↑(k + 1) + 1) - U R (-↑(k + 1))) -
      (U R (Int.negSucc k) - (2 * X * U R (-↑k) - U R (-↑k + 1))) =
    0
state_after: case a
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
⊢ U R (-1 + -↑k + 2) - (2 * X * U R (-↑k) - U R (-1 + -↑k)) - (U R (-1 + -↑k) - (2 * X * U R (-↑k) - U R (-↑k + 1))) = 0

tactic: ring_nf
state_before: case a
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
⊢ U R (-1 + -↑k + 2) - (2 * X * U R (-↑k) - U R (-1 + -↑k)) - (U R (-1 + -↑k) - (2 * X * U R (-↑k) - U R (-↑k + 1))) = 0
state_after: no goals
Theorem: card_finset_fin_le
File: Mathlib/Data/Fintype/Card.lean

tactic: simpa only [Fintype.card_fin] using s.card_le_univ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
s : Finset (Fin n)
⊢ s.card ≤ n
state_after: no goals
Theorem: Equiv.setValue_eq
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [setValue, swap_apply_left]
state_before: α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
f : α ≃ β
a : α
b : β
⊢ (f.setValue a b) a = b
state_after: no goals
Theorem: HahnSeries.sub_coeff
File: Mathlib/RingTheory/HahnSeries/Addition.lean

tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
a : Γ
⊢ (x - y).coeff a = x.coeff a - y.coeff a
state_after: no goals
Theorem: Set.inter_singleton_eq_empty
File: Mathlib/Data/Set/Basic.lean

tactic: rw [inter_comm, singleton_inter_eq_empty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ s ∩ {a} = ∅ ↔ a ∉ s
state_after: no goals
Theorem: Orientation.oangle_eq_zero_iff_oangle_rev_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rw [oangle_rev, neg_eq_zero]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ o.oangle x y = 0 ↔ o.oangle y x = 0
state_after: no goals
Theorem: Convex.sub
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
hs : Convex 𝕜 s
ht : Convex 𝕜 t
⊢ Convex 𝕜 (s - t)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
hs : Convex 𝕜 s
ht : Convex 𝕜 t
⊢ Convex 𝕜 (s + -t)

tactic: exact hs.add ht.neg
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
hs : Convex 𝕜 s
ht : Convex 𝕜 t
⊢ Convex 𝕜 (s + -t)
state_after: no goals
Theorem: MultilinearMap.compLinearMap_injective
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simpa [fun i => surjInv_eq (hf i)] using ext_iff.mp h fun i => surjInv (hf i) (x i)
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁴ : Semiring R
inst✝¹³ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝¹² : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : (i : Fin n.succ) → Module R (M i)
inst✝⁷ : (i : ι) → Module R (M₁ i)
inst✝⁶ : Module R M₂
inst✝⁵ : Module R M₃
inst✝⁴ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝³ : (i : ι) → AddCommMonoid (M₁' i)
inst✝² : (i : ι) → Module R (M₁' i)
M₁'' : ι → Type u_2
inst✝¹ : (i : ι) → AddCommMonoid (M₁'' i)
inst✝ : (i : ι) → Module R (M₁'' i)
f : (i : ι) → M₁ i →ₗ[R] M₁' i
hf : ∀ (i : ι), Surjective ⇑(f i)
g₁ g₂ : MultilinearMap R M₁' M₂
h : (fun g => g.compLinearMap f) g₁ = (fun g => g.compLinearMap f) g₂
x : (i : ι) → M₁' i
⊢ g₁ x = g₂ x
state_after: no goals
Theorem: isometry_iff_dist_eq
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [isometry_iff_nndist_eq, ← coe_nndist, NNReal.coe_inj]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
⊢ Isometry f ↔ ∀ (x y : α), dist (f x) (f y) = dist x y
state_after: no goals
Theorem: ContinuousMultilinearMap.norm_ofSubsingleton_id_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

tactic: rw [norm_ofSubsingleton]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖(ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ ≤ 1
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖ContinuousLinearMap.id 𝕜 G‖ ≤ 1

tactic: apply ContinuousLinearMap.norm_id_le
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖ContinuousLinearMap.id 𝕜 G‖ ≤ 1
state_after: no goals