tasksource/leandojo huggingface dataset:
Theorem: Multiset.rel_add_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← rel_flip, rel_add_left]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.451251
δ : Type ?u.451254
r : α → β → Prop
p : γ → δ → Prop
as : Multiset α
bs₀ bs₁ : Multiset β
⊢ Rel r as (bs₀ + bs₁) ↔ ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁

tactic: simp [rel_flip]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.451251
δ : Type ?u.451254
r : α → β → Prop
p : γ → δ → Prop
as : Multiset α
bs₀ bs₁ : Multiset β
⊢ (∃ bs₀_1 bs₁_1, Rel (flip r) bs₀ bs₀_1 ∧ Rel (flip r) bs₁ bs₁_1 ∧ as = bs₀_1 + bs₁_1) ↔
    ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁
Theorem: Bitvec.ofFin_toFin
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: dsimp [ofFin]
state_before: n : ℕ
v : Bitvec n
⊢ ofFin (toFin v) = v

tactic: rw [toFin_val, ofNat_toNat]
state_before: n : ℕ
v : Bitvec n
⊢ Bitvec.ofNat n ↑(toFin v) = v
Theorem: Matrix.rank_le_card_height
File: Mathlib/Data/Matrix/Rank.lean

tactic: haveI : Module.Finite R (m → R) := Module.Finite.pi
state_before: l : Type ?u.223607
m : Type u_2
n : Type u_3
o : Type ?u.223616
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
⊢ rank A ≤ Fintype.card m

tactic: haveI : Module.Free R (m → R) := Module.Free.pi _ _
state_before: l : Type ?u.223607
m : Type u_2
n : Type u_3
o : Type ?u.223616
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this : Module.Finite R (m → R)
⊢ rank A ≤ Fintype.card m

tactic: exact (Submodule.finrank_le _).trans (finrank_pi R).le
state_before: l : Type ?u.223607
m : Type u_2
n : Type u_3
o : Type ?u.223616
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this✝ : Module.Finite R (m → R)
this : Module.Free R (m → R)
⊢ rank A ≤ Fintype.card m
Theorem: Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: constructor
state_before: θ ψ : ℝ
⊢ sin θ = sin ψ ↔ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: intro Hsin
state_before: case mp
θ ψ : ℝ
⊢ sin θ = sin ψ → ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin
state_before: case mp
θ ψ : ℝ
Hsin : sin θ = sin ψ
⊢ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hsin with h h
state_before: case mp
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
⊢ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: right
state_before: case mp.inr
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑(π / 2 - θ) = -↑(π / 2 - ψ)
⊢ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: rw [coe_sub, coe_sub, eq_neg_iff_add_eq_zero, add_sub, sub_add_eq_add_sub, ← coe_add,
  add_halves, sub_sub, sub_eq_zero] at h
state_before: case mp.inr.h
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑(π / 2 - θ) = -↑(π / 2 - ψ)
⊢ ↑θ + ↑ψ = ↑π

tactic: exact h.symm
state_before: case mp.inr.h
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑π = ↑θ + ↑ψ
⊢ ↑θ + ↑ψ = ↑π

tactic: left
state_before: case mp.inl
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑(π / 2 - θ) = ↑(π / 2 - ψ)
⊢ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

tactic: rw [coe_sub, coe_sub] at h
state_before: case mp.inl.h
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑(π / 2 - θ) = ↑(π / 2 - ψ)
⊢ ↑θ = ↑ψ

tactic: exact sub_right_inj.1 h
state_before: case mp.inl.h
θ ψ : ℝ
Hsin : cos (π / 2 - θ) = cos (π / 2 - ψ)
h : ↑(π / 2) - ↑θ = ↑(π / 2) - ↑ψ
⊢ ↑θ = ↑ψ

tactic: rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
state_before: case mpr
θ ψ : ℝ
⊢ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π → sin θ = sin ψ

tactic: rintro (⟨k, H⟩ | ⟨k, H⟩)
state_before: case mpr
θ ψ : ℝ
⊢ ((∃ k, θ - ψ = 2 * π * ↑k) ∨ ∃ k, θ - (π - ψ) = 2 * π * ↑k) → sin θ = sin ψ

tactic: rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
  mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
