ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EuclideanGeometry.angle_eq_pi_div_two_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ∠ p₁ p₂ p₃ = π / 2
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0
tactic: rw [angle, ← InnerProductGeometry.inner_eq_zero_iff_angle_eq_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0
state_after: no goals
tactic: exact o.inner_eq_zero_of_oangle_eq_pi_div_two h
Theorem: Hindman.FS.add
File: Mathlib/Combinatorics/Hindman.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
m : M
hm : m ∈ FP a
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), m * m' ∈ FP a
state_after: case head
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m : M
a : Stream' M
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), a.head * m' ∈ FP a

case tail
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m✝ : M
a : Stream' M
m : M
hm : FP a.tail m
ih : ∃ n, ∀ m' ∈ FP (Stream'.drop n a.tail), m * m' ∈ FP a.tail
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), m * m' ∈ FP a

case cons
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m✝ : M
a : Stream' M
m : M
hm : FP a.tail m
ih : ∃ n, ∀ m' ∈ FP (Stream'.drop n a.tail), m * m' ∈ FP a.tail
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), a.head * m * m' ∈ FP a
tactic: induction' hm with a a m hm ih a m hm ih
Theorem: Homotopy.dNext_cochainComplex
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : CochainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ (dNext j) f = P.d j (j + 1) ≫ f (j + 1) j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : CochainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ P.d j ((ComplexShape.up ℕ).next j) ≫ f ((ComplexShape.up ℕ).next j) j = P.d j (j + 1) ≫ f (j + 1) j
tactic: dsimp [dNext]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : CochainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ P.d j ((ComplexShape.up ℕ).next j) ≫ f ((ComplexShape.up ℕ).next j) j = P.d j (j + 1) ≫ f (j + 1) j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : CochainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
this : (ComplexShape.up ℕ).next j = j + 1
⊢ P.d j ((ComplexShape.up ℕ).next j) ≫ f ((ComplexShape.up ℕ).next j) j = P.d j (j + 1) ≫ f (j + 1) j
tactic: have : (ComplexShape.up ℕ).next j = j + 1 := CochainComplex.next ℕ j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : CochainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
this : (ComplexShape.up ℕ).next j = j + 1
⊢ P.d j ((ComplexShape.up ℕ).next j) ≫ f ((ComplexShape.up ℕ).next j) j = P.d j (j + 1) ≫ f (j + 1) j
state_after: no goals
tactic: congr 2
Theorem: CategoryTheory.Localization.LeftBousfield.W_isoClosure
File: Mathlib/CategoryTheory/Localization/Bousfield.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.563, u_2} D
P : C → Prop
⊢ W (isoClosure P) = W P
state_after: case h
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.563, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
⊢ W (isoClosure P) f ↔ W P f
tactic: ext X Y f
state_before: case h
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.563, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
⊢ W (isoClosure P) f ↔ W P f
state_after: case h.mp
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.563, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
⊢ W (isoClosure P) f → W P f

case h.mpr
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.563, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
⊢ W P f → W (isoClosure P) f
tactic: constructor
Theorem: CategoryTheory.Limits.IsBilimit.binary_total
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
b : BinaryBicone X Y
i : b.IsBilimit
j : Discrete WalkingPair
⊢ (b.fst ≫ b.inl + b.snd ≫ b.inr) ≫ b.toCone.π.app j = 𝟙 b.pt ≫ b.toCone.π.app j
state_after: no goals
tactic: rcases j with ⟨⟨⟩⟩ <;> simp
Theorem: Finset.disjoint_filter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t s : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
⊢ _root_.Disjoint (filter p s) (filter q s) ↔ ∀ x ∈ s, p x → ¬q x
state_after: no goals
tactic: constructor <;> simp (config := { contextual := true }) [disjoint_left]
Theorem: _private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.0.WeierstrassCurve.Jacobian.toAffine_addX_of_eq
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
n d : F
hPz : P z ≠ 0
hd : d ≠ 0
⊢ W.toAffine.addX (P x / P z ^ 2) (P x / P z ^ 2) (-n / (P z * d)) =
    (n ^ 2 - W.a₁ * n * P z * d - W.a₂ * P z ^ 2 * d ^ 2 - 2 * P x * d ^ 2) / (P z * d) ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
