1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Stream'.append_take_drop
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), take n s ++ₛ drop n s = s
state_after: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), take n s ++ₛ drop n s = s

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), take n s ++ₛ drop n s = s
state_after: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), take 0 s ++ₛ drop 0 s = s

case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
⊢ ∀ (s : Stream' α), take (n' + 1) s ++ₛ drop (n' + 1) s = s

tactic: intro s
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), take 0 s ++ₛ drop 0 s = s
state_after: case zero
α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ take 0 s ++ₛ drop 0 s = s

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ take 0 s ++ₛ drop 0 s = s
state_after: no goals

tactic: intro s
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
⊢ ∀ (s : Stream' α), take (n' + 1) s ++ₛ drop (n' + 1) s = s
state_after: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
s : Stream' α
⊢ take (n' + 1) s ++ₛ drop (n' + 1) s = s

tactic: rw [take_succ, drop_succ, cons_append_stream, ih (tail s), Stream'.eta]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
s : Stream' α
⊢ take (n' + 1) s ++ₛ drop (n' + 1) s = s
state_after: no goals
Theorem: ContinuousLinearMap.add_comp
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring R₂
inst✝¹⁶ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁵ : TopologicalSpace M₁
inst✝¹⁴ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹³ : TopologicalSpace M'₁
inst✝¹² : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommMonoid M₄
inst✝⁵ : Module R₁ M₁
inst✝⁴ : Module R₁ M'₁
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : ContinuousAdd M₃
g₁ g₂ : M₂ →SL[σ₂₃] M₃
f : M₁ →SL[σ₁₂] M₂
⊢ (g₁ + g₂).comp f = g₁.comp f + g₂.comp f
state_after: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring R₂
inst✝¹⁶ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁵ : TopologicalSpace M₁
inst✝¹⁴ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹³ : TopologicalSpace M'₁
inst✝¹² : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommMonoid M₄
inst✝⁵ : Module R₁ M₁
inst✝⁴ : Module R₁ M'₁
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : ContinuousAdd M₃
g₁ g₂ : M₂ →SL[σ₂₃] M₃
f : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ ((g₁ + g₂).comp f) x✝ = (g₁.comp f + g₂.comp f) x✝

tactic: simp
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring R₂
inst✝¹⁶ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁵ : TopologicalSpace M₁
inst✝¹⁴ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹³ : TopologicalSpace M'₁
inst✝¹² : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommMonoid M₄
inst✝⁵ : Module R₁ M₁
inst✝⁴ : Module R₁ M'₁
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : ContinuousAdd M₃
g₁ g₂ : M₂ →SL[σ₂₃] M₃
f : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ ((g₁ + g₂).comp f) x✝ = (g₁.comp f + g₂.comp f) x✝
state_after: no goals
Theorem: mul_eq_right₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [Iff.comm, ← mul_left_inj' hb, one_mul]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : CancelMonoidWithZero M₀
a b c : M₀
hb : b ≠ 0
⊢ a * b = b ↔ a = 1
state_after: no goals
Theorem: Cycle.chain_map
File: Mathlib/Data/List/Cycle.lean

tactic: cases' l with a l
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
l : List β
⊢ Chain r (map f (Quotient.mk'' l)) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' l)
state_after: case nil
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
⊢ Chain r (map f (Quotient.mk'' [])) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' [])

case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ Chain r (map f (Quotient.mk'' (a :: l))) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' (a :: l))

tactic: dsimp only [Chain, ← mk''_eq_coe, Quotient.liftOn'_mk'', Cycle.map, Quotient.map', Quot.map,
  Quotient.mk'', Quotient.liftOn', Quotient.liftOn, Quot.liftOn_mk, List.map]
state_before: case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ Chain r (map f (Quotient.mk'' (a :: l))) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' (a :: l))
state_after: case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain r (f a) (List.map f l ++ [f a]) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])

tactic: rw [← concat_eq_append, ← List.map_concat, List.chain_map f]
state_before: case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain r (f a) (List.map f l ++ [f a]) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])
state_after: case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain (fun a b => r (f a) (f b)) a (l.concat a) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])

