1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.FiniteMeasure.continuous_map
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [continuous_iff_continuousAt]
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
f : Ω → Ω'
f_cont : Continuous f
⊢ Continuous fun ν => ν.map f
state_after: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
f : Ω → Ω'
f_cont : Continuous f
⊢ ∀ (x : FiniteMeasure Ω), ContinuousAt (fun ν => ν.map f) x

tactic: exact fun _ ↦ tendsto_map_of_tendsto_of_continuous _ _ continuous_id.continuousAt f_cont
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
f : Ω → Ω'
f_cont : Continuous f
⊢ ∀ (x : FiniteMeasure Ω), ContinuousAt (fun ν => ν.map f) x
state_after: no goals
Theorem: Real.closedBall_eq_Icc
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: ext y
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x r : ℝ
⊢ closedBall x r = Icc (x - r) (x + r)
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x r y : ℝ
⊢ y ∈ closedBall x r ↔ y ∈ Icc (x - r) (x + r)

tactic: rw [mem_closedBall, dist_comm, Real.dist_eq, abs_sub_le_iff, mem_Icc, ← sub_le_iff_le_add',
  sub_le_comm]
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x r y : ℝ
⊢ y ∈ closedBall x r ↔ y ∈ Icc (x - r) (x + r)
state_after: no goals
Theorem: GaussianInt.prime_of_nat_prime_of_mod_four_eq_three
File: Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean

tactic: erw [← ZMod.natCast_mod p 4, hp3]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑p
state_after: p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑3

tactic: decide
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑3
state_after: no goals

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
this : ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑p
⊢ ↑a ^ 2 + ↑b ^ 2 = ↑(a ^ 2 + b ^ 2)
state_after: no goals
Theorem: CategoryTheory.Projective.of_iso
File: Mathlib/CategoryTheory/Preadditive/Projective.lean

tactic: simp [hf']
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q : C
i : P ≅ Q
hP : Projective P
E✝ X✝ : C
f : Q ⟶ X✝
e : E✝ ⟶ X✝
e_epi : Epi e
f' : P ⟶ E✝
hf' : f' ≫ e = i.hom ≫ f
⊢ (i.inv ≫ f') ≫ e = f
state_after: no goals
Theorem: Multiset.Ico_filter_le_of_left_le
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ico, ← Finset.filter_val, Finset.Ico_filter_le_of_left_le hac]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico c b
state_after: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
⊢ (Finset.Ico c b).val = Ico c b

tactic: rfl
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
⊢ (Finset.Ico c b).val = Ico c b
state_after: no goals
Theorem: List.prev_getLast_cons'
File: Mathlib/Data/List/Cycle.lean

tactic: cases l <;> simp [prev, hx]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hxy : x ∈ y :: l
hx : x = y
⊢ (y :: l).prev x hxy = (y :: l).getLast ⋯
state_after: no goals
Theorem: Real.two_mul_arctan_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [two_mul, arctan_add_eq_add_pi (by nlinarith) (by linarith)]
state_before: x : ℝ
h : 1 < x
⊢ 2 * arctan x = arctan (2 * x / (1 - x ^ 2)) + π
state_after: x : ℝ
h : 1 < x
⊢ arctan ((x + x) / (1 - x * x)) + π = arctan (2 * x / (1 - x ^ 2)) + π

tactic: congr 2
state_before: x : ℝ
h : 1 < x
⊢ arctan ((x + x) / (1 - x * x)) + π = arctan (2 * x / (1 - x ^ 2)) + π
state_after: case e_a.e_x
x : ℝ
h : 1 < x
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)

tactic: ring
state_before: case e_a.e_x
x : ℝ
h : 1 < x
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)
state_after: no goals

tactic: nlinarith
state_before: x : ℝ
h : 1 < x
⊢ 1 < x * x
state_after: no goals

tactic: linarith
state_before: x : ℝ
h : 1 < x
⊢ 0 < x
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_id
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: unfold mapMono
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ mapMono K (𝟙 Δ) = 𝟙 (K.X Δ.len)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ (if h : Δ = Δ then eqToHom ⋯ else if h : Isδ₀ (𝟙 Δ) then K.d Δ.len Δ.len else 0) = 𝟙 (K.X Δ.len)

tactic: simp only [eq_self_iff_true, eqToHom_refl, dite_eq_ite, if_true]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ (if h : Δ = Δ then eqToHom ⋯ else if h : Isδ₀ (𝟙 Δ) then K.d Δ.len Δ.len else 0) = 𝟙 (K.X Δ.len)
state_after: no goals
Theorem: ModularCyclotomicCharacter.toFun_spec
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

