1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.HasBasis.uniformContinuousOn_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp_rw [Prod.forall, Set.inter_comm (s _), forall_mem_comm, mem_inter_iff, mem_prod, and_imp]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
ι' : Sort u_2
inst✝ : UniformSpace β
p : ι → Prop
s : ι → Set (α × α)
ha : (𝓤 α).HasBasis p s
q : ι' → Prop
t : ι' → Set (β × β)
hb : (𝓤 β).HasBasis q t
f : α → β
S : Set α
⊢ (∀ (ib : ι'), q ib → ∃ ia, p ia ∧ ∀ x ∈ s ia ∩ S ×ˢ S, (f x.1, f x.2) ∈ t ib) ↔
    ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ x ∈ S, ∀ y ∈ S, (x, y) ∈ s j → (f x, f y) ∈ t i
state_after: no goals
Theorem: List.rotate_eq_drop_append_take
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate n = drop n l ++ take n l
state_after: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate' n = drop n l ++ take n l

tactic: exact rotate'_eq_drop_append_take
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate' n = drop n l ++ take n l
state_after: no goals
Theorem: UniformSpace.ring_sep_quot
File: Mathlib/Topology/Algebra/UniformRing.lean

tactic: rw [SeparationQuotient, @inseparableSetoid_ring α r]
state_before: α✝ : Type u_1
α : Type u
r : CommRing α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalRing α
⊢ SeparationQuotient α = (α ⧸ ⊥.closure)
state_after: α✝ : Type u_1
α : Type u
r : CommRing α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalRing α
⊢ Quotient (Submodule.quotientRel ⊥.closure) = (α ⧸ ⊥.closure)

tactic: rfl
state_before: α✝ : Type u_1
α : Type u
r : CommRing α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalRing α
⊢ Quotient (Submodule.quotientRel ⊥.closure) = (α ⧸ ⊥.closure)
state_after: no goals
Theorem: WType.cardinal_mk_le_of_le'
File: Mathlib/Data/W/Cardinal.lean

tactic: induction' κ using Cardinal.inductionOn with γ
state_before: α : Type u
β : α → Type v
κ : Cardinal.{max u v}
hκ : (sum fun a => κ ^ lift.{u, v} #(β a)) ≤ κ
⊢ #(WType β) ≤ κ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{u, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ

tactic: simp_rw [← lift_umax.{v, u}] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{u, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ

tactic: nth_rewrite 1 [← lift_id'.{v, u} #γ] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => lift.{v, max v u} #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ

tactic: simp_rw [← mk_arrow, ← mk_sigma, le_def] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => lift.{v, max v u} #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : Nonempty ((i : α) × (β i → γ) ↪ γ)
⊢ #(WType β) ≤ #γ

tactic: cases' hκ with hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : Nonempty ((i : α) × (β i → γ) ↪ γ)
⊢ #(WType β) ≤ #γ
state_after: case h.intro
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (i : α) × (β i → γ) ↪ γ
⊢ #(WType β) ≤ #γ

tactic: exact Cardinal.mk_le_of_injective (elim_injective _ hκ.1 hκ.2)
state_before: case h.intro
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (i : α) × (β i → γ) ↪ γ
⊢ #(WType β) ≤ #γ
state_after: no goals
Theorem: Hyperreal.infinite_of_infinitesimal_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: cases' lt_or_gt_of_ne h0 with hn hp
state_before: x : ℝ*
h0 : x ≠ 0
hi : x⁻¹.Infinitesimal
⊢ x.Infinite
state_after: case inl
x : ℝ*
h0 : x ≠ 0
hi : x⁻¹.Infinitesimal
hn : x < 0
⊢ x.Infinite

case inr
x : ℝ*
h0 : x ≠ 0
hi : x⁻¹.Infinitesimal
hp : x > 0
⊢ x.Infinite

tactic: exact Or.inr (infiniteNeg_iff_infinitesimal_inv_neg.mpr ⟨hi, inv_lt_zero.mpr hn⟩)
state_before: case inl
x : ℝ*
h0 : x ≠ 0
hi : x⁻¹.Infinitesimal
hn : x < 0
⊢ x.Infinite
state_after: no goals

tactic: exact Or.inl (infinitePos_iff_infinitesimal_inv_pos.mpr ⟨hi, inv_pos.mpr hp⟩)
state_before: case inr
x : ℝ*
h0 : x ≠ 0
hi : x⁻¹.Infinitesimal
hp : x > 0
⊢ x.Infinite
state_after: no goals
Theorem: Set.isUnit_iff
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: constructor
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ IsUnit s → ∃ a, s = {a} ∧ IsUnit a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ (∃ a, s = {a} ∧ IsUnit a) → IsUnit s

tactic: rintro ⟨u, rfl⟩
state_before: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ IsUnit s → ∃ a, s = {a} ∧ IsUnit a
state_after: case mp.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
⊢ ∃ a, ↑u = {a} ∧ IsUnit a

tactic: obtain ⟨a, b, ha, hb, h⟩ := Set.mul_eq_one_iff.1 u.mul_inv
state_before: case mp.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
⊢ ∃ a, ↑u = {a} ∧ IsUnit a
state_after: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ ∃ a, ↑u = {a} ∧ IsUnit a

tactic: refine ⟨a, ha, ⟨a, b, h, singleton_injective ?_⟩, rfl⟩
state_before: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ ∃ a, ↑u = {a} ∧ IsUnit a
state_after: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ {b * a} = {1}

tactic: rw [← singleton_mul_singleton, ← ha, ← hb]
state_before: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ {b * a} = {1}
state_after: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ ↑u⁻¹ * ↑u = {1}

tactic: exact u.inv_mul
state_before: case mp.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
u : (Set α)ˣ
a b : α
ha : ↑u = {a}
hb : ↑u⁻¹ = {b}
h : a * b = 1
⊢ ↑u⁻¹ * ↑u = {1}
state_after: no goals

tactic: rintro ⟨a, rfl, ha⟩
state_before: case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ (∃ a, s = {a} ∧ IsUnit a) → IsUnit s
state_after: case mpr.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
a : α
ha : IsUnit a
⊢ IsUnit {a}

tactic: exact ha.set
state_before: case mpr.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
t : Set α
a : α
ha : IsUnit a
⊢ IsUnit {a}
state_after: no goals
Theorem: Set.SurjOn.invOn_invFunOn
File: Mathlib/Data/Set/Function.lean

tactic: refine ⟨?_, h.rightInvOn_invFunOn⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ InvOn (invFunOn f s) f (invFunOn f s '' t) t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ LeftInvOn (invFunOn f s) f (invFunOn f s '' t)

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ LeftInvOn (invFunOn f s) f (invFunOn f s '' t)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ invFunOn f s (f (invFunOn f s y)) = invFunOn f s y

tactic: rw [h.rightInvOn_invFunOn hy]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ invFunOn f s (f (invFunOn f s y)) = invFunOn f s y
state_after: no goals
Theorem: Finset.max'_eq_sorted_last
File: Mathlib/Data/Finset/Sort.lean

tactic: simpa using Nat.sub_lt (card_pos.mpr h) Nat.zero_lt_one
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ (sort (fun x x_1 => x ≤ x_1) s).length - 1 < (sort (fun x x_1 => x ≤ x_1) s).length
state_after: no goals
Theorem: Finset.sigma_nonempty
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp [Finset.Nonempty]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ (s.sigma t).Nonempty ↔ ∃ i ∈ s, (t i).Nonempty
state_after: no goals
Theorem: npow_mul_comm
File: Mathlib/Algebra/Group/NatPowAssoc.lean

tactic: simp only [← npow_add, add_comm]
state_before: M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
m n : ℕ
x : M
⊢ x ^ m * x ^ n = x ^ n * x ^ m
state_after: no goals
Theorem: PowerSeries.rescale_rescale
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
⊢ (rescale b) ((rescale a) f) = (rescale (a * b)) f
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ (coeff R n) ((rescale b) ((rescale a) f)) = (coeff R n) ((rescale (a * b)) f)

tactic: simp_rw [coeff_rescale]
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ (coeff R n) ((rescale b) ((rescale a) f)) = (coeff R n) ((rescale (a * b)) f)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ b ^ n * (a ^ n * (coeff R n) f) = (a * b) ^ n * (coeff R n) f

tactic: rw [mul_pow, mul_comm _ (b ^ n), mul_assoc]
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ b ^ n * (a ^ n * (coeff R n) f) = (a * b) ^ n * (coeff R n) f
state_after: no goals
Theorem: ContinuousLinearMap.isPositive_iff_complex
File: Mathlib/Analysis/InnerProductSpace/Positive.lean

tactic: simp_rw [IsPositive, forall_and, isSelfAdjoint_iff_isSymmetric,
  LinearMap.isSymmetric_iff_inner_map_self_real, conj_eq_iff_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : CompleteSpace E
inst✝³ : CompleteSpace F
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : InnerProductSpace ℂ E'
inst✝ : CompleteSpace E'
T : E' →L[ℂ] E'
⊢ T.IsPositive ↔ ∀ (x : E'), ↑(re ⟪T x, x⟫_ℂ) = ⟪T x, x⟫_ℂ ∧ 0 ≤ re ⟪T x, x⟫_ℂ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : CompleteSpace E
inst✝³ : CompleteSpace F
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : InnerProductSpace ℂ E'
inst✝ : CompleteSpace E'
T : E' →L[ℂ] E'
⊢ ((∀ (v : E'), ↑(re ⟪↑T v, v⟫_ℂ) = ⟪↑T v, v⟫_ℂ) ∧ ∀ (x : E'), 0 ≤ T.reApplyInnerSelf x) ↔
    (∀ (x : E'), ↑(re ⟪T x, x⟫_ℂ) = ⟪T x, x⟫_ℂ) ∧ ∀ (x : E'), 0 ≤ re ⟪T x, x⟫_ℂ

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : CompleteSpace E
inst✝³ : CompleteSpace F
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : InnerProductSpace ℂ E'
inst✝ : CompleteSpace E'
T : E' →L[ℂ] E'
⊢ ((∀ (v : E'), ↑(re ⟪↑T v, v⟫_ℂ) = ⟪↑T v, v⟫_ℂ) ∧ ∀ (x : E'), 0 ≤ T.reApplyInnerSelf x) ↔
    (∀ (x : E'), ↑(re ⟪T x, x⟫_ℂ) = ⟪T x, x⟫_ℂ) ∧ ∀ (x : E'), 0 ≤ re ⟪T x, x⟫_ℂ
state_after: no goals
Theorem: ciSup_div
File: Mathlib/Algebra/Bounds.lean

tactic: simp only [div_eq_mul_inv, ciSup_mul hf]
state_before: ι : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : ConditionallyCompleteLattice G
inst✝¹ : CovariantClass G G (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : Nonempty ι
f : ι → G
hf : BddAbove (range f)
a : G
⊢ (⨆ i, f i) / a = ⨆ i, f i / a
state_after: no goals
Theorem: Subtype.exists_set_subtype
File: Mathlib/Data/Set/Image.lean

tactic: rw [← exists_subset_range_and_iff, range_coe]
state_before: α : Type u_1
t : Set α
p : Set α → Prop
⊢ (∃ s, p (val '' s)) ↔ ∃ s ⊆ t, p s
state_after: no goals
Theorem: CliffordAlgebra.map_comp_map
File: Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean

tactic: ext m
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
M₁ : Type u_4
M₂ : Type u_5
M₃ : Type u_6
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R M₃
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Q₃ : QuadraticForm R M₃
f : Q₂ →qᵢ Q₃
g : Q₁ →qᵢ Q₂
⊢ (map f).comp (map g) = map (f.comp g)
state_after: case a.h
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
M₁ : Type u_4
M₂ : Type u_5
M₃ : Type u_6
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R M₃
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Q₃ : QuadraticForm R M₃
f : Q₂ →qᵢ Q₃
g : Q₁ →qᵢ Q₂
m : M₁
⊢ (((map f).comp (map g)).toLinearMap ∘ₗ ι Q₁) m = ((map (f.comp g)).toLinearMap ∘ₗ ι Q₁) m

tactic: dsimp only [LinearMap.comp_apply, AlgHom.comp_apply, AlgHom.toLinearMap_apply, AlgHom.id_apply]
state_before: case a.h
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
M₁ : Type u_4
M₂ : Type u_5
M₃ : Type u_6
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R M₃
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Q₃ : QuadraticForm R M₃
f : Q₂ →qᵢ Q₃
g : Q₁ →qᵢ Q₂
m : M₁
⊢ (((map f).comp (map g)).toLinearMap ∘ₗ ι Q₁) m = ((map (f.comp g)).toLinearMap ∘ₗ ι Q₁) m
state_after: case a.h
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
M₁ : Type u_4
M₂ : Type u_5
M₃ : Type u_6
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R M₃
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Q₃ : QuadraticForm R M₃
f : Q₂ →qᵢ Q₃
g : Q₁ →qᵢ Q₂
m : M₁
⊢ (map f) ((map g) ((ι Q₁) m)) = (map (f.comp g)) ((ι Q₁) m)

tactic: rw [map_apply_ι, map_apply_ι, map_apply_ι, QuadraticForm.Isometry.comp_apply]
state_before: case a.h
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
M₁ : Type u_4
M₂ : Type u_5
M₃ : Type u_6
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R M₃
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Q₃ : QuadraticForm R M₃
f : Q₂ →qᵢ Q₃
g : Q₁ →qᵢ Q₂
m : M₁
⊢ (map f) ((map g) ((ι Q₁) m)) = (map (f.comp g)) ((ι Q₁) m)
state_after: no goals
Theorem: Set.preimage_singleton_true
File: Mathlib/Data/Set/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
p : α → Prop
⊢ p ⁻¹' {True} = {a | p a}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
p : α → Prop
x✝ : α
⊢ x✝ ∈ p ⁻¹' {True} ↔ x✝ ∈ {a | p a}

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
p : α → Prop
x✝ : α
⊢ x✝ ∈ p ⁻¹' {True} ↔ x✝ ∈ {a | p a}
state_after: no goals
Theorem: Polynomial.hermite_eq_iterate
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

tactic: induction' n with n ih
state_before: n : ℕ
⊢ hermite n = (fun p => X * p - derivative p)^[n] 1
state_after: case zero

⊢ hermite 0 = (fun p => X * p - derivative p)^[0] 1

case succ
n : ℕ
ih : hermite n = (fun p => X * p - derivative p)^[n] 1
⊢ hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1

tactic: rfl
state_before: case zero

⊢ hermite 0 = (fun p => X * p - derivative p)^[0] 1
state_after: no goals

tactic: rw [Function.iterate_succ_apply', ← ih, hermite_succ]
state_before: case succ
n : ℕ
ih : hermite n = (fun p => X * p - derivative p)^[n] 1
⊢ hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1
state_after: no goals
Theorem: Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h
state_before: θ ψ : Angle
h : 2 • θ + 2 • ψ = ↑π
⊢ |θ.cos| = |ψ.sin|
state_after: θ ψ : Angle
h : θ = ↑(π / 2) - ψ ∨ θ = ↑(π / 2) - ψ + ↑π
⊢ |θ.cos| = |ψ.sin|

tactic: rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
state_before: θ ψ : Angle
h : θ = ↑(π / 2) - ψ ∨ θ = ↑(π / 2) - ψ + ↑π
⊢ |θ.cos| = |ψ.sin|
state_after: no goals
Theorem: Set.image_inter_on
File: Mathlib/Data/Set/Image.lean

tactic: simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
h : ∀ x ∈ t, ∀ y ∈ s, f x = f y → x = y
b : β
x✝ : b ∈ f '' s ∩ f '' t
a₁ : α
ha₁ : a₁ ∈ s
h₁ : f a₁ = b
a₂ : α
ha₂ : a₂ ∈ t
h₂ : f a₂ = b
⊢ f a₂ = f a₁
state_after: no goals
Theorem: Quiver.Path.cast_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Path.cast_eq_cast]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ HEq (cast hu hv p) p
state_after: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ HEq (_root_.cast ⋯ p) p

tactic: exact _root_.cast_heq _ _
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ HEq (_root_.cast ⋯ p) p
state_after: no goals
Theorem: MeasureTheory.AEEqFun.coeFn_comp₂Measurable
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [comp₂Measurable_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✝⁵ : BorelSpace γ
inst✝⁴ : SecondCountableTopologyEither β γ
inst✝³ : MeasurableSpace δ
inst✝² : PseudoMetrizableSpace δ
inst✝¹ : OpensMeasurableSpace δ
inst✝ : SecondCountableTopology δ
g : β → γ → δ
hg : Measurable (uncurry g)
f₁ : α →ₘ[μ] β
f₂ : α →ₘ[μ] γ
⊢ ↑(comp₂Measurable g hg f₁ f₂) =ᶠ[ae μ] fun a => g (↑f₁ a) (↑f₂ a)
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✝⁵ : BorelSpace γ
inst✝⁴ : SecondCountableTopologyEither β γ
inst✝³ : MeasurableSpace δ
inst✝² : PseudoMetrizableSpace δ
inst✝¹ : OpensMeasurableSpace δ
inst✝ : SecondCountableTopology δ
g : β → γ → δ
hg : Measurable (uncurry g)
f₁ : α →ₘ[μ] β
f₂ : α →ₘ[μ] γ
⊢ ↑(mk (fun a => g (↑f₁ a) (↑f₂ a)) ⋯) =ᶠ[ae μ] fun a => g (↑f₁ a) (↑f₂ a)

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✝⁵ : BorelSpace γ
inst✝⁴ : SecondCountableTopologyEither β γ
inst✝³ : MeasurableSpace δ
inst✝² : PseudoMetrizableSpace δ
inst✝¹ : OpensMeasurableSpace δ
inst✝ : SecondCountableTopology δ
g : β → γ → δ
hg : Measurable (uncurry g)
f₁ : α →ₘ[μ] β
f₂ : α →ₘ[μ] γ
⊢ ↑(mk (fun a => g (↑f₁ a) (↑f₂ a)) ⋯) =ᶠ[ae μ] fun a => g (↑f₁ a) (↑f₂ a)
state_after: no goals
Theorem: Real.arcsin_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [sin_zero]
state_before: x✝ y x : ℝ
⊢ sin 0 ≤ x ↔ 0 ≤ x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.naturality_φ₁
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: simp only [← cancel_mono S₂.L₂.f, assoc, φ₁_L₂_f, ← naturality_φ₂, f.f₂.comm₁₂, φ₁_L₂_f_assoc]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ : SnakeInput C
f : S₁ ⟶ S₂
⊢ S₁.φ₁ ≫ f.f₂.τ₁ = functorP.map f ≫ S₂.φ₁
state_after: no goals
Theorem: le_separableClosure'
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: simpa only [minpoly_eq] using hs ⟨x, h⟩
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
hs : ∀ (x : ↥L), (minpoly F x).Separable
x : E
h : x ∈ L
⊢ x ∈ separableClosure F E
state_after: no goals
Theorem: IsIntegralClosure.mk'_one
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rw [algebraMap_mk', RingHom.map_one]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsIntegralClosure A R B
h : optParam (IsIntegral R 1) ⋯
⊢ (algebraMap A B) (mk' A 1 h) = (algebraMap A B) 1
state_after: no goals