1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: BoxIntegral.Box.coe_inf
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: induction I
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑(I ⊓ J) = ↑I ∩ ↑J
state_after: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ↑(⊥ ⊓ J) = ↑⊥ ∩ ↑J

case coe
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
a✝ : Box ι
⊢ ↑(↑a✝ ⊓ J) = ↑↑a✝ ∩ ↑J

tactic: induction J
state_before: case coe
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
a✝ : Box ι
⊢ ↑(↑a✝ ⊓ J) = ↑↑a✝ ∩ ↑J
state_after: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ↑(↑a✝ ⊓ ⊥) = ↑↑a✝ ∩ ↑⊥

case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑(↑a✝¹ ⊓ ↑a✝) = ↑↑a✝¹ ∩ ↑↑a✝

tactic: change ((mk' _ _ : WithBot (Box ι)) : Set (ι → ℝ)) = _
state_before: case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑(↑a✝¹ ⊓ ↑a✝) = ↑↑a✝¹ ∩ ↑↑a✝
state_after: case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑(mk' (a✝¹.lower ⊔ a✝.lower) (a✝¹.upper ⊓ a✝.upper)) = ↑↑a✝¹ ∩ ↑↑a✝

tactic: simp only [coe_eq_pi, ← pi_inter_distrib, Ioc_inter_Ioc, Pi.sup_apply, Pi.inf_apply, coe_mk',
  coe_coe]
state_before: case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑(mk' (a✝¹.lower ⊔ a✝.lower) (a✝¹.upper ⊓ a✝.upper)) = ↑↑a✝¹ ∩ ↑↑a✝
state_after: no goals

tactic: change ∅ = _
state_before: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ↑(⊥ ⊓ J) = ↑⊥ ∩ ↑J
state_after: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ∅ = ↑⊥ ∩ ↑J

tactic: simp
state_before: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ∅ = ↑⊥ ∩ ↑J
state_after: no goals

tactic: change ∅ = _
state_before: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ↑(↑a✝ ⊓ ⊥) = ↑↑a✝ ∩ ↑⊥
state_after: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ∅ = ↑↑a✝ ∩ ↑⊥

tactic: simp
state_before: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ∅ = ↑↑a✝ ∩ ↑⊥
state_after: no goals
Theorem: orthogonalProjection_unit_singleton
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← smul_orthogonalProjection_singleton 𝕜 w]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ⟪v, w⟫_𝕜 • v
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ↑(‖v‖ ^ 2) • ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w)

tactic: simp [hv]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ↑(‖v‖ ^ 2) • ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w)
state_after: no goals
Theorem: ProbabilityTheory.setIntegral_stieltjesOfMeasurableRat_rat
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

tactic: rw [setIntegral_congr_ae hs (g := fun b ↦ f (a, b) q) ?_, hf.setIntegral a hs]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∫ (b : β) in s, ↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑q ∂ν a = ((κ a) (s ×ˢ Iic ↑q)).toReal
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∀ᵐ (x : β) ∂ν a, x ∈ s → ↑(stieltjesOfMeasurableRat f ⋯ (a, x)) ↑q = (fun b => f (a, b) q) x

tactic: filter_upwards [stieltjesOfMeasurableRat_ae_eq hf a q] with b hb using fun _ ↦ hb
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∀ᵐ (x : β) ∂ν a, x ∈ s → ↑(stieltjesOfMeasurableRat f ⋯ (a, x)) ↑q = (fun b => f (a, b) q) x
state_after: no goals
Theorem: Function.Antiperiodic.const_sub
File: Mathlib/Algebra/Periodic.lean

tactic: simp only [← sub_sub, h.sub_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddCommGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a - x)) (x + c) = -(fun x => f (a - x)) x
state_after: no goals
Theorem: le_of_nhds_le_nhds
File: Mathlib/Topology/Order.lean

tactic: rw [@isOpen_iff_mem_nhds _ _ t₁, @isOpen_iff_mem_nhds α _ t₂]
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s✝ : Set α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
s : Set α
⊢ IsOpen s → IsOpen s
state_after: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s✝ : Set α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
s : Set α
⊢ (∀ x ∈ s, s ∈ 𝓝 x) → ∀ x ∈ s, s ∈ 𝓝 x