tactic: rw [ModularCyclotomicCharacter_aux_spec g n t, ← zpow_natCast, ModularCyclotomicCharacter.toFun,
  ZMod.val_intCast, ← Subgroup.coe_zpow]
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ g ↑↑t = ↑(↑t ^ (χ₀ n g).val)
state_after: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ ↑↑(t ^ ModularCyclotomicCharacter_aux g n) =
    ↑(↑t ^ (ModularCyclotomicCharacter_aux g n % ↑(Fintype.card ↥(rootsOfUnity n L))))

tactic: exact Units.ext_iff.1 <| SetCoe.ext_iff.2 <| zpow_eq_zpow_emod _ pow_card_eq_one
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ ↑↑(t ^ ModularCyclotomicCharacter_aux g n) =
    ↑(↑t ^ (ModularCyclotomicCharacter_aux g n % ↑(Fintype.card ↥(rootsOfUnity n L))))
state_after: no goals
Theorem: OreLocalization.mul_cancel'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_mul_char (r₁ * s) r₂ t s r₁ 1 (by simp)]
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.108631
inst✝ : MulAction R X
r₁ r₂ : R
s t : ↥S
⊢ r₁ * ↑s /ₒ t * (r₂ /ₒ s) = r₁ * r₂ /ₒ t
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.108631
inst✝ : MulAction R X
r₁ r₂ : R
s t : ↥S
⊢ ↑1 * (r₁ * ↑s) = r₁ * ↑s
state_after: no goals
Theorem: Real.inv_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [← rpow_neg_one, ← rpow_mul hx, mul_comm]
state_before: x y✝ z : ℝ
n : ℕ
hx : 0 ≤ x
y : ℝ
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: no goals
Theorem: CliffordAlgebra.reverse_comp_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: ext x
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ reverse ∘ₗ involute.toLinearMap = involute.toLinearMap ∘ₗ reverse
state_after: case h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
⊢ (reverse ∘ₗ involute.toLinearMap) x = (involute.toLinearMap ∘ₗ reverse) x

tactic: simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply]
state_before: case h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
⊢ (reverse ∘ₗ involute.toLinearMap) x = (involute.toLinearMap ∘ₗ reverse) x
state_after: case h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
⊢ reverse (involute x) = involute (reverse x)

tactic: induction x using CliffordAlgebra.induction with
| algebraMap => simp
| ι => simp
| mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
| add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
state_before: case h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
⊢ reverse (involute x) = involute (reverse x)
state_after: no goals

tactic: simp
state_before: case h.algebraMap
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
r✝ : R
⊢ reverse (involute ((algebraMap R (CliffordAlgebra Q)) r✝)) =
    involute (reverse ((algebraMap R (CliffordAlgebra Q)) r✝))
state_after: no goals

tactic: simp
state_before: case h.ι
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ : M
⊢ reverse (involute ((ι Q) x✝)) = involute (reverse ((ι Q) x✝))
state_after: no goals

tactic: simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
state_before: case h.mul
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a b : CliffordAlgebra Q
ha : reverse (involute a) = involute (reverse a)
hb : reverse (involute b) = involute (reverse b)
⊢ reverse (involute (a * b)) = involute (reverse (a * b))
state_after: no goals

tactic: simp only [ha, hb, reverse.map_add, AlgHom.map_add]
state_before: case h.add
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a b : CliffordAlgebra Q
ha : reverse (involute a) = involute (reverse a)
hb : reverse (involute b) = involute (reverse b)
⊢ reverse (involute (a + b)) = involute (reverse (a + b))
state_after: no goals
Theorem: MeasureTheory.finStronglyMeasurable_zero
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp only [Pi.zero_apply, SimpleFunc.coe_zero, support_zero', measure_empty,
  zero_lt_top, forall_const]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
α : Type u_5
β : Type u_6
m : MeasurableSpace α
μ : Measure α
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
⊢ ∀ (n : ℕ), μ (support ↑(0 n)) < ⊤
state_after: no goals
Theorem: Set.Nonempty.eq_univ
File: Mathlib/Data/Set/Basic.lean

tactic: rintro ⟨x, hx⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
⊢ s.Nonempty → s = univ
state_after: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
⊢ s = univ

tactic: exact eq_univ_of_forall fun y => by rwa [Subsingleton.elim y x]
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
⊢ s = univ
state_after: no goals