tactic: simp
state_before: case cons
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain (fun a b => r (f a) (f b)) a (l.concat a) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
r : α → α → Prop
f : β → α
s : Cycle β
⊢ Chain r (map f (Quotient.mk'' [])) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' [])
state_after: no goals
Theorem: differentiableAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_differentiableAt_iff, differentiableAt_pi]
state_before: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ DifferentiableAt 𝕜 f y ↔ ∀ (i : ι), DifferentiableAt 𝕜 (fun x => f x i) y
state_after: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι), DifferentiableAt 𝕜 (fun x => (⇑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) y) ↔
    ∀ (i : ι), DifferentiableAt 𝕜 (fun x => f x i) y

tactic: rfl
state_before: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι), DifferentiableAt 𝕜 (fun x => (⇑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) y) ↔
    ∀ (i : ι), DifferentiableAt 𝕜 (fun x => f x i) y
state_after: no goals
Theorem: Matrix.fromColumns_neg
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext i (j | j) <;> simp
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Neg R
A₁ : Matrix n m₁ R
A₂ : Matrix n m₂ R
⊢ -A₁.fromColumns A₂ = (-A₁).fromColumns (-A₂)
state_after: no goals
Theorem: Submodule.span_induction
File: Mathlib/LinearAlgebra/Span.lean

tactic: intros x y
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
p : M → Prop
h : x ∈ span R s✝
mem : ∀ x ∈ s✝, p x
zero : p 0
add : ∀ (x y : M), p x → p y → p (x + y)
smul : ∀ (a : R) (x : M), p x → p (a • x)
s : Set M
⊢ ∀ {a b : M}, a ∈ p → b ∈ p → a + b ∈ p
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
p : M → Prop
h : x✝ ∈ span R s✝
mem : ∀ x ∈ s✝, p x
zero : p 0
add : ∀ (x y : M), p x → p y → p (x + y)
smul : ∀ (a : R) (x : M), p x → p (a • x)
s : Set M
x y : M
⊢ x ∈ p → y ∈ p → x + y ∈ p

tactic: exact add x y
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
p : M → Prop
h : x✝ ∈ span R s✝
mem : ∀ x ∈ s✝, p x
zero : p 0
add : ∀ (x y : M), p x → p y → p (x + y)
smul : ∀ (a : R) (x : M), p x → p (a • x)
s : Set M
x y : M
⊢ x ∈ p → y ∈ p → x + y ∈ p
state_after: no goals
Theorem: iSup_disjoint_iff
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [disjoint_iff, iSup_inf_eq, iSup_eq_bot]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a b : α
f : ι → α
⊢ Disjoint (⨆ i, f i) a ↔ ∀ (i : ι), Disjoint (f i) a
state_after: no goals
Theorem: PNat.Coprime.factor_eq_gcd_right
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [mul_comm]
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (b * a).gcd m
state_after: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m

tactic: apply Coprime.factor_eq_gcd_left cop am bn
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m
state_after: no goals
Theorem: polynomialFunctions.starClosure_le_equalizer
File: Mathlib/Topology/ContinuousFunction/Polynomial.lean

tactic: rw [polynomialFunctions.starClosure_eq_adjoin_X s]
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
inst✝⁶ : TopologicalSpace R
inst✝⁵ : TopologicalSemiring R
A : Type u_2
inst✝⁴ : StarRing R
inst✝³ : ContinuousStar R
inst✝² : Semiring A
inst✝¹ : StarRing A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →⋆ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ (polynomialFunctions s).starClosure ≤ StarAlgHom.equalizer φ ψ
state_after: R : Type u_1
inst✝⁷ : CommSemiring R
inst✝⁶ : TopologicalSpace R
inst✝⁵ : TopologicalSemiring R
A : Type u_2
inst✝⁴ : StarRing R
inst✝³ : ContinuousStar R
inst✝² : Semiring A
inst✝¹ : StarRing A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →⋆ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ adjoin R {(toContinuousMapOnAlgHom s) X} ≤ StarAlgHom.equalizer φ ψ

tactic: exact StarAlgHom.adjoin_le_equalizer φ ψ fun x hx => (Set.mem_singleton_iff.1 hx).symm ▸ h
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
inst✝⁶ : TopologicalSpace R
inst✝⁵ : TopologicalSemiring R
A : Type u_2
inst✝⁴ : StarRing R
inst✝³ : ContinuousStar R
inst✝² : Semiring A
inst✝¹ : StarRing A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →⋆ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ adjoin R {(toContinuousMapOnAlgHom s) X} ≤ StarAlgHom.equalizer φ ψ
state_after: no goals
Theorem: Matrix.smul_cons
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
⊢ x • vecCons y v = vecCons (x • y) (x • v)
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
i : Fin n.succ
⊢ (x • vecCons y v) i = vecCons (x • y) (x • v) i