state_before: case mpr.inl.intro
θ ψ : ℝ
k : ℤ
H : θ - ψ = 2 * π * ↑k
⊢ sin θ = sin ψ

case mpr.inr.intro
θ ψ : ℝ
k : ℤ
H : θ - (π - ψ) = 2 * π * ↑k
⊢ sin θ = sin ψ

tactic: have H' : θ + ψ = 2 * k * π + π := by
  rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
    mul_assoc] at H
state_before: case mpr.inr.intro
θ ψ : ℝ
k : ℤ
H : θ - (π - ψ) = 2 * π * ↑k
⊢ sin θ = sin ψ

tactic: rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
  mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
  MulZeroClass.mul_zero]
state_before: case mpr.inr.intro
θ ψ : ℝ
k : ℤ
H : θ - (π - ψ) = 2 * π * ↑k
H' : θ + ψ = 2 * ↑k * π + π
⊢ sin θ = sin ψ

tactic: rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
  mul_assoc] at H
state_before: θ ψ : ℝ
k : ℤ
H : θ - (π - ψ) = 2 * π * ↑k
⊢ θ + ψ = 2 * ↑k * π + π
Theorem: CategoryTheory.mapPair_equifibered
File: Mathlib/CategoryTheory/Extensive.lean

tactic: rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩
state_before: J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ NatTrans.Equifibered α

tactic: all_goals
  dsimp; simp only [Discrete.functor_map_id]
  exact IsPullback.of_horiz_isIso ⟨by simp only [Category.comp_id, Category.id_comp]⟩
state_before: case mk.left.mk.up.up
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
    (α.app { as := WalkingPair.left }) (α.app { as := { as := WalkingPair.left }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })

case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    (α.app { as := WalkingPair.right }) (α.app { as := { as := WalkingPair.right }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })

tactic: dsimp
state_before: case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    (α.app { as := WalkingPair.right }) (α.app { as := { as := WalkingPair.right }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })

