1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.prod_isUnit_iff
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: refine ⟨fun h => ?_, prod_isUnit⟩
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
⊢ IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m

tactic: induction' L with m L ih
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m
state_after: case nil
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
h : IsUnit [].prod
⊢ ∀ m ∈ [], IsUnit m

case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1

tactic: rw [prod_cons, IsUnit.mul_iff] at h
state_before: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1

tactic: exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
state_before: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: no goals

tactic: exact fun m' h' => False.elim (not_mem_nil m' h')
state_before: case nil
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
h : IsUnit [].prod
⊢ ∀ m ∈ [], IsUnit m
state_after: no goals
Theorem: inner_self_eq_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [pow_two, inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ re ⟪x, x⟫_𝕜 = ‖x‖ ^ 2
state_after: no goals
Theorem: Ideal.mul_sub_mul_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [show a * c - b * d = (a - b) * c + b * (c - d) by rw [sub_mul, mul_sub]; abel]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d ∈ I
state_after: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ (a - b) * c + b * (c - d) ∈ I

tactic: exact I.add_mem (I.mul_mem_right _ h1) (I.mul_mem_left _ h2)
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ (a - b) * c + b * (c - d) ∈ I
state_after: no goals

tactic: rw [sub_mul, mul_sub]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d = (a - b) * c + b * (c - d)
state_after: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d = a * c - b * c + (b * c - b * d)

tactic: abel
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d = a * c - b * c + (b * c - b * d)
state_after: no goals
Theorem: Int.units_mul_self
File: Mathlib/Data/Int/Order/Units.lean

tactic: rw [← sq, units_sq]
state_before: u : ℤˣ
⊢ u * u = 1
state_after: no goals
Theorem: NonUnitalAlgHom.coe_mulHom_mk
File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

tactic: rfl
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f : A →ₛₙₐ[φ] B
h₁ : ∀ (m : R) (x : A), f (m • x) = φ m • f x
h₂ : { toFun := ⇑f, map_smul' := h₁ }.toFun 0 = 0
h₃ :
  ∀ (x y : A),
    { toFun := ⇑f, map_smul' := h₁ }.toFun (x + y) =
      { toFun := ⇑f, map_smul' := h₁ }.toFun x + { toFun := ⇑f, map_smul' := h₁ }.toFun y
h₄ :
  ∀ (x y : A),
    { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun (x * y) =
      { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun x *
        { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun y
⊢ ↑{ toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } = { toFun := ⇑f, map_mul' := h₄ }
state_after: no goals
Theorem: Cardinal.card_le_of_le_ord
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← card_ord c]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c.ord.card

tactic: exact Ordinal.card_le_card ho
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c.ord.card
state_after: no goals
Theorem: Nat.Prime.pow_dvd_iff_dvd_ord_proj
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [pow_dvd_pow_iff_le_right pp.one_lt, pp.pow_dvd_iff_le_factorization hn]
state_before: a b m n✝ p✝ p k n : ℕ
pp : Prime p
hn : n ≠ 0
⊢ p ^ k ∣ n ↔ p ^ k ∣ p ^ n.factorization p
state_after: no goals
Theorem: schnirelmannDensity_le_div
File: Mathlib/Combinatorics/Schnirelmann.lean

tactic: positivity
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
n : ℕ
hn : n ≠ 0
x✝¹ : ℝ
x✝ : x✝¹ ∈ Set.range fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n
w✝ : { n // 0 < n }
hx : (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝ = x✝¹
⊢ 0 ≤ (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝
state_after: no goals
Theorem: CategoryTheory.Limits.Pi.map'_comp_map'
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: ext
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
⊢ map' p q ≫ map' p' q' = map' (p ∘ p') fun c => q (p' c) ≫ q' c
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
b✝ : γ
⊢ (map' p q ≫ map' p' q') ≫ π h b✝ = (map' (p ∘ p') fun c => q (p' c) ≫ q' c) ≫ π h b✝

tactic: simp
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
b✝ : γ
⊢ (map' p q ≫ map' p' q') ≫ π h b✝ = (map' (p ∘ p') fun c => q (p' c) ≫ q' c) ≫ π h b✝
state_after: no goals
Theorem: Finsupp.toMultiset_inf
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f g : α →₀ ℕ
⊢ toMultiset (f ⊓ g) = toMultiset f ∩ toMultiset g
state_after: case a
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f g : α →₀ ℕ
a✝ : α
⊢ Multiset.count a✝ (toMultiset (f ⊓ g)) = Multiset.count a✝ (toMultiset f ∩ toMultiset g)

tactic: simp_rw [Multiset.count_inter, Finsupp.count_toMultiset, Finsupp.inf_apply, inf_eq_min]
state_before: case a
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f g : α →₀ ℕ
a✝ : α
⊢ Multiset.count a✝ (toMultiset (f ⊓ g)) = Multiset.count a✝ (toMultiset f ∩ toMultiset g)
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.continuous_mass
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp_rw [← testAgainstNN_one]
state_before: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
⊢ Continuous fun μ => μ.mass
state_after: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
⊢ Continuous fun μ => μ.testAgainstNN 1

tactic: exact continuous_testAgainstNN_eval 1
state_before: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
⊢ Continuous fun μ => μ.testAgainstNN 1
state_after: no goals
Theorem: SemiNormedGrp.explicitCokernelDesc_normNoninc
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

tactic: refine NormedAddGroupHom.NormNoninc.normNoninc_iff_norm_le_one.2 ?_
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
hg : NormedAddGroupHom.NormNoninc g
⊢ NormedAddGroupHom.NormNoninc (explicitCokernelDesc cond)
state_after: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
hg : NormedAddGroupHom.NormNoninc g
⊢ ‖explicitCokernelDesc cond‖ ≤ 1

tactic: rw [← NNReal.coe_one]
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
hg : NormedAddGroupHom.NormNoninc g
⊢ ‖explicitCokernelDesc cond‖ ≤ 1
state_after: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
hg : NormedAddGroupHom.NormNoninc g
⊢ ‖explicitCokernelDesc cond‖ ≤ ↑1

tactic: exact
  explicitCokernelDesc_norm_le_of_norm_le cond 1
    (NormedAddGroupHom.NormNoninc.normNoninc_iff_norm_le_one.1 hg)
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
hg : NormedAddGroupHom.NormNoninc g
⊢ ‖explicitCokernelDesc cond‖ ≤ ↑1
state_after: no goals
Theorem: div_nonpos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [division_def, mul_nonpos_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
state_after: no goals
Theorem: MeasureTheory.ProgMeasurable.adapted
File: Mathlib/Probability/Process/Adapted.lean

tactic: intro i
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
⊢ Adapted f u
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
⊢ StronglyMeasurable (u i)

tactic: have : u i = (fun p : Set.Iic i × Ω => u p.1 p.2) ∘ fun x => (⟨i, Set.mem_Iic.mpr le_rfl⟩, x) :=
  rfl
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
⊢ StronglyMeasurable (u i)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
this : u i = (fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x)
⊢ StronglyMeasurable (u i)

tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
this : u i = (fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x)
⊢ StronglyMeasurable (u i)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
this : u i = (fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x)
⊢ StronglyMeasurable ((fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x))

tactic: exact (h i).comp_measurable measurable_prod_mk_left
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : TopologicalSpace β
inst✝¹ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝ : MeasurableSpace ι
h : ProgMeasurable f u
i : ι
this : u i = (fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x)
⊢ StronglyMeasurable ((fun p => u (↑p.1) p.2) ∘ fun x => (⟨i, ⋯⟩, x))
state_after: no goals
Theorem: Nat.multichoose_one_right
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction' n with n IH
state_before: n : ℕ
⊢ n.multichoose 1 = n
state_after: case zero

⊢ multichoose 0 1 = 0

case succ
n : ℕ
IH : n.multichoose 1 = n
⊢ (n + 1).multichoose 1 = n + 1

tactic: simp [multichoose_succ_succ n 0, IH]
state_before: case succ
n : ℕ
IH : n.multichoose 1 = n
⊢ (n + 1).multichoose 1 = n + 1
state_after: no goals

tactic: simp
state_before: case zero

⊢ multichoose 0 1 = 0
state_after: no goals
Theorem: List.nodupKeys_cons
File: Mathlib/Data/List/Sigma.lean

tactic: simp [keys, NodupKeys]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
s : Sigma β
l : List (Sigma β)
⊢ (s :: l).NodupKeys ↔ s.fst ∉ l.keys ∧ l.NodupKeys
state_after: no goals
Theorem: EuclideanGeometry.eq_zero_or_angle_eq_zero_or_pi_of_sign_oangle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: convert o.eq_zero_or_angle_eq_zero_or_pi_of_sign_oangle_eq_zero h <;> simp
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p p₁ p₂ : P
h : (∡ p₁ p p₂).sign = 0
⊢ p₁ = p ∨ p₂ = p ∨ ∠ p₁ p p₂ = 0 ∨ ∠ p₁ p p₂ = π
state_after: no goals
Theorem: Nat.zero_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial_succ, ascFactorial_zero, Nat.zero_add, Nat.zero_mul]
state_before: ⊢ ascFactorial 0 (succ 0) = 0
state_after: no goals

tactic: rw [ascFactorial_succ, zero_ascFactorial k, Nat.mul_zero]
state_before: k : ℕ
⊢ ascFactorial 0 (k + 1).succ = 0
state_after: no goals
Theorem: Zspan.map_fundamentalDomain
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

tactic: ext x
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
⊢ ⇑f '' fundamentalDomain b = fundamentalDomain (b.map f)
state_after: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ fundamentalDomain (b.map f)

tactic: rw [mem_fundamentalDomain, Basis.map_repr, LinearEquiv.trans_apply, ← mem_fundamentalDomain,
  show f.symm x = f.toEquiv.symm x by rfl, ← Set.mem_image_equiv]
state_before: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ fundamentalDomain (b.map f)
state_after: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ ⇑f.toEquiv '' fundamentalDomain b

tactic: rfl
state_before: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ ⇑f.toEquiv '' fundamentalDomain b
state_after: no goals

tactic: rfl
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ f.symm x = f.toEquiv.symm x
state_after: no goals
Theorem: MeasureTheory.extend_iUnion_nat
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

tactic: congr with i
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU✝ : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
f : ℕ → Set α
hm : ∀ (i : ℕ), P (f i)
mU : m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
⊢ ∑' (i : ℕ), m (f i) ⋯ = ∑' (i : ℕ), extend m (f i)
state_after: case e_f.h
α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU✝ : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
f : ℕ → Set α
hm : ∀ (i : ℕ), P (f i)
mU : m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
i : ℕ
⊢ m (f i) ⋯ = extend m (f i)

tactic: rw [extend_eq]
state_before: case e_f.h
α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU✝ : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
f : ℕ → Set α
hm : ∀ (i : ℕ), P (f i)
mU : m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
i : ℕ
⊢ m (f i) ⋯ = extend m (f i)
state_after: no goals
Theorem: SetTheory.PGame.mulOption_neg_neg
File: Mathlib/SetTheory/Game/Basic.lean

tactic: dsimp only [mulOption]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.mulOption y i j = x.mulOption (- -y) i (toLeftMovesNeg (toRightMovesNeg j))
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j =
    x.moveLeft i * - -y + x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j)) -
      x.moveLeft i * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

tactic: congr 2
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j =
    x.moveLeft i * - -y + x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j)) -
      x.moveLeft i * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y = x.moveLeft i * - -y

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

tactic: rw [neg_neg]
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y = x.moveLeft i * - -y

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

tactic: iterate 2 rw [moveLeft_neg, moveRight_neg, neg_neg]
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: no goals

tactic: rw [moveLeft_neg, moveRight_neg, neg_neg]
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: no goals
Theorem: real_inner_div_norm_mul_norm_eq_neg_one_of_ne_zero_of_neg_mul
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [real_inner_smul_self_right, norm_smul, Real.norm_eq_abs, ← mul_assoc ‖x‖, mul_comm _ |r|,
  mul_assoc, abs_of_neg hr, neg_mul, div_neg_eq_neg_div, div_self]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : r < 0
⊢ ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = -1
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : r < 0
⊢ r * (‖x‖ * ‖x‖) ≠ 0

tactic: exact mul_ne_zero hr.ne (mul_self_ne_zero.2 (norm_ne_zero_iff.2 hx))
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : r < 0
⊢ r * (‖x‖ * ‖x‖) ≠ 0
state_after: no goals