tactic: exact fun hs a ha => h _ (hs _ ha)
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s✝ : Set α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
s : Set α
⊢ (∀ x ∈ s, s ∈ 𝓝 x) → ∀ x ∈ s, s ∈ 𝓝 x
state_after: no goals
Theorem: Equiv.equivCongr_refl
File: Mathlib/Logic/Equiv/Defs.lean

tactic: ext
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
⊢ (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β)
state_after: case H.H
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
x✝¹ : α ≃ β
x✝ : α
⊢ (((Equiv.refl α).equivCongr (Equiv.refl β)) x✝¹) x✝ = ((Equiv.refl (α ≃ β)) x✝¹) x✝

tactic: rfl
state_before: case H.H
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
x✝¹ : α ≃ β
x✝ : α
⊢ (((Equiv.refl α).equivCongr (Equiv.refl β)) x✝¹) x✝ = ((Equiv.refl (α ≃ β)) x✝¹) x✝
state_after: no goals
Theorem: padicValNat_prime_prime_pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat.pow _ <| Nat.Prime.ne_zero hq.elim, padicValNat_primes neq, mul_zero]
state_before: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n : ℕ
neq : p ≠ q
⊢ padicValNat p (q ^ n) = 0
state_after: no goals
Theorem: AddCommGroup.ModEq.of_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rwa [mul_smul]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a ≡ b [PMOD z • p]
m : ℤ
hm : b - a = m • z • p
⊢ b - a = (m * z) • p
state_after: no goals
Theorem: bernoulli_one
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: norm_num [bernoulli]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli 1 = -1 / 2
state_after: no goals
Theorem: Polynomial.natDegree_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [natDegree, degree_cyclotomic]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ (cyclotomic n R).natDegree = n.totient
state_after: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ WithBot.unbot' 0 ↑n.totient = n.totient

tactic: norm_cast
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ WithBot.unbot' 0 ↑n.totient = n.totient
state_after: no goals
Theorem: Real.abs_sin_half
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← sqrt_sq_eq_abs, sin_sq_eq_half_sub, two_mul, add_halves, sub_div]
state_before: x : ℝ
⊢ |sin (x / 2)| = √((1 - cos x) / 2)
state_after: no goals
Theorem: Stream'.mem_cycle
File: Mathlib/Data/Stream/Init.lean

tactic: rw [cycle_eq]
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
h : l ≠ []
ainl : a ∈ l
⊢ a ∈ cycle l h
state_after: α : Type u
β : Type v
δ : Type w
a : α
l : List α
h : l ≠ []
ainl : a ∈ l
⊢ a ∈ l ++ₛ cycle l h

tactic: exact mem_append_stream_left _ ainl
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
h : l ≠ []
ainl : a ∈ l
⊢ a ∈ l ++ₛ cycle l h
state_after: no goals
Theorem: Ordinal.le_add_left
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa only [zero_add] using add_le_add_right (Ordinal.zero_le b) a
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_3}
⊢ a ≤ b + a
state_after: no goals
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.ex
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp_rw [SemanticallyEquivalent, ModelsBoundedFormula, BoundedFormula.realize_iff,
  BoundedFormula.realize_ex]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ T.SemanticallyEquivalent (∃'φ) (∃'ψ)
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∃ a, φ.Realize v (Fin.snoc xs a)) ↔ ∃ a, ψ.Realize v (Fin.snoc xs a)

tactic: exact fun M v xs => exists_congr fun a => h.realize_bd_iff
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∃ a, φ.Realize v (Fin.snoc xs a)) ↔ ∃ a, ψ.Realize v (Fin.snoc xs a)
state_after: no goals
Theorem: Polynomial.splits_of_splits_id
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: decide
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f x✝¹ : K[X]
hu : IsUnit x✝¹
x✝ : Splits (RingHom.id K) x✝¹
⊢ 0 ≤ 1
state_after: no goals