tactic: simp only [Discrete.functor_map_id]
state_before: case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : WalkingPair.right = WalkingPair.right) } })
    (α.app { as := WalkingPair.right }) (α.app { as := WalkingPair.right })
    (F'.map { down := { down := (_ : WalkingPair.right = WalkingPair.right) } })

tactic: exact IsPullback.of_horiz_isIso ⟨by simp only [Category.comp_id, Category.id_comp]⟩
state_before: case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (𝟙 (F.obj { as := WalkingPair.right })) (α.app { as := WalkingPair.right })
    (α.app { as := WalkingPair.right }) (𝟙 (F'.obj { as := WalkingPair.right }))

tactic: simp only [Category.comp_id, Category.id_comp]
state_before: J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ 𝟙 (F.obj { as := WalkingPair.right }) ≫ α.app { as := WalkingPair.right } =
    α.app { as := WalkingPair.right } ≫ 𝟙 (F'.obj { as := WalkingPair.right })
Theorem: Stream'.WSeq.destruct_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [destruct, think, Computation.rmap]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ Computation.destruct (destruct (think s)) = Sum.inr (destruct s)
Theorem: intervalIntegral.hasSum_integral_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegrable_iff, intervalIntegral_eq_integral_uIoc, ←
  ae_restrict_iff' (α := ℝ) (μ := μ) measurableSet_uIoc] at *
state_before: ι✝ : Type ?u.17150684
𝕜 : Type ?u.17150687
E : Type u_2
F✝ : Type ?u.17150693
A : Type ?u.17150696
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ι : Type u_1
inst✝ : Countable ι
F : ι → ℝ → E
bound : ι → ℝ → ℝ
hF_meas : ∀ (n : ι), AEStronglyMeasurable (F n) (Measure.restrict μ (Ι a b))
h_bound : ∀ (n : ι), ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → ‖F n t‖ ≤ bound n t
bound_summable : ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → Summable fun n => bound n t
bound_integrable : IntervalIntegrable (fun t => ∑' (n : ι), bound n t) μ a b
h_lim : ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → HasSum (fun n => F n t) (f t)
⊢ HasSum (fun n => ∫ (t : ℝ) in a..b, F n t ∂μ) (∫ (t : ℝ) in a..b, f t ∂μ)

tactic: exact
  (hasSum_integral_of_dominated_convergence bound hF_meas h_bound bound_summable bound_integrable
        h_lim).const_smul
    _
state_before: ι✝ : Type ?u.17150684
𝕜 : Type ?u.17150687
E : Type u_2
F✝ : Type ?u.17150693
A : Type ?u.17150696
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ι : Type u_1
inst✝ : Countable ι
F : ι → ℝ → E
bound : ι → ℝ → ℝ
hF_meas : ∀ (n : ι), AEStronglyMeasurable (F n) (Measure.restrict μ (Ι a b))
h_bound : ∀ (n : ι), ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ι a b), ‖F n x‖ ≤ bound n x
bound_summable : ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ι a b), Summable fun n => bound n x
bound_integrable : IntegrableOn (fun t => ∑' (n : ι), bound n t) (Ι a b)
h_lim : ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ι a b), HasSum (fun n => F n x) (f x)
⊢ HasSum (fun n => (if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, F n x ∂μ)
    ((if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ)
Theorem: Lagrange.basisDivisor_self
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp only [basisDivisor, sub_self, inv_zero, map_zero, MulZeroClass.zero_mul]
state_before: F : Type u_1
inst✝ : Field F
x y : F
⊢ basisDivisor x x = 0
Theorem: PartENat.lt_coe_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp only [lt_def, forall_prop_of_true, get_natCast', dom_natCast]
state_before: x : PartENat
n : ℕ
⊢ x < ↑n ↔ ∃ h, Part.get x h < n
Theorem: Metric.ball_half_subset
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [sub_self_div_two]
state_before: α : Type u
β : Type v
X : Type ?u.44437
ι : Type ?u.44440
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
h : y ∈ ball x (ε / 2)
⊢ dist y x ≤ ε - ε / 2

tactic: exact le_of_lt h
state_before: α : Type u
β : Type v
X : Type ?u.44437
ι : Type ?u.44440
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
h : y ∈ ball x (ε / 2)
⊢ dist y x ≤ ε / 2
Theorem: MeasureTheory.snorm'_add_le
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: refine' ENNReal.rpow_le_rpow _ (by simp [le_trans zero_le_one hq1] : 0 ≤ 1 / q)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2325640
G : Type ?u.2325643
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
hq1 : 1 ≤ q
⊢ (∫⁻ (a : α), ↑‖(f + g) a‖₊ ^ q ∂μ) ^ (1 / q) ≤
    (∫⁻ (a : α), ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a ^ q ∂μ) ^ (1 / q)

tactic: refine' lintegral_mono fun a => ENNReal.rpow_le_rpow _ (le_trans zero_le_one hq1)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2325640
G : Type ?u.2325643
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
hq1 : 1 ≤ q
⊢ (∫⁻ (a : α), ↑‖(f + g) a‖₊ ^ q ∂μ) ≤ ∫⁻ (a : α), ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a ^ q ∂μ

tactic: simp only [Pi.add_apply, ← ENNReal.coe_add, ENNReal.coe_le_coe, nnnorm_add_le]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2325640
G : Type ?u.2325643
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
hq1 : 1 ≤ q
a : α
⊢ ↑‖(f + g) a‖₊ ≤ ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a

tactic: simp [le_trans zero_le_one hq1]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2325640
G : Type ?u.2325643
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
hq1 : 1 ≤ q
⊢ 0 ≤ 1 / q
Theorem: Std.AssocList.mapKey_toList
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
δ : Type u_2
β : Type u_3
f : α → δ
l : AssocList α β
⊢ toList (mapKey f l) =
    List.map
      (fun x =>
        match x with
        | (a, b) => (f a, b))
      (toList l)
Theorem: locallyConnectedSpace_iff_connectedComponentIn_open
File: Mathlib/Topology/Connected.lean

tactic: constructor
state_before: α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ LocallyConnectedSpace α ↔ ∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)

tactic: intro h
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ LocallyConnectedSpace α → ∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)

tactic: exact fun F hF x _ => hF.connectedComponentIn
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
h : LocallyConnectedSpace α
⊢ ∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)

tactic: intro h
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ (∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)) → LocallyConnectedSpace α

tactic: rw [locallyConnectedSpace_iff_open_connected_subsets]
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)
⊢ LocallyConnectedSpace α

tactic: refine' fun x U hU =>
    ⟨connectedComponentIn (interior U) x,
      (connectedComponentIn_subset _ _).trans interior_subset, h _ isOpen_interior x _,
      mem_connectedComponentIn _, isConnected_connectedComponentIn_iff.mpr _⟩ <;>
  exact mem_interior_iff_mem_nhds.mpr hU
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.115042
π : ι → Type ?u.115047
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (F : Set α), IsOpen F → ∀ (x : α), x ∈ F → IsOpen (connectedComponentIn F x)
⊢ ∀ (x : α) (U : Set α), U ∈ 𝓝 x → ∃ V, V ⊆ U ∧ IsOpen V ∧ x ∈ V ∧ IsConnected V
Theorem: Cardinal.cantorFunctionAux_zero
File: Mathlib/Data/Real/Cardinality.lean

tactic: cases h : f 0 <;> simp [h]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
⊢ cantorFunctionAux c f 0 = bif f 0 then 1 else 0
Theorem: BilinForm.comp_symmCompOfNondegenerate_apply
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: erw [symmCompOfNondegenerate, LinearEquiv.apply_symm_apply (B₂.toDual b₂) _]
state_before: R : Type ?u.1833309
M : Type ?u.1833312
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type ?u.1833348
M₁ : Type ?u.1833351
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type ?u.1833960
M₂ : Type ?u.1833963
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type ?u.1834150
M₃ : Type ?u.1834153
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_2
K : Type u_1
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M
B₁✝ : BilinForm R₁ M₁
B₂✝ : BilinForm R₂ M₂
M₂' : Type ?u.1835958
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
inst✝ : FiniteDimensional K V
B₁ B₂ : BilinForm K V
b₂ : Nondegenerate B₂
v : V
⊢ ↑(↑toLin B₂) (↑(symmCompOfNondegenerate B₁ B₂ b₂) v) = ↑(↑toLin B₁) v
Theorem: AffineSubspace.comap_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← ext_iff]
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type ?u.601866
P₃ : Type ?u.601869
inst✝⁹ : Ring k
inst✝⁸ : AddCommGroup V₁
inst✝⁷ : Module k V₁
inst✝⁶ : AffineSpace V₁ P₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module k V₂
inst✝³ : AffineSpace V₂ P₂
inst✝² : AddCommGroup V₃
inst✝¹ : Module k V₃
inst✝ : AffineSpace V₃ P₃
f : P₁ →ᵃ[k] P₂
⊢ comap f ⊤ = ⊤

