1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousLinearMap.IsPositive.adjoint_conj
File: Mathlib/Analysis/InnerProductSpace/Positive.lean

tactic: convert hT.conj_adjoint (S†)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : T.IsPositive
S : F →L[𝕜] E
⊢ ((adjoint S).comp (T.comp S)).IsPositive
state_after: case h.e'_7.h.e'_24.h.e'_24
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : T.IsPositive
S : F →L[𝕜] E
⊢ S = adjoint (adjoint S)

tactic: rw [adjoint_adjoint]
state_before: case h.e'_7.h.e'_24.h.e'_24
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : T.IsPositive
S : F →L[𝕜] E
⊢ S = adjoint (adjoint S)
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_inv_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp_rw [pullbackP1Iso, pullback.lift_fst]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.fst = (gluing 𝒰 f g).ι i
state_after: no goals
Theorem: lt_inv_iff_mul_lt_one'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_inv_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b * a < b * b⁻¹ ↔ b * a < 1
state_after: no goals
Theorem: MeasureTheory.Measure.haar.prehaar_sup_eq
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ prehaar (↑K₀) U (K₁ ⊔ K₂) = prehaar (↑K₀) U K₁ + prehaar (↑K₀) U K₂
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)

tactic: rw [div_add_div_same]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = (↑(index (↑K₁) U) + ↑(index (↑K₂) U)) / ↑(index (↑K₀) U)

tactic: refine congr_arg (fun x : ℝ => x / index K₀ U) ?_
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = (↑(index (↑K₁) U) + ↑(index (↑K₂) U)) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) = ↑(index (↑K₁) U) + ↑(index (↑K₂) U)

tactic: exact mod_cast index_union_eq K₁ K₂ hU h
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) = ↑(index (↑K₁) U) + ↑(index (↑K₂) U)
state_after: no goals
Theorem: LieModule.Weight.coe_toLinear_eq_zero_iff
File: Mathlib/Algebra/Lie/Weights/Linear.lean

tactic: ext
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : LinearWeights R L M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
χ : Weight R L M
h : χ.IsZero
⊢ toLinear R L M χ = 0
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : LinearWeights R L M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
χ : Weight R L M
h : χ.IsZero
x✝ : L
⊢ (toLinear R L M χ) x✝ = 0 x✝

tactic: simp [h.eq]
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : LinearWeights R L M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
χ : Weight R L M
h : χ.IsZero
x✝ : L
⊢ (toLinear R L M χ) x✝ = 0 x✝
state_after: no goals
Theorem: List.findIdx?_replicate
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction n with
| zero => simp
| succ n ih =>
  simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, Nat.zero_lt_succ, true_and]
  split <;> simp_all
state_before: n : Nat
α✝ : Type u_1
a : α✝
p : α✝ → Bool
⊢ findIdx? p (replicate n a) = if 0 < n ∧ p a = true then some 0 else none
state_after: no goals

tactic: simp
state_before: case zero
α✝ : Type u_1
a : α✝
p : α✝ → Bool
⊢ findIdx? p (replicate 0 a) = if 0 < 0 ∧ p a = true then some 0 else none
state_after: no goals

tactic: simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, Nat.zero_lt_succ, true_and]
state_before: case succ
α✝ : Type u_1
a : α✝
p : α✝ → Bool
n : Nat
ih : findIdx? p (replicate n a) = if 0 < n ∧ p a = true then some 0 else none
⊢ findIdx? p (replicate (n + 1) a) = if 0 < n + 1 ∧ p a = true then some 0 else none
state_after: case succ
α✝ : Type u_1
a : α✝
p : α✝ → Bool
n : Nat
ih : findIdx? p (replicate n a) = if 0 < n ∧ p a = true then some 0 else none
⊢ (if p a = true then some 0 else Option.map (fun i => i + 1) (findIdx? p (replicate n a))) =
    if p a = true then some 0 else none

tactic: split <;> simp_all
state_before: case succ
α✝ : Type u_1
a : α✝
p : α✝ → Bool
n : Nat
ih : findIdx? p (replicate n a) = if 0 < n ∧ p a = true then some 0 else none
⊢ (if p a = true then some 0 else Option.map (fun i => i + 1) (findIdx? p (replicate n a))) =
    if p a = true then some 0 else none
state_after: no goals
Theorem: CategoryTheory.Cat.leftUnitor_hom_app
File: Mathlib/CategoryTheory/Category/Cat.lean

tactic: simp
state_before: B C : Cat
F : B ⟶ C
X : ↑B
⊢ (𝟙 B ≫ F).obj X = F.obj X
state_after: no goals
Theorem: Batteries.BEqCmp.cmp_iff_eq
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: simp [BEqCmp.cmp_iff_beq]
state_before: α : Type u_1
cmp : α → α → Ordering
x y : α
inst✝² : BEq α
inst✝¹ : LawfulBEq α
inst✝ : BEqCmp cmp
⊢ cmp x y = Ordering.eq ↔ x = y
state_after: no goals
Theorem: CliffordAlgebra.involute_eq_of_mem_even
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: induction x, h using even_induction with
| algebraMap r => exact AlgHom.commutes _ _
| add x y _hx _hy ihx ihy =>
  rw [map_add, ihx, ihy]