tactic: rw [map_id]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f a p : K[X]
ha0 : a ≠ 0
hp : Prime p
ih : Splits (RingHom.id K) a → Splits i a
hfi : Splits (RingHom.id K) (p * a)
⊢ p ∣ map (RingHom.id K) p
state_after: no goals
Theorem: Nat.tendsto_div_const_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: rw [Tendsto, map_div_atTop_eq_nat n hn.bot_lt]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
n : ℕ
hn : n ≠ 0
⊢ Tendsto (fun x => x / n) atTop atTop
state_after: no goals
Theorem: LinearMap.BilinForm.comp_id_left
File: Mathlib/LinearAlgebra/BilinearForm/Hom.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
r : M →ₗ[R] M
⊢ B.comp id r = B.compRight r
state_after: case H
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
r : M →ₗ[R] M
x✝ y✝ : M
⊢ ((B.comp id r) x✝) y✝ = ((B.compRight r) x✝) y✝

tactic: rfl
state_before: case H
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
r : M →ₗ[R] M
x✝ y✝ : M
⊢ ((B.comp id r) x✝) y✝ = ((B.compRight r) x✝) y✝
state_after: no goals
Theorem: Function.Commute.invOn_fixedPoints_comp
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: simpa only [h.comp_eq] using Function.invOn_fixedPoints_comp f g
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n k : ℕ
e : Perm α
h : Function.Commute f g
⊢ Set.InvOn f g (fixedPoints (f ∘ g)) (fixedPoints (f ∘ g))
state_after: no goals
Theorem: Substring.ValidFor.isEmpty
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [Substring.isEmpty, h.bsize]
state_before: l m r : List Char
x✝ : Substring
h : ValidFor l m r x✝
⊢ x✝.isEmpty = true ↔ m = []
state_after: no goals
Theorem: lt_of_smul_lt_smul_of_nonpos
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [← neg_neg a, neg_smul, neg_smul (-a), neg_lt_neg_iff] at h
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulReflectLT α β
h : a • b₁ < a • b₂
ha : a ≤ 0
⊢ b₂ < b₁
state_after: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulReflectLT α β
h : -a • b₂ < -a • b₁
ha : a ≤ 0
⊢ b₂ < b₁

tactic: exact lt_of_smul_lt_smul_of_nonneg_left h (neg_nonneg_of_nonpos ha)
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulReflectLT α β
h : -a • b₂ < -a • b₁
ha : a ≤ 0
⊢ b₂ < b₁
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.fiberBinaryProductEquiv_symm_snd_apply
File: Mathlib/CategoryTheory/Galois/Basic.lean

tactic: simp only [fiberBinaryProductEquiv, comp_obj, FintypeCat.incl_obj, Iso.toEquiv_comp,
  Equiv.symm_trans_apply, Iso.toEquiv_symm_fun]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.snd ((fiberBinaryProductEquiv F X Y).symm (x, y)) = y
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.snd
      ((PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv
        ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv (x, y))) =
    y

tactic: change ((Types.binaryProductIso _ _).inv ≫ _ ≫ (F ⋙ FintypeCat.incl).map prod.snd) _ = _
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.snd
      ((PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv
        ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv (x, y))) =
    y
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv ≫
        (PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv ≫ (F ⋙ FintypeCat.incl).map prod.snd)
      (x, y) =
    y

tactic: erw [PreservesLimitPair.iso_inv_snd, Types.binaryProductIso_inv_comp_snd]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv ≫
        (PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv ≫ (F ⋙ FintypeCat.incl).map prod.snd)
      (x, y) =
    y
state_after: no goals
Theorem: IsDedekindDomainInv.isNoetherianRing
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: refine isNoetherianRing_iff.mpr ⟨fun I : Ideal A => ?_⟩
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
⊢ IsNoetherianRing A
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
⊢ Submodule.FG I

tactic: by_cases hI : I = ⊥
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
⊢ Submodule.FG I
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG I

case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : ¬I = ⊥
⊢ Submodule.FG I

tactic: have hI : (I : FractionalIdeal A⁰ (FractionRing A)) ≠ 0 := coeIdeal_ne_zero.mpr hI
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : ¬I = ⊥
⊢ Submodule.FG I
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI✝ : ¬I = ⊥
hI : ↑I ≠ 0
⊢ Submodule.FG I

