1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ExistsContDiffBumpBase.w_nonneg
File: Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean

tactic: apply mul_nonneg _ (u_nonneg _)
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ w D x
state_after: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹

tactic: apply inv_nonneg.2
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹
state_after: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ (∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E

tactic: apply mul_nonneg (u_int_pos E).le
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ (∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E
state_after: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ |D| ^ finrank ℝ E

tactic: apply pow_nonneg (abs_nonneg D)
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ 0 ≤ |D| ^ finrank ℝ E
state_after: no goals
Theorem: PrimeMultiset.coe_prod
File: Mathlib/Data/PNat/Factors.lean

tactic: let h : (v.prod : ℕ) = ((v.map Coe.coe).map Coe.coe).prod :=
  PNat.coeMonoidHom.map_multiset_prod v.toPNatMultiset
state_before: v : PrimeMultiset
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe (Multiset.map Coe.coe v)).prod :=
  MonoidHom.map_multiset_prod PNat.coeMonoidHom v.toPNatMultiset
⊢ ↑v.prod = v.toNatMultiset.prod

tactic: rw [Multiset.map_map] at h
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe (Multiset.map Coe.coe v)).prod :=
  MonoidHom.map_multiset_prod PNat.coeMonoidHom v.toPNatMultiset
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
⊢ ↑v.prod = v.toNatMultiset.prod

tactic: have : (Coe.coe : ℕ+ → ℕ) ∘ (Coe.coe : Nat.Primes → ℕ+) = Coe.coe := funext fun p => rfl
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod

tactic: rw [this] at h
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod

tactic: exact h
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: no goals
Theorem: ProbabilityTheory.kernel.comp_apply'
File: Mathlib/Probability/Kernel/Composition.lean

tactic: rw [comp_apply, Measure.bind_apply hs (kernel.measurable _)]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : ↥(kernel β γ)
κ : ↥(kernel α β)
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((η ∘ₖ κ) a) s = ∫⁻ (b : β), (η b) s ∂κ a
state_after: no goals
Theorem: EckmannHilton.mul_assoc
File: Mathlib/GroupTheory/EckmannHilton.lean

tactic: simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib a b e₂ c
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b c : X
⊢ m₂ (m₂ a b) c = m₂ a (m₂ b c)
state_after: no goals
Theorem: List.ofFn_zero
File: Mathlib/Data/List/OfFn.lean

tactic: simp
state_before: α : Type u
f : Fin 0 → α
⊢ (ofFn f).length = [].length
state_after: no goals

tactic: contradiction
state_before: α : Type u
f : Fin 0 → α
i : ℕ
hi₁ : i < (ofFn f).length
hi₂ : i < [].length
⊢ (ofFn f).get ⟨i, hi₁⟩ = [].get ⟨i, hi₂⟩
state_after: no goals
Theorem: edist_nndist
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [edist_dist, dist_nndist, ENNReal.ofReal_coe_nnreal]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
⊢ edist x y = ↑(nndist x y)
state_after: no goals
Theorem: isSimpleModule_iff_isCoatom
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← Set.isSimpleOrder_Ici_iff_isCoatom]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R (M ⧸ m) ↔ IsCoatom m
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R (M ⧸ m) ↔ IsSimpleOrder ↑(Set.Ici m)

tactic: apply OrderIso.isSimpleOrder_iff
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R (M ⧸ m) ↔ IsSimpleOrder ↑(Set.Ici m)
state_after: case f
ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ Submodule R (M ⧸ m) ≃o ↑(Set.Ici m)

tactic: exact Submodule.comapMkQRelIso m
state_before: case f
ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ Submodule R (M ⧸ m) ≃o ↑(Set.Ici m)
state_after: no goals
Theorem: Real.Wallis.W_eq_integral_sin_pow_div_integral_sin_pow
File: Mathlib/Data/Real/Pi/Wallis.lean

tactic: rw [integral_sin_pow_even, integral_sin_pow_odd, mul_div_mul_comm, ← prod_div_distrib, inv_div]
state_before: k : ℕ
⊢ (π / 2)⁻¹ * W k = (∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k + 1)) / ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)
state_after: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 3) / ((2 * ↑x + 1) / (2 * ↑x + 2))

tactic: simp_rw [div_div_div_comm, div_div_eq_mul_div, mul_div_assoc]
state_before: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 3) / ((2 * ↑x + 1) / (2 * ↑x + 2))
state_after: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 1) * ((2 * ↑x + 2) / (2 * ↑x + 3))

tactic: rfl
state_before: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 1) * ((2 * ↑x + 2) / (2 * ↑x + 3))
state_after: no goals
Theorem: MvQPF.Cofix.dest_mk
File: Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean

tactic: have : Cofix.mk ∘ Cofix.dest = @_root_.id (Cofix F α) := funext Cofix.mk_dest
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
⊢ (mk x).dest = x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
this : mk ∘ dest = _root_.id
⊢ (mk x).dest = x

tactic: rw [Cofix.mk, Cofix.dest_corec, ← comp_map, ← Cofix.mk, ← appendFun_comp, this, id_comp,
  appendFun_id_id, MvFunctor.id_map]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
this : mk ∘ dest = _root_.id
⊢ (mk x).dest = x
state_after: no goals
Theorem: Real.comap_exp_nhdsWithin_Ioi_zero
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [← map_exp_atBot, comap_map exp_injective]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
⊢ comap rexp (𝓝[>] 0) = atBot
state_after: no goals
Theorem: pow_boole
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [pow_ite, pow_one, pow_zero]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝¹ : Monoid M
a✝ b c : M
m n : ℕ
P : Prop
inst✝ : Decidable P
a : M
⊢ (a ^ if P then 1 else 0) = if P then a else 1
state_after: no goals
Theorem: List.zipWith_rotate_one
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
β : Type u_1
f : α → α → β
x y : α
l : List α
⊢ zipWith f (x :: y :: l) ((x :: y :: l).rotate 1) = f x y :: zipWith f (y :: l) (l ++ [x])
state_after: no goals
Theorem: SignType.self_eq_neg_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a = -a ↔ a = 0
state_after: no goals
Theorem: Rat.cast_lt_zero
File: Mathlib/Data/Rat/Cast/Order.lean

tactic: norm_cast
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ ↑q < 0 ↔ q < 0
state_after: no goals
Theorem: wbtw_lineMap_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: by_cases hxy : x = y
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
⊢ Wbtw R x ((lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1
state_after: case pos
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : x = y
⊢ Wbtw R x ((lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1

case neg
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : ¬x = y
⊢ Wbtw R x ((lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1

tactic: rw [or_iff_right hxy, Wbtw, affineSegment, (lineMap_injective R hxy).mem_set_image]
state_before: case neg
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : ¬x = y
⊢ Wbtw R x ((lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1
state_after: no goals

tactic: rw [hxy, lineMap_same_apply]
state_before: case pos
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : x = y
⊢ Wbtw R x ((lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1
state_after: case pos
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : x = y
⊢ Wbtw R y y y ↔ y = y ∨ r ∈ Set.Icc 0 1

tactic: simp
state_before: case pos
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y : P
r : R
hxy : x = y
⊢ Wbtw R y y y ↔ y = y ∨ r ∈ Set.Icc 0 1
state_after: no goals
Theorem: DihedralGroup.commProb_cons
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: simp [Product, commProb_pi, Fin.prod_univ_succ]
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
l : List ℕ
⊢ commProb (Product (n :: l)) = commProb (DihedralGroup n) * commProb (Product l)
state_after: no goals
Theorem: Polynomial.expand_zero
File: Mathlib/Algebra/Polynomial/Expand.lean

tactic: simp [expand]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ (expand R 0) f = C (eval 1 f)
state_after: no goals
Theorem: List.ofFn_succ'
File: Mathlib/Data/List/OfFn.lean

tactic: induction' n with n IH
state_before: α : Type u
n : ℕ
f : Fin n.succ → α
⊢ ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last n))
state_after: case zero
α : Type u
f : Fin (succ 0) → α
⊢ ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last 0))

case succ
α : Type u
n : ℕ
IH : ∀ (f : Fin n.succ → α), ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last n))
f : Fin (n + 1).succ → α
⊢ ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last (n + 1)))

tactic: rw [ofFn_zero, concat_nil, ofFn_succ, ofFn_zero]
state_before: case zero
α : Type u
f : Fin (succ 0) → α
⊢ ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last 0))
state_after: case zero
α : Type u
f : Fin (succ 0) → α
⊢ [f 0] = [f (Fin.last 0)]

tactic: rfl
state_before: case zero
α : Type u
f : Fin (succ 0) → α
⊢ [f 0] = [f (Fin.last 0)]
state_after: no goals

tactic: rw [ofFn_succ, IH, ofFn_succ, concat_cons, Fin.castSucc_zero]
state_before: case succ
α : Type u
n : ℕ
IH : ∀ (f : Fin n.succ → α), ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last n))
f : Fin (n + 1).succ → α
⊢ ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last (n + 1)))
state_after: case succ
α : Type u
n : ℕ
IH : ∀ (f : Fin n.succ → α), ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last n))
f : Fin (n + 1).succ → α
⊢ f 0 :: (ofFn fun i => f i.castSucc.succ).concat (f (Fin.last n).succ) =
    f 0 :: (ofFn fun i => f i.succ.castSucc).concat (f (Fin.last (n + 1)))