| ι_mul_ι_mul m₁ m₂ x _hx ihx =>
  rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg]
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
h : x ∈ evenOdd Q 0
⊢ involute x = x
state_after: no goals

tactic: exact AlgHom.commutes _ _
state_before: case algebraMap
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
r : R
⊢ involute ((algebraMap R (CliffordAlgebra Q)) r) = (algebraMap R (CliffordAlgebra Q)) r
state_after: no goals

tactic: rw [map_add, ihx, ihy]
state_before: case add
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ x y : CliffordAlgebra Q
_hx : x ∈ evenOdd Q 0
_hy : y ∈ evenOdd Q 0
ihx : involute x = x
ihy : involute y = y
⊢ involute (x + y) = x + y
state_after: no goals

tactic: rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg]
state_before: case ι_mul_ι_mul
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ : CliffordAlgebra Q
m₁ m₂ : M
x : CliffordAlgebra Q
_hx : x ∈ evenOdd Q 0
ihx : involute x = x
⊢ involute ((ι Q) m₁ * (ι Q) m₂ * x) = (ι Q) m₁ * (ι Q) m₂ * x
state_after: no goals
Theorem: NumberField.canonicalEmbedding.latticeBasis_apply
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

tactic: simp only [latticeBasis, integralBasis_apply, coe_basisOfLinearIndependentOfCardEqFinrank,
  Function.comp_apply, Equiv.apply_symm_apply]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
i : Free.ChooseBasisIndex ℤ (𝓞 K)
⊢ (latticeBasis K) i = (canonicalEmbedding K) ((integralBasis K) i)
state_after: no goals
Theorem: Set.toFinset_Ioi
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: ext
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
⊢ (Ioi a).toFinset = Finset.Ioi a
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
a✝ : α
⊢ a✝ ∈ (Ioi a).toFinset ↔ a✝ ∈ Finset.Ioi a

tactic: simp
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
a✝ : α
⊢ a✝ ∈ (Ioi a).toFinset ↔ a✝ ∈ Finset.Ioi a
state_after: no goals
Theorem: HasCompactSupport.mul_right
File: Mathlib/Topology/Support.lean

tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : HasCompactSupport f
⊢ HasCompactSupport (f * f')
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0

tactic: exact hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0
state_after: no goals

tactic: simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x✝ : α
hf : f =ᶠ[coclosedCompact α] 0
x : α
hx : f x = 0 x
⊢ (f * f') x = 0 x
state_after: no goals
Theorem: List.inits_reverse
File: Mathlib/Data/List/Infix.lean

tactic: rw [tails_eq_inits l]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse l.tails).reverse
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse (map reverse l.reverse.inits).reverse).reverse

tactic: simp [reverse_involutive.comp_self, ← map_reverse]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse (map reverse l.reverse.inits).reverse).reverse
state_after: no goals
Theorem: PNat.Coprime.gcd_mul_right_cancel
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [mul_comm]
state_before: m n k : ℕ+
⊢ k.Coprime n → (m * k).gcd n = m.gcd n
state_after: m n k : ℕ+
⊢ k.Coprime n → (k * m).gcd n = m.gcd n

tactic: apply Coprime.gcd_mul_left_cancel
state_before: m n k : ℕ+
⊢ k.Coprime n → (k * m).gcd n = m.gcd n
state_after: no goals
Theorem: Asymptotics.isBigO_iff_isBoundedUnder_le_div
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [isBigO_iff, IsBoundedUnder, IsBounded, eventually_map]
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 α
h : ∀ᶠ (x : α) in l, g'' x ≠ 0
⊢ f =O[l] g'' ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖ / ‖g'' x‖
state_after: α : 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 α
h : ∀ᶠ (x : α) in l, g'' x ≠ 0
⊢ (∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g'' x‖) ↔ ∃ b, ∀ᶠ (a : α) in l, ‖f a‖ / ‖g'' a‖ ≤ b

tactic: exact
  exists_congr fun c =>
    eventually_congr <| h.mono fun x hx => (div_le_iff <| norm_pos_iff.2 hx).symm
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 α
h : ∀ᶠ (x : α) in l, g'' x ≠ 0
⊢ (∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g'' x‖) ↔ ∃ b, ∀ᶠ (a : α) in l, ‖f a‖ / ‖g'' a‖ ≤ b
state_after: no goals
Theorem: NumberField.discr_ne_zero
File: Mathlib/NumberTheory/NumberField/Discriminant.lean

tactic: rw [← (Int.cast_injective (α := ℚ)).ne_iff, coe_discr]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
⊢ discr K ≠ 0
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
⊢ Algebra.discr ℚ ⇑(integralBasis K) ≠ ↑0

