tasksource/leandojo huggingface dataset:
Theorem: EuclideanGeometry.left_dist_ne_zero_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: by_contra heq
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
⊢ dist p1 p2 ≠ 0

tactic: rw [dist_eq_zero] at heq
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : dist p1 p2 = 0
⊢ False

tactic: rw [heq, angle_eq_left] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : p1 = p2
⊢ False

tactic: exact Real.pi_ne_zero (by linarith)
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : π / 2 = π
heq : p1 = p2
⊢ False

tactic: linarith
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : π / 2 = π
heq : p1 = p2
⊢ π = 0
Theorem: Algebra.fg_trans'
File: Mathlib/RingTheory/Adjoin/Tower.lean

tactic: rw [Finset.coe_union, Finset.coe_image, Algebra.adjoin_union_eq_adjoin_adjoin,
  Algebra.adjoin_algebraMap, hs, Algebra.map_top, IsScalarTower.adjoin_range_toAlgHom, ht,
  Subalgebra.restrictScalars_top]
state_before: R✝ : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
R : Type u_1
S : Type u_2
A : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R S A
hRS : Subalgebra.FG ⊤
hSA : Subalgebra.FG ⊤
s : Finset S
hs : adjoin R ↑s = ⊤
t : Finset A
ht : adjoin S ↑t = ⊤
⊢ adjoin R ↑(Finset.image (↑(algebraMap S A)) s ∪ t) = ⊤
Theorem: AffineMap.lineMap_eq_lineMap_iff
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [lineMap_apply, lineMap_apply, ← @vsub_eq_zero_iff_eq V1, vadd_vsub_vadd_cancel_right, ←
  sub_smul, smul_eq_zero, sub_eq_zero, vsub_eq_zero_iff_eq, or_comm, eq_comm]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type ?u.464024
P2 : Type ?u.464027
V3 : Type ?u.464030
P3 : Type ?u.464033
V4 : Type ?u.464036
P4 : Type ?u.464039
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V1
inst✝¹¹ : Module k V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : Module k V2
inst✝⁷ : AffineSpace V2 P2
inst✝⁶ : AddCommGroup V3
inst✝⁵ : Module k V3
inst✝⁴ : AffineSpace V3 P3
inst✝³ : AddCommGroup V4
inst✝² : Module k V4
inst✝¹ : AffineSpace V4 P4
inst✝ : NoZeroSMulDivisors k V1
p₀ p₁ : P1
c₁ c₂ : k
⊢ ↑(lineMap p₀ p₁) c₁ = ↑(lineMap p₀ p₁) c₂ ↔ p₀ = p₁ ∨ c₁ = c₂
Theorem: CategoryTheory.SemiadditiveOfBinaryBiproducts.comp_add
File: Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean

tactic: simp only [add_eq_left_addition, ← Category.assoc]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ f ≫ (g + h) = f ≫ g + f ≫ h

tactic: congr
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ (f ≫ biprod.lift g h) ≫ biprod.desc (𝟙 Z) (𝟙 Z) = biprod.lift (f ≫ g) (f ≫ h) ≫ biprod.desc (𝟙 Z) (𝟙 Z)

tactic: ext <;> simp
state_before: case e_a
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ f ≫ biprod.lift g h = biprod.lift (f ≫ g) (f ≫ h)
Theorem: Polynomial.leadingCoeff_div
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: by_cases hq : q = 0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hpq : degree q ≤ degree p
⊢ leadingCoeff (p / q) = leadingCoeff p / leadingCoeff q

tactic: rw [div_def, leadingCoeff_mul, leadingCoeff_C,
  leadingCoeff_divByMonic_of_monic (monic_mul_leadingCoeff_inv hq) _, mul_comm,
  div_eq_mul_inv]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hpq : degree q ≤ degree p
hq : ¬q = 0
⊢ leadingCoeff (p / q) = leadingCoeff p / leadingCoeff q

tactic: rwa [degree_mul_leadingCoeff_inv q hq]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hpq : degree q ≤ degree p
hq : ¬q = 0
⊢ degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p

tactic: simp [hq]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hpq : degree q ≤ degree p
hq : q = 0
⊢ leadingCoeff (p / q) = leadingCoeff p / leadingCoeff q
Theorem: List.reverse_join
File: Mathlib/Data/List/Join.lean

