1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ENNReal.continuousOn_sub
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [ContinuousOn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ContinuousOn (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ∀ x ∈ {p | p ≠ (⊤, ⊤)}, ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} x

tactic: rintro ⟨x, y⟩ hp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ∀ x ∈ {p | p ≠ (⊤, ⊤)}, ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} x
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
hp : (x, y) ∈ {p | p ≠ (⊤, ⊤)}
⊢ ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} (x, y)

tactic: simp only [Ne, Set.mem_setOf_eq, Prod.mk.inj_iff] at hp
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
hp : (x, y) ∈ {p | p ≠ (⊤, ⊤)}
⊢ ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} (x, y)
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
hp : ¬(x = ⊤ ∧ y = ⊤)
⊢ ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} (x, y)

tactic: exact tendsto_nhdsWithin_of_tendsto_nhds (tendsto_sub (not_and_or.mp hp))
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
hp : ¬(x = ⊤ ∧ y = ⊤)
⊢ ContinuousWithinAt (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} (x, y)
state_after: no goals
Theorem: cfc_zero
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: by_cases ha : p a
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
⊢ cfc 0 a = 0
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : p a
⊢ cfc 0 a = 0

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : ¬p a
⊢ cfc 0 a = 0

tactic: exact cfc_apply (0 : R → R) a ▸ map_zero (cfcHom ha)
state_before: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : p a
⊢ cfc 0 a = 0
state_after: no goals

tactic: rw [cfc_apply_of_not_predicate a ha]
state_before: case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : ¬p a
⊢ cfc 0 a = 0
state_after: no goals
Theorem: Isometry.preimage_perpBisector
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

tactic: ext x
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
V' : Type u_3
P' : Type u_4
inst✝³ : NormedAddCommGroup V'
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : MetricSpace P'
inst✝ : NormedAddTorsor V' P'
f : P → P'
h : Isometry f
p₁ p₂ : P
⊢ f ⁻¹' ↑(perpBisector (f p₁) (f p₂)) = ↑(perpBisector p₁ p₂)
state_after: case h
V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
V' : Type u_3
P' : Type u_4
inst✝³ : NormedAddCommGroup V'
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : MetricSpace P'
inst✝ : NormedAddTorsor V' P'
f : P → P'
h : Isometry f
p₁ p₂ x : P
⊢ x ∈ f ⁻¹' ↑(perpBisector (f p₁) (f p₂)) ↔ x ∈ ↑(perpBisector p₁ p₂)

tactic: simp [mem_perpBisector_iff_dist_eq, h.dist_eq]
state_before: case h
V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
V' : Type u_3
P' : Type u_4
inst✝³ : NormedAddCommGroup V'
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : MetricSpace P'
inst✝ : NormedAddTorsor V' P'
f : P → P'
h : Isometry f
p₁ p₂ x : P
⊢ x ∈ f ⁻¹' ↑(perpBisector (f p₁) (f p₂)) ↔ x ∈ ↑(perpBisector p₁ p₂)
state_after: no goals
Theorem: Set.iUnion_Ioo_right
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : Preorder α
a✝ b c : α
inst✝ : NoMaxOrder α
a : α
⊢ ⋃ b, Ioo a b = Ioi a
state_after: no goals
Theorem: rank_eq_of_equiv_equiv
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

tactic: simpa only [lift_id] using lift_rank_eq_of_equiv_equiv i j hi hc
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : ZeroHom R R'
j : M ≃+ M₁
hi : Bijective ⇑i
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
⊢ Module.rank R M = Module.rank R' M₁
state_after: no goals
Theorem: IsPathConnected.isConnected
File: Mathlib/Topology/Connected/PathConnected.lean

tactic: rw [isConnected_iff_connectedSpace]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ IsConnected F
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ ConnectedSpace ↑F

tactic: rw [isPathConnected_iff_pathConnectedSpace] at hF
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ ConnectedSpace ↑F
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : PathConnectedSpace ↑F
⊢ ConnectedSpace ↑F

tactic: exact @PathConnectedSpace.connectedSpace _ _ hF
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : PathConnectedSpace ↑F
⊢ ConnectedSpace ↑F
state_after: no goals
Theorem: tsub_pos_iff_not_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [pos_iff_ne_zero, Ne, tsub_eq_zero_iff_le]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ 0 < a - b ↔ ¬a ≤ b
state_after: no goals
Theorem: IsAdjoinRoot.aequiv_trans
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: ext z
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
h'' : IsAdjoinRoot U f
⊢ (h.aequiv h').trans (h'.aequiv h'') = h.aequiv h''
state_after: case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
h'' : IsAdjoinRoot U f
z : S
⊢ ((h.aequiv h').trans (h'.aequiv h'')) z = (h.aequiv h'') z

