1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ZMod.valMinAbs_mem_Ioc
File: Mathlib/Data/ZMod/Basic.lean

tactic: simp_rw [valMinAbs_def_pos, Nat.le_div_two_iff_mul_two_le]
state_before: n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ x.valMinAbs * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ (if ↑x.val * 2 ≤ ↑n then ↑x.val else ↑x.val - ↑n) * 2 ∈ Set.Ioc (-↑n) ↑n

tactic: split_ifs with h
state_before: n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ (if ↑x.val * 2 ≤ ↑n then ↑x.val else ↑x.val - ↑n) * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: case pos
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ ↑x.val * 2 ∈ Set.Ioc (-↑n) ↑n

case neg
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ (↑x.val - ↑n) * 2 ∈ Set.Ioc (-↑n) ↑n

tactic: refine ⟨(neg_lt_zero.2 <| mod_cast NeZero.pos n).trans_le (mul_nonneg ?_ ?_), h⟩
state_before: case pos
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ ↑x.val * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: case pos.refine_1
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ 0 ≤ ↑x.val

case pos.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ 0 ≤ 2

tactic: exacts [Nat.cast_nonneg _, zero_le_two]
state_before: case pos.refine_1
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ 0 ≤ ↑x.val

case pos.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ↑x.val * 2 ≤ ↑n
⊢ 0 ≤ 2
state_after: no goals

tactic: refine ⟨?_, le_trans (mul_nonpos_of_nonpos_of_nonneg ?_ zero_le_two) <| Nat.cast_nonneg _⟩
state_before: case neg
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ (↑x.val - ↑n) * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: case neg.refine_1
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ -↑n < (↑x.val - ↑n) * 2

case neg.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ ↑x.val - ↑n ≤ 0

tactic: linarith only [h]
state_before: case neg.refine_1
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ -↑n < (↑x.val - ↑n) * 2
state_after: no goals

tactic: rw [sub_nonpos, Int.ofNat_le]
state_before: case neg.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ ↑x.val - ↑n ≤ 0
state_after: case neg.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ x.val ≤ n

tactic: exact x.val_lt.le
state_before: case neg.refine_2
n : ℕ
inst✝ : NeZero n
x : ZMod n
h : ¬↑x.val * 2 ≤ ↑n
⊢ x.val ≤ n
state_after: no goals
Theorem: IsLocalMinOn.fderivWithin_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf]
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMinOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ (fderivWithin ℝ f s a) y = 0
state_after: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMinOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y = 0

tactic: rfl
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMinOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y = 0
state_after: no goals
Theorem: Ordinal.nmul_one
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nmul]
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ a ⨳ 1 = a
state_after: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, ∀ b' < 1, a' ⨳ 1 ♯ a ⨳ b' < c ♯ a' ⨳ b'} = a

tactic: simp only [lt_one_iff_zero, forall_eq, nmul_zero, nadd_zero]
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, ∀ b' < 1, a' ⨳ 1 ♯ a ⨳ b' < c ♯ a' ⨳ b'} = a
state_after: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, a' ⨳ 1 < c} = a

tactic: convert csInf_Ici (α := Ordinal)
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, a' ⨳ 1 < c} = a
state_after: case h.e'_2.h.e'_3
a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ {c | ∀ a' < a, a' ⨳ 1 < c} = Set.Ici a

tactic: ext b
state_before: case h.e'_2.h.e'_3
a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ {c | ∀ a' < a, a' ⨳ 1 < c} = Set.Ici a
state_after: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ b ∈ {c | ∀ a' < a, a' ⨳ 1 < c} ↔ b ∈ Set.Ici a

tactic: simp only [Set.mem_setOf_eq, Set.mem_Ici]
state_before: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ b ∈ {c | ∀ a' < a, a' ⨳ 1 < c} ↔ b ∈ Set.Ici a
state_after: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ (∀ a' < a, a' ⨳ 1 < b) ↔ a ≤ b

