1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: multipliable_iff_cauchySeq_finset
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: classical exact cauchy_map_iff_exists_tendsto.symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : UniformSpace α
inst✝ : CompleteSpace α
f : β → α
⊢ Multipliable f ↔ CauchySeq fun s => ∏ b ∈ s, f b
state_after: no goals

tactic: exact cauchy_map_iff_exists_tendsto.symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : UniformSpace α
inst✝ : CompleteSpace α
f : β → α
⊢ Multipliable f ↔ CauchySeq fun s => ∏ b ∈ s, f b
state_after: no goals
Theorem: CategoryTheory.Limits.prodComparison_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [prodComparison, prodComparison, prod.lift_map, ← F.map_comp, ← F.map_comp, prod.comp_lift, ←
  F.map_comp, prod.map_fst, ← F.map_comp, prod.map_snd]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁴ : Category.{w, u₂} D
F : C ⥤ D
A A' B B' : C
inst✝³ : HasBinaryProduct A B
inst✝² : HasBinaryProduct A' B'
inst✝¹ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝ : HasBinaryProduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
⊢ F.map (prod.map f g) ≫ prodComparison F A' B' = prodComparison F A B ≫ prod.map (F.map f) (F.map g)
state_after: no goals
Theorem: WeierstrassCurve.coeff_Ψ₃_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rwa [coeff_Ψ₃]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
h : 3 ≠ 0
⊢ W.Ψ₃.coeff 4 ≠ 0
state_after: no goals
Theorem: MonoidHom.coprod_comp_inl
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp [coprod_apply]
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommMonoid P
f : M →* P
g : N →* P
x : M
⊢ ((f.coprod g).comp (inl M N)) x = f x
state_after: no goals
Theorem: Relation.TransGen.tail'
File: Mathlib/Logic/Relation.lean

tactic: induction hab generalizing c with
| refl => exact single hbc
| tail _ hdb IH => exact tail (IH hdb) hbc
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
hbc : r b c
⊢ TransGen r a c
state_after: no goals

tactic: exact single hbc
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b d c : α
hbc : r a c
⊢ TransGen r a c
state_after: no goals

tactic: exact tail (IH hdb) hbc
state_before: case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b d b✝ c✝ : α
a✝ : ReflTransGen r a b✝
hdb : r b✝ c✝
IH : ∀ {c : α}, r b✝ c → TransGen r a c
c : α
hbc : r c✝ c
⊢ TransGen r a c
state_after: no goals
Theorem: MvPolynomial.bind₂_map
File: Mathlib/Algebra/MvPolynomial/Monad.lean

tactic: simp [bind₂]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : S →+* MvPolynomial σ T
g : R →+* S
φ : MvPolynomial σ R
⊢ (bind₂ f) ((map g) φ) = (bind₂ (f.comp g)) φ
state_after: no goals
Theorem: Finset.Nat.antidiagonal_eq_image
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: simp only [antidiagonal_eq_map, map_eq_image, Function.Embedding.coeFn_mk]
state_before: n : ℕ
⊢ antidiagonal n = image (fun i => (i, n - i)) (range (n + 1))
state_after: no goals
Theorem: Complex.ofReal_tanh_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← tanh_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (tanh ↑x) = tanh ↑x
state_after: no goals
Theorem: midpoint_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [← vsub_sub_vsub_cancel_right p₁ p p₂, smul_sub, sub_eq_add_neg, ← smul_neg,
  neg_vsub_eq_vsub_rev, add_assoc, invOf_two_smul_add_invOf_two_smul, ← vadd_vsub_assoc,
  midpoint_comm, midpoint, lineMap_apply]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p₁ p₂ p : P