n d : F
hPz : P z ≠ 0
hd : d ≠ 0
⊢ (((n ^ 2 * (P z * d) + -(W.toAffine.a₁ * n * (P z * d) ^ 2) - (P z * d) ^ 2 * (P z * d) * W.toAffine.a₂) * P z ^ 2 -
            (P z * d) ^ 2 * (P z * d) * P x) *
          P z ^ 2 -
        (P z * d) ^ 2 * (P z * d) * P z ^ 2 * P x) *
      (P z * d) ^ 2 =
    (n ^ 2 - W.a₁ * n * P z * d - W.a₂ * P z ^ 2 * d ^ 2 - 2 * P x * d ^ 2) *
      ((P z * d) ^ 2 * (P z * d) * P z ^ 2 * P z ^ 2)
tactic: field_simp [mul_ne_zero hPz hd]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
n d : F
hPz : P z ≠ 0
hd : d ≠ 0
⊢ (((n ^ 2 * (P z * d) + -(W.toAffine.a₁ * n * (P z * d) ^ 2) - (P z * d) ^ 2 * (P z * d) * W.toAffine.a₂) * P z ^ 2 -
            (P z * d) ^ 2 * (P z * d) * P x) *
          P z ^ 2 -
        (P z * d) ^ 2 * (P z * d) * P z ^ 2 * P x) *
      (P z * d) ^ 2 =
    (n ^ 2 - W.a₁ * n * P z * d - W.a₂ * P z ^ 2 * d ^ 2 - 2 * P x * d ^ 2) *
      ((P z * d) ^ 2 * (P z * d) * P z ^ 2 * P z ^ 2)
