1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Mathlib.Tactic.Ring.single_pow
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [*]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
b : ℕ
c : R
x✝ : a ^ b = c
⊢ (a + 0) ^ b = c + 0
state_after: no goals
Theorem: MeasureTheory.neg_llr
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

tactic: filter_upwards [Measure.inv_rnDeriv hμν] with x hx
state_before: α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ -llr μ ν =ᶠ[ae μ] llr ν μ
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ (-llr μ ν) x = llr ν μ x

tactic: rw [Pi.neg_apply, llr, llr, ← log_inv, ← ENNReal.toReal_inv]
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ (-llr μ ν) x = llr ν μ x
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ log (μ.rnDeriv ν x)⁻¹.toReal = log (ν.rnDeriv μ x).toReal

tactic: congr
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ log (μ.rnDeriv ν x)⁻¹.toReal = log (ν.rnDeriv μ x).toReal
state_after: no goals
Theorem: PresheafOfModules.pushforward_map_app_apply
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
R : Dᵒᵖ ⥤ RingCat
S : Cᵒᵖ ⥤ RingCat
φ : S ⟶ F.op ⋙ R
M N : PresheafOfModules R
α : M ⟶ N
X : Cᵒᵖ
m : ↑((ModuleCat.restrictScalars (φ.app X)).obj (M.obj { unop := F.obj X.unop }))
⊢ (Hom.app ((pushforward φ).map α) X) m = (Hom.app α { unop := F.obj X.unop }) m
state_after: no goals
Theorem: Interval.length_sub_le
File: Mathlib/Algebra/Order/Interval/Basic.lean

tactic: simpa [sub_eq_add_neg] using length_add_le s (-t)
state_before: ι : Type u_1
α : Type u_2
inst✝ : OrderedAddCommGroup α
s t : Interval α
a : α
⊢ (s - t).length ≤ s.length + t.length
state_after: no goals
Theorem: FirstOrder.Language.card_functions_sum_skolem₁_le
File: Mathlib/ModelTheory/Skolem.lean

tactic: rw [card_functions_sum_skolem₁]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × (L.sum L.skolem₁).Functions n) ≤ max ℵ₀ L.card
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ max ℵ₀ L.card

tactic: trans #(Σ n, L.BoundedFormula Empty n)
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ max ℵ₀ L.card
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ #((n : ℕ) × L.BoundedFormula Empty n)

L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty n) ≤ max ℵ₀ L.card

tactic: exact
  ⟨⟨Sigma.map Nat.succ fun _ => id,
      Nat.succ_injective.sigma_map fun _ => Function.injective_id⟩⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ #((n : ℕ) × L.BoundedFormula Empty n)
state_after: no goals

tactic: refine _root_.trans BoundedFormula.card_le (lift_le.{max u v}.1 ?_)
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty n) ≤ max ℵ₀ L.card
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ lift.{max u v, max u v} (max ℵ₀ (lift.{max u v, 0} #Empty + lift.{0, max u v} L.card)) ≤
    lift.{max u v, max u v} (max ℵ₀ L.card)

tactic: simp only [mk_empty, lift_zero, lift_uzero, zero_add]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ lift.{max u v, max u v} (max ℵ₀ (lift.{max u v, 0} #Empty + lift.{0, max u v} L.card)) ≤
    lift.{max u v, max u v} (max ℵ₀ L.card)
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ lift.{max u v, max u v} (max ℵ₀ L.card) ≤ lift.{max u v, max u v} (max ℵ₀ L.card)

tactic: rfl
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ lift.{max u v, max u v} (max ℵ₀ L.card) ≤ lift.{max u v, max u v} (max ℵ₀ L.card)
state_after: no goals
Theorem: LinearIndependent.repr_eq_single
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: apply hv.repr_eq
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x✝ y : M
hv : LinearIndependent R v
i : ι
x : ↥(span R (range v))
hx : ↑x = v i
⊢ hv.repr x = Finsupp.single i 1
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x✝ y : M
hv : LinearIndependent R v
i : ι
x : ↥(span R (range v))
hx : ↑x = v i
⊢ (Finsupp.total ι M R v) (Finsupp.single i 1) = ↑x

tactic: simp [Finsupp.total_single, hx]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x✝ y : M
hv : LinearIndependent R v
i : ι
x : ↥(span R (range v))
hx : ↑x = v i
⊢ (Finsupp.total ι M R v) (Finsupp.single i 1) = ↑x
state_after: no goals
Theorem: ContinuousMap.toNNReal_mul_add_neg_mul_add_mul_neg_eq
File: Mathlib/Topology/ContinuousFunction/UniqueCFC.lean

tactic: ext x
state_before: X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
⊢ (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
    (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) x) =
    ↑(((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal) x)

tactic: simp [max_neg_zero, add_mul, mul_add]
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) x) =
    ↑(((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal) x)
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x * g x) 0 + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0) +
      (-(max (f x) 0 * g x) + max (f x) 0 * max (g x) 0) =
    -(f x * g x) + max (f x * g x) 0 + max (f x) 0 * max (g x) 0 +
      (-(max (f x) 0 * g x) + f x * g x + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0))

tactic: abel
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x * g x) 0 + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0) +
      (-(max (f x) 0 * g x) + max (f x) 0 * max (g x) 0) =
    -(f x * g x) + max (f x * g x) 0 + max (f x) 0 * max (g x) 0 +
      (-(max (f x) 0 * g x) + f x * g x + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0))