tactic: refine Fin.cases ?_ ?_ i <;> simp
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
i : Fin n.succ
⊢ (x • vecCons y v) i = vecCons (x • y) (x • v) i
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.toAffine_addX_of_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

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
⊢ 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: ring1
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
Theorem: WeierstrassCurve.Jacobian.addX_neg
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp only [addX, neg, dblZ, negY, fin3_def_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
⊢ W'.addX P (W'.neg P) = W'.dblZ P ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
⊢ P x * P x ^ 2 * P z ^ 2 - 2 * P y * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z * P z +
                      P x ^ 2 * P x * P z ^ 2 -
                    W'.a₁ * P x * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z ^ 2 * P z -
                  W'.a₁ * P y * P x * P z * P z ^ 2 +
                2 * W'.a₂ * P x * P x * P z ^ 2 * P z ^ 2 -
              W'.a₃ * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z ^ 4 * P z -
            W'.a₃ * P y * P z * P z ^ 4 +
          W'.a₄ * P x * P z ^ 4 * P z ^ 2 +
        W'.a₄ * P x * P z ^ 2 * P z ^ 4 +
      2 * W'.a₆ * P z ^ 4 * P z ^ 4 =
    (P z * (P y - (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3))) ^ 2

tactic: linear_combination -2 * P z ^ 2 * (equation_iff _).mp hP
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
⊢ P x * P x ^ 2 * P z ^ 2 - 2 * P y * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z * P z +
                      P x ^ 2 * P x * P z ^ 2 -
                    W'.a₁ * P x * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z ^ 2 * P z -
                  W'.a₁ * P y * P x * P z * P z ^ 2 +
                2 * W'.a₂ * P x * P x * P z ^ 2 * P z ^ 2 -
              W'.a₃ * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3) * P z ^ 4 * P z -
            W'.a₃ * P y * P z * P z ^ 4 +
          W'.a₄ * P x * P z ^ 4 * P z ^ 2 +
        W'.a₄ * P x * P z ^ 2 * P z ^ 4 +
      2 * W'.a₆ * P z ^ 4 * P z ^ 4 =
    (P z * (P y - (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3))) ^ 2
state_after: no goals
Theorem: compl_iSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp [compl_iInf]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : CompleteBooleanAlgebra α
a b : α
s : Set α
f : ι → α
⊢ (iSup f)ᶜᶜ = (⨅ i, (f i)ᶜ)ᶜ
state_after: no goals
Theorem: Finset.isCoatom_iff
File: Mathlib/Data/Finset/Grade.lean

