ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.alternatingProd_cons'
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
⊢ [a].alternatingProd = a * [].alternatingProd⁻¹
state_after: no goals
tactic: rw [alternatingProd_nil, inv_one, mul_one, alternatingProd_singleton]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a b : α
l : List α
⊢ (a :: b :: l).alternatingProd = a * (b :: l).alternatingProd⁻¹
state_after: no goals
tactic: rw [alternatingProd_cons_cons', alternatingProd_cons' b l, mul_inv, inv_inv, mul_assoc]
Theorem: Polynomial.bernoulli_eq_sub_sum
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

Proof steps:
state_before: n : ℕ
⊢ ↑n.succ • bernoulli n = (monomial n) ↑n.succ - ∑ k ∈ range n, ↑((n + 1).choose k) • bernoulli k
state_after: no goals
tactic: rw [Nat.cast_succ, ← sum_bernoulli n, sum_range_succ, add_sub_cancel_left, choose_succ_self_right,
    Nat.cast_succ]
Theorem: IsGroupHom.map_div
File: Mathlib/Deprecated/Group.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f : α → β
hf✝ hf : IsGroupHom f
a b : α
⊢ f (a / b) = f a / f b
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, hf.map_mul, hf.map_inv]
Theorem: MeasureTheory.mem_ae_map_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
hf : AEMeasurable f μ
s : Set β
hs : MeasurableSet s
⊢ s ∈ ae (Measure.map f μ) ↔ f ⁻¹' s ∈ ae μ
state_after: no goals
tactic: simp only [mem_ae_iff, map_apply_of_aemeasurable hf hs.compl, preimage_compl]
Theorem: ArithmeticFunction.zeta_mul_vonMangoldt
File: Mathlib/NumberTheory/VonMangoldt.lean

Proof steps:
state_before: ⊢ ↑ζ * Λ = log
state_after: ⊢ Λ * ↑ζ = log
tactic: rw [mul_comm]
state_before: ⊢ Λ * ↑ζ = log
state_after: no goals
tactic: simp
Theorem: CanonicallyOrderedCommSemiring.mul_pos
File: Mathlib/Algebra/Order/Ring/Canonical.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝ : CanonicallyOrderedCommSemiring α
a b c d : α
⊢ 0 < a * b ↔ 0 < a ∧ 0 < b
state_after: no goals
tactic: simp only [pos_iff_ne_zero, ne_eq, mul_eq_zero, not_or]
Theorem: ProbabilityTheory.gaussianReal_mul_const
File: Mathlib/Probability/Distributions/Gaussian.lean

Proof steps:
state_before: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => X ω * c) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => c * X ω) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
tactic: simp_rw [mul_comm _ c]
state_before: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => c * X ω) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: no goals
tactic: exact gaussianReal_const_mul hX c
Theorem: LinearMap.trace_eq_contract_of_basis'
File: Mathlib/LinearAlgebra/Trace.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
P : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
ι : Type u_5
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι R M
⊢ trace R M = contractLeft R M ∘ₗ ↑(dualTensorHomEquivOfBasis b).symm
state_after: no goals
tactic: simp [LinearEquiv.eq_comp_toLinearMap_symm, trace_eq_contract_of_basis b]
Theorem: Nat.dist_eq_intro
File: Mathlib/Data/Nat/Dist.lean

