1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.getElem?_zip_with_eq_some
File: Mathlib/Data/List/Zip.lean

tactic: induction l₁ generalizing l₂ i
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₁ : List α
l₂ : List β
z : γ
i : ℕ
⊢ (zipWith f l₁ l₂)[i]? = some z ↔ ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = some z ↔ ∃ x y, [][i]? = some x ∧ l₂[i]? = some y ∧ f x y = z

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
head✝ : α
tail✝ : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ), (zipWith f tail✝ l₂)[i]? = some z ↔ ∃ x y, tail✝[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
l₂ : List β
i : ℕ
⊢ (zipWith f (head✝ :: tail✝) l₂)[i]? = some z ↔ ∃ x y, (head✝ :: tail✝)[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z

tactic: simp
state_before: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = some z ↔ ∃ x y, [][i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
state_after: no goals

tactic: cases l₂ <;> cases i <;> simp_all
state_before: case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
head✝ : α
tail✝ : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ), (zipWith f tail✝ l₂)[i]? = some z ↔ ∃ x y, tail✝[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
l₂ : List β
i : ℕ
⊢ (zipWith f (head✝ :: tail✝) l₂)[i]? = some z ↔ ∃ x y, (head✝ :: tail✝)[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
state_after: no goals
Theorem: ProbabilityTheory.condCount_empty_meas
File: Mathlib/Probability/CondCount.lean

tactic: simp [condCount]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
⊢ condCount ∅ = 0
state_after: no goals
Theorem: gauge_ball
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rcases hr.eq_or_lt with rfl | hr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr : 0 ≤ r
x : E
⊢ gauge (ball 0 r) x = ‖x‖ / r
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
x✝ x : E
hr : 0 ≤ 0
⊢ gauge (ball 0 0) x = ‖x‖ / 0

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ gauge (ball 0 r) x = ‖x‖ / r

tactic: simp
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
x✝ x : E
hr : 0 ≤ 0
⊢ gauge (ball 0 0) x = ‖x‖ / 0
state_after: no goals

tactic: rw [← smul_unitBall_of_pos hr, gauge_smul_left, Pi.smul_apply, gauge_unit_ball, smul_eq_mul,
abs_of_nonneg hr.le, div_eq_inv_mul]
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ gauge (ball 0 r) x = ‖x‖ / r
state_after: case inr.symmetric
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ ∀ x ∈ ball 0 1, -x ∈ ball 0 1

tactic: simp_rw [mem_ball_zero_iff, norm_neg]
state_before: case inr.symmetric
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ ∀ x ∈ ball 0 1, -x ∈ ball 0 1
state_after: case inr.symmetric
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ ∀ (x : E), ‖x‖ < 1 → ‖x‖ < 1

tactic: exact fun _ => id
state_before: case inr.symmetric
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr✝ : 0 ≤ r
x : E
hr : 0 < r
⊢ ∀ (x : E), ‖x‖ < 1 → ‖x‖ < 1
state_after: no goals
Theorem: Primrec.vector_cons
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Primrec fun a => (a.1 ::ᵥ a.2).toList
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Primrec fun a => a.1 :: a.2.toList

tactic: exact list_cons.comp fst (vector_toList_iff.2 snd)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Primrec fun a => a.1 :: a.2.toList
state_after: no goals
Theorem: Cardinal.mk_ordinal_out
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [Ordinal.type_lt]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ (type ?m.118779).card = o.card
state_after: no goals
Theorem: Set.image_const_add_Ioc
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Ioc]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ioc b c = Ioc (a + b) (a + c)
state_after: no goals
Theorem: Homeomorph.locallyConnectedSpace
File: Mathlib/Topology/Homeomorph.lean

tactic: refine locallyConnectedSpace_of_connected_bases _ _ this fun _ _ hs ↦ ?_
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
⊢ LocallyConnectedSpace X
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
x✝¹ : X
x✝ : Set Y
hs : IsOpen x✝ ∧ h x✝¹ ∈ x✝ ∧ IsConnected x✝
⊢ IsPreconnected (⇑h.symm '' x✝)

tactic: exact hs.2.2.2.image _ h.symm.continuous.continuousOn
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
x✝¹ : X
x✝ : Set Y
hs : IsOpen x✝ ∧ h x✝¹ ∈ x✝ ∧ IsConnected x✝
⊢ IsPreconnected (⇑h.symm '' x✝)
state_after: no goals

tactic: rw [← h.symm_map_nhds_eq]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
x : X
⊢ (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
x : X
⊢ (map (⇑h.symm) (𝓝 (h x))).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x

tactic: exact (i.1 _).map _
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
x : X
⊢ (map (⇑h.symm) (𝓝 (h x))).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
state_after: no goals
Theorem: PowerSeries.derivative_inv'
File: Mathlib/RingTheory/PowerSeries/Derivative.lean

tactic: by_cases h : constantCoeff R f = 0
state_before: R : Type u_1
inst✝ : Field R
f : R⟦X⟧
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f
state_after: case pos
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : (constantCoeff R) f = 0
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f

case neg
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : ¬(constantCoeff R) f = 0
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f

tactic: apply Derivation.leibniz_of_mul_eq_one
state_before: case neg
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : ¬(constantCoeff R) f = 0
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f
state_after: case neg.h
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : ¬(constantCoeff R) f = 0
⊢ f⁻¹ * f = 1

tactic: exact PowerSeries.inv_mul_cancel (h := h)
state_before: case neg.h
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : ¬(constantCoeff R) f = 0
⊢ f⁻¹ * f = 1
state_after: no goals

tactic: suffices f⁻¹ = 0 by
  rw [this, pow_two, zero_mul, neg_zero, zero_mul, map_zero]
state_before: case pos
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : (constantCoeff R) f = 0
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f
state_after: case pos
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : (constantCoeff R) f = 0
⊢ f⁻¹ = 0

tactic: rwa [MvPowerSeries.inv_eq_zero]
state_before: case pos
R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : (constantCoeff R) f = 0
⊢ f⁻¹ = 0
state_after: no goals

tactic: rw [this, pow_two, zero_mul, neg_zero, zero_mul, map_zero]
state_before: R : Type u_1
inst✝ : Field R
f : R⟦X⟧
h : (constantCoeff R) f = 0
this : f⁻¹ = 0
⊢ (d⁄dX R) f⁻¹ = -f⁻¹ ^ 2 * (d⁄dX R) f
state_after: no goals
Theorem: Finset.nullMeasurableSet
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: apply Finset.measurableSet
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝ : MeasurableSingletonClass (NullMeasurableSpace α μ)
s : Finset α
⊢ NullMeasurableSet (↑s) μ
state_after: no goals
Theorem: implies_congr'
File: Mathlib/Tactic/Congr!.lean

tactic: cases h
state_before: α α' : Sort u
β β' : Sort v
h : α = α'
h' : α' → β = β'
⊢ (α → β) = (α' → β')
state_after: case refl
α : Sort u
β β' : Sort v
h' : α → β = β'
⊢ (α → β) = (α → β')

tactic: show (∀ (x : α), (fun _ => β) x) = _
state_before: case refl
α : Sort u
β β' : Sort v
h' : α → β = β'
⊢ (α → β) = (α → β')
state_after: case refl
α : Sort u
β β' : Sort v
h' : α → β = β'
⊢ ((x : α) → (fun x => β) x) = (α → β')

tactic: rw [funext h']
state_before: case refl
α : Sort u
β β' : Sort v
h' : α → β = β'
⊢ ((x : α) → (fun x => β) x) = (α → β')
state_after: no goals
Theorem: Rel.preimage_inter_codom_eq
File: Mathlib/Data/Rel.lean

tactic: rw [← dom_inv, preimage, preimage, image_inter_dom_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set β
⊢ r.preimage (s ∩ r.codom) = r.preimage s
state_after: no goals
Theorem: ciSup_const
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iSup, range_const, csSup_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a✝ b : α
hι : Nonempty ι
a : α
⊢ ⨆ x, a = a
state_after: no goals
Theorem: LinearMap.im_inner_adjoint_mul_self_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: simp only [mul_apply, adjoint_inner_right, inner_self_eq_norm_sq_to_K]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ im ⟪x, (adjoint T) (T x)⟫_𝕜 = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ im (↑‖T x‖ ^ 2) = 0

tactic: norm_cast
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ im (↑‖T x‖ ^ 2) = 0
state_after: no goals
Theorem: Subsemigroup.coe_sSup_of_directed_on
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

tactic: simp [mem_sSup_of_directed_on hS]
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ s ∈ S, ↑s
state_after: no goals
Theorem: CategoryTheory.NatTrans.isIso_app_iff_of_iso
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
F G : C ⥤ D
α : F ⟶ G
X Y : C
e : X ≅ Y
⊢ (F.mapIso e).hom ≫ (Arrow.mk (α.app Y)).hom = (Arrow.mk (α.app X)).hom ≫ (G.mapIso e).hom
state_after: no goals
Theorem: IsLocalizedModule.ringHom_ext
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [← lift_unique S f (k.comp f) map_unit j h, lift_unique]
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ j = k
state_after: case hl
R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ k ∘ₗ f = k ∘ₗ f

tactic: rfl
state_before: case hl
R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ k ∘ₗ f = k ∘ₗ f
state_after: no goals
Theorem: Basis.mk_eq_rank
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

tactic: haveI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)
state_after: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
this : Nontrivial R
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)

tactic: rw [← v.mk_range_eq_rank, Cardinal.mk_range_eq_of_injective v.injective]
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
this : Nontrivial R
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)
state_after: no goals
Theorem: Turing.reaches_eval
File: Mathlib/Computability/TuringMachine.lean

tactic: refine Part.ext fun _ ↦ ⟨fun h ↦ ?_, fun h ↦ ?_⟩
state_before: σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
⊢ eval f a = eval f b
state_after: case refine_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
⊢ x✝ ∈ eval f b

case refine_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
⊢ x✝ ∈ eval f a

tactic: have ⟨ac, c0⟩ := mem_eval.1 h
state_before: case refine_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
⊢ x✝ ∈ eval f b
state_after: case refine_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
ac : Reaches f a x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f b

tactic: exact mem_eval.2 ⟨(or_iff_left_of_imp fun cb ↦ (eval_maximal h).1 cb ▸ ReflTransGen.refl).1
  (reaches_total ab ac), c0⟩
state_before: case refine_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
ac : Reaches f a x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f b
state_after: no goals

tactic: have ⟨bc, c0⟩ := mem_eval.1 h
state_before: case refine_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
⊢ x✝ ∈ eval f a
state_after: case refine_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
bc : Reaches f b x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f a

tactic: exact mem_eval.2 ⟨ab.trans bc, c0⟩
state_before: case refine_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
bc : Reaches f b x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f a
state_after: no goals
Theorem: lipschitzOnWith_iff_norm_div_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: simp only [lipschitzOnWith_iff_dist_le_mul, dist_eq_norm_div]
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
⊢ LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x / f y‖ ≤ ↑C * ‖x / y‖
state_after: no goals
Theorem: Fin.extractNth_insertNth
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [extractNth]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
⊢ i.extractNth (i.insertNth x p) = (x, p)
state_after: no goals
Theorem: Filter.iSup_join
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_iSup, mem_join]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
f : ι → Filter (Filter α)
x : Set α
⊢ x ∈ ⨆ x, (f x).join ↔ x ∈ (⨆ x, f x).join
state_after: no goals
Theorem: LazyList.append_assoc
File: Mathlib/Data/LazyList/Basic.lean

tactic: induction' xs using LazyList.rec with _ _ _ _ ih
state_before: α : Type u_1
xs ys zs : LazyList α
⊢ (xs.append { fn := fun x => ys }).append { fn := fun x => zs } =
    xs.append { fn := fun x => ys.append { fn := fun x => zs } }
state_after: case nil
α : Type u_1
ys zs : LazyList α
⊢ (nil.append { fn := fun x => ys }).append { fn := fun x => zs } =
    nil.append { fn := fun x => ys.append { fn := fun x => zs } }

case cons
α : Type u_1
xs ys zs : LazyList α
hd✝ : α
tl✝ : Thunk (LazyList α)
tl_ih✝ : ?m.43165 tl✝
⊢ ((cons hd✝ tl✝).append { fn := fun x => ys }).append { fn := fun x => zs } =
    (cons hd✝ tl✝).append { fn := fun x => ys.append { fn := fun x => zs } }

case mk
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    ((fn✝ a).append { fn := fun x => ys }).append { fn := fun x => zs } =
      (fn✝ a).append { fn := fun x => ys.append { fn := fun x => zs } }
⊢ ?m.43165 { fn := fn✝ }

tactic: simp only [append, Thunk.get]
state_before: case nil
α : Type u_1
ys zs : LazyList α
⊢ (nil.append { fn := fun x => ys }).append { fn := fun x => zs } =
    nil.append { fn := fun x => ys.append { fn := fun x => zs } }
state_after: no goals

tactic: simpa only [append, cons.injEq, true_and]
state_before: case cons
α : Type u_1
xs ys zs : LazyList α
hd✝ : α
tl✝ : Thunk (LazyList α)
tl_ih✝ : ?m.43165 tl✝
⊢ ((cons hd✝ tl✝).append { fn := fun x => ys }).append { fn := fun x => zs } =
    (cons hd✝ tl✝).append { fn := fun x => ys.append { fn := fun x => zs } }
state_after: no goals

tactic: ext
state_before: case mk
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    ((fn✝ a).append { fn := fun x => ys }).append { fn := fun x => zs } =
      (fn✝ a).append { fn := fun x => ys.append { fn := fun x => zs } }
⊢ {
      fn := fun x =>
        { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys } }.get.append { fn := fun x => zs } } =
    { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys.append { fn := fun x => zs } } }
state_after: case mk.a
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    ((fn✝ a).append { fn := fun x => ys }).append { fn := fun x => zs } =
      (fn✝ a).append { fn := fun x => ys.append { fn := fun x => zs } }
⊢ {
        fn := fun x =>
          { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys } }.get.append { fn := fun x => zs } }.get =
    { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys.append { fn := fun x => zs } } }.get

tactic: apply ih
state_before: case mk.a
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    ((fn✝ a).append { fn := fun x => ys }).append { fn := fun x => zs } =
      (fn✝ a).append { fn := fun x => ys.append { fn := fun x => zs } }
⊢ {
        fn := fun x =>
          { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys } }.get.append { fn := fun x => zs } }.get =
    { fn := fun x => { fn := fn✝ }.get.append { fn := fun x => ys.append { fn := fun x => zs } } }.get
state_after: no goals
Theorem: List.sublists_perm_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: rw [← finRange_map_get l, sublists_map, sublists'_map]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ l.sublists ~ l.sublists'
state_after: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map (map l.get) (finRange l.length).sublists ~ map (map l.get) (finRange l.length).sublists'

tactic: apply Perm.map
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map (map l.get) (finRange l.length).sublists ~ map (map l.get) (finRange l.length).sublists'
state_after: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists ~ (finRange l.length).sublists'

tactic: apply (perm_ext_iff_of_nodup _ _).mpr
state_before: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists ~ (finRange l.length).sublists'
state_after: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (a : List (Fin l.length)), a ∈ (finRange l.length).sublists ↔ a ∈ (finRange l.length).sublists'

α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists.Nodup

α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists'.Nodup

tactic: simp
state_before: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (a : List (Fin l.length)), a ∈ (finRange l.length).sublists ↔ a ∈ (finRange l.length).sublists'
state_after: no goals

tactic: exact nodup_sublists.mpr (nodup_finRange _)
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists.Nodup
state_after: no goals

tactic: exact (nodup_sublists'.mpr (nodup_finRange _))
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists'.Nodup
state_after: no goals
Theorem: Finset.inter_right_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_right_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ∩ s₃ ↔ x✝ ∈ s₁ ∩ s₃ ∩ s₂
state_after: no goals