tactic: congr
state_before: case succ
α : Type u
n : ℕ
IH : ∀ (f : Fin n.succ → α), ofFn f = (ofFn fun i => f i.castSucc).concat (f (Fin.last n))
f : Fin (n + 1).succ → α
⊢ f 0 :: (ofFn fun i => f i.castSucc.succ).concat (f (Fin.last n).succ) =
    f 0 :: (ofFn fun i => f i.succ.castSucc).concat (f (Fin.last (n + 1)))
state_after: no goals
Theorem: Subgroup.mem_sup'
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp only [SetLike.exists, coe_mk, exists_prop]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x : C
⊢ (∃ y ∈ s, ∃ z ∈ t, y * z = x) ↔ ∃ y z, ↑y * ↑z = x
state_after: no goals
Theorem: Finset.inter_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (s ∩ s') ×ˢ t = s ×ˢ t ∩ s' ×ˢ t
state_after: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∩ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∩ s' ×ˢ t

tactic: simp only [← and_and_right, mem_inter, mem_product]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∩ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∩ s' ×ˢ t
state_after: no goals
Theorem: Real.contDiffOn_log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: suffices ContDiffOn ℝ ⊤ log {0}ᶜ from this.of_le le_top
state_before: x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ n log {0}ᶜ
state_after: x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ ⊤ log {0}ᶜ

tactic: refine (contDiffOn_top_iff_deriv_of_isOpen isOpen_compl_singleton).2 ?_
state_before: x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ ⊤ log {0}ᶜ
state_after: x : ℝ
n : ℕ∞
⊢ DifferentiableOn ℝ log {0}ᶜ ∧ ContDiffOn ℝ ⊤ (deriv log) {0}ᶜ

tactic: simp [differentiableOn_log, contDiffOn_inv]
state_before: x : ℝ
n : ℕ∞
⊢ DifferentiableOn ℝ log {0}ᶜ ∧ ContDiffOn ℝ ⊤ (deriv log) {0}ᶜ
state_after: no goals
Theorem: PrimeSpectrum.zeroLocus_ideal_mem_irreducibleComponents
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← vanishingIdeal_zeroLocus_eq_radical]
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
I : Ideal R
⊢ zeroLocus ↑I ∈ irreducibleComponents (PrimeSpectrum R) ↔ I.radical ∈ minimalPrimes R
state_after: R : Type u
S : Type v
inst✝ : CommSemiring R
I : Ideal R
⊢ zeroLocus ↑I ∈ irreducibleComponents (PrimeSpectrum R) ↔ vanishingIdeal (zeroLocus ↑I) ∈ minimalPrimes R

tactic: conv_lhs => rw [← (isClosed_zeroLocus _).closure_eq]
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
I : Ideal R
⊢ zeroLocus ↑I ∈ irreducibleComponents (PrimeSpectrum R) ↔ vanishingIdeal (zeroLocus ↑I) ∈ minimalPrimes R
state_after: R : Type u
S : Type v
inst✝ : CommSemiring R
I : Ideal R
⊢ closure (zeroLocus ↑I) ∈ irreducibleComponents (PrimeSpectrum R) ↔ vanishingIdeal (zeroLocus ↑I) ∈ minimalPrimes R

tactic: exact vanishingIdeal_mem_minimalPrimes.symm
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
I : Ideal R
⊢ closure (zeroLocus ↑I) ∈ irreducibleComponents (PrimeSpectrum R) ↔ vanishingIdeal (zeroLocus ↑I) ∈ minimalPrimes R
state_after: no goals
Theorem: CircleDeg1Lift.dist_map_zero_lt_of_semiconj
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [h.eq, Real.dist_eq, sub_sub, add_comm (f 0), sub_sub_eq_add_sub,
  abs_sub_comm (g₂ (f 0))]
state_before: f✝ g f g₁ g₂ : CircleDeg1Lift
h : Semiconj ⇑f ⇑g₁ ⇑g₂
⊢ dist (g₁ 0) (f (g₁ 0) - f 0) + dist (f (g₁ 0) - f 0) (g₂ 0) =
    dist (f 0 + g₁ 0) (f (g₁ 0)) + dist (g₂ 0 + f 0) (g₂ (f 0))
state_after: no goals
Theorem: QuaternionGroup.orderOf_xa
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: change _ = 2 ^ 2
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 4
state_after: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 2 ^ 2

tactic: haveI : Fact (Nat.Prime 2) := Fact.mk Nat.prime_two
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 2 ^ 2
state_after: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ orderOf (xa i) = 2 ^ 2

tactic: apply orderOf_eq_prime_pow
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ orderOf (xa i) = 2 ^ 2
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ ¬xa i ^ 2 ^ 1 = 1

case hfin
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ xa i ^ 2 ^ (1 + 1) = 1

tactic: intro h
state_before: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ ¬xa i ^ 2 ^ 1 = 1
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h : xa i ^ 2 ^ 1 = 1
⊢ False