state_after: no goals
tactic: ring1
Theorem: MeasureTheory.SimpleFunc.integrable_approxOn_range
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Integrable f μ
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}
state_after: no goals
tactic: simp
Theorem: Ideal.quotientEquivAlgOfEq_symm
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
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
⊢ (quotientEquivAlgOfEq R₁ h).symm = quotientEquivAlgOfEq R₁ ⋯
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝⁶ : CommRing R
inst✝⁵ : Semiring S
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
a✝ : A ⧸ J
⊢ (quotientEquivAlgOfEq R₁ h).symm a✝ = (quotientEquivAlgOfEq R₁ ⋯) a✝
tactic: ext
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝⁶ : CommRing R
inst✝⁵ : Semiring S
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
a✝ : A ⧸ J
⊢ (quotientEquivAlgOfEq R₁ h).symm a✝ = (quotientEquivAlgOfEq R₁ ⋯) a✝
state_after: no goals
tactic: rfl
Theorem: Rat.zero_iff_num_zero
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ a b c q : ℚ
x✝ : q = 0
⊢ q.num = 0
state_after: no goals
tactic: simp [*]
Theorem: AddSubgroup.iSup_eq_closure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
ι : Sort u_5
p : ι → Subgroup G
⊢ ⨆ i, p i = closure (⋃ i, ↑(p i))
state_after: no goals
tactic: simp_rw [closure_iUnion, closure_eq]
Theorem: Function.extend_injective
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
⊢ Injective fun g => extend f g e'
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
⊢ g₁ = g₂
tactic: intro g₁ g₂ hg
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
⊢ g₁ = g₂
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
⊢ g₁ x = g₂ x
tactic: refine funext fun x ↦ ?_
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
⊢ g₁ x = g₂ x
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : (fun g => extend f g e') g₁ (f x) = (fun g => extend f g e') g₂ (f x)
⊢ g₁ x = g₂ x
tactic: have H := congr_fun hg (f x)
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : (fun g => extend f g e') g₁ (f x) = (fun g => extend f g e') g₂ (f x)
⊢ g₁ x = g₂ x
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : g₁ x = g₂ x
⊢ g₁ x = g₂ x
tactic: simp only [hf.extend_apply] at H
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : g₁ x = g₂ x
⊢ g₁ x = g₂ x
state_after: no goals
tactic: exact H
Theorem: Nat.coprime_add_mul_right_left
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n k : ℕ
⊢ (m + k * n).Coprime n ↔ m.Coprime n
state_after: no goals
tactic: rw [Coprime, Coprime, gcd_add_mul_right_left]
Theorem: Finset.subtype_map
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ map (Embedding.subtype p) (Finset.subtype p s) = filter p s
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
x : α
⊢ x ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ x ∈ filter p s
tactic: ext x
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
x : α
⊢ x ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ x ∈ filter p s
state_after: no goals
tactic: simp [@and_comm _ (_ = _), @and_left_comm _ (_ = _), @and_comm (p x) (x ∈ s)]
Theorem: PNat.card_Ioo
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ (Ioo a b).card = ↑b - ↑a - 1
state_after: a b : ℕ+
⊢ (Ioo a b).card = (Ioo ↑a ↑b).card
tactic: rw [← Nat.card_Ioo]
state_before: a b : ℕ+
⊢ (Ioo a b).card = (Ioo ↑a ↑b).card
state_after: a b : ℕ+
⊢ (Ioo a b).card = (map (Embedding.subtype fun n => 0 < n) (Ioo a b)).card
tactic: erw [← Finset.map_subtype_embedding_Ioo _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
state_before: a b : ℕ+
⊢ (Ioo a b).card = (map (Embedding.subtype fun n => 0 < n) (Ioo a b)).card
state_after: no goals
tactic: rw [card_map]
Theorem: padicNorm.nat_lt_one_iff
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
m : ℕ
⊢ padicNorm p ↑m < 1 ↔ p ∣ m
state_after: no goals
tactic: rw [← Int.natCast_dvd_natCast, ← int_lt_one_iff, Int.cast_natCast]
Theorem: CochainComplex.HomComplex.Cochain.ofHom_injective
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
f₁ f₂ : F ⟶ G
h : ofHom f₁ = ofHom f₂
⊢ (Cocycle.equivHom F G) f₁ = (Cocycle.equivHom F G) f₂
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
f₁ f₂ : F ⟶ G
h : ofHom f₁ = ofHom f₂
⊢ ↑((Cocycle.equivHom F G) f₁) = ↑((Cocycle.equivHom F G) f₂)
tactic: ext1
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
f₁ f₂ : F ⟶ G
h : ofHom f₁ = ofHom f₂
⊢ ↑((Cocycle.equivHom F G) f₁) = ↑((Cocycle.equivHom F G) f₂)
state_after: no goals
tactic: exact h
Theorem: Traversable.id_sequence
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ sequence (pure <$> x) = pure x
state_after: no goals
tactic: simp [sequence, traverse_map, id_traverse]
Theorem: AffineIsometryEquiv.dist_pointReflection_fixed
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁵ : NormedField 𝕜
inst✝²⁴ : SeminormedAddCommGroup V
inst✝²³ : NormedSpace 𝕜 V
inst✝²² : PseudoMetricSpace P
inst✝²¹ : NormedAddTorsor V P
inst✝²⁰ : SeminormedAddCommGroup V₁
inst✝¹⁹ : NormedSpace 𝕜 V₁
inst✝¹⁸ : PseudoMetricSpace P₁
inst✝¹⁷ : NormedAddTorsor V₁ P₁
inst✝¹⁶ : SeminormedAddCommGroup V₁'
inst✝¹⁵ : NormedSpace 𝕜 V₁'
inst✝¹⁴ : MetricSpace P₁'
inst✝¹³ : NormedAddTorsor V₁' P₁'
inst✝¹² : SeminormedAddCommGroup V₂
inst✝¹¹ : NormedSpace 𝕜 V₂
inst✝¹⁰ : PseudoMetricSpace P₂
inst✝⁹ : NormedAddTorsor V₂ P₂
inst✝⁸ : SeminormedAddCommGroup V₃
inst✝⁷ : NormedSpace 𝕜 V₃
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : NormedAddTorsor V₃ P₃
inst✝⁴ : SeminormedAddCommGroup V₄
inst✝³ : NormedSpace 𝕜 V₄
inst✝² : PseudoMetricSpace P₄
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type u_14
inst✝ : TopologicalSpace α
x y : P
⊢ dist ((pointReflection 𝕜 x) y) x = dist y x
state_after: no goals
tactic: rw [← (pointReflection 𝕜 x).dist_map y x, pointReflection_self]
Theorem: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hi : VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i
hi₁ : MeasurableSet i
hj₁ : MeasurableSet j
⊢ (s.toMeasureOfZeroLE i hi₁ hi) j = ↑⟨↑s (i ∩ j), ⋯⟩
state_after: no goals
tactic: simp_rw [toMeasureOfZeroLE, Measure.ofMeasurable_apply _ hj₁, toMeasureOfZeroLE',
    s.restrict_apply hi₁ hj₁, Set.inter_comm]
Theorem: isSquare_inv
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
⊢ IsSquare a⁻¹ ↔ IsSquare a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a
⊢ IsSquare a⁻¹
tactic: constructor <;> intro h
Theorem: Order.isMax_iterate_succ_of_eq_of_ne
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_ne : n ≠ m
⊢ IsMax (succ^[n] a)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_ne : n ≠ m
h : n ≤ m
⊢ IsMax (succ^[n] a)

case inr
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_ne : n ≠ m
h : m ≤ n
⊢ IsMax (succ^[n] a)
tactic: rcases le_total n m with h | h
Theorem: Filter.iInf_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
inst✝ : Finite ι
f : ι → Set α
⊢ ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
state_after: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype (PLift ι)
⊢ ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
tactic: cases nonempty_fintype (PLift ι)
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype (PLift ι)
⊢ ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
state_after: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype (PLift ι)
⊢ ⨅ i, 𝓟 (f i.down) = 𝓟 (⋂ i, f i.down)
tactic: rw [← iInf_plift_down, ← iInter_plift_down]
Theorem: Set.mem_prod_list_ofFn
File: Mathlib/Data/Set/Pointwise/ListOfFn.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n : ℕ
a : α
s : Fin n → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
state_after: case zero
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n : ℕ
a : α
s : Fin 0 → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n✝ n : ℕ
ih : ∀ {a : α} {s : Fin n → Set α}, a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
a : α
s : Fin (n + 1) → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
tactic: induction' n with n ih generalizing a
Theorem: Language.mul_self_kstar_comm
File: Mathlib/Computability/Language.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ l∗ * l = l * l∗
state_after: no goals
tactic: simp only [kstar_eq_iSup_pow, mul_iSup, iSup_mul, ← pow_succ, ← pow_succ']
Theorem: Ordinal.sSup_ord
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (sSup s).ord ≤ a ↔ sSup (ord '' s) ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (∀ x ∈ s, x ≤ a.card) ↔ ∀ x ∈ ord '' s, x ≤ a
tactic: rw [csSup_le_iff'
        (bddAbove_iff_small.2 (@small_image _ _ _ s (Cardinal.bddAbove_iff_small.1 hs))),
      ord_le, csSup_le_iff' hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (∀ x ∈ s, x ≤ a.card) ↔ ∀ x ∈ ord '' s, x ≤ a
state_after: no goals
tactic: simp [ord_le]
Theorem: Int.span_natAbs
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: a : ℤ
⊢ Ideal.span {↑a.natAbs} = Ideal.span {a}
state_after: a : ℤ
⊢ Associated (↑a.natAbs) a
tactic: rw [Ideal.span_singleton_eq_span_singleton]
state_before: a : ℤ
⊢ Associated (↑a.natAbs) a
state_after: no goals
tactic: exact (associated_natAbs _).symm
Theorem: CategoryTheory.Square.toArrowArrowFunctor_obj_left_right
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
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Associates.prod_le_prod
File: Mathlib/Algebra/BigOperators/Associated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
⊢ p.prod ≤ q.prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this : DecidableEq (Associates α)
⊢ p.prod ≤ q.prod
tactic: haveI := Classical.decEq (Associates α)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this : DecidableEq (Associates α)
⊢ p.prod ≤ q.prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod ≤ q.prod
tactic: haveI := Classical.decEq α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod ≤ q.prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod ≤ (p + (q - p)).prod
tactic: suffices p.prod ≤ (p + (q - p)).prod by rwa [add_tsub_cancel_of_le h] at this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod ≤ (p + (q - p)).prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod * 1 ≤ p.prod * (q - p).prod
tactic: suffices p.prod * 1 ≤ p.prod * (q - p).prod by simpa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ p.prod * 1 ≤ p.prod * (q - p).prod
state_after: no goals
tactic: exact mul_mono (le_refl p.prod) one_le
Theorem: Finset.exists_superset_card_eq
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
n : ℕ
s : Finset α
hsn : s.card ≤ n
hnα : n ≤ Fintype.card α
⊢ ∃ t, s ⊆ t ∧ t.card = n
state_after: no goals
tactic: simpa using exists_subsuperset_card_eq s.subset_univ hsn hnα