tactic: exact Algebra.discr_not_zero_of_basis ℚ (integralBasis K)
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
⊢ Algebra.discr ℚ ⇑(integralBasis K) ≠ ↑0
state_after: no goals
Theorem: MeasureTheory.fundamentalFrontier_smul
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp_rw [fundamentalFrontier, smul_set_inter, smul_set_iUnion, smul_comm g (_ : G) (_ : Set α)]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁴ : Group G
inst✝³ : MulAction G α
s : Set α
x : α
inst✝² : Group H
inst✝¹ : MulAction H α
inst✝ : SMulCommClass H G α
g : H
⊢ fundamentalFrontier G (g • s) = g • fundamentalFrontier G s
state_after: no goals
Theorem: isPrimePow_of_minFac_pow_factorization_eq
File: Mathlib/Data/Nat/Factorization/PrimePow.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn')
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
h : n.minFac ^ n.factorization n.minFac = n
hn : n ≠ 1
⊢ IsPrimePow n
state_after: case inl
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k : ℕ
h : Nat.minFac 0 ^ (Nat.factorization 0) (Nat.minFac 0) = 0
hn : 0 ≠ 1
⊢ IsPrimePow 0

case inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
h : n.minFac ^ n.factorization n.minFac = n
hn : n ≠ 1
hn' : n ≠ 0
⊢ IsPrimePow n

tactic: refine ⟨_, _, (Nat.minFac_prime hn).prime, ?_, h⟩
state_before: case inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
h : n.minFac ^ n.factorization n.minFac = n
hn : n ≠ 1
hn' : n ≠ 0
⊢ IsPrimePow n
state_after: case inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
h : n.minFac ^ n.factorization n.minFac = n
hn : n ≠ 1
hn' : n ≠ 0
⊢ 0 < n.factorization n.minFac

tactic: simp [pos_iff_ne_zero, ← Finsupp.mem_support_iff, Nat.support_factorization, hn',
  Nat.minFac_prime hn, Nat.minFac_dvd]
state_before: case inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
h : n.minFac ^ n.factorization n.minFac = n
hn : n ≠ 1
hn' : n ≠ 0
⊢ 0 < n.factorization n.minFac
state_after: no goals

tactic: simp_all
state_before: case inl
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k : ℕ
h : Nat.minFac 0 ^ (Nat.factorization 0) (Nat.minFac 0) = 0
hn : 0 ≠ 1
⊢ IsPrimePow 0
state_after: no goals
Theorem: SetTheory.PGame.leftMoves_mul_cases
File: Mathlib/SetTheory/Game/Basic.lean

tactic: rw [← toLeftMovesMul.apply_symm_apply k]
state_before: x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
⊢ P k
state_after: x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
⊢ P (toLeftMovesMul (toLeftMovesMul.symm k))

tactic: rcases toLeftMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩)
state_before: x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
⊢ P (toLeftMovesMul (toLeftMovesMul.symm k))
state_after: case inl.mk
x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
ix : x.LeftMoves
iy : y.LeftMoves
⊢ P (toLeftMovesMul (Sum.inl (ix, iy)))

case inr.mk
x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
jx : x.RightMoves
jy : y.RightMoves
⊢ P (toLeftMovesMul (Sum.inr (jx, jy)))

tactic: apply hl
state_before: case inl.mk
x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
ix : x.LeftMoves
iy : y.LeftMoves
⊢ P (toLeftMovesMul (Sum.inl (ix, iy)))
state_after: no goals

tactic: apply hr
state_before: case inr.mk
x y : PGame
k : (x * y).LeftMoves
P : (x * y).LeftMoves → Prop
hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (toLeftMovesMul (Sum.inr (jx, jy)))
jx : x.RightMoves
jy : y.RightMoves
⊢ P (toLeftMovesMul (Sum.inr (jx, jy)))
state_after: no goals
Theorem: Pretrivialization.symm_apply_mk_proj
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [← e.coe_fst ex, ← e.coe_coe, e.left_inv ex]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ x : Z
ex : x ∈ e.source
⊢ ↑e.symm (proj x, (↑e x).2) = x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.exact_C₁_up
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: rw [← comp_τ₁, S.w₀₂, zero_τ₁]
state_before: C : Type u_1
inst✝¹ : Category.{?u.25998, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.v₀₁.τ₁ ≫ S.v₁₂.τ₁ = 0
state_after: no goals
Theorem: iSup_iInf_ge_nat_add
File: Mathlib/Order/CompleteLattice.lean

tactic: have hf : Monotone fun n => ⨅ i ≥ n, f i := fun n m h => biInf_mono fun i => h.trans
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i

tactic: rw [← Monotone.iSup_nat_add hf k]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n + k), f i

tactic: simp_rw [iInf_ge_eq_iInf_nat_add, ← Nat.add_assoc]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n + k), f i
state_after: no goals
Theorem: PFun.prodLift_fst_comp_snd_comp
File: Mathlib/Data/PFun.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : α →. γ
g : β →. δ
a : α × β
⊢ ∀ (b : γ × δ), b ∈ (f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) a ↔ b ∈ f.prodMap g a
state_after: no goals