tactic: rwa [Subsingleton.elim y x]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
y : α
⊢ y ∈ s
state_after: no goals
Theorem: Real.Angle.cos_eq_iff_eq_or_eq_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction ψ using Real.Angle.induction_on
state_before: θ ψ : Angle
⊢ θ.cos = ψ.cos ↔ θ = ψ ∨ θ = -ψ
state_after: case h
θ : Angle
x✝ : ℝ
⊢ θ.cos = (↑x✝).cos ↔ θ = ↑x✝ ∨ θ = -↑x✝

tactic: exact cos_eq_real_cos_iff_eq_or_eq_neg
state_before: case h
θ : Angle
x✝ : ℝ
⊢ θ.cos = (↑x✝).cos ↔ θ = ↑x✝ ∨ θ = -↑x✝
state_after: no goals
Theorem: Submodule.set_smul_eq_iSup
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

tactic: refine Eq.trans (congrArg sInf ?_) csInf_Ici
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ s • N = ⨆ a ∈ s, a • N
state_after: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p} = Set.Ici (⨆ a ∈ s, a • N)

tactic: simp_rw [← Set.Ici_def, iSup_le_iff, @forall_comm M]
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p} = Set.Ici (⨆ a ∈ s, a • N)
state_after: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄, r ∈ s → ∀ a ∈ N, r • a ∈ p} = {x | ∀ i ∈ s, i • N ≤ x}

tactic: exact Set.ext fun _ => forall₂_congr (fun _ _ => Iff.symm map_le_iff_le_comap)
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄, r ∈ s → ∀ a ∈ N, r • a ∈ p} = {x | ∀ i ∈ s, i • N ≤ x}
state_after: no goals
Theorem: MultilinearMap.alternatization_apply
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

tactic: simp only [alternatization_def, smul_apply, sum_apply]
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
⊢ (alternatization m) v = ∑ σ : Perm ι, Perm.sign σ • (domDomCongr σ m) v
state_after: no goals
Theorem: Prime.exists_mem_multiset_dvd
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : p ∣ s.prod → ∃ a ∈ s, p ∣ a
h : p ∣ (a ::ₘ s).prod
⊢ p ∣ a * s.prod
state_after: no goals
Theorem: MvPolynomial.IsHomogeneous.funext_of_le_card
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: rw [← sub_eq_zero]
state_before: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁴ inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝ : ℕ
R : Type u_5
σ : Type u_6
inst✝¹ : CommRing R
inst✝ : IsDomain R
F G : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
hG : G.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = (eval r) G
hnR : ↑n ≤ #R
⊢ F = G
state_after: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁴ inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝ : ℕ
R : Type u_5
σ : Type u_6
inst✝¹ : CommRing R
inst✝ : IsDomain R
F G : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
hG : G.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = (eval r) G
hnR : ↑n ≤ #R
⊢ F - G = 0

tactic: apply eq_zero_of_forall_eval_eq_zero_of_le_card (hF.sub hG) _ hnR
state_before: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁴ inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝ : ℕ
R : Type u_5
σ : Type u_6
inst✝¹ : CommRing R
inst✝ : IsDomain R
F G : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
hG : G.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = (eval r) G
hnR : ↑n ≤ #R
⊢ F - G = 0
state_after: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁴ inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝ : ℕ
R : Type u_5
σ : Type u_6
inst✝¹ : CommRing R
inst✝ : IsDomain R
F G : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
hG : G.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = (eval r) G
hnR : ↑n ≤ #R
⊢ ∀ (r : σ → R), (eval r) (F - G) = 0

tactic: simpa [sub_eq_zero] using h
state_before: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁴ inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝ : ℕ
R : Type u_5
σ : Type u_6
inst✝¹ : CommRing R
inst✝ : IsDomain R
F G : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
hG : G.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = (eval r) G
hnR : ↑n ≤ #R
⊢ ∀ (r : σ → R), (eval r) (F - G) = 0
state_after: no goals
Theorem: MeasureTheory.addHaarMeasure_eq_volume
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: convert (addHaarMeasure_unique volume Icc01).symm
state_before: ⊢ addHaarMeasure Icc01 = volume
state_after: case h.e'_2

⊢ addHaarMeasure Icc01 = volume ↑Icc01 • addHaarMeasure Icc01

tactic: simp [Icc01]
state_before: case h.e'_2

⊢ addHaarMeasure Icc01 = volume ↑Icc01 • addHaarMeasure Icc01
state_after: no goals
Theorem: inf_sq_eq_mul_div_mabs_div
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [← inf_mul_sup a b, ← sup_div_inf_eq_mabs_div, div_eq_mul_inv, div_eq_mul_inv, mul_inv_rev,
  inv_inv, mul_assoc, mul_inv_cancel_comm_assoc, ← pow_two]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a ⊓ b) ^ 2 = a * b / mabs (b / a)