tactic: exact preimage_univ (f := f)
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type ?u.601866
P₃ : Type ?u.601869
inst✝⁹ : Ring k
inst✝⁸ : AddCommGroup V₁
inst✝⁷ : Module k V₁
inst✝⁶ : AffineSpace V₁ P₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module k V₂
inst✝³ : AffineSpace V₂ P₂
inst✝² : AddCommGroup V₃
inst✝¹ : Module k V₃
inst✝ : AffineSpace V₃ P₃
f : P₁ →ᵃ[k] P₂
⊢ ↑(comap f ⊤) = ↑⊤
Theorem: Algebra.TensorProduct.productMap_apply_tmul
File: Mathlib/RingTheory/TensorProduct.lean

tactic: unfold productMap lmul'
state_before: R : Type u_2
A : Type u_3
B : Type u_4
S : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
a : A
b : B
⊢ ↑(productMap f g) (a ⊗ₜ[R] b) = ↑f a * ↑g b

tactic: simp
state_before: R : Type u_2
A : Type u_3
B : Type u_4
S : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
a : A
b : B
⊢ ↑(AlgHom.comp
          (algHomOfLinearMapTensorProduct (LinearMap.mul' R S)
            (_ : ∀ (a₁ a₂ b₁ b₂ : S), a₁ * a₂ * (b₁ * b₂) = a₁ * b₁ * (a₂ * b₂))
            (_ : ∀ (r : R), ↑(algebraMap R S) r * 1 = ↑(algebraMap R S) r))
          (map f g))
      (a ⊗ₜ[R] b) =
    ↑f a * ↑g b
Theorem: multiplicity.finite_int_iff
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [finite_int_iff_natAbs_finite, finite_nat_iff, pos_iff_ne_zero, Int.natAbs_ne_zero]
state_before: a b : ℤ
⊢ Finite a b ↔ _root_.Int.natAbs a ≠ 1 ∧ b ≠ 0
Theorem: MeasureTheory.NullMeasurable.congr
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [mem_preimage, mem_preimage, hx]
state_before: ι : Type ?u.25082
α : Type u_1
β : Type u_2
γ : Type ?u.25091
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
μ : Measure α
g : α → β
hf : NullMeasurable f
hg : f =ᵐ[μ] g
s : Set β
hs : MeasurableSet s
x : α
hx : f x = g x
⊢ x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s
Theorem: Real.rpow_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [rpow_logb_eq_abs b_pos b_ne_one hx.ne']
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : 0 < x
⊢ b ^ logb b x = x

tactic: exact abs_of_pos hx
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : 0 < x
⊢ abs x = x
Theorem: Matrix.StdBasisMatrix.mul_left_apply_same
File: Mathlib/Data/Matrix/Basis.lean

tactic: simp [mul_apply, stdBasisMatrix]
state_before: l : Type ?u.31097
m : Type ?u.31100
n : Type u_1
R : Type ?u.31106
α : Type u_2
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
b : n
M : Matrix n n α
⊢ (stdBasisMatrix i j c ⬝ M) i b = c * M j b
Theorem: UnionFind.rank_lt
File: Mathlib/Data/UnionFind.lean

tactic: let ⟨m, hm⟩ := self.model'
state_before: α : Type u_1
self : UnionFind α
i : ℕ
h : i < Array.size self.arr
⊢ self.arr[i].parent ≠ i → rank self i < rank self self.arr[i].parent

tactic: simpa [hm.parent_eq, hm.rank_eq, rank, size, h, (m.parent ⟨i, h⟩).2] using m.rank_lt ⟨i, h⟩
state_before: α : Type u_1
self : UnionFind α
i : ℕ
h : i < Array.size self.arr
m : UFModel (Array.size self.arr)
hm : UFModel.Models self.arr m
⊢ self.arr[i].parent ≠ i → rank self i < rank self self.arr[i].parent
Theorem: List.reduceOption_cons_of_some
File: Mathlib/Data/List/Basic.lean

tactic: simp only [reduceOption, filterMap, id.def, eq_self_iff_true, and_self_iff]
state_before: ι : Type ?u.348712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
l : List (Option α)
⊢ reduceOption (some x :: l) = x :: reduceOption l
Theorem: Finset.Ico_filter_lt
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: cases le_total b c with
| inl h => rw [Ico_filter_lt_of_right_le h, min_eq_left h]
| inr h => rw [Ico_filter_lt_of_le_right h, min_eq_right h]
state_before: ι : Type ?u.137301
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ filter (fun x => x < c) (Ico a b) = Ico a (min b c)

tactic: rw [Ico_filter_lt_of_right_le h, min_eq_left h]
state_before: case inl
ι : Type ?u.137301
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : b ≤ c
⊢ filter (fun x => x < c) (Ico a b) = Ico a (min b c)

tactic: rw [Ico_filter_lt_of_le_right h, min_eq_right h]
state_before: case inr
ι : Type ?u.137301
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : c ≤ b
⊢ filter (fun x => x < c) (Ico a b) = Ico a (min b c)
Theorem: MvPolynomial.aeval_algebraMap_eq_zero_iff
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

tactic: rw [aeval_algebraMap_apply, Algebra.algebraMap_eq_smul_one, smul_eq_zero,
  iff_false_intro (one_ne_zero' B), or_false_iff]
state_before: R : Type u_4
A : Type u_1
B : Type u_2
σ : Type u_3
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring A
inst✝⁶ : CommSemiring B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra A B
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A B
inst✝¹ : NoZeroSMulDivisors A B
inst✝ : Nontrivial B
x : σ → A
p : MvPolynomial σ R
⊢ ↑(aeval (↑(algebraMap A B) ∘ x)) p = 0 ↔ ↑(aeval x) p = 0
Theorem: lt_mul_of_one_lt_right
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : PosMulStrictMono α
ha : 0 < a
h : 1 < b
⊢ a < a * b