Proof steps:
state_before: n m k l : ℕ
h : n + m = k + l
⊢ n.dist k = (n + m).dist (k + m)
state_after: no goals
tactic: rw [dist_add_add_right]
state_before: n m k l : ℕ
h : n + m = k + l
⊢ (n + m).dist (k + m) = (k + l).dist (k + m)
state_after: no goals
tactic: rw [h]
state_before: n m k l : ℕ
h : n + m = k + l
⊢ (k + l).dist (k + m) = l.dist m
state_after: no goals
tactic: rw [dist_add_add_left]
Theorem: NNReal.mul_le_iff_le_inv
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: a b r : ℝ≥0
hr : r ≠ 0
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
state_after: a b r : ℝ≥0
hr : r ≠ 0
this : 0 < r
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
tactic: have : 0 < r := lt_of_le_of_ne (zero_le r) hr.symm
state_before: a b r : ℝ≥0
hr : r ≠ 0
this : 0 < r
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
state_after: no goals
tactic: rw [← mul_le_mul_left (inv_pos.mpr this), ← mul_assoc, inv_mul_cancel hr, one_mul]
Theorem: ProbabilityTheory.lintegral_condKernel_mem
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (κ.condKernel (a, x)) {y | (x, y) ∈ s} ∂κ.fst a = (κ a) s
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (κ.condKernel (a, x)) {y | (x, y) ∈ s} ∂κ.fst a = ((κ.fst ⊗ₖ κ.condKernel) a) s
tactic: conv_rhs => rw [← κ.disintegrate κ.condKernel]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (κ.condKernel (a, x)) {y | (x, y) ∈ s} ∂κ.fst a = ((κ.fst ⊗ₖ κ.condKernel) a) s
state_after: no goals
tactic: simp_rw [Kernel.compProd_apply _ _ _ hs]
Theorem: _private.Mathlib.Order.Interval.Finset.Defs.0.WithTop.aux
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : LocallyFiniteOrder α
x : α
p : α → Prop
⊢ (∃ a, p a ∧ ↑a = ↑x) ↔ p x
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.iIndepSet_iff
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s✝ s : ι → Set Ω
μ : Measure Ω
⊢ iIndepSet s μ ↔
    ∀ (s' : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s', MeasurableSet (f i)) → μ (⋂ i ∈ s', f i) = ∏ i ∈ s', μ (f i)
state_after: no goals
tactic: simp only [iIndepSet_iff_iIndep, iIndep_iff]
Theorem: SimpleGraph.Walk.exists_cons_eq_concat
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : G.Adj u v
p : G.Walk v w
⊢ ∃ x q, ∃ (h' : G.Adj x w), cons h p = q.concat h'
state_after: no goals
tactic: induction p generalizing u with
  | nil => exact ⟨_, nil, h, rfl⟩
  | cons h' p ih =>
    obtain ⟨y, q, h'', hc⟩ := ih h'
    refine ⟨y, cons h q, h'', ?_⟩
    rw [concat_cons, hc]
Theorem: mem_nhdsWithin_insert
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ t ∈ 𝓝[insert a s] a ↔ a ∈ t ∧ t ∈ 𝓝[s] a
state_after: no goals
tactic: simp
Theorem: iterateFrobeniusEquiv_one_apply
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
x : R
⊢ (iterateFrobeniusEquiv R p 1) x = x ^ p
state_after: no goals
tactic: rw [iterateFrobeniusEquiv_def, pow_one]
Theorem: Behrend.map_zero
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d✝ k N : ℕ
x : Fin n → ℕ
d : ℕ
a : Fin 0 → ℕ
⊢ (map d) a = 0
state_after: no goals
tactic: simp [map]
Theorem: Polynomial.X_eq_normalize
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
⊢ X = normalize X
state_after: no goals
tactic: simp only [normalize_apply, normUnit_X, Units.val_one, mul_one]
Theorem: SzemerediRegularity.m_pos
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
inst✝ : Nonempty α
hPα : P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α
⊢ 0 < m
state_after: no goals
tactic: sz_positivity
Theorem: Real.Angle.tan_coe
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: x : ℝ
⊢ (↑x).tan = Real.tan x
state_after: no goals
tactic: rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
Theorem: Rat.le_floor
File: Mathlib/Data/Rat/Floor.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
⊢ z ≤ { num := n, den := d, den_nz := h, reduced := c }.floor ↔ ↑z ≤ { num := n, den := d, den_nz := h, reduced := c }
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
⊢ z ≤ n / ↑d ↔ ↑z ≤ { num := n, den := d, den_nz := h, reduced := c }
tactic: simp only [Rat.floor_def']
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
⊢ z ≤ n / ↑d ↔ ↑z ≤ { num := n, den := d, den_nz := h, reduced := c }
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d
tactic: rw [mk'_eq_divInt]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d
tactic: have h' := Int.ofNat_lt.2 (Nat.pos_of_ne_zero h)
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ z * ↑d ≤ n
tactic: conv =>
      rhs
      rw [intCast_eq_divInt, Rat.divInt_le_divInt zero_lt_one h', mul_one]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ z * ↑d ≤ n
state_after: no goals
tactic: exact Int.le_ediv_iff_mul_le h'
Theorem: MvPolynomial.C_mul_X_pow_eq_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
s : σ
a : R
n : ℕ
⊢ C a * X s ^ n = (monomial (Finsupp.single s n)) a
state_after: no goals
tactic: rw [← zero_add (Finsupp.single s n), monomial_add_single, C_apply]
Theorem: IntermediateField.iInf_toSubalgebra
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
ι : Sort u_3
S : ι → IntermediateField F E
⊢ ↑(iInf S).toSubalgebra = ↑(⨅ i, (S i).toSubalgebra)
state_after: no goals
tactic: simp [iInf]
Theorem: Finset.Icc_subset_Icc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Icc a₁ b₁ ⊆ Icc a₂ b₂
state_after: no goals
tactic: simpa [← coe_subset] using Set.Icc_subset_Icc ha hb
Theorem: List.ranges_join'
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
a : ℕ
l : List ℕ
⊢ (a :: l).ranges.join = range (Nat.sum (a :: l))
state_after: no goals
tactic: simp only [sum_cons, join, ← map_join, ranges_join', range_add]
Theorem: Polynomial.support_map_of_injective
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
f : R →+* S
hf : Function.Injective ⇑f
⊢ (map f p).support = p.support
state_after: no goals
tactic: simp_rw [Finset.ext_iff, mem_support_iff, coeff_map, ← map_zero f, hf.ne_iff,
    forall_const]
Theorem: IsAddUnit.isAddUnit_iff_addLeft_bijective
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a✝ b c a : M
h : IsUnit a
y : M
⊢ (fun x => a * x) (↑h.unit⁻¹ * y) = y
state_after: no goals
tactic: simp [← mul_assoc]
Theorem: infIccOrderIsoIccSup_apply_coe
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ ↑((fun x => ⟨a ⊓ ↑x, ⋯⟩) ((fun x => ⟨↑x ⊔ b, ⋯⟩) x)) = ↑x
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ a ⊓ (↑x ⊔ b) = ↑x
tactic: change a ⊓ (↑x ⊔ b) = ↑x
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ a ⊓ (↑x ⊔ b) = ↑x
state_after: no goals
tactic: rw [sup_comm, ← inf_sup_assoc_of_le _ x.prop.2, sup_eq_right.2 x.prop.1]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ ↑((fun x => ⟨↑x ⊔ b, ⋯⟩) ((fun x => ⟨a ⊓ ↑x, ⋯⟩) x)) = ↑x
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ a ⊓ ↑x ⊔ b = ↑x
tactic: change a ⊓ ↑x ⊔ b = ↑x
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ a ⊓ ↑x ⊔ b = ↑x
state_after: no goals
tactic: rw [inf_comm, inf_sup_assoc_of_le _ x.prop.1, inf_eq_left.2 x.prop.2]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ { toFun := fun x => ⟨↑x ⊔ b, ⋯⟩, invFun := fun x => ⟨a ⊓ ↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } x ≤
      { toFun := fun x => ⟨↑x ⊔ b, ⋯⟩, invFun := fun x => ⟨a ⊓ ↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } y ↔
    x ≤ y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ x ≤ y
tactic: simp only [Subtype.mk_le_mk, Equiv.coe_fn_mk, and_true_iff, le_sup_right]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ x ≤ y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ ↑x ≤ ↑y
tactic: rw [← Subtype.coe_le_coe]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ ↑x ≤ ↑y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ ↑x ≤ ↑y
tactic: refine ⟨fun h => ?_, fun h => sup_le_sup_right h _⟩
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ ↑x ≤ ↑y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ a ⊓ (↑x ⊔ b) ≤ a ⊓ (↑y ⊔ b)
tactic: rw [← sup_eq_right.2 x.prop.1, inf_sup_assoc_of_le _ x.prop.2, sup_comm, ←
      sup_eq_right.2 y.prop.1, inf_sup_assoc_of_le _ y.prop.2, sup_comm b]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ a ⊓ (↑x ⊔ b) ≤ a ⊓ (↑y ⊔ b)
state_after: no goals
tactic: exact inf_le_inf_left _ h
Theorem: Set.encard_congr
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ≃ ↑t
⊢ s.encard = t.encard
state_after: no goals
tactic: rw [← encard_univ_coe, ← encard_univ_coe t, encard_univ, encard_univ, PartENat.card_congr e]
Theorem: mul_div_cancel_left
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c d a b : G
⊢ a * b / a = b
state_after: no goals
tactic: rw [div_eq_inv_mul, inv_mul_cancel_left]
Theorem: CategoryTheory.Abelian.imageIsoImage_inv
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ Limits.image.ι f ≫ cokernel.π f = 0
state_after: no goals
tactic: simp [← cancel_epi (factorThruImage f)]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (imageIsoImage f).inv = kernel.lift (cokernel.π f) (Limits.image.ι f) ⋯
state_after: case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (factorThruImage f ≫ (imageIsoImage f).inv) ≫ equalizer.ι (cokernel.π f) 0 =
    (factorThruImage f ≫ kernel.lift (cokernel.π f) (Limits.image.ι f) ⋯) ≫ equalizer.ι (cokernel.π f) 0
tactic: ext
state_before: case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (factorThruImage f ≫ (imageIsoImage f).inv) ≫ equalizer.ι (cokernel.π f) 0 =
    (factorThruImage f ≫ kernel.lift (cokernel.π f) (Limits.image.ι f) ⋯) ≫ equalizer.ι (cokernel.π f) 0
state_after: no goals
tactic: rw [IsImage.isoExt_inv, image.isImage_lift, Limits.image.fac_lift,
    imageStrongEpiMonoFactorisation_e, Category.assoc, kernel.lift_ι, equalizer_as_kernel,
    kernel.lift_ι, Limits.image.fac]
Theorem: Multiset.one_le_prod_of_one_le
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
l : List α
hl : ∀ x ∈ ⟦l⟧, 1 ≤ x
⊢ 1 ≤ prod ⟦l⟧
state_after: no goals
tactic: simpa using List.one_le_prod_of_one_le hl
Theorem: Rat.divInt_self'
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q : ℚ
n : ℤ
hn : n ≠ 0
⊢ n /. n = 1
state_after: no goals
tactic: simpa using divInt_mul_right (n := 1) (d := 1) hn
Theorem: Module.End.isSemisimple_sub_algebraMap_iff
File: Mathlib/LinearAlgebra/Semisimple.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
μ : R
⊢ (f - (algebraMap R (End R M)) μ).IsSemisimple ↔ f.IsSemisimple
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
μ : R
⊢ ∀ (p : Submodule R M), p ≤ Submodule.comap (f - (algebraMap R (End R M)) μ) p ↔ p ≤ Submodule.comap f p
tactic: suffices ∀ p : Submodule R M, p ≤ p.comap (f - algebraMap R (Module.End R M) μ) ↔ p ≤ p.comap f by
    simp [isSemisimple_iff, this]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
μ : R
⊢ ∀ (p : Submodule R M), p ≤ Submodule.comap (f - (algebraMap R (End R M)) μ) p ↔ p ≤ Submodule.comap f p
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
μ : R
p : Submodule R M
h : p ≤ Submodule.comap (f - (algebraMap R (End R M)) μ) p
x : M
hx : x ∈ p
⊢ x ∈ Submodule.comap f p
tactic: refine fun p ↦ ⟨fun h x hx ↦ ?_, fun h x hx ↦ p.sub_mem (h hx) (p.smul_mem μ hx)⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
μ : R
p : Submodule R M
h : p ≤ Submodule.comap (f - (algebraMap R (End R M)) μ) p
x : M
hx : x ∈ p
⊢ x ∈ Submodule.comap f p
state_after: no goals
tactic: simpa using p.add_mem (h hx) (p.smul_mem μ hx)
Theorem: Submodule.mem_orthogonal_singleton_iff_inner_left
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
⊢ v ∈ (span 𝕜 {u})ᗮ ↔ ⟪v, u⟫_𝕜 = 0
state_after: no goals
tactic: rw [mem_orthogonal_singleton_iff_inner_right, inner_eq_zero_symm]
Theorem: mul_eq_zero_of_ne_zero_imp_eq_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
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✝ : MulZeroClass M₀
a✝ b✝ a b : M₀
h : a ≠ 0 → b = 0
ha : a = 0
⊢ a * b = 0
state_after: no goals
tactic: rw [ha, zero_mul]
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✝ : MulZeroClass M₀
a✝ b✝ a b : M₀
h : a ≠ 0 → b = 0
ha : ¬a = 0
⊢ a * b = 0
state_after: no goals
tactic: rw [h ha, mul_zero]
Theorem: Function.Embedding.optionEmbeddingEquiv_apply_fst
File: Mathlib/Logic/Embedding/Set.lean

Proof steps:
state_before: α : Type ?u.1065
β : Type ?u.1066
f : Option α ↪ β
⊢ ∀ (x : Option α), ((fun f => f.fst.optionElim ↑f.snd ⋯) ((fun f => ⟨coeWithTop.trans f, ⟨f none, ⋯⟩⟩) f)) x = f x
state_after: case some
α : Type ?u.1065
β : Type ?u.1066
f : Option α ↪ β
val✝ : α
⊢ f ↑val✝ = f (some val✝)
tactic: rintro (_ | _) <;> simp [Option.coe_def]
state_before: case some
α : Type ?u.1065
β : Type ?u.1066
f : Option α ↪ β
val✝ : α
⊢ f ↑val✝ = f (some val✝)
state_after: no goals
tactic: rfl
state_before: α : Type ?u.1065
β : Type ?u.1066
x✝ : (f : α ↪ β) × ↑(range ⇑f)ᶜ
f : α ↪ β
y : β
hy : y ∈ (range ⇑f)ᶜ
⊢ (fun f => ⟨coeWithTop.trans f, ⟨f none, ⋯⟩⟩) ((fun f => f.fst.optionElim ↑f.snd ⋯) ⟨f, ⟨y, hy⟩⟩) = ⟨f, ⟨y, hy⟩⟩
state_after: case a.h
α : Type ?u.1065
β : Type ?u.1066
x✝¹ : (f : α ↪ β) × ↑(range ⇑f)ᶜ
f : α ↪ β
y : β
hy : y ∈ (range ⇑f)ᶜ
x✝ : α
⊢ (f.optionElim y ⋯) ↑x✝ = f x✝
tactic: ext <;> simp [Option.coe_def]
state_before: case a.h
α : Type ?u.1065
β : Type ?u.1066
x✝¹ : (f : α ↪ β) × ↑(range ⇑f)ᶜ
f : α ↪ β
y : β
hy : y ∈ (range ⇑f)ᶜ
x✝ : α
⊢ (f.optionElim y ⋯) ↑x✝ = f x✝
state_after: no goals
tactic: rfl