state_after: no goals
Theorem: Nat.le_and_le_add_one_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [le_add_one_iff, and_or_left, ← Nat.le_antisymm_iff, eq_comm, and_iff_right_of_imp]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ n ≤ m ∧ m ≤ n + 1 ↔ m = n ∨ m = n + 1
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m = n + 1 → n ≤ m

tactic: rintro rfl
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m = n + 1 → n ≤ m
state_after: a b c d n k : ℕ
p q : ℕ → Prop
⊢ n ≤ n + 1

tactic: exact n.le_succ
state_before: a b c d n k : ℕ
p q : ℕ → Prop
⊢ n ≤ n + 1
state_after: no goals
Theorem: Function.support_smul_subset_left
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [Pi.smul_apply', hf, zero_smul]
state_before: α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
g : α → M
x : α
hfg : x ∈ support (f • g)
hf : f x = 0
⊢ (f • g) x = 0
state_after: no goals
Theorem: Nat.base_pow_length_digits_le
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | _ | b) <;> try simp_all
state_before: n b m : ℕ
hb : 1 < b
⊢ m ≠ 0 → b ^ (b.digits m).length ≤ b * m
state_after: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m

tactic: exact base_pow_length_digits_le' b m
state_before: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m
state_after: no goals

tactic: simp_all
state_before: case succ.succ
n m b : ℕ
hb : 1 < b + 1 + 1
⊢ m ≠ 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m
state_after: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m
Theorem: Finset.Nontrivial.exists_cons_eq
File: Mathlib/Data/Finset/Basic.lean

tactic: classical
obtain ⟨a, ha, b, hb, hab⟩ := hs
have : b ∈ s.erase a := mem_erase.2 ⟨hab.symm, hb⟩
refine ⟨(s.erase a).erase b, a, ?_, b, ?_, ?_, ?_⟩ <;>
  simp [insert_erase this, insert_erase ha, *]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nontrivial
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s
state_after: no goals

tactic: obtain ⟨a, ha, b, hb, hab⟩ := hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nontrivial
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s

tactic: have : b ∈ s.erase a := mem_erase.2 ⟨hab.symm, hb⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
this : b ∈ s.erase a
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s

tactic: refine ⟨(s.erase a).erase b, a, ?_, b, ?_, ?_, ?_⟩ <;>
  simp [insert_erase this, insert_erase ha, *]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
this : b ∈ s.erase a
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s
state_after: no goals
Theorem: EReal.preimage_coe_Ioo_top
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← Ioi_inter_Iio]
state_before: x : ℝ
⊢ Real.toEReal ⁻¹' Ioo ↑x ⊤ = Ioi x
state_after: x : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iio ⊤) = Ioi x

tactic: simp
state_before: x : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iio ⊤) = Ioi x
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable.integral_kernel_compProd
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

tactic: filter_upwards [ae_ae_of_ae_compProd hf.ae_eq_mk] with _ hx using integral_congr_ae hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝³ : NormedAddCommGroup E
κ : ↥(kernel α β)
inst✝² : IsSFiniteKernel κ
η : ↥(kernel (α × β) γ)
inst✝¹ : IsSFiniteKernel η
a : α
inst✝ : NormedSpace ℝ E
f : β × γ → E
hf : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ (fun x => ∫ (y : γ), f (x, y) ∂η (a, x)) =ᶠ[ae (κ a)] fun x =>
    ∫ (y : γ), AEStronglyMeasurable.mk f hf (x, y) ∂η (a, x)
state_after: no goals
Theorem: Real.hasSum_arctan
File: Mathlib/Analysis/SpecialFunctions/Complex/Arctan.lean

tactic: simpa
state_before: x : ℝ
hx : ‖x‖ < 1
⊢ ‖↑x‖ < 1
state_after: no goals
Theorem: Fin.predAbove_castSucc_of_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [predAbove_of_castSucc_lt _ _ (castSucc_lt_castSucc_iff.2 h)]
state_before: n m : ℕ
p i : Fin n
h : p < i
hi : optParam (i.castSucc ≠ 0) ⋯
⊢ p.predAbove i.castSucc = i.castSucc.pred hi
state_after: no goals
Theorem: HomologicalComplex.cylinder.ι₀_π
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

tactic: simp [π]
state_before: C : Type u_1
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝³ : HasHomotopyCofiber φ
inst✝² : DecidableRel c.Rel
inst✝¹ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
⊢ ι₀ K ≫ π K = 𝟙 K
state_after: no goals