tactic: exact I.fg_of_isUnit (IsFractionRing.injective A (FractionRing A)) (h.isUnit hI)
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI✝ : ¬I = ⊥
hI : ↑I ≠ 0
⊢ Submodule.FG I
state_after: no goals

tactic: rw [hI]
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG I
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG ⊥

tactic: apply Submodule.fg_bot
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✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG ⊥
state_after: no goals
Theorem: Polynomial.map_dvd_map'
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: by_cases H : x = 0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
⊢ map f x ∣ map f y ↔ x ∣ y
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : x = 0
⊢ map f x ∣ map f y ↔ x ∣ y

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : ¬x = 0
⊢ map f x ∣ map f y ↔ x ∣ y

tactic: rw [H, Polynomial.map_zero, zero_dvd_iff, zero_dvd_iff, map_eq_zero]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : x = 0
⊢ map f x ∣ map f y ↔ x ∣ y
state_after: no goals

tactic: classical
rw [← normalize_dvd_iff, ← @normalize_dvd_iff R[X], normalize_apply, normalize_apply,
  coe_normUnit_of_ne_zero H, coe_normUnit_of_ne_zero (mt (map_eq_zero f).1 H),
  leadingCoeff_map, ← map_inv₀ f, ← map_C, ← Polynomial.map_mul,
  map_dvd_map _ f.injective (monic_mul_leadingCoeff_inv H)]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : ¬x = 0
⊢ map f x ∣ map f y ↔ x ∣ y
state_after: no goals

tactic: rw [← normalize_dvd_iff, ← @normalize_dvd_iff R[X], normalize_apply, normalize_apply,
  coe_normUnit_of_ne_zero H, coe_normUnit_of_ne_zero (mt (map_eq_zero f).1 H),
  leadingCoeff_map, ← map_inv₀ f, ← map_C, ← Polynomial.map_mul,
  map_dvd_map _ f.injective (monic_mul_leadingCoeff_inv H)]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : ¬x = 0
⊢ map f x ∣ map f y ↔ x ∣ y
state_after: no goals
Theorem: ProbabilityTheory.kernel.iIndep.meas_iInter
File: Mathlib/Probability/Independence/Kernel.lean

tactic: filter_upwards [h.meas_biInter (fun i (_ : i ∈ Finset.univ) ↦ hs _)] with a ha
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
state_after: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
a : α
ha : (κ a) (⋂ i ∈ Finset.univ, s i) = ∏ i : ι, (κ a) (s i)
⊢ (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)

tactic: simp [← ha]
state_before: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
a : α
ha : (κ a) (⋂ i ∈ Finset.univ, s i) = ∏ i : ι, (κ a) (s i)
⊢ (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
state_after: no goals
Theorem: FractionalIdeal.one_le
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: rw [← coe_le_coe, coe_one, Submodule.one_le, mem_coe]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ 1 ≤ I ↔ 1 ∈ I
state_after: no goals
Theorem: List.rdropWhile_concat
File: Mathlib/Data/List/DropRight.lean

tactic: simp only [rdropWhile, dropWhile, reverse_append, reverse_singleton, singleton_append]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rdropWhile p (l ++ [x]) = if p x = true then rdropWhile p l else l ++ [x]
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => dropWhile p l.reverse
      | false => x :: l.reverse).reverse =
    if p x = true then (dropWhile p l.reverse).reverse else l ++ [x]

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => dropWhile p l.reverse
      | false => x :: l.reverse).reverse =
    if p x = true then (dropWhile p l.reverse).reverse else l ++ [x]
state_after: no goals
Theorem: RCLike.inv_I
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: by_cases h : (I : K) = 0
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ I⁻¹ = -I
state_after: case pos
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : I = 0
⊢ I⁻¹ = -I

case neg
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : ¬I = 0
⊢ I⁻¹ = -I

tactic: simp [h]
state_before: case pos
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : I = 0
⊢ I⁻¹ = -I
state_after: no goals

tactic: field_simp [I_mul_I_of_nonzero h]
state_before: case neg
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : ¬I = 0
⊢ I⁻¹ = -I
state_after: no goals