tactic: simp_rw [← isAtom_compl, Finset.isAtom_iff, compl_eq_iff_isCompl, eq_compl_iff_isCompl]
state_before: α : Type u_1
s t : Finset α
a : α
inst✝¹ : Fintype α
inst✝ : DecidableEq α
⊢ IsCoatom s ↔ ∃ a, s = {a}ᶜ
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.simpleFunc_bot
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: have hf_meas := @SimpleFunc.measurableSet_fiber α _ ⊥ f
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
f : α →ₛ β
inst✝ : Nonempty β
⊢ ∃ c, ∀ (x : α), ↑f x = c
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
f : α →ₛ β
inst✝ : Nonempty β
hf_meas : ∀ (x : β), MeasurableSet (↑f ⁻¹' {x})
⊢ ∃ c, ∀ (x : α), ↑f x = c

tactic: simp_rw [MeasurableSpace.measurableSet_bot_iff] at hf_meas
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
f : α →ₛ β
inst✝ : Nonempty β
hf_meas : ∀ (x : β), MeasurableSet (↑f ⁻¹' {x})
⊢ ∃ c, ∀ (x : α), ↑f x = c
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
f : α →ₛ β
inst✝ : Nonempty β
hf_meas : ∀ (x : β), ↑f ⁻¹' {x} = ∅ ∨ ↑f ⁻¹' {x} = univ
⊢ ∃ c, ∀ (x : α), ↑f x = c

tactic: exact (exists_eq_const_of_preimage_singleton hf_meas).imp fun c hc ↦ congr_fun hc
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
f : α →ₛ β
inst✝ : Nonempty β
hf_meas : ∀ (x : β), ↑f ⁻¹' {x} = ∅ ∨ ↑f ⁻¹' {x} = univ
⊢ ∃ c, ∀ (x : α), ↑f x = c
state_after: no goals
Theorem: linearIndependent_option
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp only [← linearIndependent_option', Option.casesOn'_none_coe]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
v : Option ι → V
⊢ LinearIndependent K v ↔ LinearIndependent K (v ∘ some) ∧ v none ∉ span K (range (v ∘ some))
state_after: no goals
Theorem: LieAlgebra.IsKilling.span_weight_eq_top
File: Mathlib/Algebra/Lie/Weights/Killing.lean

tactic: refine eq_top_iff.mpr (le_trans ?_ (LieModule.range_traceForm_le_span_weight K H L))
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝² : H.IsCartanSubalgebra
inst✝¹ : IsTriangularizable K (↥H) L
inst✝ : IsKilling K L
⊢ span K (range (Weight.toLinear K (↥H) L)) = ⊤
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝² : H.IsCartanSubalgebra
inst✝¹ : IsTriangularizable K (↥H) L
inst✝ : IsKilling K L
⊢ ⊤ ≤ LinearMap.range (traceForm K (↥H) L)

tactic: rw [← traceForm_flip K H L, ← LinearMap.dualAnnihilator_ker_eq_range_flip,
  ker_traceForm_eq_bot_of_isCartanSubalgebra, Submodule.dualAnnihilator_bot]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝² : H.IsCartanSubalgebra
inst✝¹ : IsTriangularizable K (↥H) L
inst✝ : IsKilling K L
⊢ ⊤ ≤ LinearMap.range (traceForm K (↥H) L)
state_after: no goals
Theorem: Multiset.card_erase_eq_ite
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
⊢ card (s.erase a) = if a ∈ s then (card s).pred else card s
state_after: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
h : a ∈ s
⊢ card (s.erase a) = if a ∈ s then (card s).pred else card s

case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
h : a ∉ s
⊢ card (s.erase a) = if a ∈ s then (card s).pred else card s

tactic: rwa [card_erase_of_mem h, if_pos]
state_before: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
h : a ∈ s
⊢ card (s.erase a) = if a ∈ s then (card s).pred else card s
state_after: no goals

tactic: rwa [erase_of_not_mem h, if_neg]
state_before: case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
h : a ∉ s
⊢ card (s.erase a) = if a ∈ s then (card s).pred else card s
state_after: no goals
Theorem: intervalIntegral.smul_integral_comp_mul_right
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_right]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ c • ∫ (x : ℝ) in a..b, f (x * c) = ∫ (x : ℝ) in a * c..b * c, f x
state_after: no goals
Theorem: Real.le_exp_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: by_cases h_zero : x = 0
state_before: x✝ y x : ℝ
⊢ x ≤ rexp (log x)
state_after: case pos
x✝ y x : ℝ
h_zero : x = 0
⊢ x ≤ rexp (log x)

case neg
x✝ y x : ℝ
h_zero : ¬x = 0
⊢ x ≤ rexp (log x)

tactic: rw [h_zero, log, dif_pos rfl, exp_zero]
state_before: case pos
x✝ y x : ℝ
h_zero : x = 0
⊢ x ≤ rexp (log x)
state_after: case pos
x✝ y x : ℝ
h_zero : x = 0
⊢ 0 ≤ 1

tactic: exact zero_le_one
state_before: case pos
x✝ y x : ℝ
h_zero : x = 0
⊢ 0 ≤ 1
state_after: no goals

tactic: rw [exp_log_eq_abs h_zero]
state_before: case neg
x✝ y x : ℝ
h_zero : ¬x = 0
⊢ x ≤ rexp (log x)
state_after: case neg
x✝ y x : ℝ
h_zero : ¬x = 0
⊢ x ≤ |x|

tactic: exact le_abs_self _
state_before: case neg
x✝ y x : ℝ
h_zero : ¬x = 0
⊢ x ≤ |x|
state_after: no goals
Theorem: Ordinal.mem_closed_iff_sup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [← mem_closure_iff_sup, hs.closure_eq]
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : IsClosed s
⊢ a ∈ s ↔ ∃ ι, ∃ (_ : Nonempty ι), ∃ f, (∀ (i : ι), f i ∈ s) ∧ sup f = a
state_after: no goals