state_after: no goals
Theorem: List.untrop_prod
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
l : List (Tropical R)
⊢ untrop l.prod = (map untrop l).sum
state_after: case nil
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
⊢ untrop [].prod = (map untrop []).sum

case cons
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
hd : Tropical R
tl : List (Tropical R)
IH : untrop tl.prod = (map untrop tl).sum
⊢ untrop (hd :: tl).prod = (map untrop (hd :: tl)).sum

tactic: simp
state_before: case nil
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
⊢ untrop [].prod = (map untrop []).sum
state_after: no goals

tactic: simp [← IH]
state_before: case cons
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
hd : Tropical R
tl : List (Tropical R)
IH : untrop tl.prod = (map untrop tl).sum
⊢ untrop (hd :: tl).prod = (map untrop (hd :: tl)).sum
state_after: no goals
Theorem: Vector3.append_left
File: Mathlib/Data/Vector3.lean

tactic: simp [*, left]
state_before: α : Type u_1
m✝ n✝ m : ℕ
v : Vector3 α (m + 1)
n : ℕ
w : Vector3 α n
a : α
_t : Vector3 α m
⊢ ((a :: _t) +-+ w) (left n fz) = (a :: _t) fz
state_after: no goals

tactic: simp [append_left, left]
state_before: α : Type u_1
m✝ n✝ m : ℕ
i : Fin2 m
v : Vector3 α (m + 1)
n : ℕ
w : Vector3 α n
_a : α
t : Vector3 α m
⊢ ((_a :: t) +-+ w) (left n i.fs) = (_a :: t) i.fs
state_after: no goals
Theorem: Primrec.ite
File: Mathlib/Computability/Primrec.lean

tactic: simpa [Bool.cond_decide] using cond hc hf hg
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
c : α → Prop
inst✝ : DecidablePred c
f g : α → σ
hc : PrimrecPred c
hf : Primrec f
hg : Primrec g
⊢ Primrec fun a => if c a then f a else g a
state_after: no goals
Theorem: Multiset.singleton_disjoint
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Disjoint]
state_before: α : Type u_1
β : Type v
γ : Type u_2
l : Multiset α
a : α
⊢ {a}.Disjoint l ↔ a ∉ l
state_after: no goals
Theorem: completeSpace_congr
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [completeSpace_iff_isComplete_range he.toUniformInducing, e.range_eq_univ,
  completeSpace_iff_isComplete_univ]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
e : α ≃ β
he : UniformEmbedding ⇑e
⊢ CompleteSpace α ↔ CompleteSpace β
state_after: no goals
Theorem: CochainComplex.mappingCone.lift_fst
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
⊢ (Cochain.ofHom (lift φ α β eq)).comp ↑(fst φ) ⋯ = ↑α
state_after: no goals
Theorem: CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial_hom
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: ext
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsInitial X
⊢ (zeroIsoIsInitial t).hom = 0
state_after: no goals
Theorem: SetTheory.PGame.Impartial.equiv_or_fuzzy_zero
File: Mathlib/SetTheory/Game/Impartial.lean

tactic: rcases lt_or_equiv_or_gt_or_fuzzy G 0 with (h | h | h | h)
state_before: G : PGame
inst✝ : G.Impartial
⊢ G ≈ 0 ∨ G ‖ 0
state_after: case inl
G : PGame
inst✝ : G.Impartial
h : G < 0
⊢ G ≈ 0 ∨ G ‖ 0

case inr.inl
G : PGame
inst✝ : G.Impartial
h : G ≈ 0
⊢ G ≈ 0 ∨ G ‖ 0

case inr.inr.inl
G : PGame
inst✝ : G.Impartial
h : 0 < G
⊢ G ≈ 0 ∨ G ‖ 0