tactic: exact h.aequiv_aequiv h' h'' z
state_before: case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
h'' : IsAdjoinRoot U f
z : S
⊢ ((h.aequiv h').trans (h'.aequiv h'')) z = (h.aequiv h'') z
state_after: no goals
Theorem: abs_circleMap_zero
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [circleMap]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
R θ : ℝ
⊢ Complex.abs (circleMap 0 R θ) = |R|
state_after: no goals
Theorem: hasStrictDerivAt_exp_of_mem_ball
File: Mathlib/Analysis/SpecialFunctions/Exponential.lean

tactic: simpa using (hasStrictFDerivAt_exp_of_mem_ball hx).hasStrictDerivAt
state_before: 𝕂 : Type u_1
inst✝² : NontriviallyNormedField 𝕂
inst✝¹ : CompleteSpace 𝕂
inst✝ : CharZero 𝕂
x : 𝕂
hx : x ∈ EMetric.ball 0 (expSeries 𝕂 𝕂).radius
⊢ HasStrictDerivAt (exp 𝕂) (exp 𝕂 x) x
state_after: no goals
Theorem: Rat.divInt_div_divInt
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [div_def, inv_divInt, divInt_mul_divInt']
state_before: q : ℚ
n₁ d₁ n₂ d₂ : ℤ
⊢ n₁ /. d₁ / (n₂ /. d₂) = n₁ * d₂ /. (d₁ * n₂)
state_after: no goals
Theorem: MvPolynomial.vars_sub_of_disjoint
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

tactic: rw [← vars_neg q] at hpq
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
hpq : Disjoint p.vars q.vars
⊢ (p - q).vars = p.vars ∪ q.vars
state_after: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
hpq : Disjoint p.vars (-q).vars
⊢ (p - q).vars = p.vars ∪ q.vars

tactic: convert vars_add_of_disjoint hpq using 2 <;> simp [sub_eq_add_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
hpq : Disjoint p.vars (-q).vars
⊢ (p - q).vars = p.vars ∪ q.vars
state_after: no goals
Theorem: Nat.pow_le_iff_le_log
File: Mathlib/Data/Nat/Log.lean

tactic: induction' y using Nat.strong_induction_on with y ih generalizing x
state_before: b : ℕ
hb : 1 < b
x y : ℕ
hy : y ≠ 0
⊢ b ^ x ≤ y ↔ x ≤ log b y
state_after: case h
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
x : ℕ
hy : y ≠ 0
⊢ b ^ x ≤ y ↔ x ≤ log b y

tactic: dsimp
state_before: case h.zero
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
⊢ b ^ 0 ≤ y ↔ 0 ≤ log b y
state_after: case h.zero
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
⊢ 1 ≤ y ↔ 0 ≤ log b y

tactic: omega
state_before: case h.zero
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
⊢ 1 ≤ y ↔ 0 ≤ log b y
state_after: no goals

tactic: rw [log]
state_before: case h.succ
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ log b y
state_after: case h.succ
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ if h : b ≤ y ∧ 1 < b then log b (y / b) + 1 else 0

tactic: split_ifs with h
state_before: case h.succ
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ if h : b ≤ y ∧ 1 < b then log b (y / b) + 1 else 0
state_after: case pos
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ log b (y / b) + 1

case neg
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : ¬(b ≤ y ∧ 1 < b)
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ 0

tactic: have b_pos : 0 < b := lt_of_succ_lt hb
state_before: case pos
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ log b (y / b) + 1
state_after: case pos
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
b_pos : 0 < b
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ log b (y / b) + 1

tactic: rw [Nat.add_le_add_iff_right, ← ih (y / b) (div_lt_self
  (Nat.pos_iff_ne_zero.2 hy) hb) (Nat.div_pos h.1 b_pos).ne', le_div_iff_mul_le b_pos,
  pow_succ', Nat.mul_comm]
state_before: case pos
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
b_pos : 0 < b
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ log b (y / b) + 1
state_after: no goals

tactic: exact iff_of_false (fun hby => h ⟨(le_self_pow x.succ_ne_zero _).trans hby, hb⟩)
  (not_succ_le_zero _)
state_before: case neg
b : ℕ
hb : 1 < b
y : ℕ
ih : ∀ m < y, ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : ¬(b ≤ y ∧ 1 < b)
⊢ b ^ (x + 1) ≤ y ↔ x + 1 ≤ 0
state_after: no goals
Theorem: WithTop.mul_def
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: cases a <;> cases b <;> aesop
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
⊢ a * b = if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b
state_after: no goals
Theorem: PartialEquiv.eq_symm_apply
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: rw [← e.right_inv hy, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : x = ↑e.symm y
⊢ ↑e x = y
state_after: no goals

tactic: rw [← e.left_inv hx, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : ↑e x = y
⊢ x = ↑e.symm y
state_after: no goals
Theorem: ZMod.cast_cast_zmod_of_le
File: Mathlib/Data/ZMod/Basic.lean

tactic: have : NeZero n := ⟨((Nat.zero_lt_of_ne_zero hm.out).trans_le h).ne'⟩
state_before: m n : ℕ
hm : NeZero m
h : m ≤ n
a : ZMod m
⊢ a.cast.cast = a
state_after: m n : ℕ
hm : NeZero m
h : m ≤ n
a : ZMod m
this : NeZero n
⊢ a.cast.cast = a

tactic: rw [cast_eq_val, val_cast_eq_val_of_lt (a.val_lt.trans_le h), natCast_zmod_val]
state_before: m n : ℕ
hm : NeZero m
h : m ≤ n
a : ZMod m
this : NeZero n
⊢ a.cast.cast = a
state_after: no goals
Theorem: MeasureTheory.IsStoppingTime.measurableSet_inter_le_const_iff
File: Mathlib/Probability/Process/Stopping.lean

tactic: rw [IsStoppingTime.measurableSet_min_iff hτ (isStoppingTime_const _ i),
  IsStoppingTime.measurableSpace_const, IsStoppingTime.measurableSet]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
⊢ MeasurableSet (s ∩ {ω | τ ω ≤ i}) ↔ MeasurableSet (s ∩ {ω | τ ω ≤ i})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
⊢ (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})) ↔
    (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})) ∧ MeasurableSet (s ∩ {ω | τ ω ≤ i})

tactic: refine ⟨fun h => ⟨h, ?_⟩, fun h j => h.1 j⟩
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
⊢ (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})) ↔
    (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})) ∧ MeasurableSet (s ∩ {ω | τ ω ≤ i})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
h : ∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})
⊢ MeasurableSet (s ∩ {ω | τ ω ≤ i})

tactic: specialize h i
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
h : ∀ (i_1 : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i_1})
⊢ MeasurableSet (s ∩ {ω | τ ω ≤ i})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
h : MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i})
⊢ MeasurableSet (s ∩ {ω | τ ω ≤ i})

tactic: rwa [Set.inter_assoc, Set.inter_self] at h
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
h : MeasurableSet (s ∩ {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ i})
⊢ MeasurableSet (s ∩ {ω | τ ω ≤ i})
state_after: no goals
Theorem: Int.fract_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [fract]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x : ℤ
⊢ fract x = 0 x
state_after: no goals
Theorem: mem_ball_iff_norm''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_ball, dist_eq_norm_div]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ ball a r ↔ ‖b / a‖ < r
state_after: no goals
Theorem: MvPolynomial.IsHomogeneous.C_mul
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: simpa only [zero_add] using (isHomogeneous_C _ _).mul 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 : ℕ
hφ : φ.IsHomogeneous m
r : R
⊢ (C r * φ).IsHomogeneous m
state_after: no goals
Theorem: bihimp_bihimp_bihimp_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [bihimp_assoc, bihimp_left_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ b ⇔ (c ⇔ d) = a ⇔ c ⇔ (b ⇔ d)
state_after: no goals
Theorem: Matrix.det_eq_elem_of_subsingleton
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: have := uniqueOfSubsingleton k
state_before: m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
⊢ A.det = A k k
state_after: m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
this : Unique n
⊢ A.det = A k k

tactic: convert det_unique A
state_before: m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
this : Unique n
⊢ A.det = A k k
state_after: no goals
Theorem: TopCat.of_homeoOfIso
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: dsimp [homeoOfIso, isoOfHomeo]
state_before: X Y : TopCat
f : X ≅ Y
⊢ isoOfHomeo (homeoOfIso f) = f
state_after: X Y : TopCat
f : X ≅ Y
⊢ {
      hom :=
        { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
            continuous_invFun := ⋯ }.toContinuousMap,
      inv :=
        { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
              continuous_invFun := ⋯ }.symm.toContinuousMap,
      hom_inv_id := ⋯, inv_hom_id := ⋯ } =
    f

tactic: ext
state_before: X Y : TopCat
f : X ≅ Y
⊢ {
      hom :=
        { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
            continuous_invFun := ⋯ }.toContinuousMap,
      inv :=
        { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
              continuous_invFun := ⋯ }.symm.toContinuousMap,
      hom_inv_id := ⋯, inv_hom_id := ⋯ } =
    f
state_after: case w.w
X Y : TopCat
f : X ≅ Y
x✝ : (forget TopCat).obj X
⊢ {
          hom :=
            { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
                continuous_invFun := ⋯ }.toContinuousMap,
          inv :=
            { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
                  continuous_invFun := ⋯ }.symm.toContinuousMap,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
      x✝ =
    f.hom x✝

tactic: rfl
state_before: case w.w
X Y : TopCat
f : X ≅ Y
x✝ : (forget TopCat).obj X
⊢ {
          hom :=
            { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
                continuous_invFun := ⋯ }.toContinuousMap,
          inv :=
            { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
                  continuous_invFun := ⋯ }.symm.toContinuousMap,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
      x✝ =
    f.hom x✝
state_after: no goals