tactic: induction' L with _ _ ih
state_before: α : Type u_1
β : Type ?u.18531
L : List (List α)
⊢ reverse (join L) = join (reverse (map reverse L))

tactic: rfl
state_before: case nil
α : Type u_1
β : Type ?u.18531
⊢ reverse (join []) = join (reverse (map reverse []))

tactic: rw [join, reverse_append, ih, map_cons, reverse_cons', join_concat]
state_before: case cons
α : Type u_1
β : Type ?u.18531
head✝ : List α
tail✝ : List (List α)
ih : reverse (join tail✝) = join (reverse (map reverse tail✝))
⊢ reverse (join (head✝ :: tail✝)) = join (reverse (map reverse (head✝ :: tail✝)))
Theorem: Polynomial.Separable.of_dvd
File: Mathlib/FieldTheory/Separable.lean

tactic: rcases hfg with ⟨f', rfl⟩
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
hf : Separable f
hfg : g ∣ f
⊢ Separable g

tactic: exact Separable.of_mul_left hf
state_before: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
g f' : R[X]
hf : Separable (g * f')
⊢ Separable g
Theorem: Uniform.continuousAt_iff'_right
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [ContinuousAt, tendsto_nhds_right]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.197144
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
⊢ ContinuousAt f b ↔ Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α)
Theorem: WittVector.negIsPoly
File: Mathlib/RingTheory/WittVector/IsPoly.lean

tactic: intros
state_before: p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Fact (Nat.Prime p)
⊢ ∀ ⦃R : Type u_1⦄ [inst : CommRing R] (x : 𝕎 R),
    (-x).coeff = fun n => ↑(aeval x.coeff) ((fun n => ↑(rename Prod.snd) (wittNeg p n)) n)

tactic: funext n
state_before: p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
⊢ (-x✝).coeff = fun n => ↑(aeval x✝.coeff) ((fun n => ↑(rename Prod.snd) (wittNeg p n)) n)

tactic: rw [neg_coeff, aeval_eq_eval₂Hom, eval₂Hom_rename]
state_before: case h
p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
n : ℕ
⊢ coeff (-x✝) n = ↑(aeval x✝.coeff) ((fun n => ↑(rename Prod.snd) (wittNeg p n)) n)

tactic: apply eval₂Hom_congr rfl _ rfl
state_before: case h
p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
n : ℕ
⊢ peval (wittNeg p n) ![x✝.coeff] = ↑(eval₂Hom (algebraMap ℤ R✝) (x✝.coeff ∘ Prod.snd)) (wittNeg p n)

tactic: ext ⟨i, k⟩
state_before: p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
n : ℕ
⊢ uncurry ![x✝.coeff] = x✝.coeff ∘ Prod.snd

tactic: fin_cases i
state_before: case h.mk
p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
n : ℕ
i : Fin 1
k : ℕ
⊢ uncurry ![x✝.coeff] (i, k) = (x✝.coeff ∘ Prod.snd) (i, k)

tactic: rfl
state_before: case h.mk.head
p : ℕ
R S : Type u
σ : Type ?u.633934
idx : Type ?u.633937
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ : 𝕎 R✝
n k : ℕ
⊢ uncurry ![x✝.coeff] ({ val := 0, isLt := (_ : 0 < 1) }, k) =
    (x✝.coeff ∘ Prod.snd) ({ val := 0, isLt := (_ : 0 < 1) }, k)
Theorem: Filter.Tendsto.prod_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atBot_atBot_eq]
state_before: ι : Type ?u.286644
ι' : Type ?u.286647
α : Type u_1
β : Type ?u.286653
γ : Type u_2
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf γ
f g : α → γ
hf : Tendsto f atBot atBot
hg : Tendsto g atBot atBot
⊢ Tendsto (Prod.map f g) atBot atBot