tactic: refine ⟨fun H => le_of_forall_lt fun c hc => ?_, fun ha c hc => ?_⟩
state_before: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ (∀ a' < a, a' ⨳ 1 < b) ↔ a ≤ b
state_after: case h.e'_2.h.e'_3.h.refine_1
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
H : ∀ a' < a, a' ⨳ 1 < b
c : Ordinal.{u_1}
hc : c < a
⊢ c < b

case h.e'_2.h.e'_3.h.refine_2
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
ha : a ≤ b
c : Ordinal.{u_1}
hc : c < a
⊢ c ⨳ 1 < b

tactic: simpa only [nmul_one c] using H c hc
state_before: case h.e'_2.h.e'_3.h.refine_1
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
H : ∀ a' < a, a' ⨳ 1 < b
c : Ordinal.{u_1}
hc : c < a
⊢ c < b
state_after: no goals

tactic: simpa only [nmul_one c] using hc.trans_le ha
state_before: case h.e'_2.h.e'_3.h.refine_2
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
ha : a ≤ b
c : Ordinal.{u_1}
hc : c < a
⊢ c ⨳ 1 < b
state_after: no goals
Theorem: Finset.prod_of_isEmpty
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [eq_empty_of_isEmpty s, prod_empty]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : IsEmpty α
s : Finset α
⊢ ∏ i ∈ s, f i = 1
state_after: no goals
Theorem: PFun.lift_graph
File: Mathlib/Data/PFun.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α → β
a : α
b : β
⊢ (∃ (_ : True), f a = b) ↔ f a = b
state_after: no goals
Theorem: GeneralizedContinuedFraction.exists_rat_eq_nth_denominator
File: Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean

tactic: rcases exists_gcf_pair_rat_eq_nth_conts v n with ⟨⟨_, b⟩, nth_cont_eq⟩
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ ∃ q, (of v).denominators n = ↑q
state_after: case intro.mk
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a✝ b : ℚ
nth_cont_eq : (of v).continuants n = Pair.map Rat.cast { a := a✝, b := b }
⊢ ∃ q, (of v).denominators n = ↑q

tactic: use b
state_before: case intro.mk
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a✝ b : ℚ
nth_cont_eq : (of v).continuants n = Pair.map Rat.cast { a := a✝, b := b }
⊢ ∃ q, (of v).denominators n = ↑q
state_after: case h
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a✝ b : ℚ
nth_cont_eq : (of v).continuants n = Pair.map Rat.cast { a := a✝, b := b }
⊢ (of v).denominators n = ↑b

tactic: simp [denom_eq_conts_b, nth_cont_eq]
state_before: case h
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a✝ b : ℚ
nth_cont_eq : (of v).continuants n = Pair.map Rat.cast { a := a✝, b := b }
⊢ (of v).denominators n = ↑b
state_after: no goals
Theorem: HomologicalComplex.inr_biprodXIso_inv
File: Mathlib/Algebra/Homology/HomologicalComplexBiprod.lean

tactic: simp [biprodXIso]
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K L : HomologicalComplex C c
inst✝ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (L.X i)
i : ι
⊢ biprod.inr ≫ (K.biprodXIso L i).inv = biprod.inr.f i
state_after: no goals
Theorem: CategoryTheory.yonedaEquiv_naturality
File: Mathlib/CategoryTheory/Yoneda.lean

tactic: change (f.app (op X) ≫ F.map g.op) (𝟙 X) = f.app (op Y) (𝟙 Y ≫ g)
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ F.map g.op (yonedaEquiv f) = yonedaEquiv (yoneda.map g ≫ f)
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ (f.app { unop := X } ≫ F.map g.op) (𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)

