ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.neg_vecMul
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
⊢ -v ᵥ* A = -(v ᵥ* A)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
x✝ : n
⊢ (-v ᵥ* A) x✝ = (-(v ᵥ* A)) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
x✝ : n
⊢ (-v ᵥ* A) x✝ = (-(v ᵥ* A)) x✝
state_after: no goals
tactic: apply neg_dotProduct
Theorem: AddSubgroup.nontrivial_iff_ne_bot
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 H : Subgroup G
⊢ Nontrivial ↥H ↔ H ≠ ⊥
state_after: 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 H : Subgroup G
⊢ (∃ x ∈ H, x ≠ 1) ↔ ¬∀ x ∈ H, x = 1
tactic: rw [nontrivial_iff_exists_ne_one, ne_eq, eq_bot_iff_forall]
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 H : Subgroup G
⊢ (∃ x ∈ H, x ≠ 1) ↔ ¬∀ x ∈ H, x = 1
state_after: no goals
tactic: simp only [ne_eq, not_forall, exists_prop]
Theorem: MeasureTheory.Submartingale.sum_sub_upcrossingStrat_mul
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ Submartingale (fun n => ∑ k ∈ Finset.range n, (1 - upcrossingStrat a b f N k) * (f (k + 1) - f k)) ℱ μ
state_after: case refine_1
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), (1 - upcrossingStrat a b f N n) ω ≤ 1

case refine_2
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), 0 ≤ (1 - upcrossingStrat a b f N n) ω
tactic: refine hf.sum_mul_sub (fun n => (adapted_const ℱ 1 n).sub (hf.adapted.upcrossingStrat_adapted n))
    (?_ : ∀ n ω, (1 - upcrossingStrat a b f N n) ω ≤ 1) ?_
Theorem: CochainComplex.mappingCone.triangleMapOfHomotopy_comm₃
File: Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{?u.44267, u_2} D
inst✝⁵ : Preadditive C
inst✝⁴ : HasZeroObject C
inst✝³ : HasBinaryBiproducts C
inst✝² : Preadditive D
inst✝¹ : HasZeroObject D
inst✝ : HasBinaryBiproducts D
K L : CochainComplex C ℤ
φ : K ⟶ L
K₁ L₁ K₂ L₂ K₃ L₃ : CochainComplex C ℤ
φ₁ : K₁ ⟶ L₁
φ₂ : K₂ ⟶ L₂
a : K₁ ⟶ K₂
b : L₁ ⟶ L₂
H : Homotopy (φ₁ ≫ b) (a ≫ φ₂)
⊢ mapOfHomotopy H ≫ (triangle φ₂).mor₃ = (triangle φ₁).mor₃ ≫ (CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).map a
state_after: case h
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{?u.44267, u_2} D
inst✝⁵ : Preadditive C
inst✝⁴ : HasZeroObject C
inst✝³ : HasBinaryBiproducts C
inst✝² : Preadditive D
inst✝¹ : HasZeroObject D
inst✝ : HasBinaryBiproducts D
K L : CochainComplex C ℤ
φ : K ⟶ L
K₁ L₁ K₂ L₂ K₃ L₃ : CochainComplex C ℤ
φ₁ : K₁ ⟶ L₁
φ₂ : K₂ ⟶ L₂
a : K₁ ⟶ K₂
b : L₁ ⟶ L₂
H : Homotopy (φ₁ ≫ b) (a ≫ φ₂)
p : ℤ
⊢ (mapOfHomotopy H ≫ (triangle φ₂).mor₃).f p =
    ((triangle φ₁).mor₃ ≫ (CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).map a).f p
tactic: ext p
state_before: case h
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{?u.44267, u_2} D
inst✝⁵ : Preadditive C
inst✝⁴ : HasZeroObject C
inst✝³ : HasBinaryBiproducts C
inst✝² : Preadditive D
inst✝¹ : HasZeroObject D
inst✝ : HasBinaryBiproducts D
K L : CochainComplex C ℤ
φ : K ⟶ L
K₁ L₁ K₂ L₂ K₃ L₃ : CochainComplex C ℤ
φ₁ : K₁ ⟶ L₁
φ₂ : K₂ ⟶ L₂
a : K₁ ⟶ K₂
b : L₁ ⟶ L₂
H : Homotopy (φ₁ ≫ b) (a ≫ φ₂)
p : ℤ
⊢ (mapOfHomotopy H ≫ (triangle φ₂).mor₃).f p =
    ((triangle φ₁).mor₃ ≫ (CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).map a).f p