tactic: exact hf.prod_map_prod_atBot hg
state_before: ι : Type ?u.286644
ι' : Type ?u.286647
α : Type u_1
β : Type ?u.286653
γ : Type u_2
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf γ
f g : α → γ
hf : Tendsto f atBot atBot
hg : Tendsto g atBot atBot
⊢ Tendsto (Prod.map f g) (atBot ×ˢ atBot) atBot
Theorem: HasSum.even_add_odd
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: have := mul_right_injective₀ (two_ne_zero' ℕ)
state_before: α : Type u_1
β : Type ?u.265508
γ : Type ?u.265511
δ : Type ?u.265514
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a b : α
s : Finset β
inst✝ : ContinuousAdd α
f : ℕ → α
he : HasSum (fun k => f (2 * k)) a
ho : HasSum (fun k => f (2 * k + 1)) b
⊢ HasSum f (a + b)

tactic: replace he := this.hasSum_range_iff.2 he
state_before: α : Type u_1
β : Type ?u.265508
γ : Type ?u.265511
δ : Type ?u.265514
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a b : α
s : Finset β
inst✝ : ContinuousAdd α
f : ℕ → α
he : HasSum (fun k => f (2 * k)) a
ho : HasSum (fun k => f (2 * k + 1)) b
this : Injective ((fun x x_1 => x * x_1) 2)
⊢ HasSum f (a + b)

tactic: replace ho := ((add_left_injective 1).comp this).hasSum_range_iff.2 ho
state_before: α : Type u_1
β : Type ?u.265508
γ : Type ?u.265511
δ : Type ?u.265514
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a b : α
s : Finset β
inst✝ : ContinuousAdd α
f : ℕ → α
ho : HasSum (fun k => f (2 * k + 1)) b
this : Injective ((fun x x_1 => x * x_1) 2)
he : HasSum (fun x => f ↑x) a
⊢ HasSum f (a + b)

tactic: refine' he.add_isCompl _ ho
state_before: α : Type u_1
β : Type ?u.265508
γ : Type ?u.265511
δ : Type ?u.265514
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a b : α
s : Finset β
inst✝ : ContinuousAdd α
f : ℕ → α
this : Injective ((fun x x_1 => x * x_1) 2)
he : HasSum (fun x => f ↑x) a
ho : HasSum (fun x => f ↑x) b
⊢ HasSum f (a + b)
Theorem: SimpleGraph.left_nonuniformWitnesses_card
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: rw [nonuniformWitnesses, dif_pos h]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ ↑(card s) * ε ≤ ↑(card (nonuniformWitnesses G ε s t).fst)

tactic: exact (not_isUniform_iff.1 h).choose_spec.2.choose_spec.2.1
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ ↑(card s) * ε ≤
    ↑(card
        (Exists.choose
              (_ :
                ∃ s',
                  s' ⊆ s ∧
                    ∃ t',
                      t' ⊆ t ∧
                        ↑(card s) * ε ≤ ↑(card s') ∧
                          ↑(card t) * ε ≤ ↑(card t') ∧ ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))),
            Exists.choose
              (_ :
                ∃ t',
                  t' ⊆ t ∧
                    ↑(card s) * ε ≤
                        ↑(card
                            (Exists.choose
                              (_ :
                                ∃ s',
                                  s' ⊆ s ∧
                                    ∃ t',
                                      t' ⊆ t ∧
                                        ↑(card s) * ε ≤ ↑(card s') ∧
                                          ↑(card t) * ε ≤ ↑(card t') ∧
                                            ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))))) ∧
                      ↑(card t) * ε ≤ ↑(card t') ∧
                        ε ≤
                          ↑(abs
                              (edgeDensity G
                                  (Exists.choose
                                    (_ :
                                      ∃ s',
                                        s' ⊆ s ∧
                                          ∃ t',
                                            t' ⊆ t ∧
                                              ↑(card s) * ε ≤ ↑(card s') ∧
                                                ↑(card t) * ε ≤ ↑(card t') ∧
                                                  ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))))
                                  t' -
                                edgeDensity G s t)))).fst)
Theorem: Complex.log_mul_ofReal
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [mul_comm, log_ofReal_mul hr hx, add_comm]
state_before: r : ℝ
hr : 0 < r
x : ℂ
hx : x ≠ 0
⊢ log (x * ↑r) = ↑(Real.log r) + log x
Theorem: Path.map_trans
File: Mathlib/Topology/PathConnected.lean

tactic: ext t
state_before: X : Type u_1
Y✝ : Type ?u.304721
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y✝
x y z : X
ι : Type ?u.304736
γ✝ γ : Path x y
γ' : Path y z
Y : Type u_2
inst✝ : TopologicalSpace Y
f : X → Y
h : Continuous f
⊢ map (trans γ γ') h = trans (map γ h) (map γ' h)

tactic: rw [trans_apply, map_coe, Function.comp_apply, trans_apply]
state_before: case a.h
X : Type u_1
Y✝ : Type ?u.304721
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y✝
x y z : X
ι : Type ?u.304736
γ✝ γ : Path x y
γ' : Path y z
Y : Type u_2
inst✝ : TopologicalSpace Y
f : X → Y
h : Continuous f
t : ↑I
⊢ ↑(map (trans γ γ') h) t = ↑(trans (map γ h) (map γ' h)) t

tactic: split_ifs <;> rfl
state_before: case a.h
X : Type u_1
Y✝ : Type ?u.304721
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y✝
x y z : X
ι : Type ?u.304736
γ✝ γ : Path x y
γ' : Path y z
Y : Type u_2
inst✝ : TopologicalSpace Y
f : X → Y
h : Continuous f
t : ↑I
⊢ f
      (if h : ↑t ≤ 1 / 2 then ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
      else ↑γ' { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) }) =
    if h_1 : ↑t ≤ 1 / 2 then ↑(map γ h) { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
    else ↑(map γ' h) { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) }
Theorem: Complex.re_add_im
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: z : ℂ
⊢ (↑z.re + ↑z.im * I).re = z.re ∧ (↑z.re + ↑z.im * I).im = z.im
Theorem: Set.algebraMap_mem_center
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp [Algebra.commutes, Set.mem_center_iff]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
r : R
⊢ ↑(algebraMap R A) r ∈ Set.center A
Theorem: Array.sizeOf_get
File: src/lean/Init/Data/Array/Mem.lean

tactic: cases as
state_before: α : Type u_1
inst✝ : SizeOf α
as : Array α
i : Fin (size as)
⊢ sizeOf (get as i) < sizeOf as

tactic: simp [get]
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
data✝ : List α
i : Fin (size { data := data✝ })
⊢ sizeOf (get { data := data✝ } i) < sizeOf { data := data✝ }

tactic: apply Nat.lt_trans (List.sizeOf_get ..)
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
data✝ : List α
i : Fin (size { data := data✝ })
⊢ sizeOf (List.get data✝ i) < 1 + sizeOf data✝

tactic: simp_arith
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
data✝ : List α
i : Fin (size { data := data✝ })
⊢ sizeOf data✝ < 1 + sizeOf data✝
Theorem: parallelogram_law
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_add_add_self, inner_sub_sub_self]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1814317
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner (x + y) (x + y) + inner (x - y) (x - y) = 2 * (inner x x + inner y y)

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1814317
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x x + inner x y + inner y x + inner y y + (inner x x - inner x y - inner y x + inner y y) =
    2 * (inner x x + inner y y)
Theorem: Submodule.inner_left_of_mem_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: rw [inner_eq_zero_symm]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.23535
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
hu : u ∈ K
hv : v ∈ Kᗮ
⊢ inner v u = 0

tactic: exact inner_right_of_mem_orthogonal hu hv
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.23535
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
hu : u ∈ K
hv : v ∈ Kᗮ
⊢ inner u v = 0
Theorem: Finset.inter_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_comm]
state_before: α : Type u_1
β : Type ?u.181246
γ : Type ?u.181249
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ↔ x✝ ∈ s₂ ∩ s₁
Theorem: List.subset_singleton_iff
File: Mathlib/Data/List/Basic.lean

tactic: simp only [eq_replicate, subset_def, mem_singleton, exists_eq_left']
state_before: ι : Type ?u.18245
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
L : List α
⊢ L ⊆ [a] ↔ ∃ n, L = replicate n a
Theorem: Nat.ModEq.add_left_cancel
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp only [modEq_iff_dvd, Int.ofNat_add] at *
state_before: m n a b c d : ℕ
h₁ : a ≡ b [MOD n]
h₂ : a + c ≡ b + d [MOD n]
⊢ c ≡ d [MOD n]

tactic: rw [add_sub_add_comm] at h₂
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b + ↑d - (↑a + ↑c)
⊢ ↑n ∣ ↑d - ↑c

tactic: convert _root_.dvd_sub h₂ h₁ using 1
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑n ∣ ↑d - ↑c

tactic: rw [add_sub_cancel']
state_before: case h.e'_4
m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑d - ↑c = ↑b - ↑a + (↑d - ↑c) - (↑b - ↑a)
Theorem: IsBoundedLinearMap.zero
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simp [le_refl]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.18308
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
⊢ ∀ (x : E), ‖↑0 x‖ ≤ 0 * ‖x‖
Theorem: PrimeMultiset.prod_zero
File: Mathlib/Data/PNat/Factors.lean

tactic: dsimp [Prod]
state_before: ⊢ prod 0 = 1

tactic: exact Multiset.prod_zero
state_before: ⊢ prod 0 = 1
Theorem: MeasureTheory.SignedMeasure.singularPart_totalVariation
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: have :
  (s.singularPart μ).toJordanDecomposition =
    ⟨s.toJordanDecomposition.posPart.singularPart μ,
      s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
  refine' JordanDecomposition.toSignedMeasure_injective _
  rw [toSignedMeasure_toJordanDecomposition]
  rfl
state_before: α : Type u_1
β : Type ?u.301151
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ totalVariation (singularPart s μ) =
    Measure.singularPart (toJordanDecomposition s).posPart μ + Measure.singularPart (toJordanDecomposition s).negPart μ

tactic: refine' JordanDecomposition.toSignedMeasure_injective _
state_before: α : Type u_1
β : Type ?u.301151
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ toJordanDecomposition (singularPart s μ) =
    JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
      (Measure.singularPart (toJordanDecomposition s).negPart μ)
      (_ :
        Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
          Measure.singularPart (toJordanDecomposition s).negPart μ)

tactic: rw [toSignedMeasure_toJordanDecomposition]
state_before: α : Type u_1
β : Type ?u.301151
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ JordanDecomposition.toSignedMeasure (toJordanDecomposition (singularPart s μ)) =
    JordanDecomposition.toSignedMeasure
      (JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
        (Measure.singularPart (toJordanDecomposition s).negPart μ)
        (_ :
          Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
            Measure.singularPart (toJordanDecomposition s).negPart μ))

tactic: rfl
state_before: α : Type u_1
β : Type ?u.301151
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ singularPart s μ =
    JordanDecomposition.toSignedMeasure
      (JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
        (Measure.singularPart (toJordanDecomposition s).negPart μ)
        (_ :
          Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
            Measure.singularPart (toJordanDecomposition s).negPart μ))

tactic: rw [totalVariation, this]
state_before: α : Type u_1
β : Type ?u.301151
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
this :
  toJordanDecomposition (singularPart s μ) =
    JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
      (Measure.singularPart (toJordanDecomposition s).negPart μ)
      (_ :
        Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
          Measure.singularPart (toJordanDecomposition s).negPart μ)
⊢ totalVariation (singularPart s μ) =
    Measure.singularPart (toJordanDecomposition s).posPart μ + Measure.singularPart (toJordanDecomposition s).negPart μ
Theorem: Real.sin_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sin_add]
state_before: x : ℝ
⊢ sin (x + π / 2) = cos x
Theorem: Bool.true_xor
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases b <;> simp
state_before: b : Bool
⊢ xor true b = !b
Theorem: ENNReal.coe_toNNReal_le_self
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [toNNReal_coe]
state_before: α : Type ?u.18443
β : Type ?u.18446
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
⊢ ↑(ENNReal.toNNReal ↑r) ≤ ↑r
Theorem: Irrational.ne_int
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← Rat.cast_coe_int]
state_before: x : ℝ
h : Irrational x
m : ℤ
⊢ x ≠ ↑m

tactic: exact h.ne_rat _
state_before: x : ℝ
h : Irrational x
m : ℤ
⊢ x ≠ ↑↑m
Theorem: Polynomial.degree_cyclotomic_pos
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [degree_cyclotomic n R, Nat.cast_pos]
state_before: n : ℕ
R : Type u_1
hpos : 0 < n
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ 0 < degree (cyclotomic n R)

tactic: exact Nat.totient_pos hpos
state_before: n : ℕ
R : Type u_1
hpos : 0 < n
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ 0 < Nat.totient n