⊢ midpoint R p₁ p₂ -ᵥ p = ⅟2 • (p₁ -ᵥ p) + ⅟2 • (p₂ -ᵥ p)
state_after: no goals
Theorem: Filter.sInter_lift_sets
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [sInter_eq_biInter, mem_setOf_eq, Filter.mem_sets, mem_lift_sets hg, iInter_exists,
  iInter_and, @iInter_comm _ (Set β)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
hg : Monotone g
⊢ ⋂₀ {s | s ∈ f.lift g} = ⋂ s ∈ f, ⋂₀ {t | t ∈ g s}
state_after: no goals
Theorem: rank_matrix'
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: rw [rank_matrix, lift_mul, lift_umax.{v, u}]
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹² : Ring R
inst✝¹¹ : CommRing S
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : StrongRankCondition R
inst✝³ : Module.Free R M
inst✝² : Module.Free R M'
m n : Type v
inst✝¹ : Finite m
inst✝ : Finite n
⊢ Module.rank R (Matrix m n R) = lift.{u, v} (#m * #n)
state_after: no goals
Theorem: HasDerivAtFilter.scomp
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: simpa using ((hg.restrictScalars 𝕜).comp x hh hL).hasDerivAtFilter
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hg : HasDerivAtFilter g₁ g₁' (h x) L'
hh : HasDerivAtFilter h h' x L
hL : Tendsto h L L'
⊢ HasDerivAtFilter (g₁ ∘ h) (h' • g₁') x L
state_after: no goals
Theorem: MeasureTheory.integral_eq_zero_of_mul_left_eq_neg
File: Mathlib/MeasureTheory/Group/Integral.lean

tactic: simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_left_eq_self]
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulLeftInvariant
hf' : ∀ (x : G), f (g * x) = -f x
⊢ ∫ (x : G), f x ∂μ = 0
state_after: no goals
Theorem: SatisfiesM.imp
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

tactic: rw [← h, ← comp_map]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
        x =
    x✝
state_after: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ (Subtype.val ∘ fun x =>
        match x with
        | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
      x =
    Subtype.val <$> x

tactic: rfl
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ (Subtype.val ∘ fun x =>
        match x with
        | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
      x =
    Subtype.val <$> x
state_after: no goals
Theorem: Asymptotics.IsBigO.eq_zero_of_norm_pow_within
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp_rw [sub_self, norm_zero, zero_pow hn]
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 α
f : E'' → F''
s : Set E''
x₀ : E''
n : ℕ
h : f =O[𝓝[s] x₀] fun x => ‖x - x₀‖ ^ n
hx₀ : x₀ ∈ s
hn : n ≠ 0
⊢ ‖x₀ - x₀‖ ^ n = 0
state_after: no goals
Theorem: CategoryTheory.Limits.equalizer.isoSourceOfSelf_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ 𝟙 X ≫ f = 𝟙 X ≫ f
state_after: no goals

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ (isoSourceOfSelf f).inv = lift (𝟙 X) ⋯
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ (isoSourceOfSelf f).inv ≫ ι f f = lift (𝟙 X) ⋯ ≫ ι f f

tactic: simp [equalizer.isoSourceOfSelf]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ (isoSourceOfSelf f).inv ≫ ι f f = lift (𝟙 X) ⋯ ≫ ι f f
state_after: no goals
Theorem: LeftOrdContinuous.lt_iff
File: Mathlib/Order/OrdContinuous.lean

tactic: simp only [lt_iff_le_not_le, hf.le_iff h]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
hf : LeftOrdContinuous f
h : Injective f
x y : α
⊢ f x < f y ↔ x < y
state_after: no goals
Theorem: Sylow.characteristic_of_normal
File: Mathlib/GroupTheory/Sylow.lean

tactic: haveI := Sylow.unique_of_normal P h
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
⊢ (↑P).Characteristic
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
⊢ (↑P).Characteristic

tactic: rw [characteristic_iff_map_eq]
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
⊢ (↑P).Characteristic
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
⊢ ∀ (ϕ : G ≃* G), Subgroup.map ϕ.toMonoidHom ↑P = ↑P

tactic: intro Φ
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
⊢ ∀ (ϕ : G ≃* G), Subgroup.map ϕ.toMonoidHom ↑P = ↑P
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ Subgroup.map Φ.toMonoidHom ↑P = ↑P

tactic: show (Φ • P).toSubgroup = P.toSubgroup
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ Subgroup.map Φ.toMonoidHom ↑P = ↑P
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ ↑(Φ • P) = ↑P

tactic: congr
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ ↑(Φ • P) = ↑P
state_after: case e_self
G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ Φ • P = P

tactic: simp [eq_iff_true_of_subsingleton]
state_before: case e_self
G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
h : (↑P).Normal
this : Unique (Sylow p G)
Φ : G ≃* G
⊢ Φ • P = P
state_after: no goals
Theorem: TopologicalSpace.IsTopologicalBasis.dense_iff
File: Mathlib/Topology/Bases.lean

tactic: simp only [Dense, hb.mem_closure_iff]
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
b : Set (Set α)
hb : IsTopologicalBasis b
s : Set α
⊢ Dense s ↔ ∀ o ∈ b, o.Nonempty → (o ∩ s).Nonempty
state_after: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
b : Set (Set α)
hb : IsTopologicalBasis b
s : Set α
⊢ (∀ (x : α), ∀ o ∈ b, x ∈ o → (o ∩ s).Nonempty) ↔ ∀ o ∈ b, o.Nonempty → (o ∩ s).Nonempty

tactic: exact ⟨fun h o hb ⟨a, ha⟩ => h a o hb ha, fun h a o hb ha => h o hb ⟨a, ha⟩⟩
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
b : Set (Set α)
hb : IsTopologicalBasis b
s : Set α
⊢ (∀ (x : α), ∀ o ∈ b, x ∈ o → (o ∩ s).Nonempty) ↔ ∀ o ∈ b, o.Nonempty → (o ∩ s).Nonempty
state_after: no goals
Theorem: Set.isCompl_range_inl_range_inr
File: Mathlib/Data/Set/Image.lean

tactic: rintro y ⟨⟨x₁, rfl⟩, ⟨x₂, h⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
⊢ range Sum.inl ⊓ range Sum.inr ≤ ⊥
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
x₁ : α
x₂ : β
h : Sum.inr x₂ = Sum.inl x₁
⊢ Sum.inl x₁ ∈ ⊥

tactic: exact Sum.noConfusion h
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
x₁ : α
x₂ : β
h : Sum.inr x₂ = Sum.inl x₁
⊢ Sum.inl x₁ ∈ ⊥
state_after: no goals

tactic: rintro (x | y) - <;> [left; right] <;> exact mem_range_self _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
⊢ ⊤ ≤ range Sum.inl ⊔ range Sum.inr
state_after: no goals
Theorem: Fintype.card_subtype_lt
File: Mathlib/Data/Fintype/Card.lean

tactic: rwa [Subtype.range_coe_subtype]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
hx : ¬p x
⊢ ?m.37844 ∉ Set.range Subtype.val
state_after: no goals
Theorem: CliffordAlgebra.ι_mul_ι_add_swap_of_isOrtho
File: Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean

tactic: rw [ι_mul_ι_add_swap, h.polar_eq_zero]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
a b : M
h : Q.IsOrtho a b
⊢ (ι Q) a * (ι Q) b + (ι Q) b * (ι Q) a = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
a b : M
h : Q.IsOrtho a b
⊢ (algebraMap R (CliffordAlgebra Q)) 0 = 0

tactic: simp
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
a b : M
h : Q.IsOrtho a b
⊢ (algebraMap R (CliffordAlgebra Q)) 0 = 0
state_after: no goals
Theorem: Matrix.frobenius_norm_col
File: Mathlib/Analysis/Matrix.lean

tactic: simp_rw [frobenius_norm_def, Fintype.sum_unique, PiLp.norm_eq_of_L2, Real.sqrt_eq_rpow]
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
v : n → α
⊢ ‖col ι v‖ = ‖(WithLp.equiv 2 (n → α)).symm v‖
state_after: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
v : n → α
⊢ (∑ x : n, ‖col ι v x default‖ ^ 2) ^ (1 / 2) = (∑ i : n, ‖(WithLp.equiv 2 (n → α)).symm v i‖ ^ 2) ^ (1 / 2)

tactic: simp only [col_apply, Real.rpow_two, WithLp.equiv_symm_pi_apply]
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
v : n → α
⊢ (∑ x : n, ‖col ι v x default‖ ^ 2) ^ (1 / 2) = (∑ i : n, ‖(WithLp.equiv 2 (n → α)).symm v i‖ ^ 2) ^ (1 / 2)
state_after: no goals
Theorem: fourier_zero
File: Mathlib/Analysis/Fourier/AddCircle.lean

tactic: induction x using QuotientAddGroup.induction_on'
state_before: T : ℝ
x : AddCircle T
⊢ (fourier 0) x = 1
state_after: case H
T z✝ : ℝ
⊢ (fourier 0) ↑z✝ = 1

tactic: simp only [fourier_coe_apply]
state_before: case H
T z✝ : ℝ
⊢ (fourier 0) ↑z✝ = 1
state_after: case H
T z✝ : ℝ
⊢ Complex.exp (2 * ↑π * Complex.I * ↑0 * ↑z✝ / ↑T) = 1

tactic: norm_num
state_before: case H
T z✝ : ℝ
⊢ Complex.exp (2 * ↑π * Complex.I * ↑0 * ↑z✝ / ↑T) = 1
state_after: no goals
Theorem: Set.smul_set_neg
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← image_smul, ← image_neg, image_image, smul_neg]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Monoid α
inst✝¹ : AddGroup β
inst✝ : DistribMulAction α β
a : α
s : Set α
t : Set β
⊢ a • -t = -(a • t)
state_after: no goals
Theorem: ProbabilityTheory.iIndepFun.cgf_sum
File: Mathlib/Probability/Moments.lean

tactic: simp_rw [cgf]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ cgf (∑ i ∈ s, X i) μ t = ∑ i ∈ s, cgf (X i) μ t
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ log (mgf (∑ i ∈ s, X i) μ t) = ∑ x ∈ s, log (mgf (X x) μ t)

tactic: rw [← log_prod _ _ fun j hj => ?_]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ log (mgf (∑ i ∈ s, X i) μ t) = ∑ x ∈ s, log (mgf (X x) μ t)
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ log (mgf (∑ i ∈ s, X i) μ t) = log (∏ i ∈ s, mgf (X i) μ t)

Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
j : ι
hj : j ∈ s
⊢ mgf (X j) μ t ≠ 0

tactic: rw [h_indep.mgf_sum h_meas]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ log (mgf (∑ i ∈ s, X i) μ t) = log (∏ i ∈ s, mgf (X i) μ t)
state_after: no goals

tactic: exact (mgf_pos (h_int j hj)).ne'
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsProbabilityMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun i => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
s : Finset ι
h_int : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
j : ι
hj : j ∈ s
⊢ mgf (X j) μ t ≠ 0
state_after: no goals
Theorem: Real.rpow_def_of_nonpos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: split_ifs with h <;> simp [rpow_def, *]
state_before: x✝ y✝ z x : ℝ
hx : x ≤ 0
y : ℝ
⊢ x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y) * cos (y * π)
state_after: case neg
x✝ y✝ z x : ℝ
hx : x ≤ 0
y : ℝ
h : ¬x = 0
⊢ (↑x ^ ↑y).re = rexp (log x * y) * cos (y * π)

tactic: exact rpow_def_of_neg (lt_of_le_of_ne hx h) _
state_before: case neg
x✝ y✝ z x : ℝ
hx : x ≤ 0
y : ℝ
h : ¬x = 0
⊢ (↑x ^ ↑y).re = rexp (log x * y) * cos (y * π)
state_after: no goals
Theorem: Nat.sum_divisors_eq_sum_properDivisors_add_self
File: Mathlib/NumberTheory/Divisors.lean

tactic: rcases Decidable.eq_or_ne n 0 with (rfl | hn)
state_before: n : ℕ
⊢ ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n
state_after: case inl

⊢ ∑ i ∈ divisors 0, i = ∑ i ∈ properDivisors 0, i + 0

case inr
n : ℕ
hn : n ≠ 0
⊢ ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n

tactic: simp
state_before: case inl

⊢ ∑ i ∈ divisors 0, i = ∑ i ∈ properDivisors 0, i + 0
state_after: no goals

tactic: rw [← cons_self_properDivisors hn, Finset.sum_cons, add_comm]
state_before: case inr
n : ℕ
hn : n ≠ 0
⊢ ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.OpenCover.iSup_opensRange
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

tactic: rw [Opens.coe_iSup]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ↑(⨆ i, Hom.opensRange (𝒰.map i)) = ↑⊤
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ⋃ i, ↑(Hom.opensRange (𝒰.map i)) = ↑⊤

tactic: exact 𝒰.iUnion_range
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ⋃ i, ↑(Hom.opensRange (𝒰.map i)) = ↑⊤
state_after: no goals