1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: hasMFDerivAt_neg
File: Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean

tactic: convert hf.neg <;> rw [neg_neg]
state_before: 𝕜 : Type u_1
inst✝¹⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁷ : NormedAddCommGroup E
inst✝¹⁶ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹⁵ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹⁴ : TopologicalSpace M
inst✝¹³ : ChartedSpace H M
inst✝¹² : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁹ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁸ : TopologicalSpace M'
inst✝⁷ : ChartedSpace H' M'
inst✝⁶ : SmoothManifoldWithCorners I' M'
E'' : Type u_8
inst✝⁵ : NormedAddCommGroup E''
inst✝⁴ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝³ : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝² : TopologicalSpace M''
inst✝¹ : ChartedSpace H'' M''
inst✝ : SmoothManifoldWithCorners I'' M''
s : Set M
x z : M
f g : M → E'
f' g' : TangentSpace I z →L[𝕜] E'
hf : HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f')
⊢ HasMFDerivAt I 𝓘(𝕜, E') f z f'
state_after: no goals
Theorem: Finset.nonMemberSubfamily_image_insert
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp [eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ nonMemberSubfamily a (image (insert a) 𝒜) = ∅
state_after: no goals
Theorem: EReal.sign_mul_abs
File: Mathlib/Data/Real/EReal.lean

tactic: simp
state_before: ⊢ ↑(sign ⊥) * ↑⊥.abs = ⊥
state_after: no goals

tactic: simp
state_before: ⊢ ↑(sign ⊤) * ↑⊤.abs = ⊤
state_after: no goals

tactic: rw [sign_coe, coe_abs, ← coe_coe_sign, ← coe_mul, sign_mul_abs]
state_before: x : ℝ
⊢ ↑(sign ↑x) * ↑(↑x).abs = ↑x
state_after: no goals
Theorem: List.pairwise_iff_get
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

tactic: rw [pairwise_iff_getElem]
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ Pairwise R l ↔ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
state_after: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]) ↔
    ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)

tactic: constructor <;> intro h
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]) ↔
    ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
state_after: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
⊢ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)

case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
⊢ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]

tactic: intros i j h'
state_before: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
⊢ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
state_after: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
i j : Fin l.length
h' : i < j
⊢ R (l.get i) (l.get j)

tactic: exact h _ _ _ _ h'
state_before: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
i j : Fin l.length
h' : i < j
⊢ R (l.get i) (l.get j)
state_after: no goals

tactic: intros i j hi hj h'
state_before: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
⊢ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
state_after: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ R l[i] l[j]

tactic: exact h ⟨i, hi⟩ ⟨j, hj⟩ h'
state_before: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ R l[i] l[j]
state_after: no goals
Theorem: Metric.isBounded_iff_nndist
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simp only [isBounded_iff_exists_ge 0, NNReal.exists, ← NNReal.coe_le_coe, ← dist_nndist,
  NNReal.coe_mk, exists_prop]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
⊢ IsBounded s ↔ ∃ C, ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → nndist x y ≤ C
state_after: no goals
Theorem: PrimrecPred.and
File: Mathlib/Computability/Primrec.lean

tactic: simp
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 σ
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
hp : PrimrecPred p
hq : PrimrecPred q
n : α
⊢ (decide (p n) && decide (q n)) = decide ((fun a => p a ∧ q a) n)
state_after: no goals
Theorem: TensorAlgebra.GradedAlgebra.ι_apply
File: Mathlib/LinearAlgebra/TensorAlgebra/Grading.lean

tactic: simpa only [pow_one] using LinearMap.mem_range_self _ m
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ (TensorAlgebra.ι R) m ∈ LinearMap.range (TensorAlgebra.ι R) ^ 1
state_after: no goals
Theorem: Dense.smul
File: Mathlib/Topology/Algebra/ConstMulAction.lean

tactic: rw [dense_iff_closure_eq] at hs ⊢
state_before: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : Dense s
⊢ Dense (c • s)
state_after: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : closure s = univ
⊢ closure (c • s) = univ

tactic: rw [closure_smul, hs, smul_set_univ]
state_before: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : closure s = univ
⊢ closure (c • s) = univ
state_after: no goals
Theorem: IsBezout.span_gcd_eq_span_gcd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [Ideal.span_singleton_eq_span_singleton]
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ Ideal.span {GCDMonoid.gcd x y} = Ideal.span {gcd x y}
state_after: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ Associated (GCDMonoid.gcd x y) (gcd x y)

