ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EquivFunctor.mapEquiv_refl
File: Mathlib/Control/EquivFunctor.lean

Proof steps:
state_before: f : Type u₀ → Type u₁
inst✝ : EquivFunctor f
α✝ β : Type u₀
e : α✝ ≃ β
α : Type u₀
⊢ mapEquiv f (Equiv.refl α) = Equiv.refl (f α)
state_after: case H
f : Type u₀ → Type u₁
inst✝ : EquivFunctor f
α✝ β : Type u₀
e : α✝ ≃ β
α : Type u₀
x✝ : f α
⊢ (mapEquiv f (Equiv.refl α)) x✝ = (Equiv.refl (f α)) x✝
tactic: ext
state_before: case H
f : Type u₀ → Type u₁
inst✝ : EquivFunctor f
α✝ β : Type u₀
e : α✝ ≃ β
α : Type u₀
x✝ : f α
⊢ (mapEquiv f (Equiv.refl α)) x✝ = (Equiv.refl (f α)) x✝
state_after: no goals
tactic: simp [mapEquiv]
Theorem: CategoryTheory.Limits.coprod.desc_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryCoproduct X Y
f : V ⟶ W
g : X ⟶ V
h : Y ⟶ V
⊢ desc g h ≫ f = desc (g ≫ f) (h ≫ f)
state_after: no goals
tactic: ext <;> simp
Theorem: IsSelfAdjoint.star_add_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : AddCommMonoid R
inst✝ : StarAddMonoid R
x : R
⊢ IsSelfAdjoint (star x + x)
state_after: no goals
tactic: simp only [isSelfAdjoint_iff, add_comm, star_add, star_star]
Theorem: Nat.mem_primeFactors_iff_mem_primeFactorsList
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
⊢ p ∈ n.primeFactors ↔ p ∈ n.primeFactorsList
state_after: no goals
tactic: simp only [primeFactors, List.mem_toFinset]
Theorem: Ideal.pi_quotient_surjective
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hf : Pairwise fun i j => IsCoprime (I i) (I j)
x : (i : ι) → R ⧸ I i
⊢ ∃ r, ∀ (i : ι), (Quotient.mk (I i)) r = x i
state_after: case intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hf : Pairwise fun i j => IsCoprime (I i) (I j)
y : R ⧸ ⨅ i, I i
⊢ ∃ r, ∀ (i : ι), (Quotient.mk (I i)) r = (quotientInfToPiQuotient I) y i
tactic: obtain ⟨y, rfl⟩ := Ideal.quotientInfToPiQuotient_surj hf x
state_before: case intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hf : Pairwise fun i j => IsCoprime (I i) (I j)
y : R ⧸ ⨅ i, I i
⊢ ∃ r, ∀ (i : ι), (Quotient.mk (I i)) r = (quotientInfToPiQuotient I) y i
state_after: case intro.intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hf : Pairwise fun i j => IsCoprime (I i) (I j)
r : R
⊢ ∃ r_1, ∀ (i : ι), (Quotient.mk (I i)) r_1 = (quotientInfToPiQuotient I) ((Quotient.mk (⨅ i, I i)) r) i
tactic: obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective y
state_before: case intro.intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hf : Pairwise fun i j => IsCoprime (I i) (I j)
r : R
⊢ ∃ r_1, ∀ (i : ι), (Quotient.mk (I i)) r_1 = (quotientInfToPiQuotient I) ((Quotient.mk (⨅ i, I i)) r) i
state_after: no goals
tactic: exact ⟨r, fun i ↦ rfl⟩
Theorem: YoungDiagram.le_of_transpose_le
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ ν : YoungDiagram
h_le : μ.transpose ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c ∈ ν.transpose.cells
state_after: μ ν : YoungDiagram
h_le : μ.transpose ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c.swap ∈ ν
tactic: simp only [mem_cells, mem_transpose]
state_before: μ ν : YoungDiagram
h_le : μ.transpose ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c.swap ∈ ν
state_after: case a
μ ν : YoungDiagram
h_le : μ.transpose ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c.swap ∈ μ.transpose.cells
tactic: apply h_le
state_before: case a
μ ν : YoungDiagram
h_le : μ.transpose ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c.swap ∈ μ.transpose.cells
state_after: no goals
tactic: simpa
Theorem: List.takeDTR_go_eq
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
dflt : α✝
acc : Array α✝
x✝ : List α✝
⊢ takeDTR.go dflt 0 x✝ acc = acc.data ++ takeD 0 x✝ dflt
state_after: no goals
tactic: simp [takeDTR.go]
state_before: α✝ : Type u_1
dflt : α✝
acc : Array α✝
n✝ : Nat
⊢ takeDTR.go dflt (n✝ + 1) [] acc = acc.data ++ takeD (n✝ + 1) [] dflt
state_after: no goals
tactic: simp [takeDTR.go, replicate_succ]
state_before: α✝ : Type u_1
dflt : α✝
acc : Array α✝
n✝ : Nat
head✝ : α✝
l : List α✝
⊢ takeDTR.go dflt (n✝ + 1) (head✝ :: l) acc = acc.data ++ takeD (n✝ + 1) (head✝ :: l) dflt
state_after: no goals
tactic: simp [takeDTR.go, takeDTR_go_eq _ l]
Theorem: MeasureTheory.upperCrossingTime_le
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
n m : ℕ
ω : Ω
⊢ upperCrossingTime a b f N n ω ≤ N
state_after: case zero
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
m : ℕ
ω : Ω
⊢ upperCrossingTime a b f N 0 ω ≤ N

