ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: convex_vadd
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
a : E
h : Convex 𝕜 (a +ᵥ s)
⊢ Convex 𝕜 s
state_after: no goals
tactic: simpa using h.vadd (-a)
Theorem: Function.Bijective.existsUnique_iff
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
hf : Bijective f
p : β → Prop
x✝ : ∃! y, p y
y : β
hpy : (fun y => p y) y
hy : ∀ (y_1 : β), (fun y => p y) y_1 → y_1 = y
x : α
hx : f x = y
⊢ (fun x => p (f x)) x
state_after: no goals
tactic: simpa [hx]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
hf : Bijective f
p : β → Prop
x✝ : ∃! x, p (f x)
x : α
hpx : (fun x => p (f x)) x
hx : ∀ (y : α), (fun x => p (f x)) y → y = x
y : β
hy : (fun y => p y) y
z : α
hz : f z = y
⊢ (fun x => p (f x)) z
state_after: no goals
tactic: simpa [hz]
Theorem: HahnSeries.addOppositeEquiv_symm_orderTop
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ (addOppositeEquiv.symm x).orderTop = (AddOpposite.unop x).orderTop
state_after: no goals
tactic: rw [← addOppositeEquiv_orderTop, AddEquiv.apply_symm_apply]
Theorem: Nat.nth_strictMono
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (nth p)
state_after: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (Subtype.val ∘ ⇑(Subtype.orderIsoOfNat (setOf p)))
tactic: rw [nth_eq_orderIsoOfNat hf]
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (Subtype.val ∘ ⇑(Subtype.orderIsoOfNat (setOf p)))
state_after: no goals
tactic: exact (Subtype.strictMono_coe _).comp (OrderIso.strictMono _)
Theorem: FractionalIdeal.map_map_symm
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g✝ : P →ₐ[R] P'
g : P ≃ₐ[R] P'
⊢ map (↑g.symm) (map (↑g) I) = I
state_after: no goals
tactic: rw [← map_comp, g.symm_comp, map_id]
Theorem: jacobiTheta₂_undef
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
hτ : τ.im ≤ 0
⊢ jacobiTheta₂ z τ = 0
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂_term b z τ
tactic: apply tsum_eq_zero_of_not_summable
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂_term b z τ
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
tactic: rw [summable_jacobiTheta₂_term_iff]
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
state_after: no goals
tactic: exact not_lt.mpr hτ
Theorem: SimpleGraph.Subgraph.degree_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ G.degree v
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ Fintype.card ↑(G.neighborSet v)
tactic: rw [← card_neighborSet_eq_degree]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ Fintype.card ↑(G.neighborSet v)
state_after: no goals
tactic: exact Set.card_le_card (G'.neighborSet_subset v)
Theorem: Finset.slice_union_shadow_falling_succ
File: Mathlib/Combinatorics/SetFamily/LYM.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ 𝒜 # k ∪ ∂ (falling (k + 1) 𝒜) = falling k 𝒜
state_after: case a
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ s ∈ 𝒜 # k ∪ ∂ (falling (k + 1) 𝒜) ↔ s ∈ falling k 𝒜
tactic: ext s
state_before: case a
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ s ∈ 𝒜 # k ∪ ∂ (falling (k + 1) 𝒜) ↔ s ∈ falling k 𝒜
state_after: case a
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ (s ∈ 𝒜 ∧ s.card = k ∨ ∃ s_1, ((∃ t ∈ 𝒜, s_1 ⊆ t) ∧ s_1.card = k + 1) ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔
    (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k
tactic: simp_rw [mem_union, mem_slice, mem_shadow_iff, mem_falling]
state_before: case a
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ (s ∈ 𝒜 ∧ s.card = k ∨ ∃ s_1, ((∃ t ∈ 𝒜, s_1 ⊆ t) ∧ s_1.card = k + 1) ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔
    (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k
state_after: case a.mp
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ (s ∈ 𝒜 ∧ s.card = k ∨ ∃ s_1, ((∃ t ∈ 𝒜, s_1 ⊆ t) ∧ s_1.card = k + 1) ∧ ∃ a ∈ s_1, s_1.erase a = s) →
    (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k

case a.mpr
𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ s : Finset α
⊢ (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k →
    s ∈ 𝒜 ∧ s.card = k ∨ ∃ s_1, ((∃ t ∈ 𝒜, s_1 ⊆ t) ∧ s_1.card = k + 1) ∧ ∃ a ∈ s_1, s_1.erase a = s
tactic: constructor
Theorem: WeierstrassCurve.Jacobian.polynomialZ_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
⊢ W'.polynomialZ =
    C W'.a₁ * X x * X y + C (3 * W'.a₃) * X y * X z ^ 2 -
      (C (2 * W'.a₂) * X x ^ 2 * X z + C (4 * W'.a₄) * X x * X z ^ 3 + C (6 * W'.a₆) * X z ^ 5)
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv z)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C W'.a₁ * X x * X y + C (3 * W'.a₃) * X y * X z ^ 2 -
      (C (2 * W'.a₂) * X x ^ 2 * X z + C (4 * W'.a₄) * X x * X z ^ 3 + C (6 * W'.a₆) * X z ^ 5)
tactic: rw [polynomialZ, polynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv z)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C W'.a₁ * X x * X y + C (3 * W'.a₃) * X y * X z ^ 2 -
      (C (2 * W'.a₂) * X x ^ 2 * X z + C (4 * W'.a₄) * X x * X z ^ 3 + C (6 * W'.a₆) * X z ^ 5)
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 0 + (((0 * X x + C W'.a₁ * 0) * X y + C W'.a₁ * X x * 0) * X z + C W'.a₁ * X x * X y * 1) +
        ((0 * X y + C W'.a₃ * 0) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 1)) -
      (↑3 * X x ^ (3 - 1) * 0 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 0)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 1)) +
          ((0 * X x + C W'.a₄ * 0) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 1)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 1))) =
    C W'.a₁ * X x * X y + 3 * C W'.a₃ * X y * X z ^ 2 -
      (2 * C W'.a₂ * X x ^ 2 * X z + 4 * C W'.a₄ * X x * X z ^ 3 + 6 * C W'.a₆ * X z ^ 5)
tactic: pderiv_simp
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 0 + (((0 * X x + C W'.a₁ * 0) * X y + C W'.a₁ * X x * 0) * X z + C W'.a₁ * X x * X y * 1) +
        ((0 * X y + C W'.a₃ * 0) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 1)) -
      (↑3 * X x ^ (3 - 1) * 0 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 0)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 1)) +
          ((0 * X x + C W'.a₄ * 0) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 1)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 1))) =
    C W'.a₁ * X x * X y + 3 * C W'.a₃ * X y * X z ^ 2 -
      (2 * C W'.a₂ * X x ^ 2 * X z + 4 * C W'.a₄ * X x * X z ^ 3 + 6 * C W'.a₆ * X z ^ 5)
state_after: no goals
tactic: ring1
Theorem: CategoryTheory.Localization.Construction.natTransExtension_hcomp
File: Mathlib/CategoryTheory/Localization/Construction.lean

Proof steps:
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G✝ : C ⥤ D
hG : W.IsInvertedBy G✝
F G : W.Localization ⥤ D
τ : W.Q ⋙ F ⟶ W.Q ⋙ G
⊢ 𝟙 W.Q ◫ natTransExtension τ = τ
state_after: no goals
tactic: aesop_cat
Theorem: sq_pos_of_neg
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : StrictOrderedRing R
a : R
ha : a < 0
⊢ 0 < a ^ 2
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : StrictOrderedRing R
a : R
ha : a < 0
⊢ 0 < a * a
tactic: rw [sq]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : StrictOrderedRing R
a : R
ha : a < 0
⊢ 0 < a * a
state_after: no goals
tactic: exact mul_pos_of_neg_of_neg ha ha
Theorem: IsFreeGroupoid.SpanningTree.treeHom_eq
File: Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean

Proof steps:
state_before: G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a : G
p : Path (root (WideSubquiver.toType (Symmetrify (Generators G)) T)) a
⊢ treeHom T a = homOfPath T p
state_after: no goals
tactic: rw [treeHom, Unique.default_eq]
Theorem: FractionalIdeal.count_pow
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℕ
I : FractionalIdeal R⁰ K
⊢ count K v (I ^ n) = ↑n * count K v I
state_after: case zero
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
⊢ count K v (I ^ 0) = ↑0 * count K v I

case succ
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
n : ℕ
h : count K v (I ^ n) = ↑n * count K v I
⊢ count K v (I ^ (n + 1)) = ↑(n + 1) * count K v I
tactic: induction' n with n h
Theorem: MeasureTheory.ae_eq_empty
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
⊢ (∀ᵐ (x : α) ∂μ, x ∉ s) ↔ μ s = 0
state_after: no goals
tactic: simp only [ae_iff, Classical.not_not, setOf_mem_eq]
Theorem: Bimon_.ofMon_Comon_obj_comul_hom
File: Mathlib/CategoryTheory/Monoidal/Bimon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ (Comon_ C)
⊢ ((Comon_.forgetMonoidal C).mapMon.obj M).mul ≫ M.X.comul =
    (M.X.comul ⊗ M.X.comul) ≫ ((Comon_.forgetMonoidal C).mapMon.obj M ⊗ (Comon_.forgetMonoidal C).mapMon.obj M).mul
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ (Comon_ C)
⊢ (𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom) ≫ M.X.comul =
    (M.X.comul ⊗ M.X.comul) ≫
      tensor_μ C (M.X.X, M.X.X) (M.X.X, M.X.X) ≫ (𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom ⊗ 𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom)
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ (Comon_ C)
⊢ (𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom) ≫ M.X.comul =
    (M.X.comul ⊗ M.X.comul) ≫
      tensor_μ C (M.X.X, M.X.X) (M.X.X, M.X.X) ≫ (𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom ⊗ 𝟙 (M.X.X ⊗ M.X.X) ≫ M.mul.hom)
state_after: no goals
tactic: simp [tensor_μ]
Theorem: Finset.pimage_subset
File: Mathlib/Data/Finset/PImage.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t✝ : Finset α
b : β
t : Finset β
⊢ pimage f s ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t
state_after: no goals
tactic: simp [subset_iff, @forall_swap _ β]
Theorem: isOpenMap_sigma
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f : Sigma σ → X
⊢ IsOpenMap f ↔ ∀ (i : ι), IsOpenMap fun a => f ⟨i, a⟩
state_after: no goals
tactic: simp only [isOpenMap_iff_nhds_le, Sigma.forall, Sigma.nhds_eq, map_map, comp]
Theorem: DirichletCharacter.changeLevel_self
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
⊢ (changeLevel ⋯) χ = χ
state_after: no goals
tactic: simp [changeLevel, ZMod.unitsMap]
Theorem: MvPFunctor.M.bisim'
File: Mathlib/Data/PFunctor/Multivariate/M.lean

Proof steps:
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u} n
R : P.M α → P.M α → Prop
h : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y
x y : P.M α
r : R x y
⊢ x = y
state_after: case refine_3
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u} n
R : P.M α → P.M α → Prop
h : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y
x y : P.M α
r : R x y
this : ∀ (x y : P.M α), EqvGen R x y → x = y
⊢ x = y

case refine_1
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u} n
R : P.M α → P.M α → Prop
h : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y
x y : P.M α
r : R x y
⊢ Equivalence (EqvGen R)

case refine_2
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u} n
R : P.M α → P.M α → Prop
h : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y
x y : P.M α
r : R x y
⊢ ∀ (x y : P.M α),
    EqvGen R x y → (TypeVec.id ::: Quot.mk (EqvGen R)) <$$> dest P x = (TypeVec.id ::: Quot.mk (EqvGen R)) <$$> dest P y
tactic: have := M.bisim₀ P (EqvGen R) ?_ ?_
Theorem: quadraticChar_isQuadratic
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
⊢ (quadraticChar F).IsQuadratic
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
tactic: intro a
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
state_after: case pos
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1

case neg
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : ¬a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
tactic: by_cases ha : a = 0
Theorem: List.get?_succ_scanl
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
i : ℕ
⊢ (scanl f b l).get? (i + 1) = ((scanl f b l).get? i).bind fun x => Option.map (fun y => f x y) (l.get? i)
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
i : ℕ
⊢ (scanl f b []).get? (i + 1) = ((scanl f b []).get? i).bind fun x => Option.map (fun y => f x y) ([].get? i)

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
i : ℕ
⊢ (scanl f b (hd :: tl)).get? (i + 1) =
    ((scanl f b (hd :: tl)).get? i).bind fun x => Option.map (fun y => f x y) ((hd :: tl).get? i)
tactic: induction' l with hd tl hl generalizing b i
Theorem: Ideal.associatesNonZeroDivisorsEquivIsPrincipal_mul
File: Mathlib/RingTheory/Ideal/IsPrincipal.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
x y : Associates ↥R⁰
⊢ ↑↑((associatesNonZeroDivisorsEquivIsPrincipal R) (x * y)) =
    ↑↑((associatesNonZeroDivisorsEquivIsPrincipal R) x) * ↑↑((associatesNonZeroDivisorsEquivIsPrincipal R) y)
state_after: no goals
tactic: simp_rw [associatesNonZeroDivisorsEquivIsPrincipal_coe, _root_.map_mul, Submonoid.coe_mul,
    associatesEquivIsPrincipal_mul]
Theorem: Finset.disjSups_right_comm
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s t u v : Finset α
⊢ s ○ t ○ u = s ○ u ○ t
state_after: no goals
tactic: simp_rw [disjSups_assoc, disjSups_comm]
Theorem: Basis.SmithNormalForm.coord_apply_embedding_eq_smul_coord
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
i : Fin n
⊢ snf.bM.coord (snf.f i) ∘ₗ N.subtype = snf.a i • snf.bN.coord i
state_after: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m✝ : ↥N
i : Fin n
m : ↥N
⊢ (snf.bM.coord (snf.f i) ∘ₗ N.subtype) m = (snf.a i • snf.bN.coord i) m
tactic: ext m
state_before: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m✝ : ↥N
i : Fin n
m : ↥N
⊢ (snf.bM.coord (snf.f i) ∘ₗ N.subtype) m = (snf.a i • snf.bN.coord i) m
state_after: no goals
tactic: simp [Pi.smul_apply (snf.a i)]
Theorem: DirichletCharacter.mul_convolution_distrib
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
n : ℕ
χ : DirichletCharacter R n
f g : ℕ → R
⊢ (fun x => χ ↑x) * f ⍟ ((fun x => χ ↑x) * g) = (fun x => χ ↑x) * (f ⍟ g)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
⊢ ((fun x => χ ↑x) * f ⍟ ((fun x => χ ↑x) * g)) n = ((fun x => χ ↑x) * (f ⍟ g)) n
tactic: ext n
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
⊢ ((fun x => χ ↑x) * f ⍟ ((fun x => χ ↑x) * g)) n = ((fun x => χ ↑x) * (f ⍟ g)) n
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
⊢ ∑ x ∈ n.divisorsAntidiagonal, χ ↑x.1 * f x.1 * (χ ↑x.2 * g x.2) = ∑ i ∈ n.divisorsAntidiagonal, χ ↑n * (f i.1 * g i.2)
tactic: simp only [Pi.mul_apply, LSeries.convolution_def, Finset.mul_sum]
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
⊢ ∑ x ∈ n.divisorsAntidiagonal, χ ↑x.1 * f x.1 * (χ ↑x.2 * g x.2) = ∑ i ∈ n.divisorsAntidiagonal, χ ↑n * (f i.1 * g i.2)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ χ ↑p.1 * f p.1 * (χ ↑p.2 * g p.2) = χ ↑n * (f p.1 * g p.2)
tactic: refine Finset.sum_congr rfl fun p hp ↦ ?_
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ χ ↑p.1 * f p.1 * (χ ↑p.2 * g p.2) = χ ↑n * (f p.1 * g p.2)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ χ ↑p.1 * f p.1 * (χ ↑p.2 * g p.2) = χ ↑p.1 * χ ↑p.2 * (f p.1 * g p.2)
tactic: rw [(mem_divisorsAntidiagonal.mp hp).1.symm, cast_mul, map_mul]
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
n✝ : ℕ
χ : DirichletCharacter R n✝
f g : ℕ → R
n : ℕ
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ χ ↑p.1 * f p.1 * (χ ↑p.2 * g p.2) = χ ↑p.1 * χ ↑p.2 * (f p.1 * g p.2)
state_after: no goals
tactic: exact mul_mul_mul_comm ..
Theorem: Ultrafilter.comap_pure
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
m : α → β
a : α
inj : Injective m
large : range m ∈ pure (m a)
⊢ 𝓟 (m ⁻¹' {m a}) = ↑(pure a)
state_after: no goals
tactic: rw [coe_pure, ← principal_singleton, ← image_singleton, preimage_image_eq _ inj]
Theorem: Complex.log_conj
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℂ
h : x.arg ≠ π
⊢ log ((starRingEnd ℂ) x) = (starRingEnd ℂ) (log x)
state_after: no goals
tactic: rw [log_conj_eq_ite, if_neg h]