tactic: exact associated_of_dvd_dvd
  (IsBezout.dvd_gcd (GCDMonoid.gcd_dvd_left _ _) <| GCDMonoid.gcd_dvd_right _ _)
  (GCDMonoid.dvd_gcd (IsBezout.gcd_dvd_left _ _) <| IsBezout.gcd_dvd_right _ _)
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ Associated (GCDMonoid.gcd x y) (gcd x y)
state_after: no goals
Theorem: Real.tendsto_Icc_vitaliFamily_left
File: Mathlib/MeasureTheory/Covering/OneDim.lean

tactic: refine (VitaliFamily.tendsto_filterAt_iff _).2 ⟨?_, ?_⟩
state_before: x : ℝ
⊢ Tendsto (fun y => Icc y x) (𝓝[<] x) ((vitaliFamily volume 1).filterAt x)
state_after: case refine_1
x : ℝ
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ∈ (vitaliFamily volume 1).setsAt x

case refine_2
x : ℝ
⊢ ∀ ε > 0, ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε

tactic: filter_upwards [self_mem_nhdsWithin] with y hy using Icc_mem_vitaliFamily_at_left hy
state_before: case refine_1
x : ℝ
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ∈ (vitaliFamily volume 1).setsAt x
state_after: no goals

tactic: intro ε εpos
state_before: case refine_2
x : ℝ
⊢ ∀ ε > 0, ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε
state_after: case refine_2
x ε : ℝ
εpos : ε > 0
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε

tactic: have : x ∈ Ioc (x - ε) x := ⟨by linarith, le_refl _⟩
state_before: case refine_2
x ε : ℝ
εpos : ε > 0
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε
state_after: case refine_2
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε

tactic: filter_upwards [Icc_mem_nhdsWithin_Iio this] with y hy
state_before: case refine_2
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε
state_after: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Metric.closedBall x ε

tactic: rw [closedBall_eq_Icc]
state_before: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Metric.closedBall x ε
state_after: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Icc (x - ε) (x + ε)

tactic: exact Icc_subset_Icc hy.1 (by linarith)
state_before: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Icc (x - ε) (x + ε)
state_after: no goals

tactic: linarith
state_before: x ε : ℝ
εpos : ε > 0
⊢ x - ε < x
state_after: no goals

tactic: linarith
state_before: x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ x ≤ x + ε
state_after: no goals
Theorem: MeasureTheory.lmarginal_congr
File: Mathlib/MeasureTheory/Integral/Marginal.lean