case inr.inr.inr
G : PGame
inst✝ : G.Impartial
h : G ‖ 0
⊢ G ≈ 0 ∨ G ‖ 0

tactic: exact ((nonneg G) h).elim
state_before: case inl
G : PGame
inst✝ : G.Impartial
h : G < 0
⊢ G ≈ 0 ∨ G ‖ 0
state_after: no goals

tactic: exact Or.inl h
state_before: case inr.inl
G : PGame
inst✝ : G.Impartial
h : G ≈ 0
⊢ G ≈ 0 ∨ G ‖ 0
state_after: no goals

tactic: exact ((nonpos G) h).elim
state_before: case inr.inr.inl
G : PGame
inst✝ : G.Impartial
h : 0 < G
⊢ G ≈ 0 ∨ G ‖ 0
state_after: no goals

tactic: exact Or.inr h
state_before: case inr.inr.inr
G : PGame
inst✝ : G.Impartial
h : G ‖ 0
⊢ G ≈ 0 ∨ G ‖ 0
state_after: no goals
Theorem: Ordinal.log_of_not_one_lt_left
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: simp only [log, dif_neg h]
state_before: b : Ordinal.{u_1}
h : ¬1 < b
x : Ordinal.{u_1}
⊢ log b x = 0
state_after: no goals
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.symm
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [BoundedFormula.realize_iff, Iff.comm, ← BoundedFormula.realize_iff]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (ψ ⇔ φ).Realize v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⇔ ψ).Realize v xs

tactic: exact h M v xs
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⇔ ψ).Realize v xs
state_after: no goals
Theorem: List.chain'_pair
File: Mathlib/Data/List/Chain.lean

tactic: simp only [chain'_singleton, chain'_cons, and_true_iff]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b x y : α
⊢ Chain' R [x, y] ↔ R x y
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.naturalityProperty.stableUnderInverse
File: Mathlib/CategoryTheory/MorphismProperty/Composition.lean

tactic: simp only [naturalityProperty] at he ⊢
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : naturalityProperty app e.hom
⊢ naturalityProperty app e.inv
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.inv ≫ app X = app Y ≫ F₂.map e.inv

tactic: rw [← cancel_epi (F₁.map e.hom)]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.inv ≫ app X = app Y ≫ F₂.map e.inv
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.hom ≫ F₁.map e.inv ≫ app X = F₁.map e.hom ≫ app Y ≫ F₂.map e.inv

tactic: slice_rhs 1 2 => rw [he]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.hom ≫ F₁.map e.inv ≫ app X = F₁.map e.hom ≫ app Y ≫ F₂.map e.inv
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.hom ≫ F₁.map e.inv ≫ app X = (app X ≫ F₂.map e.hom) ≫ F₂.map e.inv

tactic: simp only [Category.assoc, ← F₁.map_comp_assoc, ← F₂.map_comp, e.hom_inv_id, Functor.map_id,
  Category.id_comp, Category.comp_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y : C
e : X ≅ Y
he : F₁.map e.hom ≫ app Y = app X ≫ F₂.map e.hom
⊢ F₁.map e.hom ≫ F₁.map e.inv ≫ app X = (app X ≫ F₂.map e.hom) ≫ F₂.map e.inv
state_after: no goals
Theorem: one_le_padicValNat_of_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rwa [← PartENat.coe_le_coe, padicValNat_def' hp.out.ne_one hn, ← pow_dvd_iff_le_multiplicity,
  pow_one]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
div : p ∣ n
⊢ 1 ≤ padicValNat p n
state_after: no goals
Theorem: HurwitzZeta.hasSum_int_cosKernel₀
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: simpa? using hasSum_ite_sub_hasSum (hasSum_int_cosKernel a ht) 0
says simpa only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_pow, ofReal_intCast,
  Int.cast_zero, mul_zero, Complex.exp_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true,
  zero_pow, zero_mul, Real.exp_zero, ofReal_one, mul_one] using
  hasSum_ite_sub_hasSum (hasSum_int_cosKernel a ht) 0
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => if n = 0 then 0 else cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)))
    (↑(cosKernel (↑a) t) - 1)
state_after: no goals

tactic: simpa only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_pow, ofReal_intCast,
Int.cast_zero, mul_zero, Complex.exp_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true,
zero_pow, zero_mul, Real.exp_zero, ofReal_one, mul_one] using
hasSum_ite_sub_hasSum (hasSum_int_cosKernel a ht) 0
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => if n = 0 then 0 else cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)))
    (↑(cosKernel (↑a) t) - 1)
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.not_all_isAtomic
File: Mathlib/ModelTheory/Syntax.lean