tactic: simp only [pow_one, xa_sq] at h
state_before: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h : xa i ^ 2 ^ 1 = 1
⊢ False
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h : a ↑n = 1
⊢ False

tactic: injection h with h'
state_before: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h : a ↑n = 1
⊢ False
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h' : ↑n = 0
⊢ False

tactic: apply_fun ZMod.val at h'
state_before: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h' : ↑n = 0
⊢ False
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h' : (↑n).val = ZMod.val 0
⊢ False

tactic: simp only [ZMod.val_natCast, ZMod.val_zero, Nat.zero_div, Nat.mod_mul_left_div_self,
  Nat.div_self (NeZero.pos n)] at h'
state_before: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
h' : (↑n).val / n = ZMod.val 0 / n
⊢ False
state_after: no goals

tactic: norm_num
state_before: case hfin
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ xa i ^ 2 ^ (1 + 1) = 1
state_after: no goals
Theorem: Subgroup.iSup_eq_closure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp_rw [closure_iUnion, closure_eq]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
ι : Sort u_5
p : ι → Subgroup G
⊢ ⨆ i, p i = closure (⋃ i, ↑(p i))
state_after: no goals
Theorem: Nat.dvd_of_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: cases m
state_before: n m : ℕ
h : n ∈ m.divisors
⊢ n ∣ m
state_after: case zero
n : ℕ
h : n ∈ divisors 0
⊢ n ∣ 0

case succ
n n✝ : ℕ
h : n ∈ (n✝ + 1).divisors
⊢ n ∣ n✝ + 1

tactic: apply dvd_zero
state_before: case zero
n : ℕ
h : n ∈ divisors 0
⊢ n ∣ 0
state_after: no goals

tactic: simp [mem_divisors.1 h]
state_before: case succ
n n✝ : ℕ
h : n ∈ (n✝ + 1).divisors
⊢ n ∣ n✝ + 1
state_after: no goals
Theorem: NNReal.le_of_forall_lt_one_mul_le
File: Mathlib/Data/NNReal/Basic.lean

tactic: have hx : x ≠ 0 := pos_iff_ne_zero.1 (lt_of_le_of_lt (zero_le _) ha)
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
⊢ a ≤ y
state_after: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
⊢ a ≤ y

tactic: have hx' : x⁻¹ ≠ 0 := by rwa [Ne, inv_eq_zero]
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
⊢ a ≤ y
state_after: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
⊢ a ≤ y

tactic: have : a * x⁻¹ < 1 := by rwa [← lt_inv_iff_mul_lt hx', inv_inv]
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
⊢ a ≤ y
state_after: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
this : a * x⁻¹ < 1
⊢ a ≤ y

tactic: have : a * x⁻¹ * x ≤ y := h _ this
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
this : a * x⁻¹ < 1
⊢ a ≤ y
state_after: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
this✝ : a * x⁻¹ < 1
this : a * x⁻¹ * x ≤ y
⊢ a ≤ y

tactic: rwa [mul_assoc, inv_mul_cancel hx, mul_one] at this
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
this✝ : a * x⁻¹ < 1
this : a * x⁻¹ * x ≤ y
⊢ a ≤ y
state_after: no goals

tactic: rwa [Ne, inv_eq_zero]
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
⊢ x⁻¹ ≠ 0
state_after: no goals

tactic: rwa [← lt_inv_iff_mul_lt hx', inv_inv]
state_before: x y : ℝ≥0
h : ∀ a < 1, a * x ≤ y
a : ℝ≥0
ha : a < x
hx : x ≠ 0
hx' : x⁻¹ ≠ 0
⊢ a * x⁻¹ < 1
state_after: no goals
Theorem: CategoryTheory.ShortComplex.opcyclesMap_comp_descOpcycles
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: rw [← φ.comm₁₂_assoc, hk, comp_zero]
state_before: C : Type u_1
inst✝³ : Category.{?u.223619, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝¹ : S.HasRightHomology
φ : S₁ ⟶ S
inst✝ : S₁.HasRightHomology
⊢ S₁.f ≫ φ.τ₂ ≫ k = 0
state_after: no goals

tactic: simp only [← cancel_epi (S₁.pOpcycles), p_opcyclesMap_assoc, p_descOpcycles]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝¹ : S.HasRightHomology
φ : S₁ ⟶ S
inst✝ : S₁.HasRightHomology
⊢ opcyclesMap φ ≫ S.descOpcycles k hk = S₁.descOpcycles (φ.τ₂ ≫ k) ⋯
state_after: no goals
Theorem: Equiv.Perm.extendDomain_apply_image
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.extendDomain]
state_before: α' : Type u_1
β' : Type u_2
e : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
a : α'
⊢ (e.extendDomain f) ↑(f a) = ↑(f (e a))
state_after: no goals