case succ
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
m : ℕ
ω : Ω
n✝ : ℕ
⊢ upperCrossingTime a b f N (n✝ + 1) ω ≤ N
tactic: cases n
Theorem: MeasureTheory.Integrable.sub
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → β
hf : Integrable f μ
hg : Integrable g μ
⊢ Integrable (f - g) μ
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: Nat.Prime.dvd_choose_pow_iff
File: Mathlib/Data/Nat/Multiplicity.lean

Proof steps:
state_before: p n k : ℕ
hp : Prime p
⊢ p ∣ (p ^ n).choose k ↔ k ≠ 0 ∧ k ≠ p ^ n
state_after: no goals
tactic: refine ⟨fun h => ⟨?_, ?_⟩, fun h => dvd_choose_pow hp h.1 h.2⟩ <;> rintro rfl <;>
    simp [hp.ne_one] at h
Theorem: Subalgebra.fg_bot_toSubmodule
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R✝ : Type u_1
M : Type u_2
inst✝⁵ : Semiring R✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R✝ M
R : Type u_3
A : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
⊢ span R ↑{1} = Subalgebra.toSubmodule ⊥
state_after: no goals
tactic: simp [Algebra.toSubmodule_bot, one_eq_span]
Theorem: WeierstrassCurve.Jacobian.negMap_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negMap ⟦P⟧ = ⟦![P x / P z ^ 2, W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3), 1]⟧
state_after: no goals
tactic: rw [negMap_eq, neg_of_Z_ne_zero hPz, smul_eq _ <| Ne.isUnit hPz]
Theorem: List.foldl_eq_of_comm'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
hf : ∀ (a : α) (b c : β), f (f a b) c = f (f a c) b
a : α
b c : β
l : List β
⊢ foldl f a (b :: c :: l) = f (foldl f a (c :: l)) b
state_after: no goals
tactic: rw [foldl, foldl, foldl, ← foldl_eq_of_comm' .., foldl, hf]
Theorem: List.indexOf_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
x : α
xs : List α
y : α
inst✝ : BEq α
⊢ indexOf y (x :: xs) = bif x == y then 0 else indexOf y xs + 1
state_after: α : Type u_1
x : α
xs : List α
y : α
inst✝ : BEq α
⊢ findIdx (fun x => x == y) (x :: xs) = bif x == y then 0 else findIdx (fun x => x == y) xs + 1
tactic: dsimp [indexOf]
state_before: α : Type u_1
x : α
xs : List α
y : α
inst✝ : BEq α
⊢ findIdx (fun x => x == y) (x :: xs) = bif x == y then 0 else findIdx (fun x => x == y) xs + 1
state_after: no goals
tactic: simp [findIdx_cons]
Theorem: MeasureTheory.OuterMeasure.biInf_apply
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
state_after: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
this : Nonempty ↑I
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
tactic: haveI := hI.to_subtype
state_before: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
this : Nonempty ↑I
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
state_after: no goals
tactic: simp only [← iInf_subtype'', iInf_apply]
Theorem: ContinuousMultilinearMap.norm_map_snoc_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei i.castSucc
x : Ei (last n)
⊢ ‖f‖ * ∏ i : Fin (n + 1), ‖snoc m x i‖ = (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei i.castSucc
x : Ei (last n)
⊢ ‖f‖ * ((∏ i : Fin n, ‖snoc m x i.castSucc‖) * ‖snoc m x (last n)‖) = (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖
tactic: rw [prod_univ_castSucc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei i.castSucc
x : Ei (last n)
⊢ ‖f‖ * ((∏ i : Fin n, ‖snoc m x i.castSucc‖) * ‖snoc m x (last n)‖) = (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖
state_after: no goals
tactic: simp [mul_assoc]
Theorem: CategoryTheory.Square.map_X₄
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
sq : Square C
F : C ⥤ D
⊢ F.map sq.f₁₂ ≫ F.map sq.f₂₄ = F.map sq.f₁₃ ≫ F.map sq.f₃₄
state_after: no goals
tactic: simpa using F.congr_map sq.fac
Theorem: AddAction.mem_stabilizer_finset_iff_subset_vadd_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ a ∈ stabilizer G s ↔ s ⊆ a • s
state_after: no goals
tactic: rw [mem_stabilizer_iff, Finset.subset_iff_eq_of_card_le (Finset.card_smul_finset _ _).le, eq_comm]
Theorem: Batteries.DList.toList_singleton
File: Mathlib/Data/DList/Defs.lean

Proof steps:
state_before: α : Type u
x : α
⊢ (singleton x).toList = [x]
state_after: no goals
tactic: simp
Theorem: MeasureTheory.measurePreserving_add_prod_neg_right
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ MeasurePreserving (fun z => (z.1 * z.2, z.1⁻¹)) (μ.prod ν) (μ.prod ν)
state_after: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ (fun z => (z.1 * z.2, z.1⁻¹)) = (fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)
tactic: convert (measurePreserving_prod_div_swap ν μ).comp (measurePreserving_prod_mul_swap_right μ ν)
    using 1
state_before: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ (fun z => (z.1 * z.2, z.1⁻¹)) = (fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)
state_after: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
x y : G
⊢ ((x, y).1 * (x, y).2, (x, y).1⁻¹) = ((fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)) (x, y)
tactic: ext1 ⟨x, y⟩
state_before: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
x y : G
⊢ ((x, y).1 * (x, y).2, (x, y).1⁻¹) = ((fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)) (x, y)
state_after: no goals
tactic: simp_rw [Function.comp_apply, div_mul_eq_div_div_swap, div_self', one_div]
Theorem: LinearMap.eq_adjoint_iff_basis
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
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
ι₁ : Type u_5
ι₂ : Type u_6
b₁ : Basis ι₁ 𝕜 E
b₂ : Basis ι₂ 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
⊢ A = adjoint B ↔ ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜
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
ι₁ : Type u_5
ι₂ : Type u_6
b₁ : Basis ι₁ 𝕜 E
b₂ : Basis ι₂ 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜
⊢ A = adjoint B
tactic: refine ⟨fun h x y => by rw [h, adjoint_inner_left], fun h => ?_⟩
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
ι₁ : Type u_5
ι₂ : Type u_6
b₁ : Basis ι₁ 𝕜 E
b₂ : Basis ι₂ 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜
⊢ A = adjoint B
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
ι₁ : Type u_5
ι₂ : Type u_6
b₁ : Basis ι₁ 𝕜 E
b₂ : Basis ι₂ 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜
i₁ : ι₁
⊢ A (b₁ i₁) = (adjoint B) (b₁ i₁)
tactic: refine Basis.ext b₁ fun i₁ => ?_
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
ι₁ : Type u_5
ι₂ : Type u_6
b₁ : Basis ι₁ 𝕜 E
b₂ : Basis ι₂ 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜
i₁ : ι₁
⊢ A (b₁ i₁) = (adjoint B) (b₁ i₁)
state_after: no goals
tactic: exact ext_inner_right_basis b₂ fun i₂ => by simp only [adjoint_inner_left, h i₁ i₂]
Theorem: MeasureTheory.Measure.apply_eq_zero_of_isEmpty
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : IsEmpty α
x✝ : MeasurableSpace α
μ : Measure α
s : Set α
⊢ μ s = 0
state_after: no goals
tactic: rw [eq_empty_of_isEmpty s, measure_empty]
Theorem: Action.ρAut_apply_inv
File: Mathlib/RepresentationTheory/Action/Basic.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : Grp
A : Action V (MonCat.of ↑G)
g : ↑G
⊢ A.ρ (g⁻¹ * g) = 𝟙 A.V
state_after: no goals
tactic: rw [inv_mul_self, ρ_one]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : Grp
A : Action V (MonCat.of ↑G)
g : ↑G
⊢ A.ρ (g * g⁻¹) = 𝟙 A.V
state_after: no goals
tactic: rw [mul_inv_self, ρ_one]
Theorem: Metric.closure_eq_iInter_thickening'
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs₀ : s ⊆ Ioi 0
hs : ∀ (ε : ℝ), 0 < ε → (s ∩ Ioc 0 ε).Nonempty
⊢ closure E = ⋂ δ ∈ s, thickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs₀ : s ⊆ Ioi 0
hs : ∀ (ε : ℝ), 0 < ε → (s ∩ Ioc 0 ε).Nonempty
⊢ cthickening 0 E = ⋂ δ ∈ s, thickening δ E
tactic: rw [← cthickening_zero]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs₀ : s ⊆ Ioi 0
hs : ∀ (ε : ℝ), 0 < ε → (s ∩ Ioc 0 ε).Nonempty
⊢ cthickening 0 E = ⋂ δ ∈ s, thickening δ E
state_after: no goals
tactic: apply cthickening_eq_iInter_thickening' le_rfl _ hs₀ hs
Theorem: Function.Antiperiodic.neg
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ Antiperiodic f (-c)
state_after: no goals
tactic: simpa only [sub_eq_add_neg, Antiperiodic] using h.sub_eq
Theorem: Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

Proof steps:
state_before: l : Filter ℂ
hre : Tendsto re l atTop
r : ℝ
hr : im =O[l] fun z => z.re ^ r
n : ℕ
z : ℂ
hz : 0 ≤ z.re
⊢ (fun z => (z.re ^ r) ^ n) z = (fun z => z.re ^ (r * ↑n)) z
state_after: no goals
tactic: simp only [Real.rpow_mul hz r n, Real.rpow_natCast]
Theorem: Filter.top_pow
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ n : ℕ
x✝ : n + 2 ≠ 0
⊢ ⊤ ^ (n + 2) = ⊤
state_after: no goals
tactic: rw [pow_succ, top_pow n.succ_ne_zero, top_mul_top]
Theorem: SeparationQuotient.comap_map_mk_uniformity
File: Mathlib/Topology/UniformSpace/Separation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Filter.comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) = 𝓤 α
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Filter.comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) ≤ 𝓤 α
tactic: refine le_antisymm ?_ le_comap_map
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Filter.comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) ≤ 𝓤 α
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
⊢ ∃ i ∈ 𝓤 α, Prod.map mk mk ⁻¹' (Prod.map mk mk '' id i) ⊆ id U
tactic: refine ((((𝓤 α).basis_sets.map _).comap _).le_basis_iff uniformity_hasBasis_open).2 fun U hU ↦ ?_
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
⊢ ∃ i ∈ 𝓤 α, Prod.map mk mk ⁻¹' (Prod.map mk mk '' id i) ⊆ id U
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x₁ x₂ : α
x✝ : (x₁, x₂) ∈ Prod.map mk mk ⁻¹' (Prod.map mk mk '' id U)
y₁ y₂ : α
hyU : (y₁, y₂) ∈ id U
hxy : Prod.map mk mk (y₁, y₂) = Prod.map mk mk (x₁, x₂)
⊢ (x₁, x₂) ∈ id U
tactic: refine ⟨U, hU.1, fun (x₁, x₂) ⟨(y₁, y₂), hyU, hxy⟩ ↦ ?_⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x₁ x₂ : α
x✝ : (x₁, x₂) ∈ Prod.map mk mk ⁻¹' (Prod.map mk mk '' id U)
y₁ y₂ : α
hyU : (y₁, y₂) ∈ id U
hxy : Prod.map mk mk (y₁, y₂) = Prod.map mk mk (x₁, x₂)
⊢ (x₁, x₂) ∈ id U
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x₁ x₂ : α
x✝ : (x₁, x₂) ∈ Prod.map mk mk ⁻¹' (Prod.map mk mk '' id U)
y₁ y₂ : α
hyU : (y₁, y₂) ∈ id U
hxy : Inseparable y₁ x₁ ∧ Inseparable y₂ x₂
⊢ (x₁, x₂) ∈ id U
tactic: simp only [Prod.map, Prod.ext_iff, mk_eq_mk] at hxy
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x₁ x₂ : α
x✝ : (x₁, x₂) ∈ Prod.map mk mk ⁻¹' (Prod.map mk mk '' id U)
y₁ y₂ : α
hyU : (y₁, y₂) ∈ id U
hxy : Inseparable y₁ x₁ ∧ Inseparable y₂ x₂
⊢ (x₁, x₂) ∈ id U
state_after: no goals
tactic: exact ((hxy.1.prod hxy.2).mem_open_iff hU.2).1 hyU