tactic: cases con
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : φ.all.IsAtomic
⊢ False
state_after: no goals
Theorem: StarSubalgebra.closedEmbedding_inclusion
File: Mathlib/Topology/Algebra/StarSubalgebra.lean

tactic: convert (Set.range_subtype_map id _).symm
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ Subtype.val ⁻¹' ↑S₁ = range ⇑(inclusion h)
state_after: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ↑S₁ = id '' {x | x ∈ S₁}

case convert_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ∀ x ∈ S₁, id x ∈ S₂

tactic: rw [Set.image_id]
state_before: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ↑S₁ = id '' {x | x ∈ S₁}
state_after: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ↑S₁ = {x | x ∈ S₁}

tactic: rfl
state_before: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ↑S₁ = {x | x ∈ S₁}
state_after: no goals

tactic: intro _ h'
state_before: case convert_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
⊢ ∀ x ∈ S₁, id x ∈ S₂
state_after: case convert_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
x✝ : A
h' : x✝ ∈ S₁
⊢ id x✝ ∈ S₂

tactic: apply h h'
state_before: case convert_4
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
x✝ : A
h' : x✝ ∈ S₁
⊢ id x✝ ∈ S₂
state_after: no goals
Theorem: skewAdjointPart_eq_I_smul_imaginaryPart
File: Mathlib/Data/Complex/Module.lean

tactic: simp [imaginaryPart_apply_coe, smul_smul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
x : A
⊢ ↑((skewAdjointPart ℝ) x) = I • ↑(ℑ x)
state_after: no goals
Theorem: Ideal.mem_quotient_iff_mem_sup
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [← mem_comap, comap_map_of_surjective (Quotient.mk I) Quotient.mk_surjective, ←
  ker_eq_comap_bot, mk_ker]
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I J : Ideal R
x : R
⊢ (Quotient.mk I) x ∈ map (Quotient.mk I) J ↔ x ∈ J ⊔ I
state_after: no goals
Theorem: Cardinal.empty_infinite_Theory_isComplete
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp
state_before: L : Language
κ : Cardinal.{w}
T : L.Theory
⊢ lift.{0, 0} Language.empty.card ≤ lift.{0, 0} ℵ₀
state_after: no goals
Theorem: Complex.eq_re_of_ofReal_le
File: Mathlib/Data/Complex/Order.lean

tactic: rw [eq_comm, ← conj_eq_iff_re, conj_eq_iff_im, ← (Complex.le_def.1 hz).2, Complex.ofReal_im]
state_before: r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z = ↑z.re
state_after: no goals
Theorem: Fin2.rev_rev
File: Mathlib/Data/Fin/Fin2.lean

tactic: induction i <;> simp_all [rev]
state_before: n : ℕ
i : Fin2 n
⊢ i.rev.rev = i
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable'.congr
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean

tactic: obtain ⟨f', hf'_meas, hff'⟩ := hf
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝ : TopologicalSpace β
f g : α → β
hf : AEStronglyMeasurable' m f μ
hfg : f =ᶠ[ae μ] g
⊢ AEStronglyMeasurable' m g μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝ : TopologicalSpace β
f g : α → β
hfg : f =ᶠ[ae μ] g
f' : α → β
hf'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ AEStronglyMeasurable' m g μ

tactic: exact ⟨f', hf'_meas, hfg.symm.trans hff'⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝ : TopologicalSpace β
f g : α → β
hfg : f =ᶠ[ae μ] g
f' : α → β
hf'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ AEStronglyMeasurable' m g μ
state_after: no goals
Theorem: Ideal.spanNorm_singleton
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: obtain ⟨x, hx', rfl⟩ := (Set.mem_image _ _ _).mp hx
state_before: R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : Algebra R S
r : S
x : R
hx : x ∈ ⇑(Algebra.norm R) '' ↑(span {r})
⊢ (Algebra.norm R) r ∣ x
state_after: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : Algebra R S
r x : S
hx' : x ∈ ↑(span {r})
hx : (Algebra.norm R) x ∈ ⇑(Algebra.norm R) '' ↑(span {r})
⊢ (Algebra.norm R) r ∣ (Algebra.norm R) x

tactic: exact map_dvd _ (mem_span_singleton.mp hx')
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : Algebra R S
r x : S
hx' : x ∈ ↑(span {r})
hx : (Algebra.norm R) x ∈ ⇑(Algebra.norm R) '' ↑(span {r})
⊢ (Algebra.norm R) r ∣ (Algebra.norm R) x
state_after: no goals