tactic: dsimp [lmarginal, updateFinset_def]
state_before: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝ y✝ : (i : δ) → π i
i : δ
x y : (i : δ) → π i
f : ((i : δ) → π i) → ℝ≥0∞
h : ∀ i ∉ s, x i = y i
⊢ (∫⋯∫⁻_s, f ∂μ) x = (∫⋯∫⁻_s, f ∂μ) y
state_after: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝ y✝ : (i : δ) → π i
i : δ
x y : (i : δ) → π i
f : ((i : δ) → π i) → ℝ≥0∞
h : ∀ i ∉ s, x i = y i
⊢ (∫⁻ (y : (i : { x // x ∈ s }) → π ↑i), f fun i => if hi : i ∈ s then y ⟨i, hi⟩ else x i ∂Measure.pi fun i => μ ↑i) =
    ∫⁻ (y_1 : (i : { x // x ∈ s }) → π ↑i), f fun i => if hi : i ∈ s then y_1 ⟨i, hi⟩ else y i ∂Measure.pi fun i => μ ↑i

tactic: rcongr
state_before: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝ y✝ : (i : δ) → π i
i : δ
x y : (i : δ) → π i
f : ((i : δ) → π i) → ℝ≥0∞
h : ∀ i ∉ s, x i = y i
⊢ (∫⁻ (y : (i : { x // x ∈ s }) → π ↑i), f fun i => if hi : i ∈ s then y ⟨i, hi⟩ else x i ∂Measure.pi fun i => μ ↑i) =
    ∫⁻ (y_1 : (i : { x // x ∈ s }) → π ↑i), f fun i => if hi : i ∈ s then y_1 ⟨i, hi⟩ else y i ∂Measure.pi fun i => μ ↑i
state_after: case e_f.h.e_a.h.e_e.h
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝³ y✝ : (i : δ) → π i
i : δ
x y : (i : δ) → π i
f : ((i : δ) → π i) → ℝ≥0∞
h : ∀ i ∉ s, x i = y i
x✝² : (i : { x // x ∈ s }) → π ↑i
x✝¹ : δ
x✝ : x✝¹ ∉ s
⊢ x x✝¹ = y x✝¹

tactic: exact h _ ‹_›
state_before: case e_f.h.e_a.h.e_e.h
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝³ y✝ : (i : δ) → π i
i : δ
x y : (i : δ) → π i
f : ((i : δ) → π i) → ℝ≥0∞
h : ∀ i ∉ s, x i = y i
x✝² : (i : { x // x ∈ s }) → π ↑i
x✝¹ : δ
x✝ : x✝¹ ∉ s
⊢ x x✝¹ = y x✝¹
state_after: no goals
Theorem: Orientation.norm_kahler
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: simpa using o.abs_kahler x y
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ‖(o.kahler x) y‖ = ‖x‖ * ‖y‖
state_after: no goals
Theorem: CategoryTheory.IsUniversalColimit.whiskerEquivalence_iff
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

tactic: simp
state_before: J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
K✝ : Type u_1
inst✝² : Category.{?u.134693, u_1} K✝
D : Type u_2
inst✝¹ : Category.{?u.134700, u_2} D
K : Type u_3
inst✝ : Category.{u_4, u_3} K
e : J ≌ K
F : K ⥤ C
c : Cocone F
hc : IsUniversalColimit (Cocone.whisker e.functor c)
⊢ ∀ (j : K),
    ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).ι.app
          j ≫
        (Iso.refl
            ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).pt).hom =
      c.ι.app j
state_after: no goals
Theorem: UniqueMul.of_mulOpposite
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: simpa [and_comm] using h (mem_map_of_mem _ bB) (mem_map_of_mem _ aA) (congr_arg op ab)
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul (map { toFun := op, inj' := ⋯ } B) (map { toFun := op, inj' := ⋯ } A) (op b0) (op a0)
a b : G
aA : a ∈ A
bB : b ∈ B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
state_after: no goals
Theorem: zero_zpow_eq
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: split_ifs with h
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℤ
⊢ 0 ^ n = if n = 0 then 1 else 0
state_after: case pos
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℤ
h : n = 0
⊢ 0 ^ n = 1

case neg
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℤ
h : ¬n = 0
⊢ 0 ^ n = 0

tactic: rw [h, zpow_zero]
state_before: case pos
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℤ
h : n = 0
⊢ 0 ^ n = 1
state_after: no goals

tactic: rw [zero_zpow _ h]
state_before: case neg
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℤ
h : ¬n = 0
⊢ 0 ^ n = 0
state_after: no goals
Theorem: Finset.disjoint_union_left
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_left, mem_union, or_imp, forall_and]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ _root_.Disjoint (s ∪ t) u ↔ _root_.Disjoint s u ∧ _root_.Disjoint t u
state_after: no goals
Theorem: Ideal.le_of_pow_le_prime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: by_cases hP0 : P = ⊥
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
⊢ I ≤ P
state_after: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : P = ⊥
⊢ I ≤ P

case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : ¬P = ⊥
⊢ I ≤ P

tactic: rw [← Ideal.dvd_iff_le] at h ⊢
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : ¬P = ⊥
⊢ I ≤ P
state_after: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : P ∣ I ^ n
hP0 : ¬P = ⊥
⊢ P ∣ I

tactic: exact ((Ideal.prime_iff_isPrime hP0).mpr hP).dvd_of_dvd_pow h
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : P ∣ I ^ n
hP0 : ¬P = ⊥
⊢ P ∣ I
state_after: no goals

tactic: simp only [hP0, le_bot_iff] at h ⊢
state_before: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : P = ⊥
⊢ I ≤ P
state_after: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
hP0 : P = ⊥
h : I ^ n = ⊥
⊢ I = ⊥

tactic: exact pow_eq_zero h
state_before: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
hP0 : P = ⊥
h : I ^ n = ⊥
⊢ I = ⊥
state_after: no goals
Theorem: Profinite.NobelingProof.Products.eval_πs'
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: rw [← LocallyConstant.coe_inj, ← LocallyConstant.toFun_eq_coe]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ (πs' C h) (eval (π C fun x => ord I x < o₁) l) = eval (π C fun x => ord I x < o₂) l
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ ((πs' C h) (eval (π C fun x => ord I x < o₁) l)).toFun = ⇑(eval (π C fun x => ord I x < o₂) l)

tactic: exact evalFacProps C (fun (i : I) ↦ ord I i < o₁) (fun (i : I) ↦ ord I i < o₂) hlt
  (fun _ hh ↦ lt_of_lt_of_le hh h)
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ ((πs' C h) (eval (π C fun x => ord I x < o₁) l)).toFun = ⇑(eval (π C fun x => ord I x < o₂) l)
state_after: no goals
Theorem: Cubic.degree_of_b_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_a_eq_zero ha, degree_quadratic hb]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b ≠ 0
⊢ P.toPoly.degree = 2
state_after: no goals
Theorem: integrableOn_Iic_iff_integrableOn_Iio'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [← Iio_union_right, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr hb.lt_top), and_true_iff]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
hb : μ {b} ≠ ⊤
⊢ IntegrableOn f (Iic b) μ ↔ IntegrableOn f (Iio b) μ
state_after: no goals
Theorem: Nat.mod_mul_mod
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [mul_mod, mod_mod, ← mul_mod]
state_before: a✝ b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
a b c : ℕ
⊢ a % c * b % c = a * b % c
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.range_eq_empty_of_isEmpty
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [← Finset.not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ f.range = ∅
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ ¬f.range.Nonempty

tactic: by_contra h
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ ¬f.range.Nonempty
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
h : f.range.Nonempty
⊢ False

tactic: obtain ⟨y, hy_mem⟩ := h
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
h : f.range.Nonempty
⊢ False
state_after: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ f.range
⊢ False

tactic: rw [SimpleFunc.mem_range, Set.mem_range] at hy_mem
state_before: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ f.range
⊢ False
state_after: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, ↑f y_1 = y
⊢ False

tactic: obtain ⟨x, hxy⟩ := hy_mem
state_before: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, ↑f y_1 = y
⊢ False
state_after: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False

tactic: rw [isEmpty_iff] at hα
state_before: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
state_after: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : α → False
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False

tactic: exact hα x
state_before: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : α → False
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
state_after: no goals
Theorem: Real.rpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [rpow_def_of_pos hx, mul_add, exp_add]
state_before: x✝ y✝¹ z✝¹ w x y✝ z✝ : ℝ
hx : 0 < x
y z : ℝ
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: no goals
Theorem: SetTheory.PGame.le_birthday
File: Mathlib/SetTheory/Game/Birthday.lean

tactic: simp [le_birthday (xL i)]
state_before: xl β✝ : Type u_1
xL : xl → PGame
a✝ : β✝ → PGame
i : (mk xl β✝ xL a✝).LeftMoves
⊢ (mk xl β✝ xL a✝).moveLeft i ≤
    (mk xl β✝ xL a✝).birthday.toPGame.moveLeft (toLeftMovesToPGame ⟨((mk xl β✝ xL a✝).moveLeft i).birthday, ⋯⟩)
state_after: no goals
Theorem: Submodule.map_op_one
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: ext x
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ map (↑(opLinearEquiv R)) 1 = 1
state_after: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
x : Aᵐᵒᵖ
⊢ x ∈ map (↑(opLinearEquiv R)) 1 ↔ x ∈ 1

tactic: induction x
state_before: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
x : Aᵐᵒᵖ
⊢ x ∈ map (↑(opLinearEquiv R)) 1 ↔ x ∈ 1
state_after: case h.h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n X✝ : A
⊢ op X✝ ∈ map (↑(opLinearEquiv R)) 1 ↔ op X✝ ∈ 1

tactic: simp
state_before: case h.h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n X✝ : A
⊢ op X✝ ∈ map (↑(opLinearEquiv R)) 1 ↔ op X✝ ∈ 1
state_after: no goals
Theorem: xor_not_not
File: Mathlib/Logic/Basic.lean

tactic: simp [Xor', or_comm, and_comm]
state_before: a b : Prop
⊢ Xor' (¬a) ¬b ↔ Xor' a b
state_after: no goals