tactic: rw [← f.naturality]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ (f.app { unop := X } ≫ F.map g.op) (𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ ((yoneda.obj X).map g.op ≫ f.app { unop := Y }) (𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)

tactic: dsimp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ ((yoneda.obj X).map g.op ≫ f.app { unop := Y }) (𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ f.app { unop := Y } (g ≫ 𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)

tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
F : Cᵒᵖ ⥤ Type v₁
f : yoneda.obj X ⟶ F
g : Y ⟶ X
⊢ f.app { unop := Y } (g ≫ 𝟙 X) = f.app { unop := Y } (𝟙 Y ≫ g)
state_after: no goals
Theorem: Num.le_iff_cmp
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cmp_swap]
state_before: α : Type u_1
m n : Num
⊢ n.cmp m = Ordering.lt ↔ m.cmp n = Ordering.gt
state_after: α : Type u_1
m n : Num
⊢ (m.cmp n).swap = Ordering.lt ↔ m.cmp n = Ordering.gt

tactic: cases cmp m n <;> decide
state_before: α : Type u_1
m n : Num
⊢ (m.cmp n).swap = Ordering.lt ↔ m.cmp n = Ordering.gt
state_after: no goals
Theorem: Cardinal.zero_eq_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: norm_cast
state_before: m : ℕ∞
⊢ 0 = ↑m ↔ m = 0
state_after: m : ℕ∞
⊢ 0 = m ↔ m = 0

tactic: apply eq_comm
state_before: m : ℕ∞
⊢ 0 = m ↔ m = 0
state_after: no goals
Theorem: eq_imp_of_iff_imp
File: Mathlib/Tactic/Congr!.lean

tactic: cases he
state_before: x y : Prop
p : x = y → Prop
h : ∀ (he : x ↔ y), p ⋯
he : x = y
⊢ p he
state_after: case refl
x : Prop
p : x = x → Prop
h : ∀ (he : x ↔ x), p ⋯
⊢ p ⋯

tactic: exact h Iff.rfl
state_before: case refl
x : Prop
p : x = x → Prop
h : ∀ (he : x ↔ x), p ⋯
⊢ p ⋯
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.trim_congr
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

tactic: simp (config := { contextual := true }) only [trim, H]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → m₁ s = m₂ s
⊢ m₁.trim = m₂.trim
state_after: no goals
Theorem: List.get_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp
state_before: n m step i : Nat
H : i < (range' n m step).length
⊢ (range' n m step).get ⟨i, H⟩ = n + step * i
state_after: no goals
Theorem: Orientation.sin_oangle_sub_left_mul_norm_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x - y) x).sin * ‖x - y‖ = ‖y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin * ‖x - y‖ = ‖y‖

tactic: exact (-o).sin_oangle_sub_right_mul_norm_of_oangle_eq_pi_div_two h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin * ‖x - y‖ = ‖y‖
state_after: no goals
Theorem: Set.image2_iUnion_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [← image_prod, prod_iUnion, image_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ image2 f s (⋃ i, t i) = ⋃ i, image2 f s (t i)
state_after: no goals
Theorem: MeasureTheory.AEEqFun.coeFn_compMeasurable
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [compMeasurable_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ ↑(compMeasurable g hg f) =ᶠ[ae μ] g ∘ ↑f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) ⋯) =ᶠ[ae μ] g ∘ ↑f

tactic: apply coeFn_mk
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) ⋯) =ᶠ[ae μ] g ∘ ↑f
state_after: no goals
Theorem: Fin.natCast_eq_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [ext_iff, Nat.dvd_iff_mod_eq_zero]
state_before: n✝ m a n : ℕ
inst✝ : NeZero n
⊢ ↑a = 0 ↔ n ∣ a
state_after: no goals
Theorem: Booleanisation.lift_lt_comp
File: Mathlib/Order/Booleanisation.lean

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

tactic: assumption
state_before: case sep
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : Disjoint a b
⊢ Disjoint a b
state_after: no goals
Theorem: CategoryTheory.regularTopology.coverPreserving
File: Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean

tactic: rw [eq_induced F]
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
⊢ CoverPreserving (regularTopology C) (regularTopology D) F
state_after: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
⊢ CoverPreserving (F.inducedTopologyOfIsCoverDense (regularTopology D)) (regularTopology D) F

tactic: apply LocallyCoverDense.inducedTopology_coverPreserving
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
⊢ CoverPreserving (F.inducedTopologyOfIsCoverDense (regularTopology D)) (regularTopology D) F
state_after: no goals
Theorem: jacobiTheta_S_smul
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

tactic: have h0 : (τ : ℂ) ≠ 0 := ne_of_apply_ne im (zero_im.symm ▸ ne_of_gt τ.2)
state_before: τ : ℍ
⊢ jacobiTheta ↑(ModularGroup.S • τ) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ
state_after: τ : ℍ
h0 : ↑τ ≠ 0
⊢ jacobiTheta ↑(ModularGroup.S • τ) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ

tactic: have h1 : (-I * τ) ^ (1 / 2 : ℂ) ≠ 0 := by
  rw [Ne, cpow_eq_zero_iff, not_and_or]
  exact Or.inl <| mul_ne_zero (neg_ne_zero.mpr I_ne_zero) h0
state_before: τ : ℍ
h0 : ↑τ ≠ 0
⊢ jacobiTheta ↑(ModularGroup.S • τ) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ
state_after: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta ↑(ModularGroup.S • τ) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ

tactic: simp_rw [UpperHalfPlane.modular_S_smul, jacobiTheta_eq_jacobiTheta₂]
state_before: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta ↑(ModularGroup.S • τ) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ
state_after: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta₂ 0 ↑(UpperHalfPlane.mk (-↑τ)⁻¹ ⋯) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta₂ 0 ↑τ

tactic: conv_rhs => erw [← ofReal_zero, jacobiTheta₂_functional_equation 0 τ]
state_before: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta₂ 0 ↑(UpperHalfPlane.mk (-↑τ)⁻¹ ⋯) = (-I * ↑τ) ^ (1 / 2) * jacobiTheta₂ 0 ↑τ
state_after: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta₂ 0 ↑(UpperHalfPlane.mk (-↑τ)⁻¹ ⋯) =
    (-I * ↑τ) ^ (1 / 2) * (1 / (-I * ↑τ) ^ (1 / 2) * cexp (-↑π * I * 0 ^ 2 / ↑τ) * jacobiTheta₂ (0 / ↑τ) (-1 / ↑τ))

tactic: rw [zero_pow two_ne_zero, mul_zero, zero_div, Complex.exp_zero, mul_one, ← mul_assoc, mul_one_div,
  div_self h1, one_mul, UpperHalfPlane.coe_mk, inv_neg, neg_div, one_div]
state_before: τ : ℍ
h0 : ↑τ ≠ 0
h1 : (-I * ↑τ) ^ (1 / 2) ≠ 0
⊢ jacobiTheta₂ 0 ↑(UpperHalfPlane.mk (-↑τ)⁻¹ ⋯) =
    (-I * ↑τ) ^ (1 / 2) * (1 / (-I * ↑τ) ^ (1 / 2) * cexp (-↑π * I * 0 ^ 2 / ↑τ) * jacobiTheta₂ (0 / ↑τ) (-1 / ↑τ))
state_after: no goals

tactic: rw [Ne, cpow_eq_zero_iff, not_and_or]
state_before: τ : ℍ
h0 : ↑τ ≠ 0
⊢ (-I * ↑τ) ^ (1 / 2) ≠ 0
state_after: τ : ℍ
h0 : ↑τ ≠ 0
⊢ ¬-I * ↑τ = 0 ∨ ¬1 / 2 ≠ 0

