1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: hasFTaylorSeriesUpTo_top_iff'
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp only [← hasFTaylorSeriesUpToOn_univ_iff, hasFTaylorSeriesUpToOn_top_iff', mem_univ,
  forall_true_left, hasFDerivWithinAt_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ HasFTaylorSeriesUpTo ⊤ f p ↔
    (∀ (x : E), (p x 0).uncurry0 = f x) ∧ ∀ (m : ℕ) (x : E), HasFDerivAt (fun y => p y m) (p x m.succ).curryLeft x
state_after: no goals
Theorem: IsGroupHom.inv_ker_one
File: Mathlib/Deprecated/Subgroup.lean

tactic: have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f (a * b⁻¹) = 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : f a * (f b)⁻¹ = 1
⊢ f (a * b⁻¹) = 1

tactic: rwa [← hf.map_inv, ← hf.map_mul] at this
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : f a * (f b)⁻¹ = 1
⊢ f (a * b⁻¹) = 1
state_after: no goals

tactic: rw [h, mul_right_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f a * (f b)⁻¹ = 1
state_after: no goals
Theorem: Algebra.TensorProduct.basisAux_tmul
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: ext
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
m : M
⊢ (basisAux A b) (a ⊗ₜ[R] m) = a • Finsupp.mapRange ⇑(algebraMap R A) ⋯ (b.repr m)
state_after: case h
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
m : M
a✝ : ι
⊢ ((basisAux A b) (a ⊗ₜ[R] m)) a✝ = (a • Finsupp.mapRange ⇑(algebraMap R A) ⋯ (b.repr m)) a✝

tactic: simp [basisAux, ← Algebra.commutes, Algebra.smul_def]
state_before: case h
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
m : M
a✝ : ι
⊢ ((basisAux A b) (a ⊗ₜ[R] m)) a✝ = (a • Finsupp.mapRange ⇑(algebraMap R A) ⋯ (b.repr m)) a✝
state_after: no goals
Theorem: MeasureTheory.Lp.norm_constL_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: positivity
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : IsFiniteMeasure μ
c : E
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Fact (1 ≤ p)
⊢ 0 ≤ (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.realize_rel₁
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Relations.boundedFormula₁, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 1
t : L.Term (α ⊕ Fin l)
⊢ (R.boundedFormula₁ t).Realize v xs ↔ RelMap R ![realize (Sum.elim v xs) t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 1
t : L.Term (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (![t] i)) = RelMap R ![realize (Sum.elim v xs) t]

tactic: refine congr rfl (funext fun _ => ?_)
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 1
t : L.Term (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (![t] i)) = RelMap R ![realize (Sum.elim v xs) t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 1
t : L.Term (α ⊕ Fin l)
x✝ : Fin 1
⊢ realize (Sum.elim v xs) (![t] x✝) = ![realize (Sum.elim v xs) t] x✝

tactic: simp only [Matrix.cons_val_fin_one]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 1
t : L.Term (α ⊕ Fin l)
x✝ : Fin 1
⊢ realize (Sum.elim v xs) (![t] x✝) = ![realize (Sum.elim v xs) t] x✝
state_after: no goals
Theorem: MulAction.mem_stabilizer_finset_iff_subset_smul_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

tactic: rw [mem_stabilizer_iff, Finset.subset_iff_eq_of_card_le (Finset.card_smul_finset _ _).le, eq_comm]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ a ∈ stabilizer G s ↔ s ⊆ a • s
state_after: no goals
Theorem: Real.inner_le_Lp_mul_Lq_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: convert inner_le_Lp_mul_Lq s f g hpq using 3 <;> apply sum_congr rfl <;> intro i hi <;>
  simp only [abs_of_nonneg, hf i hi, hg i hi]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : p.IsConjExponent q
hf : ∀ i ∈ s, 0 ≤ f i
hg : ∀ i ∈ s, 0 ≤ g i
⊢ ∑ i ∈ s, f i * g i ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) * (∑ i ∈ s, g i ^ q) ^ (1 / q)
state_after: no goals
Theorem: List.fst_lt_of_mem_enum
File: Mathlib/Data/List/Enum.lean

tactic: simpa using fst_lt_add_of_mem_enumFrom h
state_before: α : Type u_1
β : Type u_2
x : ℕ × α
l : List α
h : x ∈ l.enum
⊢ x.1 < l.length
state_after: no goals
Theorem: Ordinal.opow_one_add
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [opow_add, opow_one]
state_before: a b : Ordinal.{u_1}
⊢ a ^ (1 + b) = a * a ^ b
state_after: no goals
Theorem: List.ranges_nodup
File: Mathlib/Data/List/Range.lean

tactic: rw [ranges_join']
state_before: α : Type u
l s : List ℕ
hs : s ∈ l.ranges
⊢ Pairwise (fun x x_1 => x ≠ x_1) l.ranges.join
state_after: α : Type u
l s : List ℕ
hs : s ∈ l.ranges
⊢ Pairwise (fun x x_1 => x ≠ x_1) (range (Nat.sum l))

tactic: exact nodup_range _
state_before: α : Type u
l s : List ℕ
hs : s ∈ l.ranges
⊢ Pairwise (fun x x_1 => x ≠ x_1) (range (Nat.sum l))
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.le_restrict_empty
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro j _
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
⊢ v.restrict ∅ ≤ w.restrict ∅
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
j : Set α
a✝ : MeasurableSet j
⊢ ↑(v.restrict ∅) j ≤ ↑(w.restrict ∅) j

tactic: rw [restrict_empty, restrict_empty]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
j : Set α
a✝ : MeasurableSet j
⊢ ↑(v.restrict ∅) j ≤ ↑(w.restrict ∅) j
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.restrict_iSup
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

tactic: simp [restrict]
state_before: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
ι : Sort u_3
s : Set α
m : ι → OuterMeasure α
⊢ (restrict s) (⨆ i, m i) = ⨆ i, (restrict s) (m i)
state_after: no goals
Theorem: Set.Infinite.meas_eq_top
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simpa [Subtype.val_inj]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
s : Set α
hs : s.Infinite
h' : ∃ ε, ε ≠ 0 ∧ ∀ x ∈ s, ε ≤ μ {x}
ε : ℝ≥0∞
hne✝ : ε ≠ 0
hε : ∀ x ∈ s, ε ≤ μ {x}
this : Infinite ↑s
x y : ↑s
hne : x ≠ y
⊢ (Disjoint on fun x => {↑x}) x y
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
s : Set α
hs : s.Infinite
h' : ∃ ε, ε ≠ 0 ∧ ∀ x ∈ s, ε ≤ μ {x}
ε : ℝ≥0∞
hne : ε ≠ 0
hε : ∀ x ∈ s, ε ≤ μ {x}
this : Infinite ↑s
⊢ μ (⋃ x, {↑x}) = μ s
state_after: no goals
Theorem: Bool.ofNat_toNat
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ ofNat b.toNat = b
state_after: no goals
Theorem: Finset.Icc_self
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_eq_singleton, coe_Icc, Set.Icc_self]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b c a : α
⊢ Icc a a = {a}
state_after: no goals
Theorem: RingHom.fieldRange_eq_map
File: Mathlib/Algebra/Field/Subfield.lean

tactic: ext
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
g : L →+* M
f : K →+* L
⊢ f.fieldRange = Subfield.map f ⊤
state_after: case h
K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
g : L →+* M
f : K →+* L
x✝ : L
⊢ x✝ ∈ f.fieldRange ↔ x✝ ∈ Subfield.map f ⊤

tactic: simp
state_before: case h
K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
g : L →+* M
f : K →+* L
x✝ : L
⊢ x✝ ∈ f.fieldRange ↔ x✝ ∈ Subfield.map f ⊤
state_after: no goals
Theorem: Surreal.zsmul_pow_two_powHalf
File: Mathlib/SetTheory/Surreal/Dyadic.lean

tactic: rw [mul_assoc]
state_before: m : ℤ
n k : ℕ
⊢ ↑m * 2 ^ n * powHalf (n + k) = ↑m * powHalf k
state_after: m : ℤ
n k : ℕ
⊢ ↑m * (2 ^ n * powHalf (n + k)) = ↑m * powHalf k

tactic: congr
state_before: m : ℤ
n k : ℕ
⊢ ↑m * (2 ^ n * powHalf (n + k)) = ↑m * powHalf k
state_after: case e_a
m : ℤ
n k : ℕ
⊢ 2 ^ n * powHalf (n + k) = powHalf k

tactic: exact nsmul_pow_two_powHalf' n k
state_before: case e_a
m : ℤ
n k : ℕ
⊢ 2 ^ n * powHalf (n + k) = powHalf k
state_after: no goals
Theorem: IsUnit.mem_unitary_of_star_mul_self
File: Mathlib/Algebra/Star/Unitary.lean

tactic: refine unitary.mem_iff.mpr ⟨h_mul, ?_⟩
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u ∈ unitary R
state_after: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u * star u = 1

tactic: lift u to Rˣ using hu
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u * star u = 1
state_after: case intro
R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : Rˣ
h_mul : star ↑u * ↑u = 1
⊢ ↑u * star ↑u = 1

tactic: exact left_inv_eq_right_inv h_mul u.mul_inv ▸ u.mul_inv
state_before: case intro
R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : Rˣ
h_mul : star ↑u * ↑u = 1
⊢ ↑u * star ↑u = 1
state_after: no goals
Theorem: Set.mem_dite_empty_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [mem_dite, mem_empty_iff_false, imp_false, not_not]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : p → Set α
x : α
⊢ (x ∈ if h : p then t h else ∅) ↔ ∃ (h : p), x ∈ t h
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : p → Set α
x : α
⊢ (∀ (h : p), x ∈ t h) ∧ p ↔ ∃ (h : p), x ∈ t h

tactic: exact ⟨fun h => ⟨h.2, h.1 h.2⟩, fun ⟨h₁, h₂⟩ => ⟨fun _ => h₂, h₁⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : p → Set α
x : α
⊢ (∀ (h : p), x ∈ t h) ∧ p ↔ ∃ (h : p), x ∈ t h
state_after: no goals
Theorem: LinearMap.BilinForm.exists_bilinForm_self_ne_zero
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: lift B to QuadraticForm R M using hB₂ with Q
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
htwo : Invertible 2
B : BilinForm R M
hB₁ : B ≠ 0
hB₂ : IsSymm B
⊢ ∃ x, ¬IsOrtho B x x
state_after: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
htwo : Invertible 2
B : BilinForm R M
Q : QuadraticForm R M
hB₁✝ hB₁ : (QuadraticForm.associatedHom ℕ) Q ≠ 0
⊢ ∃ x, ¬IsOrtho ((QuadraticForm.associatedHom ℕ) Q) x x

tactic: obtain ⟨x, hx⟩ := QuadraticForm.exists_quadraticForm_ne_zero hB₁
state_before: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
htwo : Invertible 2
B : BilinForm R M
Q : QuadraticForm R M
hB₁✝ hB₁ : (QuadraticForm.associatedHom ℕ) Q ≠ 0
⊢ ∃ x, ¬IsOrtho ((QuadraticForm.associatedHom ℕ) Q) x x
state_after: case intro.intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
htwo : Invertible 2
B : BilinForm R M
Q : QuadraticForm R M
hB₁✝ hB₁ : (QuadraticForm.associatedHom ℕ) Q ≠ 0
x : M
hx : Q x ≠ 0
⊢ ∃ x, ¬IsOrtho ((QuadraticForm.associatedHom ℕ) Q) x x

tactic: exact ⟨x, fun h => hx (Q.associated_eq_self_apply ℕ x ▸ h)⟩
state_before: case intro.intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
htwo : Invertible 2
B : BilinForm R M
Q : QuadraticForm R M
hB₁✝ hB₁ : (QuadraticForm.associatedHom ℕ) Q ≠ 0
x : M
hx : Q x ≠ 0
⊢ ∃ x, ¬IsOrtho ((QuadraticForm.associatedHom ℕ) Q) x x
state_after: no goals
Theorem: Complex.Gamma_ofReal
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: rw [Gamma, eq_comm, ← Complex.conj_eq_iff_re, ← Complex.Gamma_conj, Complex.conj_ofReal]
state_before: s : ℝ
⊢ Complex.Gamma ↑s = ↑(Gamma s)
state_after: no goals
Theorem: gauge_eq_one_iff_mem_frontier
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rw [eq_iff_le_not_lt, gauge_le_one_iff_mem_closure hc hs₀, gauge_lt_one_iff_mem_interior hc hs₀]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ gauge s x = 1 ↔ x ∈ frontier s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ x ∈ closure s ∧ x ∉ interior s ↔ x ∈ frontier s

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ x ∈ closure s ∧ x ∉ interior s ↔ x ∈ frontier s
state_after: no goals
Theorem: Submonoid.fg_iff_add_fg
File: Mathlib/GroupTheory/Finiteness.lean

tactic: simp [← Submonoid.toAddSubmonoid_closure, hS]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
h : P.FG
S : Set M
hS : closure S = P
hf : S.Finite
⊢ AddSubmonoid.closure (⇑Additive.toMul ⁻¹' S) = toAddSubmonoid P
state_after: no goals

tactic: simp [← AddSubmonoid.toSubmonoid'_closure, hT]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
h : (toAddSubmonoid P).FG
T : Set (Additive M)
hT : AddSubmonoid.closure T = toAddSubmonoid P
hf : T.Finite
⊢ closure (⇑Multiplicative.ofAdd ⁻¹' T) = P
state_after: no goals
Theorem: List.foldl_op_eq_op_foldr_assoc
File: Mathlib/Data/List/Basic.lean

tactic: simp only [foldl_cons, foldr_cons, foldl_assoc, ha.assoc]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op ((a :: l) <*> a₁) a₂ = op a₁ (foldr (fun x x_1 => op x x_1) a₂ (a :: l))
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op a₁ (op (l <*> a) a₂) = op a₁ (op a (foldr (fun x x_1 => op x x_1) a₂ l))

tactic: rw [foldl_op_eq_op_foldr_assoc]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op a₁ (op (l <*> a) a₂) = op a₁ (op a (foldr (fun x x_1 => op x x_1) a₂ l))
state_after: no goals
Theorem: Polynomial.eraseLead_add_of_natDegree_lt_left
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
⊢ (p + q).eraseLead = p.eraseLead + q
state_after: case a
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n

tactic: by_cases nd : n = p.natDegree
state_before: case a
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n
state_after: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : n = p.natDegree
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n

case neg
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : ¬n = p.natDegree
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n

tactic: rw [nd, eraseLead_coeff, if_pos (natDegree_add_eq_left_of_natDegree_lt pq).symm]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : n = p.natDegree
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n
state_after: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : n = p.natDegree
⊢ 0 = (p.eraseLead + q).coeff p.natDegree

tactic: simpa using (coeff_eq_zero_of_natDegree_lt pq).symm
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : n = p.natDegree
⊢ 0 = (p.eraseLead + q).coeff p.natDegree
state_after: no goals

tactic: rw [eraseLead_coeff, coeff_add, coeff_add, eraseLead_coeff, if_neg, if_neg nd]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : ¬n = p.natDegree
⊢ (p + q).eraseLead.coeff n = (p.eraseLead + q).coeff n
state_after: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : ¬n = p.natDegree
⊢ ¬n = (p + q).natDegree

tactic: rintro rfl
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
n : ℕ
nd : ¬n = p.natDegree
⊢ ¬n = (p + q).natDegree
state_after: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
nd : ¬(p + q).natDegree = p.natDegree
⊢ False

tactic: exact nd (natDegree_add_eq_left_of_natDegree_lt pq)
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : q.natDegree < p.natDegree
nd : ¬(p + q).natDegree = p.natDegree
⊢ False
state_after: no goals
Theorem: Monoid.CoprodI.range_eq_iSup
File: Mathlib/GroupTheory/CoprodI.lean

tactic: apply le_antisymm (lift_range_le _ f fun i => le_iSup (fun i => MonoidHom.range (f i)) i)
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
⊢ (lift f).range = ⨆ i, (f i).range
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
⊢ ⨆ i, (f i).range ≤ (lift f).range

tactic: apply iSup_le _
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
⊢ ⨆ i, (f i).range ≤ (lift f).range
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
⊢ ∀ (i : ι), (f i).range ≤ (lift f).range

tactic: rintro i _ ⟨x, rfl⟩
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
⊢ ∀ (i : ι), (f i).range ≤ (lift f).range
state_after: case intro
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
i : ι
x : G i
⊢ (f i) x ∈ (lift f).range

tactic: exact ⟨of x, by simp only [lift_of]⟩
state_before: case intro
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
i : ι
x : G i
⊢ (f i) x ∈ (lift f).range
state_after: no goals

tactic: simp only [lift_of]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝² : Monoid N✝
G : ι → Type u_4
inst✝¹ : (i : ι) → Group (G i)
N : Type u_5
inst✝ : Group N
f : (i : ι) → G i →* N
i : ι
x : G i
⊢ (lift f) (of x) = (f i) x
state_after: no goals