state_after: no goals
tactic: simp [ext_from_iff _ _ _ rfl, triangle, mapOfHomotopy,
    Cochain.rightShift_v _ 1 0 _ p p _ (p + 1) rfl]
Theorem: TopCat.Presheaf.pushforwardToOfIso_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C Y
𝒢 : Presheaf C X
H₂ : ℱ ⟶ (pushforward C H₁.hom).obj 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (Opens.map H₁.hom).op.obj (op ((Opens.map H₁.inv).obj (unop U))) = U
state_after: no goals
tactic: simp [Opens.map, Set.preimage_preimage]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C Y
𝒢 : Presheaf C X
H₂ : ℱ ⟶ (pushforward C H₁.hom).obj 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (pushforwardToOfIso H₁ H₂).app U = H₂.app (op ((Opens.map H₁.inv).obj (unop U))) ≫ 𝒢.map (eqToHom ⋯)
state_after: no goals
tactic: simp [pushforwardToOfIso, Equivalence.toAdjunction]
Theorem: Polynomial.leadingCoeff_mul'
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ (p * q).leadingCoeff = p.leadingCoeff * q.leadingCoeff
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ (p * q).coeff (p * q).natDegree = p.coeff p.natDegree * q.coeff q.natDegree
tactic: unfold leadingCoeff
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ (p * q).coeff (p * q).natDegree = p.coeff p.natDegree * q.coeff q.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ p.leadingCoeff * q.leadingCoeff = p.coeff p.natDegree * q.coeff q.natDegree
tactic: rw [natDegree_mul' h, coeff_mul_degree_add_degree]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ p.leadingCoeff * q.leadingCoeff = p.coeff p.natDegree * q.coeff q.natDegree
state_after: no goals
tactic: rfl
Theorem: Multiset.le_inf
File: Mathlib/Data/Multiset/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s : Multiset α
a : α
⊢ a ≤ inf 0 ↔ ∀ b ∈ 0, a ≤ b
state_after: no goals
tactic: simp
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s : Multiset α
a : α
⊢ ∀ (a_1 : α) (s : Multiset α), (a ≤ s.inf ↔ ∀ b ∈ s, a ≤ b) → (a ≤ (a_1 ::ₘ s).inf ↔ ∀ b ∈ a_1 ::ₘ s, a ≤ b)
state_after: no goals
tactic: simp (config := { contextual := true }) [or_imp, forall_and]
Theorem: Real.fourierIntegralInv_eq'
File: Mathlib/Analysis/Fourier/FourierTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
f : V → E
w : V
⊢ 𝓕⁻ f w = ∫ (v : V), Complex.exp (↑(2 * π * ⟪v, w⟫_ℝ) * Complex.I) • f v
state_after: no goals
tactic: simp_rw [fourierIntegralInv_eq, Submonoid.smul_def, Real.fourierChar_apply]
Theorem: Matrix.vecMul_add
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
⊢ x ᵥ* (A + B) = x ᵥ* A + x ᵥ* B
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
x✝ : n
⊢ (x ᵥ* (A + B)) x✝ = (x ᵥ* A + x ᵥ* B) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
x✝ : n
⊢ (x ᵥ* (A + B)) x✝ = (x ᵥ* A + x ᵥ* B) x✝
state_after: no goals
tactic: apply dotProduct_add
Theorem: uncountable_iff_forall_not_surjective
File: Mathlib/Data/Countable/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
inst✝ : Nonempty α
⊢ Uncountable α ↔ ∀ (f : ℕ → α), ¬Surjective f
state_after: no goals
tactic: rw [← not_countable_iff, countable_iff_exists_surjective, not_exists]
Theorem: Set.uIoc_injective_right
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b b₁ b₂ c d x a : α
⊢ Injective fun b => Ι b a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : (fun b => Ι b a) b = (fun b => Ι b a) c
⊢ b = c
tactic: rintro b c h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : (fun b => Ι b a) b = (fun b => Ι b a) c
⊢ b = c
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : ∀ (x : α), x ∈ (fun b => Ι b a) b ↔ x ∈ (fun b => Ι b a) c
⊢ b = c
tactic: rw [Set.ext_iff] at h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : ∀ (x : α), x ∈ (fun b => Ι b a) b ↔ x ∈ (fun b => Ι b a) c
⊢ b = c
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : ∀ (x : α), x ∈ (fun b => Ι b a) b ↔ x ∈ (fun b => Ι b a) c
ha : b ≤ a
⊢ b = c

case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
h : ∀ (x : α), x ∈ (fun b => Ι b a) b ↔ x ∈ (fun b => Ι b a) c
ha : a < b
⊢ b = c
tactic: obtain ha | ha := le_or_lt b a
Theorem: List.sum_map_filter_add_sum_map_filter_not
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝¹ : CommMonoid M
a : M
l✝ l₁ l₂ : List M
p : α → Prop
inst✝ : DecidablePred p
f : α → M
l : List α
⊢ (map f (filter (fun b => decide (p b)) l)).prod * (map f (filter (fun x => decide ¬p x) l)).prod = (map f l).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝¹ : CommMonoid M
a : M
l✝ l₁ l₂ : List M
p : α → Prop
inst✝ : DecidablePred p
f : α → M
l : List α
⊢ (map (fun a => if p a then f a else f a) l).prod = (map f l).prod
tactic: rw [← prod_map_ite]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝¹ : CommMonoid M
a : M
l✝ l₁ l₂ : List M
p : α → Prop
inst✝ : DecidablePred p
f : α → M
l : List α
⊢ (map (fun a => if p a then f a else f a) l).prod = (map f l).prod
state_after: no goals
tactic: simp only [ite_self]
Theorem: Num.cast_le
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : Num
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : Num
⊢ ¬↑n < ↑m ↔ m ≤ n
tactic: rw [← not_lt]
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : Num
⊢ ¬↑n < ↑m ↔ m ≤ n
state_after: no goals
tactic: exact not_congr cast_lt
Theorem: CategoryTheory.Limits.compYonedaSectionsEquiv_symm_apply_coe
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ ((const J).obj (op X)).map f ≫ (fun j => Quiver.Hom.op (↑s j)) j' = (fun j => Quiver.Hom.op (↑s j)) j ≫ F.map f
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ 𝟙 (op X) ≫ (↑s j').op = (↑s j).op ≫ F.map f
tactic: dsimp
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ 𝟙 (op X) ≫ (↑s j').op = (↑s j).op ≫ F.map f
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ (↑s j').op = (↑s j).op ≫ F.map f
tactic: rw [Category.id_comp]
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ (↑s j').op = (↑s j).op ≫ F.map f
state_after: no goals
tactic: exact Quiver.Hom.unop_inj (s.property f).symm
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
τ : (const J).obj (op X) ⟶ F
j j' : J
f : j ⟶ j'
⊢ Quiver.Hom.op ((F ⋙ yoneda.obj X).map f ((fun j => (τ.app j).unop) j)) = ((fun j => (τ.app j).unop) j').op
state_after: no goals
tactic: simpa using (τ.naturality f).symm
Theorem: QuadraticMap.polar_prod
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup P
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R P
Q₁ : QuadraticMap R M₁ P
Q₂ : QuadraticMap R M₂ P
x y : M₁ × M₂
⊢ polar (⇑(Q₁.prod Q₂)) x y = polar (⇑Q₁) x.1 y.1 + polar (⇑Q₂) x.2 y.2
state_after: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup P
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R P
Q₁ : QuadraticMap R M₁ P
Q₂ : QuadraticMap R M₂ P
x y : M₁ × M₂
⊢ Q₁ (x.1 + y.1) + Q₂ (x.2 + y.2) - (Q₁ x.1 + Q₂ x.2) - (Q₁ y.1 + Q₂ y.2) =
    Q₁ (x.1 + y.1) - Q₁ x.1 - Q₁ y.1 + (Q₂ (x.2 + y.2) - Q₂ x.2 - Q₂ y.2)
tactic: dsimp [polar]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup P
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R P
Q₁ : QuadraticMap R M₁ P
Q₂ : QuadraticMap R M₂ P
x y : M₁ × M₂
⊢ Q₁ (x.1 + y.1) + Q₂ (x.2 + y.2) - (Q₁ x.1 + Q₂ x.2) - (Q₁ y.1 + Q₂ y.2) =
    Q₁ (x.1 + y.1) - Q₁ x.1 - Q₁ y.1 + (Q₂ (x.2 + y.2) - Q₂ x.2 - Q₂ y.2)
state_after: no goals
tactic: abel
Theorem: Set.biInter_insert
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
a : α
s : Set α
t : α → Set β
⊢ ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x
state_after: no goals
tactic: simp
Theorem: Set.uIoc_of_le
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
h : a ≤ b
⊢ Ι a b = Ioc a b
state_after: no goals
tactic: simp [uIoc, h]
Theorem: Set.prod_eq_univ
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
inst✝¹ : Nonempty α
inst✝ : Nonempty β
⊢ s ×ˢ t = univ ↔ s = univ ∧ t = univ
state_after: no goals
tactic: simp [eq_univ_iff_forall, forall_and]
Theorem: WeierstrassCurve.Jacobian.equiv_of_X_eq_of_Y_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 Q : Fin 3 → F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 = Q y * P z ^ 3
⊢ P ≈ Q
state_after: case h
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 = Q y * P z ^ 3
⊢ (fun m => m • Q) (Units.mk0 (P z) hPz / Units.mk0 (Q z) hQz) = P
tactic: use Units.mk0 _ hPz / Units.mk0 _ hQz
state_before: case h
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 = Q y * P z ^ 3
⊢ (fun m => m • Q) (Units.mk0 (P z) hPz / Units.mk0 (Q z) hQz) = P
state_after: no goals
tactic: simp only [Units.smul_def, smul_fin3, Units.val_div_eq_div_val, Units.val_mk0, div_pow, mul_comm,
    mul_div, ← hx, ← hy, mul_div_cancel_right₀ _ <| pow_ne_zero _ hQz, mul_div_cancel_right₀ _ hQz,
    fin3_def]
Theorem: Pell.isPell_one
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
⊢ az a * az a - ↑(Pell.d a1) * 1 * 1 = 1
state_after: no goals
tactic: simp [dz_val]
Theorem: NormedAddGroupHom.range_comp_incl_top
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
⊢ (f.comp (incl ⊤)).range = f.range
state_after: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
⊢ f.toAddMonoidHom.range = f.range
tactic: simp [comp_range, incl_range, ← AddMonoidHom.range_eq_map]
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
⊢ f.toAddMonoidHom.range = f.range
state_after: no goals
tactic: rfl
Theorem: EMetric.empty_or_nonempty_of_hausdorffEdist_ne_top
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
⊢ s = ∅ ∧ t = ∅ ∨ s.Nonempty ∧ t.Nonempty
state_after: case inl
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
hs : s = ∅
⊢ s = ∅ ∧ t = ∅ ∨ s.Nonempty ∧ t.Nonempty

case inr
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
hs : s.Nonempty
⊢ s = ∅ ∧ t = ∅ ∨ s.Nonempty ∧ t.Nonempty
tactic: rcases s.eq_empty_or_nonempty with hs | hs
Theorem: inv_le_iff_one_le_mul'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * b ↔ 1 ≤ a * b
state_after: no goals
tactic: rw [mul_inv_self]
Theorem: range_two_mul_add_one
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
⊢ (Set.range fun x => 2 * x + 1) = {a | Odd a}
state_after: case h
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
x : α
⊢ (x ∈ Set.range fun x => 2 * x + 1) ↔ x ∈ {a | Odd a}
tactic: ext x
state_before: case h
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
x : α
⊢ (x ∈ Set.range fun x => 2 * x + 1) ↔ x ∈ {a | Odd a}
state_after: no goals
tactic: simp [Odd, eq_comm]
Theorem: CategoryTheory.Over.ConstructProducts.conesEquivFunctor_obj_π_app
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean

Proof steps:
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : { as := X }.as = { as := Y }.as
⊢ ((Functor.const (Discrete J)).obj (mk (c.π.app none))).map { down := { down := f } } ≫
      (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := Y } =
    (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := X } ≫
      F.map { down := { down := f } }
state_after: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
tactic: dsimp at f ⊢
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
state_after: no goals
tactic: aesop_cat
Theorem: Asymptotics.isBigO_one_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (f =O[l] fun _x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖
state_after: no goals
tactic: simp only [isBigO_iff, norm_one, mul_one, IsBoundedUnder, IsBounded, eventually_map]