tactic: exact Or.inl <| mul_ne_zero (neg_ne_zero.mpr I_ne_zero) h0
state_before: τ : ℍ
h0 : ↑τ ≠ 0
⊢ ¬-I * ↑τ = 0 ∨ ¬1 / 2 ≠ 0
state_after: no goals
Theorem: sbtw_const_vadd_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, Sbtw, wbtw_const_vadd_iff, (AddAction.injective v).ne_iff,
  (AddAction.injective v).ne_iff]
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'
x y z : P
v : V
⊢ Sbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Sbtw R x y z
state_after: no goals
Theorem: wbtw_comm
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Wbtw, Wbtw, affineSegment_comm]
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'
x y z : P
⊢ Wbtw R x y z ↔ Wbtw R z y x
state_after: no goals
Theorem: Nat.succ_div_of_dvd
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [succ_div, if_pos hba]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : b ∣ a + 1
⊢ (a + 1) / b = a / b + 1
state_after: no goals
Theorem: Orientation.sin_oangle_sub_left_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x - y) x).sin = ‖y‖ / ‖x - y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin = ‖y‖ / ‖x - y‖

tactic: exact (-o).sin_oangle_sub_right_of_oangle_eq_pi_div_two h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin = ‖y‖ / ‖x - y‖
state_after: no goals
Theorem: Batteries.RBNode.balance1_All
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold balance1
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p (l.balance1 v r) ↔ p v ∧ All p l ∧ All p r
state_after: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r

tactic: split <;> simp [and_assoc, and_left_comm]
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r
state_after: no goals
Theorem: MeasureTheory.StronglyMeasurable.finStronglyMeasurable
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : Zero β
m0 : MeasurableSpace α
hf : StronglyMeasurable f
μ : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ x ∈ univᶜ, f x = 0
state_after: no goals

tactic: rwa [Measure.restrict_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : Zero β
m0 : MeasurableSpace α
hf : StronglyMeasurable f
μ : Measure α
inst✝ : SigmaFinite μ
⊢ SigmaFinite (μ.restrict univ)
state_after: no goals
Theorem: CliffordAlgebra.EquivEven.e0_mul_v_mul_e0
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

tactic: rw [← neg_v_mul_e0, ← neg_mul, mul_assoc, e0_mul_e0, mul_neg_one, neg_neg]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ e0 Q * (v Q) m * e0 Q = (v Q) m
state_after: no goals
Theorem: Real.concaveOn_rpow
File: Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean

tactic: rcases eq_or_lt_of_le hp₀ with (rfl | hp₀)
state_before: p : ℝ
hp₀ : 0 ≤ p
hp₁ : p ≤ 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ p
state_after: case inl
hp₀ : 0 ≤ 0
hp₁ : 0 ≤ 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ 0

case inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁ : p ≤ 1
hp₀ : 0 < p
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ p

tactic: rcases eq_or_lt_of_le hp₁ with (rfl | hp₁)
state_before: case inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁ : p ≤ 1
hp₀ : 0 < p
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ p
state_after: case inr.inl
hp₀✝ : 0 ≤ 1
hp₁ : 1 ≤ 1
hp₀ : 0 < 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ 1

case inr.inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁✝ : p ≤ 1
hp₀ : 0 < p
hp₁ : p < 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ p

tactic: exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn
state_before: case inr.inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁✝ : p ≤ 1
hp₀ : 0 < p
hp₁ : p < 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ p
state_after: no goals

tactic: simpa only [rpow_zero] using concaveOn_const (c := 1) (convex_Ici _)
state_before: case inl
hp₀ : 0 ≤ 0
hp₁ : 0 ≤ 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ 0
state_after: no goals

tactic: simpa only [rpow_one] using concaveOn_id (convex_Ici _)
state_before: case inr.inl
hp₀✝ : 0 ≤ 1
hp₁ : 1 ≤ 1
hp₀ : 0 < 1
⊢ ConcaveOn ℝ (Ici 0) fun x => x ^ 1
state_after: no goals